amp 0.5.2 → 0.5.3

data/lib/amp/repository/tag_manager.rb

@@ -1,319 +0,0 @@
-module Amp
-  module Repositories
-    ##
-    # = TagManager
-    # This module handles all tag-related (but not branch tag) functionality
-    # of the repository. 
-    module TagManager
-      include Amp::RevlogSupport::Node
-      
-      TAG_FORBIDDEN_LETTERS = ":\r\n"
-      ##
-      # Returns a list of all the tags as a hash, mapping each tag to the tip-most
-      # changeset it applies to.
-      #
-      # @return [Hash] a hash, sorted by revision index (i.e. its order in the commit
-      #   history), with the keys:
-      #   :revision => the revision index of the changeset,
-      #   :tag => the name of the tag,
-      #   :node => the node-id of the changeset
-      def tag_list
-        list = []
-        tags.each do |tag, node|
-          begin
-            r = changelog.revision(node)
-          rescue
-            r = -2
-          end
-          list << {:revision => r, :tag => tag, :node => node}
-        end
-        list.sort {|i1, i2| i1[:revision] <=> i2[:revision] }
-      end
-      
-      ##
-      # Returns the tag-type of the given tag. This could be "local", which means it is
-      # not shared among repositories.
-      #
-      # @param [String] tag_name the name of the tag to lookup, such as "tip"
-      # @return [String] the type of the requested tag, such as "local".
-      def tag_type(tag_name)
-        tags #load the tags
-        @tags_type_cache[tag_name]
-      end
-      
-      ##
-      # Returns the tags for a given revision (by ID).
-      #
-      # @param [String] node the node-ID, in binary form.
-      # @return [Array<String>] a list of tags for the given node.
-      def tags_for_node(node)
-        return (@tags_for_node_cache[node] || []) if @tags_for_node_cache
-        @tags_for_node_cache = {}
-        tags.each do |tag, tag_node|
-          @tags_for_node_cache[tag_node] ||= [] # make sure there's an array
-          @tags_for_node_cache[tag_node] << tag # add the tag to it
-        end
-        @tags_for_node_cache[node] || []
-      end
-      
-      ##
-      # Invalidates the tag cache. Removes all ivars relating to tags.
-      def invalidate_tag_cache!
-        @tags_for_node_cache = nil
-        @tags_cache = nil
-        @tags_type_cache = nil
-      end
-      
-      ##
-      # Loads all of the tags from the tag-cache file stored as .hgtags. Returns
-      # a hash, mapping tag names to node-IDs.
-      #
-      # @return [Hash] a hash mapping tags to node-IDs.
-      def tags
-        return @tags_cache if @tags_cache
-        
-        global_tags, tag_types = {}, {}
-        
-        file = nil
-        # For each current .hgtags file in our history (including multi-heads), read in
-        # the tags
-        hg_tags_nodes.each do |rev, node, file_node|
-          # get the file
-          f = (f && f.file(file_node)) || self.versioned_file(".hgtags", :file_id => file_node.file_node)
-          # read the tags, as global, because they're versioned.
-          read_tags(f.data.split("\n"), f, "global", global_tags, tag_types)
-        end
-        
-        # Now do locally stored tags, that aren't committed/versioned
-        begin
-          # get the local file, stored in .hg/
-          data = @hg_opener.read("localtags")
-          # Read the tags as local, because they are not versioned
-          read_tags(data.split_newlines,"local_tags","local",global_tags, tag_types)
-        rescue Errno::ENOENT
-          # do nothing. most people don't have this file.
-        end
-        # Save our tags for use later. Use ivars.
-        @tags_cache = {}
-        @tags_type_cache = {}
-        # Go through the global tags to store them in the cache
-        global_tags.each do |k, nh|
-          # the node ID is the first part of the stored data
-          n = nh.first
-          
-          # update the cache
-          @tags_cache[k] = n unless n == NULL_ID
-          @tags_type_cache[k] = tag_types[k]
-        end
-        
-        # tip = special tag
-        @tags_cache["tip"] = self.changelog.tip
-        
-        # return our tags
-        @tags_cache
-      end
-      
-      ##
-      # Adds the given tag to a given changeset, and commits to preserve it.
-      #
-      # @param [String, Array] names a list of tags (or just 1 tag) to apply to
-      #   the changeset
-      # @param [String, Integer] node the node to apply the tag to
-      # @param [Hash] opts the opts for tagging
-      # @option [String] opts message ("added tag _tag_ to changeset _node_") 
-      #   the commit message to use. 
-      # @option [Boolean] opts local (false) is the tag a local one? I.E., will it be
-      #   shared across repos?
-      # @option [String] opts user ($USER) the username to apply for the commit
-      # @option [Time] opts time (Time.now) what should the commit-time be marked as?
-      # @option [String] opts parent (nil) The parent revision of the one we
-      #   are tagging. or something.
-      # @option [Hash] opts extra ({}) the extra data to apply for the commit.
-      def apply_tag(names, node, opts={})
-        use_dirstate = opts[:parent].nil?
-        all_letters  = names.kind_of?(Array) ? names.join : names
-        (TAG_FORBIDDEN_LETTERS.size-1).downto 0 do |i|
-          if all_letters.include? TAG_FORBIDDEN_LETTERS[i, 1]
-            raise abort("#{TAG_FORBIDDEN_LETTERS[i,1]} not allowed in a tag name!")
-          end
-        end
-        
-        prev_tags = ""
-        # If it's a local tag, we just write the file and bounce. mad easy yo.
-        if opts[:local]
-          @hg_opener.open("localtags","r+") do |fp|
-            prev_tags = fp.read
-            write_tags(fp,names, nil, prev_tags)
-          end
-          return
-        end
-        
-        # ok, it's a global tag. now we have to handle versioning and shit.
-        if use_dirstate
-          prev_tags = working_read(".hgtags") rescue ""
-          file = @file_opener.open(".hgtags","a")
-        else
-          prev_tags = versioned_file(".hgtags", :change_id => parent).data
-          file = @file_opener.open(".hgtags","w")
-          
-          file.write prev_tags if prev_tags && prev_tags.any?
-        end
-        
-        write_tags(file, node, names, prev_tags)
-        file.close
-        if use_dirstate && dirstate[".hgtags"].status == :untracked
-          self.add([".hgtags"])
-        end
-        
-        tag_node = commit :files => [".hgtags"], 
-                          :message => opts[:message], 
-                          :user => opts[:user],
-                          :date => opts[:date], 
-                          :p1 => opts[:parent], 
-                          :extra => opts[:extra]
-        
-        tag_node
-      end
-      
-      private
-      
-      ##
-      # Goes through all the heads in the repository, getting the state of the .hgtags
-      # file at each head. We then return a list, with each entry mapping revision index
-      # and node ID to the .hgtags file at that head. If two different heads have the same
-      # .hgtags file, only 1 is returned with it.
-      #
-      # @return [[Fixnum, String, VersionedFile]] each head with a different .hgtags file
-      #   at that point. That way we have the most recent copy of .hgtags, even if the file
-      #   differs on different heads.
-      def hg_tags_nodes
-        heads = self.heads.reverse
-        last = {}
-        return_list = []
-        heads.each do |node|
-          changeset = self[node]
-          rev = changeset.revision
-          begin
-            file_node = changeset.get_file(".hgtags")
-          rescue
-            next
-          end
-          return_list << [rev, node, file_node]
-          return_list[last[file_node]] = nil if last[file_node] # replace old head
-          
-          last[file_node] = return_list.size - 1
-        end
-        return return_list.reject {|item| item.nil?}
-      end
-      
-      ##
-      # Writes the tags to the given stream. This method must be aware of previously
-      # written tags. Also, any new tags must state what the node to use for writing is.
-      #
-      # @param [IO, #write] file the output stream to write to. Could be a file, or any IO.
-      # @param [String] node a binary node ID for any newly-added tags
-      # @param [Array] names A list of all the tag names to write
-      # @param [Hash] prev_tags the previously written string (or something)
-      def write_tags(file, node, names, prev_tags)
-        file.seek(0, IO::SEEK_END)
-        if prev_tags && prev_tags.any? && prev_tags[-1,1] != "\n"
-          file.write "\n"
-        end
-        names.each do |name|
-          if @tags_type_cache && @tags_type_cache[name]
-            old = @tags_cache[name] || NULL_ID
-            file.write("#{old.hexlify} #{name}\n")
-          end
-          file.write("#{node.hexlify} #{name}\n")
-        end
-      end
-      
-      ##
-      # Reads in an .hgtags file and parses it, while respecting global tags.
-      # This is where things get kinda messy, because otherwise we'd just be parsing
-      # a simple text file. Anyway, global_tags are tags like "tip" -> the current tip
-      # - they're programmatically assigned tags.
-      #
-      # @param [Array<String>] lines the file, split into lines
-      # @param [String] fn the file that we are parsing, only for debug purposes
-      # @param [String] tag_type what kind of tag are we looking at? usually "local"
-      #   or "global" or nothing. For example, a local-only tag isn't committed - these
-      #   need to be treated differently.
-      # @param [Hash] global_tags maps nodes to global tags, such as "tip".
-      # @param [Hash] tag_types maps nodes to what type of tag they are
-      # @return [Hash] the list of tags we have read in.
-      #
-      # @todo encodings, handle local encodings
-      def read_tags(lines, fn, tag_type, global_tags, tag_types)
-        # This is our tag list we'll be building.
-        file_tags = {}
-        
-        # Each line is of the format:
-        # [char * 40, node ID] [tag]
-        # 0123456789012345678901234567890123456789 crazymerge
-        lines.each_with_index do |line, count|
-          # skip if we have no text to parse
-          next if line.nil? || line.empty?
-          
-          # split once, so we could theoretically have spaces in tag names
-          s = line.split(" ", 2)
-          # make sure we parsed the tag entry alright
-          if s.size != 2
-            UI::warn "Can't parse entry, filename #{fn} line #{count}"
-            next
-          end
-          
-          # Node comes first, tag comes second
-          node, tag = s
-          tag.strip! #TODO: encodings, handle local encodings
-          
-          # Convert to binary so we can look it up in our repo
-          bin_node = node.unhexlify
-          
-          # Is it in our repo? if not, skip to the next tag.
-          unless self.changelog.node_map[bin_node]
-            UI::warn "Tag #{key} refers to unknown node"
-            next
-          end
-          
-          # heads is a list of the nodes that have this same tag
-          heads = []
-          # have we already seen this tag?
-          if file_tags[tag]
-            # pull out the old data
-            n, heads = file_tags[tag]
-            # add our new node to the list for this tag
-            heads << n
-          end
-           # update our tag list
-          file_tags[tag] = [bin_node, heads]
-        end
-        
-        # For each tag that we have...
-        file_tags.each do |k, nh|
-          # Is this a reserved, global tag? Or, just one that's been used already? 
-          # like "tip"? if not, we're ok
-          unless global_tags[k]
-            # update global_tags with our new tag
-            global_tags[k] = nh
-            # set the tag_types hash as well
-            tag_types[k] = tag_type
-            next
-          end
-          # we prefer the global tag if:
-          #  it supercedes us OR
-          #  mutual supercedes and it has a higher rank
-          # otherwise we win because we're tip-most
-          an, ah = nh
-          bn, bh = global_tags[k]
-          if [bn != an, bh[an], (!ah[bn] || bh.size > ah.size)].all?
-            an = bn
-          end
-          ah += bh.select {|n| !ah[n]}
-          global_tags[k] = an, ah
-          tag_types[k] = tag_type
-        end
-      end
-    end
-  end
-end

