amp 0.5.2 → 0.5.3

data/lib/amp/merges/simple_merge.rb

@@ -1,450 +0,0 @@
-module Amp
-  module Merges
-    
-    class MergeAssertion < StandardError; end
-    ##
-    # SimpleMerge - basic 3-way merging
-    #
-    # This class takes 2 texts and a common ancestor text, and tries
-    # to produce a text incorporating all the changes from ancestor->local
-    # and ancestor->remote. It will produce the annoying >>>>>> ====== <<<<<
-    # markers just like mercurial/cvs does.
-    #
-    # For the record, for any methods that don't have comments in the code, I
-    # have an excuse: I don't understand the code.
-    #
-    # p.s. threeway. hehe. three way.
-    class ThreeWayMerger
-      
-      def assert(val, msg="Assertion failed")
-        raise MergeAssertion.new(msg) unless val
-      end
-      
-      # Have there been any conflicts in the merge?
-      attr_accessor :conflicts
-      
-      ##
-      # Performs a 3-way merge on the 3 files provided. Saves the merged file over the
-      # local file. This basically handles the file juggling while applying the instance
-      # methods to do merging.
-      #
-      # @param [String] local path to the original local file
-      # @param [String] base path to a (temporary) base file
-      # @param [String] other path to a (temporary) target file
-      # @param [Hash] opts additional options for merging
-      # @return [Boolean] were there conflicts during the merge?
-      def self.three_way_merge(local, base, other, opts={})
-        name_a = local
-        name_b = other
-        labels = opts[:labels] || []
-        
-        name_a = labels.shift if labels.any?
-        name_b = labels.shift if labels.any?
-        raise abort("You can only specify 2 labels") if labels.any?
-        
-        local_text = read_file local
-        base_text  = read_file base
-        other_text = read_file other
-        local = Pathname.new(local).realpath
-        unless opts[:print]
-          # special temp name for our new merged file
-          newname = File.amp_make_tmpname local
-          out     = File.open newname, "w"
-          
-          # add rename method to this object to do atomicity
-          def out.rename(local, newname)
-            self.close
-            File.unlink(local)
-            File.move(newname, local)
-          end
-        else
-          out = STDOUT
-        end
-        
-        reprocess = !opts[:no_minimal]
-        merger = ThreeWayMerger.new(base_text, local_text, other_text)
-        merger.merge_lines(:name_a => name_a, :name_b => name_b, :reprocess => reprocess) do |line|
-          out.write line
-        end
-        
-        out.rename(local, newname) unless opts[:print]
-        
-        if merger.conflicts
-          unless opts[:quiet]
-            UI.warn("conflicts during merge.")
-          end
-          return true # yes conflicts
-        end
-        
-        false # no conflicts
-      end
-      
-      ##
-      # Initializes the merger object with the 3 necessary texts, as well as
-      # subsections to merge (if we don't want to merge the entire texts).
-      #
-      # @param [String] base_text the common ancestor text, from which we
-      #   are merging changes
-      # @param [String] a_text one descendent text - typically the local copy
-      #   of the file
-      # @param [String] b_text the other descendent text - typically a copy
-      #   committed by somebody else.
-      # @param [String] base_subset (base_text.split_newlines) the subsection
-      #   of the common ancestor we are concerned with (if not merging full texts)
-      # @param [String] a_subset (a_text.split_newlines) the subsection
-      #   of the first text we are concerned with (if not merging full texts)
-      # @param [String] b_subset (b_text.split_newlines) the subsection
-      #   of the second text we are concerned with (if not merging full texts)
-      def initialize(base_text, a_text, b_text, base=nil, a=nil, b=nil)
-        @base_text, @a_text, @b_text = base_text, a_text, b_text
-        @base = base || @base_text.split_lines_better
-        @a    = a    || @a_text.split_lines_better
-        @b    = b    || @b_text.split_lines_better
-      end
-      
-      ##
-      # Merges the texts in a CVS-like form. The start_marker, mid_markers, and end_marker
-      # arguments are used to delimit conflicts. Yields lines - doesn't return anything.
-      #
-      # @yield the merged lines
-      # @yieldparam [String] line 1 line that belongs in the merged file.
-      def merge_lines(opts = {})
-        defaults = {:name_a => nil, :name_b => nil, :name_base => nil,
-                    :start_marker => "<<<<<<<", :mid_marker => "=======", 
-                    :end_marker => ">>>>>>>", :base_marker => nil, :reprocess => false}
-        opts = defaults.merge(opts)
-        
-        @conflicts = false # no conflicts yet!
-        # Figure out what our newline character is (silly windows)
-        newline = "\n"
-        if @a.size > 0
-          newline = "\r\n" if @a.first.end_with?("\r\n")
-          newline = "\r"   if @a.first.end_with?("\r")
-        end
-        
-        if opts[:base_marker] && opts[:reprocess]
-          raise ArgumentError.new("Can't reprocess and show base markers!")
-        end
-        
-        # Add revision names to the markers
-        opts[:start_marker] += " #{opts[:name_a]}"    if opts[:name_a]
-        opts[:end_marker]   += " #{opts[:name_b]}"    if opts[:name_b]
-        opts[:base_marker]  += " #{opts[:name_base]}" if opts[:name_base] && opts[:base_marker]
-        
-        merge_method = opts[:reprocess] ? :reprocessed_merge_regions : :merge_regions
-        self.send(merge_method) do |*t|
-          status = t[0]
-          case status
-          when :unchanged
-            t[1].upto(t[2]-1) {|i| yield @base[i] } # nothing changed, use base
-          when :a, :same
-            t[1].upto(t[2]-1) {|i| yield @a[i]    } # local (A) insertion
-          when :b
-            t[1].upto(t[2]-1) {|i| yield @b[i]    } # remote (B) insertion
-          when :conflict
-            @conflicts = true # :-( we have conflicts
-            
-            yield opts[:start_marker] + newline # do the <<<<<<
-            t[3].upto(t[4]-1) {|i| yield @a[i]} # and the local copy
-            
-            if opts[:base_marker]
-              yield base_marker + newline       # do the base
-              t[1].upto(t[2]-1) {|i| yield @base[i]} # and the base lines
-            end
-            
-            yield opts[:mid_marker] + newline   # do the =====
-            t[5].upto(t[6]-1) {|i| yield @b[i]} # and the remote copy
-            yield opts[:end_marker] + newline   # and then >>>>>>
-          else
-            raise ArgumentError.new("invalid region: #{status.inspect}")
-          end
-        end
-        
-      end
-      
-      ##
-      # Yield sequence of line groups.  Each one is a tuple:
-      # 
-      # :unchanged, lines
-      #      Lines unchanged from base
-      # 
-      # :a, lines
-      #      Lines taken from a
-      # 
-      # :same, lines
-      #      Lines taken from a (and equal to b)
-      # 
-      # :b, lines
-      #      Lines taken from b
-      # 
-      # :conflict, base_lines, a_lines, b_lines
-      #      Lines from base were changed to either a or b and conflict.
-      def merge_groups
-        merge_regions do |list|
-          case list[0]
-          when :unchanged
-            yield list[0], @base[list[1]..(list[2]-1)]
-          when :a, :same
-            yield list[0],    @a[list[1]..(list[2]-1)]
-          when :b
-            yield list[0],    @b[list[1]..(list[2]-1)]
-          when :conflict
-            yield list[0], @base[list[1]..(list[2]-1)],
-                              @a[list[3]..(list[4]-1)],
-                              @b[list[5]..(list[6]-1)]
-          else
-            raise ArgumentError.new(list[0])
-          end
-        end
-      end
-      
-      ##
-      # Yield sequences of matching and conflicting regions.
-      # 
-      # This returns tuples, where the first value says what kind we
-      # have:
-      # 
-      # 'unchanged', start, end
-      #      Take a region of base[start:end]
-      # 
-      # 'same', astart, aend
-      #      b and a are different from base but give the same result
-      # 
-      # 'a', start, end
-      #      Non-clashing insertion from a[start:end]
-      # 
-      # Method is as follows:
-      # 
-      # The two sequences align only on regions which match the base
-      # and both descendents.  These are found by doing a two-way diff
-      # of each one against the base, and then finding the
-      # intersections between those regions.  These "sync regions"
-      # are by definition unchanged in both and easily dealt with.
-      # 
-      # The regions in between can be in any of three cases:
-      # conflicted, or changed on only one side.
-      #
-      # @yield Arrays of regions that require merging
-      def merge_regions
-        ##     NOTE: we use "z" as an abbreviation for "base" or the "ancestor", because
-        #      we can't very well abbreviate "ancestor" as "a" or "base" as "b".
-        idx_z = idx_a = idx_b = 0
-        
-        find_sync_regions.each do |match|
-          z_match, z_end = match[:base_start], match[:base_end]
-          a_match, a_end = match[:a_start   ], match[:a_end   ]
-          b_match, b_end = match[:b_start   ], match[:b_end   ]
-          
-          match_len = z_end - z_match
-          assert match_len >= 0
-          assert match_len == (a_end - a_match), "expected #{match_len}, got #{(a_end - a_match)} (#{a_end} - #{a_match})"
-          assert match_len == (b_end - b_match)
-          
-          len_a = a_match - idx_a
-          len_b = b_match - idx_b
-          len_base = z_match - idx_z
-          assert len_a >= 0
-          assert len_b >= 0
-          assert len_base >= 0
-          
-          if len_a > 0 || len_b > 0
-            equal_a = compare_range(@a, idx_a, a_match, @base, idx_z, z_match)
-            equal_b = compare_range(@b, idx_b, b_match, @base, idx_z, z_match)
-            same    = compare_range(@a, idx_a, a_match, @b,    idx_b, b_match)
-            
-            if same
-              yield :same, idx_a, a_match
-            elsif equal_a && !equal_b
-              yield :b, idx_b, b_match
-            elsif equal_b && !equal_a
-              yield :a, idx_a, a_match
-            elsif !equal_a && !equal_b
-              yield :conflict, idx_z, z_match, idx_a, a_match, idx_b, b_match
-            else
-              raise AssertionError.new("can't handle a=b=base but unmatched!")
-            end
-            
-            idx_a = a_match
-            idx_b = b_match
-          end
-          idx_z = z_match
-          
-          if match_len > 0
-            assert idx_a == a_match
-            assert idx_b == b_match
-            assert idx_z == z_match
-            
-            yield :unchanged, z_match, z_end
-            
-            idx_a = a_end
-            idx_b = b_end
-            idx_z = z_end
-          end
-        end
-      end
-      
-      ##
-      # Take the merge regions yielded by merge_regions, and remove lines where both A and
-      # B (local & remote) have made the same changes.
-      def reprocessed_merge_regions
-        merge_regions do |*region|
-          if region[0] != :conflict
-            yield *region
-            next
-          end
-          type, idx_z, z_match, idx_a, a_match, idx_b, b_match = region
-          a_region = @a[idx_a..(a_match-1)]
-          b_region = @b[idx_b..(b_match-1)]
-          matches = Amp::Diffs::MercurialDiff.get_matching_blocks(a_region.join, b_region.join)
-          
-          next_a = idx_a
-          next_b = idx_b
-          
-          matches[0..-2].each do |block|
-            region_ia, region_ib, region_len = block[:start_a], block[:start_b], block[:length]
-            region_ia += idx_a
-            region_ib += idx_b
-            
-            reg = mismatch_region(next_a, region_ia, next_b, region_ib)
-            
-            yield *reg if reg
-            yield :same, region_ia, region_len + region_ia
-            
-            next_a = region_ia + region_len
-            next_b = region_ib + region_len
-            
-          end
-          reg = mismatch_region(next_a, a_match, next_b, b_match)
-          yield *reg if reg
-        end
-      end
-      
-      
-      
-      ##
-      # Returns a list of sync'd regions, where both descendents match the base.
-      # Generates a list of {:base_start, :base_end, :a_start, :a_end, :b_start, :b_end}
-      #
-      # @return [Array<Hash>] A list of sync regions, each stored as a hash, with the
-      #   keys {:base_start, :base_end, :a_start, :a_end, :b_start, :b_end}. There is
-      #   always a zero-length sync region at the end of any file (because the EOF always
-      #   matches).
-      def find_sync_regions
-        idx_a = idx_b = 0
-        a_matches = Amp::Diffs::MercurialDiff.get_matching_blocks(@base_text, @a_text)
-        b_matches = Amp::Diffs::MercurialDiff.get_matching_blocks(@base_text, @b_text)
-        
-        len_a, len_b = a_matches.size, b_matches.size
-        sync_regions = []
-        
-        while idx_a < len_a && idx_b < len_b
-          next_a, next_b = a_matches[idx_a], b_matches[idx_b]
-          
-          a_base, a_match, a_len = next_a[:start_a], next_a[:start_b], next_a[:length]
-          b_base, b_match, b_len = next_b[:start_a], next_b[:start_b], next_b[:length]
-          
-          intersection = (a_base..(a_base+a_len)) - (b_base..(b_base+b_len))
-          if intersection
-            # add the sync region
-            sync_regions << synced_region_for_intersection(intersection, a_base, b_base, a_match, b_match)
-          end
-          if (a_base + a_len) < (b_base + b_len)
-            idx_a += 1
-          else
-            idx_b += 1
-          end
-        end
-        # add the EOF-marker
-        inter_base = @base.size
-        a_base     = @a.size
-        b_base     = @b.size
-        sync_regions << {:base_start => inter_base, :base_end => inter_base,
-                         :a_start    => a_base,   :a_end    => a_base      ,  
-                         :b_start    => b_base,   :b_end    => b_base      }
-        
-        sync_regions
-      end
-      
-      def synced_region_for_intersection(intersection, a_base, b_base, a_match, b_match)
-        inter_base = intersection.begin
-        inter_end  = intersection.end
-        inter_len  = inter_end - inter_base
-        
-        # found a match of base[inter_base..inter_end] - this may be less than the region
-        # that matches in either one. Let's do some assertions
-        #assert inter_len <= a_len
-        #assert inter_len <= b_len
-        assert a_base    <= inter_base
-        assert b_base    <= inter_base
-        
-        # shift section downward or upward
-        a_sub = a_match + (inter_base - a_base)
-        b_sub = b_match + (inter_base - b_base)
-        # end points = base_len + starts
-        a_end = a_sub + inter_len
-        b_end = b_sub + inter_len
-        
-        # make sure the texts are equal of course....
-        assert @base[inter_base..(inter_end-1)] == @a[a_sub..(a_end-1)]
-        assert @base[inter_base..(inter_end-1)] == @b[b_sub..(b_end-1)]
-        
-        # return the sync region
-        {:base_start => inter_base, :base_end => inter_end,
-         :a_start    => a_sub,   :a_end    => a_end       ,  
-         :b_start    => b_sub,   :b_end    => b_end       }
-      end
-      
-      private
-      
-      def mismatch_region(next_a, region_ia, next_b, region_ib)
-        if next_a < region_ia || next_b < region_ib
-          return :conflict, nil, nil, next_a, region_ia, next_b, region_ib
-        end
-        nil
-      end
-      
-      ##
-      # Reads a file, but raises warnings if it's binary and we shouldn't be
-      # working with it.
-      #
-      # @param [String] filename the path to the file to read
-      # @param [Hash] opts the options for handling binary files
-      def self.read_file(filename, opts={})
-        text = File.read filename
-        if text.binary?
-          message = "#{filename} appears to be a binary file."
-          raise abort(message) unless opts[:text]
-          UI.warn(message) unless opts[:quiet]
-        end
-        text
-      end
-      
-      ##
-      # Compares arr_a[a_start...a_end] == arr_b[b_start...b_end], without
-      # actually cutting up the array and thus allocating memory.
-      #
-      # @param [Array<Comparable>] arr_a an array of objects that can be compared to arr_b
-      # @param [Integer] a_start the index to begin comparison
-      # @param [Integer] a_end the index to end comparison (exclusive - arr_a[a_end] is NOT
-      #   compared to arr_b[b_end])
-      # @param [Array<Comparable>] arr_b an array of objects that can be compared to arr_a
-      # @param [Integer] b_start the index to begin comparison
-      # @param [Integer] b_end the index to end comparison (exclusive - arr_a[a_end] is NOT
-      #   compared to arr_b[b_end])
-      # @return [Boolean] true if arr_a == arr_b, false if arr_a != arr_b
-      def compare_range(arr_a, a_start, a_end, arr_b, b_start, b_end)
-        return false if (a_end - a_start) != (b_end - b_start)
-        idx_a, idx_b = a_start, b_start
-        while idx_a < a_end && idx_b < b_end
-          return false if arr_a[idx_a] != arr_b[idx_b]
-          idx_a += 1
-          idx_b += 1
-        end
-        true
-      end
-      
-    end
-  end
-end
-
-Threesome = Amp::Merges::ThreeWayMerger

