amp 0.5.2 → 0.5.3

data/lib/amp/repository/mercurial/repo_format/tag_manager.rb

@@ -0,0 +1,322 @@
+module Amp
+  module Repositories
+    module Mercurial
+      
+      ##
+      # = TagManager
+      # This module handles all tag-related (but not branch tag) functionality
+      # of the repository. 
+      module TagManager
+        include Amp::Mercurial::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 ||= nil)
+          @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 ||= nil)
+          
+          global_tags, tag_types = {}, {}
+          
+          f = 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.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
+            staging_area.add(".hgtags")
+          end
+          
+          tag_node = commit :modified => [".hgtags"], 
+                            :message => opts[:message], 
+                            :user => opts[:user],
+                            :date => opts[:date],
+                            :parents => [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.include?(an), (!ah.include?(bn) || bh.size > ah.size)].all?
+              an = bn
+            end
+            ah += bh.select {|n| !ah.include?(n) }
+            global_tags[k] = an, ah
+            tag_types[k] = tag_type
+          end
+        end
+      end
+    end
+  end
+end

data/lib/amp/repository/mercurial/repo_format/updatable.rb

@@ -0,0 +1,543 @@
+module Amp
+  module Repositories
+    module Mercurial
+      
+      ##
+      # This module contains all the code that makes a repository able to
+      # update its working directory.
+      module Updatable
+        include Amp::Mercurial::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.changed_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.changed_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.changed_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)
+          #p [working_changeset, parent2, parent_ancestor] # KILLME
+          ## 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.all_files.include?(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} #{target_changeset[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_entry
+          remote_manifest = remote.manifest_entry
+          ancestor_manifest = ancestor.manifest_entry
+          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 m == a ? n : m
+            end
+            
+            return m if m && m.any? && m != a # changed from a to m
+            return n if n && 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::Mercurial::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]]
+              else # case 2 A,B/B/B, # case 4,21 A/B/B
+                act["local copied to #{file2}", :merge, file, file2, file, # or local moved to
+                    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
+        
+        ##
+        # Compare two actions in the update action list
+        #
+        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 }
+          
+          moves = scan_for_merges actions, working_changeset, target_changeset
+          
+          # 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
+        
+        ##
+        # Add merges in the action list to the merge state.
+        #
+        # @param [Array<Object>] actions 
+        def scan_for_merges(actions, working_changeset, target_changeset)
+          moves = []
+          # prescan for merges in the list of actions.
+          actions.select {|act| act[1] == :merge}.each do |a|
+            # destructure the list
+            file, action, file2, filename_dest, flags, move = a
+            UI.debug("preserving #{file} for resolve of #{filename_dest}")
+            # look up our changeset for the merge state entry
+            vf_local = working_changeset[file] 
+            vf_other = target_changeset[file2]
+            vf_base  = vf_local.ancestor(vf_other) || versioned_file(file, :file_id => NULL_REV)
+            # track this merge!
+            merge_state.add(vf_local, vf_other, vf_base, filename_dest, flags) 
+            
+            moves << file if file != filename_dest && move
+          end
+          moves
+        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
+end