# # add_file "restrictions.cc" # # add_file "restrictions.hh" # # patch "ChangeLog" # from [903334a73c0c015e1ce5b9a51c8a2304a8c330e6] # to [30828634f0fb1e8318afa57d8002db5e8956ffd9] # # patch "Makefile.am" # from [6ae74fd87e02e96ff5c7f0c2ed159e7494c77f34] # to [aa59fd43d68778699352e7fe93eecb95a6b62de2] # # patch "commands.cc" # from [c20f279625ddbfae2957ccfa54961b85a68318fc] # to [ce7dfe3a3b86b971225af0a7284b6e8d6d1e6a40] # # patch "database_check.hh" # from [68dfc0e92acf9cba9346c0eb67e32a929b930cea] # to [98374bcba5840ad01efdec5f36a0159568e124d7] # # patch "restrictions.cc" # from [] # to [03e4eb83e836f713c20e4d1f94fe26f792e18d51] # # patch "restrictions.hh" # from [] # to [5779a2e7cd59e34200501b14c0328fc40b72a8c3] # --- ChangeLog +++ ChangeLog @@ -1,3 +1,26 @@ +2005-04-30 Derek Scherger + + * Makefile.am (MOST_SOURCES): add restrictions.{cc,hh} + * commands.cc (extract_rearranged_paths): + (extract_delta_paths): + (extract_changed_paths): + (add_intermediate_paths): + (restrict_path_set): + (restrict_rename_set): + (restrict_path_rearrangement): + (restrict_delta_map): + (calculate_restricted_rearrangement): + (calculate_restricted_revision): + (calculate_current_revision): + (calculate_restricted_change_set): move to restrictions.{cc,hh} + (maybe_update_inodeprints): + (cat): + (dodiff): + (update): rename calculate_current_revision to + calculate_unrestricted_revision + * database_check.hh: update header guard #define + * restrictions.{cc,hh}: add new files + 2005-04-30 Nathaniel Smith * commands.cc: Add a placeholder OPT_NONE for commands that don't --- Makefile.am +++ Makefile.am @@ -39,6 +39,7 @@ inodeprint.cc inodeprint.hh \ selectors.cc selectors.hh \ annotate.cc annotate.hh \ + restrictions.cc restrictions.hh \ \ cleanup.hh unit_tests.hh interner.hh \ cycle_detector.hh randomfile.hh adler32.hh quick_alloc.hh \ --- commands.cc +++ commands.cc @@ -35,6 +35,7 @@ #include "netsync.hh" #include "packet.hh" #include "rcs_import.hh" +#include "restrictions.hh" #include "sanity.hh" #include "transforms.hh" #include "ui.hh" @@ -199,7 +200,7 @@ size_t col2 = 0; for (size_t i = 0; i < sorted.size(); ++i) { - col2 = col2 > idx(sorted, i)->cmdgroup.size() ? col2 : idx(sorted, i)->cmdgroup.size(); + col2 = col2 > idx(sorted, i)->cmdgroup.size() ? col2 : idx(sorted, i)->cmdgroup.size(); } for (size_t i = 0; i < sorted.size(); ++i) @@ -281,261 +282,6 @@ } static void -extract_rearranged_paths(change_set::path_rearrangement const & rearrangement, path_set & paths) -{ - paths.insert(rearrangement.deleted_files.begin(), rearrangement.deleted_files.end()); - paths.insert(rearrangement.deleted_dirs.begin(), rearrangement.deleted_dirs.end()); - - for (map::const_iterator i = rearrangement.renamed_files.begin(); - i != rearrangement.renamed_files.end(); ++i) - { - paths.insert(i->first); - paths.insert(i->second); - } - - for (map::const_iterator i = rearrangement.renamed_dirs.begin(); - i != rearrangement.renamed_dirs.end(); ++i) - { - paths.insert(i->first); - paths.insert(i->second); - } - - paths.insert(rearrangement.added_files.begin(), rearrangement.added_files.end()); -} - -static void -extract_delta_paths(change_set::delta_map const & deltas, path_set & paths) -{ - for (change_set::delta_map::const_iterator i = deltas.begin(); i != deltas.end(); ++i) - { - paths.insert(i->first); - } -} - -static void -extract_changed_paths(change_set const & cs, path_set & paths) -{ - extract_rearranged_paths(cs.rearrangement, paths); - extract_delta_paths(cs.deltas, paths); -} - -static void -add_intermediate_paths(path_set & paths) -{ - path_set intermediate_paths; - - for (path_set::const_iterator i = paths.begin(); i != paths.end(); ++i) - { - // we know that file_path's are normalized relative paths. So we can - // find intermediate paths simply by searching for /. - std::string::size_type j = std::string::npos; - while ((j = (*i)().rfind('/', j)) != std::string::npos) - { - file_path dir((*i)().substr(0, j)); - if (intermediate_paths.find(dir) != intermediate_paths.end()) break; - if (paths.find(dir) != paths.end()) break; - intermediate_paths.insert(dir); - --j; - } - } - - paths.insert(intermediate_paths.begin(), intermediate_paths.end()); -} - - -static void -restrict_path_set(string const & type, - path_set const & paths, - path_set & included, - path_set & excluded, - app_state & app) -{ - for (path_set::const_iterator i = paths.begin(); i != paths.end(); ++i) - { - if (app.restriction_includes(*i)) - { - L(F("restriction includes %s %s\n") % type % *i); - included.insert(*i); - } - else - { - L(F("restriction excludes %s %s\n") % type % *i); - excluded.insert(*i); - } - } -} - -static void -restrict_rename_set(string const & type, - std::map const & renames, - std::map & included, - std::map & excluded, - app_state & app) -{ - for (std::map::const_iterator i = renames.begin(); - i != renames.end(); ++i) - { - // include renames if either source or target name is included in the restriction - if (app.restriction_includes(i->first) || app.restriction_includes(i->second)) - { - L(F("restriction includes %s '%s' to '%s'\n") % type % i->first % i->second); - included.insert(*i); - } - else - { - L(F("restriction excludes %s '%s' to '%s'\n") % type % i->first % i->second); - excluded.insert(*i); - } - } -} - -static void -restrict_path_rearrangement(change_set::path_rearrangement const & work, - change_set::path_rearrangement & included, - change_set::path_rearrangement & excluded, - app_state & app) -{ - restrict_path_set("delete file", work.deleted_files, - included.deleted_files, excluded.deleted_files, app); - restrict_path_set("delete dir", work.deleted_dirs, - included.deleted_dirs, excluded.deleted_dirs, app); - - restrict_rename_set("rename file", work.renamed_files, - included.renamed_files, excluded.renamed_files, app); - restrict_rename_set("rename dir", work.renamed_dirs, - included.renamed_dirs, excluded.renamed_dirs, app); - - restrict_path_set("add file", work.added_files, - included.added_files, excluded.added_files, app); -} - -static void -restrict_delta_map(change_set::delta_map const & deltas, - change_set::delta_map & included, - change_set::delta_map & excluded, - app_state & app) -{ - for (change_set::delta_map::const_iterator i = deltas.begin(); i!= deltas.end(); ++i) - { - if (app.restriction_includes(i->first)) - { - L(F("restriction includes delta on %s\n") % i->first); - included.insert(*i); - } - else - { - L(F("restriction excludes delta on %s\n") % i->first); - excluded.insert(*i); - } - } -} - -static void -calculate_restricted_rearrangement(app_state & app, - vector const & args, - manifest_id & old_manifest_id, - revision_id & old_revision_id, - manifest_map & m_old, - path_set & old_paths, - path_set & new_paths, - change_set::path_rearrangement & included, - change_set::path_rearrangement & excluded) -{ - change_set::path_rearrangement work; - - get_base_revision(app, - old_revision_id, - old_manifest_id, m_old); - - extract_path_set(m_old, old_paths); - - get_path_rearrangement(work); - - path_set valid_paths(old_paths); - extract_rearranged_paths(work, valid_paths); - add_intermediate_paths(valid_paths); - - app.set_restriction(valid_paths, args); - - restrict_path_rearrangement(work, included, excluded, app); - - apply_path_rearrangement(old_paths, included, new_paths); -} - -static void -calculate_restricted_revision(app_state & app, - vector const & args, - revision_set & rev, - manifest_map & m_old, - manifest_map & m_new, - change_set::path_rearrangement & excluded) -{ - manifest_id old_manifest_id; - revision_id old_revision_id; - boost::shared_ptr cs(new change_set()); - path_set old_paths, new_paths; - - rev.edges.clear(); - m_old.clear(); - m_new.clear(); - - calculate_restricted_rearrangement(app, args, - old_manifest_id, old_revision_id, - m_old, old_paths, new_paths, - cs->rearrangement, excluded); - - build_restricted_manifest_map(new_paths, m_old, m_new, app); - complete_change_set(m_old, m_new, *cs); - - calculate_ident(m_new, rev.new_manifest); - L(F("new manifest is %s\n") % rev.new_manifest); - - rev.edges.insert(make_pair(old_revision_id, - make_pair(old_manifest_id, cs))); -} - -static void -calculate_restricted_revision(app_state & app, - vector const & args, - revision_set & rev, - manifest_map & m_old, - manifest_map & m_new) -{ - change_set::path_rearrangement work; - calculate_restricted_revision(app, args, rev, m_old, m_new, work); -} - -static void -calculate_current_revision(app_state & app, - revision_set & rev, - manifest_map & m_old, - manifest_map & m_new) -{ - vector empty_args; - calculate_restricted_revision(app, empty_args, rev, m_old, m_new); -} - -static void -calculate_restricted_change_set(app_state & app, - vector const & args, - change_set const & cs, - change_set & included, - change_set & excluded) -{ - path_set valid_paths; - - extract_changed_paths(cs, valid_paths); - add_intermediate_paths(valid_paths); - - app.set_restriction(valid_paths, args); - - restrict_path_rearrangement(cs.rearrangement, - included.rearrangement, excluded.rearrangement, app); - - restrict_delta_map(cs.deltas, included.deltas, excluded.deltas, app); -} - -static void maybe_update_inodeprints(app_state & app) { if (!in_inodeprints_mode()) @@ -543,7 +289,7 @@ inodeprint_map ipm_new; revision_set rev; manifest_map man_old, man_new; - calculate_current_revision(app, rev, man_old, man_new); + calculate_unrestricted_revision(app, rev, man_old, man_new); for (manifest_map::const_iterator i = man_new.begin(); i != man_new.end(); ++i) { manifest_map::const_iterator o = man_old.find(i->first); @@ -1575,7 +1321,7 @@ manifest_map m_old, m_new; app.require_working_copy(); - calculate_current_revision(app, rev, m_old, m_new); + calculate_unrestricted_revision(app, rev, m_old, m_new); calculate_ident(m_new, ident); write_manifest_map(m_new, dat); @@ -1603,7 +1349,7 @@ manifest_map m_old, m_new; app.require_working_copy(); - calculate_current_revision(app, rev, m_old, m_new); + calculate_unrestricted_revision(app, rev, m_old, m_new); calculate_ident(rev, ident); write_revision_set(rev, dat); } @@ -1905,9 +1651,9 @@ extract_path_set(man, old_paths); path_set valid_paths(old_paths); + extract_rearranged_paths(work, valid_paths); add_intermediate_paths(valid_paths); - app.set_restriction(valid_paths, args); restrict_path_rearrangement(work, included, excluded, app); @@ -2928,7 +2674,7 @@ N(app.db.revision_exists(r_old_id), F("revision %s does not exist") % r_old_id); app.db.get_revision(r_old_id, r_old); - calculate_current_revision(app, r_new, m_old, m_new); + calculate_unrestricted_revision(app, r_new, m_old, m_new); I(r_new.edges.size() == 1 || r_new.edges.size() == 0); N(r_new.edges.size() == 1, F("current revision has no ancestor")); new_is_archived = false; @@ -3211,7 +2957,7 @@ app.make_branch_sticky(); app.require_working_copy(); - calculate_current_revision(app, r_working, m_old, m_working); + calculate_unrestricted_revision(app, r_working, m_old, m_working); I(r_working.edges.size() == 1); r_old_id = edge_old_revision(r_working.edges.begin()); @@ -3698,9 +3444,9 @@ extract_path_set(m_old, old_paths); path_set valid_paths(old_paths); + extract_rearranged_paths(work, valid_paths); add_intermediate_paths(valid_paths); - app.set_restriction(valid_paths, args); restrict_path_rearrangement(work, included, excluded, app); --- database_check.hh +++ database_check.hh @@ -1,5 +1,5 @@ -#ifndef __FSCK_HH__ -#define __FSCK_HH__ +#ifndef __DATABASE_CHECK_HH__ +#define __DATABASE_CHECK_HH__ // copyright (C) 2005 derek scherger // all rights reserved. --- restrictions.cc +++ restrictions.cc @@ -0,0 +1,270 @@ +// copyright (C) 2005 derek scherger +// all rights reserved. +// licensed to the public under the terms of the GNU GPL (>= 2) +// see the file COPYING for details + +#include +#include +#include + +#include "manifest.hh" +#include "restrictions.hh" +#include "revision.hh" +#include "transforms.hh" + +void +extract_rearranged_paths(change_set::path_rearrangement const & rearrangement, path_set & paths) +{ + paths.insert(rearrangement.deleted_files.begin(), rearrangement.deleted_files.end()); + paths.insert(rearrangement.deleted_dirs.begin(), rearrangement.deleted_dirs.end()); + + for (std::map::const_iterator i = rearrangement.renamed_files.begin(); + i != rearrangement.renamed_files.end(); ++i) + { + paths.insert(i->first); + paths.insert(i->second); + } + + for (std::map::const_iterator i = rearrangement.renamed_dirs.begin(); + i != rearrangement.renamed_dirs.end(); ++i) + { + paths.insert(i->first); + paths.insert(i->second); + } + + paths.insert(rearrangement.added_files.begin(), rearrangement.added_files.end()); +} + +static void +extract_delta_paths(change_set::delta_map const & deltas, path_set & paths) +{ + for (change_set::delta_map::const_iterator i = deltas.begin(); i != deltas.end(); ++i) + { + paths.insert(i->first); + } +} + +static void +extract_changed_paths(change_set const & cs, path_set & paths) +{ + extract_rearranged_paths(cs.rearrangement, paths); + extract_delta_paths(cs.deltas, paths); +} + +void +add_intermediate_paths(path_set & paths) +{ + path_set intermediate_paths; + + for (path_set::const_iterator i = paths.begin(); i != paths.end(); ++i) + { + // we know that file_path's are normalized relative paths. So we can + // find intermediate paths simply by searching for /. + std::string::size_type j = std::string::npos; + while ((j = (*i)().rfind('/', j)) != std::string::npos) + { + file_path dir((*i)().substr(0, j)); + if (intermediate_paths.find(dir) != intermediate_paths.end()) break; + if (paths.find(dir) != paths.end()) break; + intermediate_paths.insert(dir); + --j; + } + } + + paths.insert(intermediate_paths.begin(), intermediate_paths.end()); +} + + +static void +restrict_path_set(std::string const & type, + path_set const & paths, + path_set & included, + path_set & excluded, + app_state & app) +{ + for (path_set::const_iterator i = paths.begin(); i != paths.end(); ++i) + { + if (app.restriction_includes(*i)) + { + L(F("restriction includes %s %s\n") % type % *i); + included.insert(*i); + } + else + { + L(F("restriction excludes %s %s\n") % type % *i); + excluded.insert(*i); + } + } +} + +static void +restrict_rename_set(std::string const & type, + std::map const & renames, + std::map & included, + std::map & excluded, + app_state & app) +{ + for (std::map::const_iterator i = renames.begin(); + i != renames.end(); ++i) + { + // include renames if either source or target name is included in the restriction + if (app.restriction_includes(i->first) || app.restriction_includes(i->second)) + { + L(F("restriction includes %s '%s' to '%s'\n") % type % i->first % i->second); + included.insert(*i); + } + else + { + L(F("restriction excludes %s '%s' to '%s'\n") % type % i->first % i->second); + excluded.insert(*i); + } + } +} + +void +restrict_path_rearrangement(change_set::path_rearrangement const & work, + change_set::path_rearrangement & included, + change_set::path_rearrangement & excluded, + app_state & app) +{ + restrict_path_set("delete file", work.deleted_files, + included.deleted_files, excluded.deleted_files, app); + restrict_path_set("delete dir", work.deleted_dirs, + included.deleted_dirs, excluded.deleted_dirs, app); + + restrict_rename_set("rename file", work.renamed_files, + included.renamed_files, excluded.renamed_files, app); + restrict_rename_set("rename dir", work.renamed_dirs, + included.renamed_dirs, excluded.renamed_dirs, app); + + restrict_path_set("add file", work.added_files, + included.added_files, excluded.added_files, app); +} + +static void +restrict_delta_map(change_set::delta_map const & deltas, + change_set::delta_map & included, + change_set::delta_map & excluded, + app_state & app) +{ + for (change_set::delta_map::const_iterator i = deltas.begin(); i!= deltas.end(); ++i) + { + if (app.restriction_includes(i->first)) + { + L(F("restriction includes delta on %s\n") % i->first); + included.insert(*i); + } + else + { + L(F("restriction excludes delta on %s\n") % i->first); + excluded.insert(*i); + } + } +} + +void +calculate_restricted_rearrangement(app_state & app, + std::vector const & args, + manifest_id & old_manifest_id, + revision_id & old_revision_id, + manifest_map & m_old, + path_set & old_paths, + path_set & new_paths, + change_set::path_rearrangement & included, + change_set::path_rearrangement & excluded) +{ + change_set::path_rearrangement work; + + get_base_revision(app, + old_revision_id, + old_manifest_id, m_old); + + extract_path_set(m_old, old_paths); + + get_path_rearrangement(work); + + path_set valid_paths(old_paths); + extract_rearranged_paths(work, valid_paths); + add_intermediate_paths(valid_paths); + + app.set_restriction(valid_paths, args); + + restrict_path_rearrangement(work, included, excluded, app); + + apply_path_rearrangement(old_paths, included, new_paths); +} + +void +calculate_restricted_revision(app_state & app, + std::vector const & args, + revision_set & rev, + manifest_map & m_old, + manifest_map & m_new, + change_set::path_rearrangement & excluded) +{ + manifest_id old_manifest_id; + revision_id old_revision_id; + boost::shared_ptr cs(new change_set()); + path_set old_paths, new_paths; + + rev.edges.clear(); + m_old.clear(); + m_new.clear(); + + calculate_restricted_rearrangement(app, args, + old_manifest_id, old_revision_id, + m_old, old_paths, new_paths, + cs->rearrangement, excluded); + + build_restricted_manifest_map(new_paths, m_old, m_new, app); + complete_change_set(m_old, m_new, *cs); + + calculate_ident(m_new, rev.new_manifest); + L(F("new manifest is %s\n") % rev.new_manifest); + + rev.edges.insert(std::make_pair(old_revision_id, + std::make_pair(old_manifest_id, cs))); +} + +void +calculate_restricted_revision(app_state & app, + std::vector const & args, + revision_set & rev, + manifest_map & m_old, + manifest_map & m_new) +{ + change_set::path_rearrangement work; + calculate_restricted_revision(app, args, rev, m_old, m_new, work); +} + +void +calculate_unrestricted_revision(app_state & app, + revision_set & rev, + manifest_map & m_old, + manifest_map & m_new) +{ + std::vector empty_args; + calculate_restricted_revision(app, empty_args, rev, m_old, m_new); +} + +void +calculate_restricted_change_set(app_state & app, + std::vector const & args, + change_set const & cs, + change_set & included, + change_set & excluded) +{ + path_set valid_paths; + + extract_changed_paths(cs, valid_paths); + add_intermediate_paths(valid_paths); + + app.set_restriction(valid_paths, args); + + restrict_path_rearrangement(cs.rearrangement, + included.rearrangement, excluded.rearrangement, app); + + restrict_delta_map(cs.deltas, included.deltas, excluded.deltas, app); +} + + --- restrictions.hh +++ restrictions.hh @@ -0,0 +1,57 @@ +#ifndef __RESTRICTIONS_HH__ +#define __RESTRICTIONS_HH__ + +// copyright (C) 2005 derek scherger +// all rights reserved. +// licensed to the public under the terms of the GNU GPL (>= 2) +// see the file COPYING for details + +#include "app_state.hh" +#include "change_set.hh" +#include "vocab.hh" + +void extract_rearranged_paths(change_set::path_rearrangement + const & rearrangement, path_set & paths); + +void add_intermediate_paths(path_set & paths); + +void restrict_path_rearrangement(change_set::path_rearrangement const & work, + change_set::path_rearrangement & included, + change_set::path_rearrangement & excluded, + app_state & app); + +void calculate_restricted_rearrangement(app_state & app, + std::vector const & args, + manifest_id & old_manifest_id, + revision_id & old_revision_id, + manifest_map & m_old, + path_set & old_paths, + path_set & new_paths, + change_set::path_rearrangement & included, + change_set::path_rearrangement & excluded); + +void calculate_restricted_revision(app_state & app, + std::vector const & args, + revision_set & rev, + manifest_map & m_old, + manifest_map & m_new, + change_set::path_rearrangement & excluded); + +void calculate_restricted_revision(app_state & app, + std::vector const & args, + revision_set & rev, + manifest_map & m_old, + manifest_map & m_new); + +void calculate_unrestricted_revision(app_state & app, + revision_set & rev, + manifest_map & m_old, + manifest_map & m_new); + +void calculate_restricted_change_set(app_state & app, + std::vector const & args, + change_set const & cs, + change_set & included, + change_set & excluded); + +#endif // header guard