data/lib/amp/repository/branch_manager.rb

@@ -1,234 +0,0 @@
-module Amp
-  module Repositories
-    ##
-    # = BranchManager
-    # Michael Scott for Amp.
-    #
-    # More seriously, this class handles reading/writing to the branch cache
-    # and figuring out what the head revisions are for each branch and such.
-    module BranchManager
-      include Amp::RevlogSupport::Node
-      
-      ##
-      # Saves the branches with the given "partial" and the last_rev index.
-      def save_branch_cache(partial, last_rev)
-        tiprev = self.size - 1
-        # If our cache is outdated, then update it and re-write it
-        if last_rev != tiprev
-          # search for new heads
-          update_branches!(partial, last_rev+1, tiprev+1)
-          # write our data out
-          write_branches!(partial, self.changelog.tip, tiprev)
-        end
-        # return our mappings
-        partial
-      end
-      
-      ##
-      # Loads the head revisions for each branch. Each branch has at least one, but
-      # possible more than one, head.
-      #
-      # @return [Hash] a map, where the branch names are keys and the values
-      #   are the heads of the branch
-      def branch_heads
-        # Gets the mapping of branch names to branch heads, but uses caching to avoid
-        # doing IO and tedious computation over and over. As long as our tip doesn't
-        # change, the cache will remain valid.
-        
-        # Check our current tip
-        tip = self.changelog.tip
-        # Do we have a cache, and if we do, is the saved cache == tip?
-        if !@branch_cache.nil? && @branch_cache_tip == tip
-          # if so, cache HIT
-          return @branch_cache
-        end
-        
-        # nope? cache miss
-        # save the old tip
-        oldtip = @branch_cache_tip
-        # save the new tip
-        @branch_cache_tip = tip
-        
-        # reset the branch cache
-        @branch_cache = @branch_cache.nil? ? {} : @branch_cache.clear # returns same hash, but empty
-        # if we didn't have an old cache, or it was invalid, read in the branches again
-        if oldtip.nil? || self.changelog.node_map[oldtip].nil?
-          partial, last, last_rev = read_branches!
-        else
-          # Otherwise, dig up the cached hash!
-          last_rev = self.changelog.rev(oldtip)
-          # Get the last branch cache
-          partial = @u_branch_cache
-        end
-        # Save the branch cache (updating it if we have to)
-        save_branch_cache(partial, last_rev)
-        
-        # Cache our saved hash
-        @u_branch_cache = partial
-        
-        # Copy the partial into the branch_cache
-        partial.each { |k, v| @branch_cache[k] = v }
-        @branch_cache
-      end
-      
-      # Returns a dict where branch names map to the tipmost head of
-      # the branch, open heads come before closed
-      def branch_tags
-        tags = {}
-        branch_heads.each do |branch_node, local_heads|
-          head = nil
-          local_heads.reverse_each do |h| # get the tip if its a closed
-            if !(changelog.read(h)[5].include?("close"))
-              head = h
-              break
-            end
-          end
-          head = local_heads.last if head.nil?
-          tags[branch_node] = head # it's the tip
-        end
-        return tags
-      end
-      
-      ##
-      # Saves the branches, the tip-most node, and the tip-most revision
-      # to the branch cache.
-      #
-      def save_branches(branches, tip, tip_revision)
-        write_branches!(branches, tip, tip_revision)
-      end
-      
-      private
-      
-      ##
-      # Reads in the branches from the branch.cache file, stored in the root
-      # of the repository's .hg folder. While the repository could figure out
-      # what each branch's heads are each time the program is run, that would
-      # be quite slow. So we cache them in a file, along with the tip of the
-      # repository, so we know if our cache has become inaccurate.
-      # The format is very simple:
-      #     [tip_node_id] [tip_revision_number]
-      #     [branch_head_node_id] [branch_name]
-      #     [branch_head_node_id] [branch_name]
-      #     [branch_head_node_id] [branch_name]
-      #
-      # Example:
-      #     0abc3135810abc3135810abc3135810abc313581 603
-      #     0abc3135810abc3135810abc3135810abc313581 default
-      #     1234567890123456789012345678901234567890 other_branch
-      #     0987654321098765432109876543210987654321 other_branch
-      #
-      # In the example, other_branch has 2 heads. This is acceptable. The tip of the
-      # repository is node 0abc3135, revision 603, which is the only head of the default
-      # branch.
-      #
-      # @return [[Hash, String, Integer]] The results are returned in the form of:
-      #   [partial, tip_node_id, tip_rev_index], where +partial+ is a mapping of
-      #   branch names to an array of their heads.
-      def read_branches!
-        partial, last, last_rev = {}, nil, nil
-        lines = nil
-        invalid = false
-        
-        begin
-          # read in all the lines. This file should be short, so don't worry about
-          # performance concerns of a File.read() call (this call is actually
-          # Opener#read, which then calls File.read)
-          lines = @hg_opener.read("branchheads.cache").split("\n")
-        rescue SystemCallError # IO Errors, i.e. if there is no branch.cache file
-          return {}, NULL_ID, NULL_REV
-        end
-        # use catch, not exceptions (exceptions are more costly)
-        valid = catch(:invalid) do
-          # Read in the tip node and tip revision #
-          last, last_rev = lines.shift.split(" ", 2)
-          last, last_rev = last.unhexlify, last_rev.to_i
-          
-          # if we aren't matching up with the current repo, then invalidate the cache
-          if last_rev > self.size || self[last_rev].node != last
-            throw :invalid, false
-          end
-          
-          # Go through each next line and read in a head-branch pair
-          lines.each do |line|
-            # empty = useless line
-            next if line.nil? || line.empty?
-            # split on " ", only once so we can have a space in a branch name
-            node, _label = line.split(" ", 2)
-            # and assign to our "partial" i.e. our list of branch-heads
-            partial[_label.strip] ||= []
-            partial[_label.strip] << node.unhexlify
-          end
-        end
-        
-        # if invalid was thrown.... bail
-        unless valid
-          UI.puts("invalidating branch cache (tip different)")
-          partial, last, last_rev = {}, NULL_ID, NULL_REV
-        end
-        
-        # Return our results!
-        [partial, last, last_rev]
-      end
-      
-      ##
-      # Invalidates the tag cache. Removes all ivars relating to tags.
-      def invalidate_branch_cache!
-        @branch_cache = nil
-        @branch_cache_tip = nil
-        @u_branch_cache = nil
-      end
-      
-      ##
-      # Goes through from revision +start+ to revision +stop+ and searches for
-      # new branch heads for each branch. Annoying, yes. But necessary to keep the
-      # cache up to date.
-      #
-      # @param [Hash] partial the current pairing of branch names to heads. Might
-      #   be incomplete, which is why it's called "partial"
-      # @param [Integer] start the revision # to start looking new branch heads
-      # @param [Integer] stop the last revision in which to look for branch heads
-      def update_branches!(partial, start, stop)
-        (start..(stop-1)).each do |r|
-          # get the changeset
-          changeset = self[r]
-          # look at its branch
-          branch = changeset.branch
-          # get that branch's partial list of heads
-          
-          branch_heads = (partial[branch] ||= [])
-          # add this changeset
-          branch_heads << changeset.node
-          # remove our parents from this branch's list of heads if they're in there,
-          # because if they have children, they aren't heads.
-          changeset.parents.each do |parent|
-            # get the node_id
-            parent_node = parent.node
-            # remove the parent
-            branch_heads.delete parent_node if branch_heads.include? parent_node
-          end
-        end
-      end
-      
-      ##
-      # Writes the branches out to the branch cache. Simple as that. See #read_branches!
-      # for the file format.
-      #
-      # @see read_branches!
-      # @param [Hash] branches a mapping of branch names to arrays of their head node IDs
-      # @param [String] tip the tip of this repository's node ID
-      # @param [Integer] tip_revision the index # of this repository's tip
-      def write_branches!(branches, tip, tip_revision)
-        @hg_opener.open "branchheads.cache", "w" do |f|
-          f << "#{tip.hexlify} #{tip_revision}\n"
-          branches.each do |_label, nodes|
-            nodes.each {|node| f << "#{node.hexlify} #{_label}\n" }
-          end
-        end
-      rescue SystemCallError
-        
-      end
-    end
-    MichaelScott = BranchManager # hehehe
-  end
-end
-