amp 0.5.2 → 0.5.3

data/lib/amp/repository/mercurial/merging/simple_merge.rb

@@ -0,0 +1,452 @@
+module Amp
+  module Merges
+    module Mercurial
+      
+      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 = 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::Mercurial::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::Mercurial::MercurialDiff.get_matching_blocks(@base_text, @a_text)
+          b_matches = Amp::Diffs::Mercurial::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
+      
+      Threesome = ThreeWayMerger
+    end
+  end
+end

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

@@ -0,0 +1,266 @@
+module Amp
+  module Repositories
+    module Mercurial
+      
+      ##
+      # = 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::Mercurial::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
+        
+        ##
+        # Accesses specific branch head data from the repository. All arguments
+        # are optional.
+        #
+        # @param [Hash] opts the options for the branch head loading
+        # @option opts [Boolean] :branch (self[nil].branch) The branch to look up
+        # @option opts [Fixnum] :start (0) the revision to start frmo
+        # @option opts [Boolean] :closed return closed branches if true
+        # @return 
+        def branch_heads(opts = {})
+          opts[:branch] ||= self[nil].branch
+          
+          all_heads = load_branch_heads
+          branch_heads = all_heads[opts[:branch]] or return []
+          branch_heads.reverse!
+          
+          if opts[:start]
+            branch_heads = changelog.nodes_between([opts[:start]], branch_heads)[2] # TODO: untested
+          end
+          if !opts[:closed]
+            branch_heads.reject! {|head| changelog.read(head)[5].include?("close")}
+          end
+          branch_heads
+        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 load_branch_heads
+          @branch_cache ||= nil
+          @branch_cache_tip ||= nil
+          # 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 = {}
+          load_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 = false
+
+          # 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
+            valid = false
+          else
+          
+            # 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
+            valid = true
+          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
+end
+