data/lib/amp/repository/updatable.rb

@@ -1,532 +0,0 @@
-module Amp
-  module Repositories
-    
-    ##
-    # This module contains all the code that makes a repository able to
-    # update its working directory.
-    module Updatable
-      include Amp::RevlogSupport::Node
-      
-      ##
-      # Updates the repository to the given node. One of the major operations on a repository.
-      # This will update the working directory to the given node.
-      #
-      # @todo add lock
-      # @param [String, Integer] node the revision to which we are updating the repository. Can
-      #   be either nil, a node ID, or an integer. If it is nil, it will update
-      #   to the latest revision.
-      # @param [Boolean] branch_merge whether to merge between branches
-      # @param [Boolean] force whether to force branch merging or file overwriting
-      # @param [Proc, #call] partial a function to filter file lists (dirstate not updated if this
-      #   is passed)
-      # @return [Array<Integer>] a set of statistics about the update. In the form:
-      #   [updated, merged, removed, unresolved] where each entry is the # of files in that category.
-      def update(node=nil, branch_merge=false, force=false, partial=nil)
-        # debugger
-        self.status(:node_1 => self.dirstate.parents.first, :node_2 => nil)
-        working_changeset = self[nil]
-        # tip of current branch
-        node ||= branch_tags[working_changeset.branch]
-        node = self.lookup("tip") if node.nil? && working_changeset.branch == "default"
-        if node.nil?
-          raise abort("branch #{working_changeset.branch} not found")
-        end
-        
-        overwrite = force && !branch_merge
-        parent_list = working_changeset.parents
-        parent1, parent2 = parent_list.first, self[node]
-        parent_ancestor = parent1.ancestor(parent2)
-        
-        fp1, fp2, xp1, xp2 = parent1.node, parent2.node, parent1.to_s, parent2.to_s
-        fast_forward = false
-        
-        ## In this section, we make sure that we can actually do an update.
-        ## No use starting an udpate if we can't finish!
-        
-        if !overwrite && parent_list.size > 1
-          raise abort("outstanding uncommitted merges")
-        end
-        
-        if branch_merge
-          if parent_ancestor == parent2
-            raise abort("can't merge with ancestor")
-          elsif parent_ancestor == parent1
-            if parent1.branch != parent2.branch
-              fast_forward = true
-            else
-              raise abort("nothing to merge (use 'hg update' or check"+
-                                   " 'hg heads')")
-            end
-          end
-          if !force && (working_changeset.files.any? || working_changeset.deleted.any?)
-            raise abort("oustanding uncommitted changes")
-          end
-        elsif !overwrite
-          if parent_ancestor == parent1 || parent_ancestor == parent2
-            # do nothing
-          elsif parent1.branch == parent2.branch
-            if working_changeset.files.any? || working_changeset.deleted.any?
-              raise abort("crosses branches (use 'hg merge' or "+
-                                   "'hg update -C' to discard changes)")
-            end
-            raise abort("crosses branches (use 'hg merge' or 'hg update -C')")
-          elsif working_changeset.files.any? || working_changeset.deleted.any?
-            raise abort("crosses named branches (use 'hg update -C'"+
-                                 " to discard changes)")
-          else
-            overwrite = true
-          end
-        end
-        
-        ## Alright, now let's figure out exactly what we have to do to make this update.
-        ## Shall we?
-        
-        actions = []
-        check_unknown(working_changeset, parent2) if force
-        check_collision(parent2) if false # case-sensitive file-system? seriously?
-        
-        actions += forget_removed(working_changeset, parent2, branch_merge)
-        actions += manifest_merge(working_changeset, parent2, parent_ancestor, 
-                                  overwrite, partial)
-                                  
-        ## Apply phase - apply the changes we just generated.
-        unless branch_merge # just jump to the new revision
-          fp1, fp2, xp1, xp2 = fp2, NULL_ID, xp2, ''
-        end
-        unless partial
-          run_hook :preupdate, :throw => true, :parent1 => xp1, :parent2 => xp2
-        end
-
-        stats = apply_updates(actions, working_changeset, parent2)
-        
-        unless partial
-          record_updates(actions, branch_merge)
-          dirstate.parents = [fp1, fp2]
-          if !branch_merge && !fast_forward
-            dirstate.branch = parent2.branch
-          end
-          run_hook :update, :parent1 => xp1, :parent2 => xp2, :error => stats[3]
-          dirstate.write
-        end
-        
-        return stats
-          
-      end
-      
-      ##
-      # Merge two heads
-      def merge(node, force=false)
-        update node, true, force, false
-      end
-      
-      ##
-      # Updates the repository to the given node, clobbering (removing) changes
-      # along the way. This has the effect of turning the working directory into
-      # a pristine copy of the requested changeset. Really just a nice way of
-      # skipping some arguments for the caller.
-      #
-      # @param [String] node the requested node
-      def clean(node)
-        update node, false, true, nil
-      end
-      
-      private
-      
-      ##
-      # This method will make sure that there are no differences between
-      # untracked files in the working directory, and tracked files in
-      # the new changeset. 
-      #
-      # @param [WorkingDirectoryChangeset] working_changeset the current working directory
-      # @param [Changeset] target_changeset the destination changeset (that we're updating to)
-      # @raise [AbortError] if an untracked file in the working directory is different from
-      #   a tracked file in the target changeset, this abort error will be raised.
-      def check_unknown(working_changeset, target_changeset)
-        working_changeset.unknown.each do |file|
-          if target_changeset[file] && target_changeset[file].cmp(working_changeset[file].data())
-            raise abort("Untracked file in the working directory differs from "+
-                                 "a tracked file in the requested revision: #{file}")
-          end
-        end
-      end
-      
-      ##
-      # This method will check if the target changeset will cause name collisions
-      # when filenames are changed to all lower-case. This is important because
-      # in the store, the file-logs are all changed to lower-case.
-      #
-      # @param [Changeset] target_changeset the destination changeset (that we're updating to)
-      # @raise [AbortError] If two files have the same lower-case name, in 1 changeset,
-      #   this error will be thrown.
-      def check_collision(target_changeset)
-        folded_names = {}
-        target_changeset.each do |file|
-          folded = file.downcase
-          if folded_names[folded]
-            raise abort("Case-folding name collision between #{folded_names[folded]} and #{file}.")
-          end
-          folded_names[folded] = file
-        end
-      end
-      
-      ##
-      # Forget removed files (docs ripped from mercurial)
-      # 
-      # If we're jumping between revisions (as opposed to merging), and if
-      # neither the working directory nor the target rev has the file,
-      # then we need to remove it from the dirstate, to prevent the
-      # dirstate from listing the file when it is no longer in the
-      # manifest.
-      # 
-      # If we're merging, and the other revision has removed a file
-      # that is not present in the working directory, we need to mark it
-      # as removed.
-      #
-      # @param [WorkingDirectoryChangeset] working_changeset the current working directory
-      # @param [Changeset] target_changeset the destination changeset (that we're updating to)
-      # @param [Boolean] branch_merge whether or not to delete working files
-      # @return [[String, Symbol]] a list of actions that should be taken to complete
-      #   a successful transition from working_changeset to target_changeset.
-      def forget_removed(working_changeset, target_changeset, branch_merge)
-        action_list = []
-        action = branch_merge ? :remove : :forget
-        working_changeset.deleted.each do |file|
-          action_list << [file, action] unless target_changeset[file]
-        end
-        
-        unless branch_merge
-          working_changeset.removed.each do |file|
-            action_list << [file, :forget] unless target_changeset[file]
-          end
-        end
-        
-        action_list
-      end
-      
-      ##
-      # Merge the local working changeset (local), and the target changeset (remote),
-      # using the common ancestor (ancestor). Generates a merge action list to update
-      # the manifest.
-      #
-      # @param [Changeset] local The working-directory changeset we're merging from
-      # @param [Changeset] remote The target changeset we need to merge to
-      # @param [Changeset] ancestor A common ancestor between the 2 parents
-      # @param [Boolean] overwrite Can we delete working files?
-      # @param [Proc] partial a function to filter file lists
-      # @return [[String, Symbol]] A list of actions that should be taken to complete
-      #   a successful transition from local to remote.
-      def manifest_merge(local, remote, ancestor, overwrite, partial)
-        UI::status("resolving manifests")
-        UI::debug(" overwrite #{overwrite} partial #{partial}")
-        UI::debug(" ancestor #{ancestor} local #{local} remote #{remote}")
-        
-        local_manifest = local.manifest
-        remote_manifest = remote.manifest
-        ancestor_manifest = ancestor.manifest
-        backwards = (ancestor == remote)
-        action_list = []
-        copy, copied, diverge = {}, {}, {}
-        
-        flag_merge = lambda do |file_local, file_remote, file_ancestor|
-          file_remote = file_ancestor = file_local unless file_remote
-          
-          a = ancestor_manifest.flags[file_ancestor]
-          m = local_manifest.flags[file_local]
-          n = remote_manifest.flags[file_remote]
-          
-          return m if m == n # flags are identical, we're fine
-          
-          if m.any? && n.any?
-            unless a.any? # i'm so confused, ask the user what the flag should be!
-              r = UI.ask("conflicting flags for #{file_local} (n)one, e(x)ec, or "+
-                            "sym(l)ink?")
-              return (r != "n") ? r : ''
-            end
-            return n if m == a # changed from m to n
-            return m # changed from n to m
-          end
-          
-          return m if m.any? && m != a # changed from a to m
-          return n if n.any? && n != a # changed from a to n
-          return '' #no more flag
-        end
-        
-        act = lambda do |message, move, file, *args|
-          UI::debug(" #{file}: #{message} -> #{move}")
-          action_list << [file, move] + args
-        end
-        
-        if ancestor && !(backwards || overwrite)
-          if @config["merge", "followcopies", Boolean, true]
-            dirs = @config["merge", "followdirs", Boolean, false] # don't track directory renames
-            copy, diverge = Amp::Graphs::CopyCalculator.find_copies(self, local, remote, ancestor, dirs)
-          end
-          copied = Hash.with_keys(copy.values)
-          diverge.each do |of, fl|
-            act["divergent renames", :divergent_rename, of, fl]
-          end
-        end
-        
-        # Compare manifests
-        local_manifest.each do |file, node|
-          next if partial && !partial[file]
-          
-          if remote_manifest[file]
-            rflags = (overwrite || backwards) ? remote_manifest.flags[file] : flag_merge[file,nil,nil]
-            # Are files different?
-            if node != remote_manifest[file]
-              anc_node = ancestor_manifest[file] || NULL_ID
-              
-              if overwrite # Can we kill the file?
-                act["clobbering", :get, file, rflags]
-              elsif backwards # Or are we going back in time and cleaning?
-                if !(node[20..-1]) || !(remote[file].cmp(local[file].data))
-                  act["reverting", :get, file, rflags]
-                end
-              elsif node != anc_node && remote_manifest[file] != anc_node
-                # are both nodes different from the ancestor?
-                act["versions differ", :merge, file, file, file, rflags, false]
-              elsif remote_manifest[file] != anc_node
-                # is remote's version newer?
-                act["remote is newer", :get, file, rflags]
-              elsif local_manifest.flags[file] != rflags
-                # local is newer, not overwrite, check mode bits (wtf does this mean)
-                act["update permissions", :exec, file, rflags]
-              end
-            elsif local_manifest.flags[file] != rflags
-              act["update permissions", :exec, file, rflags]
-            end
-          elsif copied[file]
-            next
-          elsif copy[file]
-            file2 = copy[file]
-            if !remote_manifest[file2] #directory rename
-              act["remote renamed directory to #{file2}", :d, file, nil, file2, local_manifest.flags[file]]
-            elsif local_manifest[file2] # case 2 A,B/B/B
-              act["local copied to #{file2}", :merge, file, file2, file, 
-                  flag_merge[file, file2, file2], false]
-            else # case 4,21 A/B/B
-              act["local moved to #{file2}", :merge, file, file2, file,
-                  flag_merge[file, file2, file2], false]
-            end
-          elsif ancestor_manifest[file]
-            if node != ancestor_manifest[file] && !overwrite
-              if UI.ask("local changed #{file} which remote deleted\n" +
-                        "use (c)hanged version or (d)elete?") == "d"
-                act["prompt delete", :remove, file]
-              else
-                act["prompt keep", :add, file]
-              end
-            else
-              act["other deleted", :remove, file]
-            end
-          else
-            if (overwrite && node[20..-1] != "u") || (backwards && node[20..-1].empty?)
-              act["remote deleted", :remove, file]
-            end
-          end   
-        end
-        
-        remote_manifest.each do |file, node|
-          next if partial && !(partial[file])
-          next if local_manifest[file]
-          next if copied[file]
-          if copy[file]
-            file2 = copy[file]
-            if !(local_manifest[file2])
-              act["local renamed directory to #{file2}", :directory, nil, file,
-                  file2, remote_manifest.flags[file]]
-            elsif remote_manifest[file2]
-              act["remote copied to #{file}", :merge, file2, file, file,
-                  flag_merge[file2, file, file2], false]
-            else
-              act["remote moved to #{file}", :merge, file2, file, file,
-                  flag_merge[file2, file, file2], true]
-            end
-          elsif ancestor_manifest[file]
-            if overwrite || backwards
-              act["recreating", :get, file, remote_manifest.flags[file]]
-            elsif node != ancestor_manifest[file]
-              if UI.ask("remote changed #{file} which local deleted\n" +
-                        "use (c)hanged version or leave (d)eleted?") == "c"
-                act["prompt recreating", :get, file, remote_manifest.flags[file]]
-              end
-            end
-          else
-            act["remote created", :get, file, remote_manifest.flags[file]]
-          end
-        end
-        
-        action_list
-      end
-      
-      def action_cmp(action1, action2)
-        move1 = action1[1] # action out of the tuple
-        move2 = action2[1] # action out of the tuple
-        
-        return action1 <=> action2 if move1 == move2
-        return -1 if move1 == :remove
-        return 1  if move2 == :remove
-        return action1 <=> action2
-      end
-      
-      ##
-      # Apply the merge action list to the working directory, in order to migrate from
-      # working_changeset to target_changeset.
-      #
-      # @todo add path auditor
-      # @param [Array<Array>] actions list of actions to take to migrate from {working_changeset} to
-      #   {target_changeset}.
-      # @param [WorkingDirectoryChangeset] working_changeset the current changeset in the repository
-      # @param [Changeset] target_changeset the changeset we are updating the working directory to.
-      # @return [Hash] Statistics about the update. Keys are:
-      #   :updated => files that were changed
-      #   :merged  => files that were merged
-      #   :removed => files that were removed
-      #   :unresolved => files that had conflicts when merging that we couldn't fix
-      def apply_updates(actions, working_changeset, target_changeset)
-        updated, merged, removed, unresolved = [], [], [], []
-        merge_state.reset(working_changeset.parents.first.node)
-        
-        moves = []
-        actions.sort! {|a1, a2| action_cmp a1, a2 }
-        
-        # prescan for merges in the list of actions.
-        actions.each do |a|
-          file, action = a[0], a[1]
-          if action == :merge # ah ha! a merge.
-            file2, filename_dest, flags, move = a[2..-1] # grab some info about it
-            UI.debug("preserving #{file} for resolve of #{filename_dest}")
-            vf_local = working_changeset[file] # look up our changesets we'll need later
-            vf_other = target_changeset[file2]
-            vf_base  = vf_local.ancestor(vf_other) || versioned_file(file, :file_id => NULL_REV)
-            merge_state.add(vf_local, vf_other, vf_base, filename_dest, flags) # track this merge!
-            
-            moves << file if file != filename_dest && move
-          end
-        end
-        
-        # If we're moving any files, we can remove renamed ones now
-        moves.each do |file|
-          if File.amp_lexist?(working_join(file))
-            UI.debug("removing #{file}")
-            File.unlink(working_join(file))
-          end
-        end
-        
-        # TODO: add path auditor
-        
-        actions.each do |action|
-          file, choice = action[0], action[1]
-          next if file && file[0,1] == "/"
-          case choice
-          when :remove
-            UI.note "removing #{file}"
-            File.unlink(working_join(file))
-            removed << file
-          when :merge
-            file2, file_dest, flags, move = action[2..-1]
-            result = merge_state.resolve(file_dest, working_changeset, target_changeset)
-            
-            unresolved << file if result
-            updated    << file if result.nil?
-            merged     << file if result == false
-            
-            File.amp_set_executable(working_join(file_dest), flags && flags.include?('x'))
-            if (file != file_dest && move && File.amp_lexist?(working_join(file)))
-              UI.debug("removing #{file}")
-              File.unlink(working_join(file))
-            end
-          when :get
-            flags = action[2]
-            UI.note("getting #{file}")
-            data = target_changeset.get_file(file).data
-            working_write(file, data, flags)
-            updated << file
-          when :directory
-            file2, file_dest, flags = action[2..-1]
-            if file && file.any?
-              UI.note("moving #{file} to #{file_dest}")
-              File.move(file, file_dest)
-            end
-            if file2 && file2.any?
-              UI.note("getting #{file2} to #{file_dest}")
-              data = target_changeset.get_file(file2).data
-              working_write(file_dest, data, flags)
-            end
-            updated << file
-          when :divergent_rename
-            filelist = action[2]
-            UI.warn("detected divergent renames of #{f} to:")
-            filelist.each {|fn| UI.warn fn }
-          when :exec
-            flags = action[2]
-            File.amp_set_executable(working_join(file), flags.include?('x'))
-          end
-          
-        end
-        
-        hash = {:updated    => updated    ,
-                :merged     => merged     ,
-                :removed    => removed    ,
-                :unresolved => unresolved }
-                
-        class << hash
-          def success?; self[:unresolved].empty?; end
-        end
-        
-        hash
-      end
-      
-      ##
-      # Records all the updates being made while merging to the new working directory.
-      # It records them by writing to the dirstate.
-      #
-      # @param [Array<Array>] actions a list of actions to take
-      # @param [Boolean] branch_merge is this a branch merge?
-      def record_updates(actions, branch_merge)
-        actions.each do |action|
-          file, choice = action[0], action[1]
-          case choice
-          when :remove
-            branch_merge and dirstate.remove(file) or dirstate.forget(file)
-          when :add
-            dirstate.add file unless branch_merge
-          when :forget
-            dirstate.forget file
-          when :get
-            branch_merge and dirstate.dirty(file) or dirstate.normal(file)
-          when :merge
-            file2, file_dest, flag, move = action[2..-1]
-            if branch_merge
-              dirstate.merge(file_dest)
-              if file != file2 #copy/rename
-                dirstate.remove file if move
-                dirstate.copy(file,  file_dest) if file != file_dest
-                dirstate.copy(file2, file_dest) if file == file_dest
-              end
-            else
-              dirstate.maybe_dirty(file_dest)
-              dirstate.forget(file) if move
-            end
-          when :directory
-            file2, file_dest, flag = action[2..-1]
-            next if !file2 && !(dirstate.include?(file))
-            
-            if branch_merge
-              dirstate.add file_dest
-              if file && file.any?
-                dirstate.remove file
-                dirstate.copy file, file_dest
-              end
-              dirstate.copy file2, file_dest if file2 && file2.any?
-            else
-              dirstate.normal file_dest
-              dirstate.forget file if file && file.any?
-            end
-          end
-        end
-      end
-    end
-  end
-end