amp 0.5.0

data/lib/amp/revlogs/manifest.rb

@@ -0,0 +1,195 @@
+module Amp
+  
+  class ManifestEntry < DelegateClass(Hash)
+    
+    ##
+    # Initializes the dictionary. It can be empty, by initializing with no
+    # arguments, or with more data by assigning them.
+    # 
+    # It is a hash of Filename => node_id
+    # 
+    # @param [Hash] mapping the initial settings of the dictionary
+    # @param [Hash] flags the flag settings of the dictionary
+    def initialize(mapping=nil, flags=nil)
+      @source_hash = mapping || {}
+      super(@source_hash || {})
+      @flags = flags || {}
+    end
+    
+    def inspect
+      "#<ManifestEntry " + @source_hash.inspect + "\n" +
+      "                " + @flags.inspect + ">"
+    end
+    
+    def flags(file=nil)
+      file ? @flags[file] : @flags
+    end
+    
+    def files; keys; end
+    
+    def delete(*args)
+      super(*args)
+      flags.delete(*args)
+    end
+    
+    ##
+    # Clones the dictionary
+    def clone
+      self.class.new @source_hash.dup, @flags.dup
+    end
+    
+    # @see clone
+    alias_method :dup, :clone
+    
+    ##
+    # Mark a file to be checked later on
+    # 
+    # @param [String] file the file to be marked for later checking
+    # @param []
+    def mark_for_later(file, node)
+      self[file]  = nil # notice how we DIDN'T use `self.delete file`
+      flags[file] = node.flags file
+    end
+    
+  end
+
+  
+  ##
+  # = Manifest
+  # A Manifest is a special type of revision log. It stores lists of files
+  # that are being tracked, with some flags associated with each one. The
+  # manifest is where you can go to find what files a revision changed,
+  # and any extra information about the file via its flags.
+  class Manifest < Revlog
+    
+    attr_accessor :manifest_list
+    
+    ##
+    # Parses a bunch of text and interprets it as a manifest entry.
+    # It then maps them onto a ManifestEntry that stores the real
+    # info.
+    # 
+    # @param [String] lines the string that contains the information
+    #   we need to parse.
+    def self.parse(lines)
+      mf_dict = ManifestEntry.new
+      
+      lines.split("\n").each do |line|
+        f, n = line.split("\0")
+        if n.size > 40
+          mf_dict.flags[f] = n[40..-1]
+          mf_dict[f] = n[0..39].unhexlify
+        else
+          mf_dict[f] = n.unhexlify
+        end
+      end
+      
+      mf_dict
+    end    
+    
+    def initialize(opener)
+      @map_cache = nil
+      @list_cache = nil
+      super(opener, "00manifest.i")
+    end
+    
+    ##
+    # Reads the difference between the given node and the revision
+    # before that.
+    # 
+    # @param [String] node the node_id of the revision to diff
+    # @return [ManifestEntry] the dictionary with the info between
+    #   the given revision and the one before that
+    def read_delta(node)
+      r = self.revision_index_for_node node
+      return self.class.parse(Diffs::MercurialDiff.patch_text(self.revision_diff(r-1, r)))
+    end
+    
+    ##
+    # Parses the manifest's data at a given revision's node_id
+    # 
+    # @param [String, Symbol] node the node_id of the revision. If a symbol,
+    #   it better be :tip or else shit will go down.
+    # @return [ManifestEntry] the dictionary mapping the
+    #   flags, filenames, digests, etc from the parsed data
+    def read(node)
+      node = tip if node == :tip
+      
+      return ManifestEntry.new if node == NULL_ID
+      return @map_cache[1] if @map_cache && @map_cache[0] == node
+      
+      text = decompress_revision node
+      
+      @list_cache = text
+      mapping = self.class.parse(text)
+      @map_cache = [node, mapping]
+      mapping
+    end
+    
+    ##
+    # Digs up the information about how a file changed in the revision
+    # specified by the provided node_id.
+    # 
+    # @param [String] nodes the node_id of the revision we're interested in
+    # @param [String] f the path to the file we're interested in
+    # @return [[String, String], [nil, nil]] The data stored in the manifest about the
+    #   file. The first String is a digest, the second String is the extra
+    #   info stored alongside the file. Returns [nil, nil] if the node is not there
+    def find(node, f)
+      if @map_cache && node == @map_cache[0]
+        return [@map_cache[1][f], @map_cache[1].flags[f]]
+      end
+      mapping = read(node)
+      return [mapping[f],  (mapping.flags[f] || "")]
+    end
+    ##
+    # Checks the list for files invalid characters that aren't allowed in
+    # filenames.
+    # 
+    # @raise [RevlogSupport::RevlogError] if the path contains an invalid
+    #   character, raise.
+    def check_forbidden(list)
+      list.each do |f|
+        if f =~ /\n/ || f =~ /\r/
+          raise RevlogSupport::RevlogError.new("\\r and \\n are disallowed in "+
+                                               "filenames")
+        end
+      end
+    end
+    
+    def encode_file(file, manifest)
+      "#{file}\000#{manifest[file].hexlify}#{manifest.flags[file]}\n"
+    end
+    
+
+    def add(map, journal, link, p1=nil, p2=nil, changed=nil)
+      if changed || changed.empty? || @list_cache ||
+          @list_cache.empty? || p1.nil? || @map_cache[0] != p1
+        check_forbidden map
+        @list_cache = map.map {|f,n| f}.sort.map {|f| encode_file f, map }.join
+        
+        n = add_revision(@list_cache, journal, link, p1, p2)
+        @map_cache = [n, map]
+        
+        return n
+      end
+      
+      check_forbidden changed[0] # added files, check if they're forbidden
+      
+      mapping = Manifest.parse(@list_cache)
+      
+      changed[0].each do |x| 
+        mapping[x] = map[x].hexlify
+        mapping.flags[x] = map.flags[x]
+      end
+      
+      changed[1].each {|x| mapping.delete x }
+      @list_cache = mapping.map {|k, v| k}.sort.map {|fn| encode_file(fn, mapping)}.join
+      
+      n = add_revision(@list_cache, journal, link, p1, p2)
+      @map_cache = [n, map]
+      
+      n
+    end
+  end
+end

data/lib/amp/revlogs/node.rb

@@ -0,0 +1,18 @@
+module Amp
+  module RevlogSupport
+    module Node
+      # the null node ID - just 20 null bytes
+      NULL_ID = "\0" * 20
+      # -1 is the null revision (the last one in the index)
+      NULL_REV = -1
+      
+      ##
+      # Returns the node in a short hexadecimal format - only 6 bytes => 12 hex bytes
+      #
+      # @return [String] the node, in hex, and chopped a bit
+      def short(node)
+        node.short_hex
+      end
+    end
+  end
+end

data/lib/amp/revlogs/revlog.rb

@@ -0,0 +1,1032 @@
+require 'set'
+
+module Amp
+  
+  ##
+  # = Revlog
+  # A revlog is a generic file that represents a revision history. This
+  # class, while generic, is extremely importantly and highly functional.
+  # While the {Amp::Manifest} and {Amp::ChangeLog} classes inherit
+  # from Revlog, one can open either file using the base Revlog class.
+  #
+  # A Revision log is based on two things: an index, which stores some
+  # meta-data about each revision in the repository's history, and
+  # some data associated with each revision. The data is stored as
+  # a (possibly zlib-compressed) diff.
+  #
+  # There are two versions of revision logs - version 0 and version NG.
+  # This information is handled by the {Amp::RevlogSupport:Index} classes.
+  #
+  # Sometimes the data is stored in a separate file from the index. This
+  # is up to the system to decide.
+  #
+  class Revlog
+    include Enumerable
+    include RevlogSupport::Node
+    
+    # the file paths to the index and data files
+    attr_reader :index_file, :data_file
+    # The actual {Index} object.
+    attr_reader :index
+    
+    ##
+    # Initializes the revision log with an opener object (which handles how
+    # the interface to opening the files) and the path to the index itself.
+    # 
+    # @param [Amp::Opener] opener an object that will handle opening the file
+    # @param [String] indexfile the path to the index file
+    def initialize(opener, indexfile)
+      @opener = opener
+      @index_file = indexfile
+      @data_file  = indexfile[0..-3] + ".d"
+      @chunk_cache = nil
+      @index = RevlogSupport::Index.parse(opener, indexfile)
+      
+      # add the null, terminating index entry if it isn't already there
+      if @index.index.empty? || @index.is_a?(RevlogSupport::LazyIndex) || 
+                               @index.index[-1].node_id.not_null?
+        # the use of @index.index is deliberate!
+        @index.index << RevlogSupport::IndexEntry.new(0,0,0,-1,-1,-1,-1,NULL_ID)
+      end
+    end
+    alias_method :revlog_initialize, :initialize
+    
+    ##
+    # Actually opens the file.
+    def open(path, mode="r")
+      @opener.open(path, mode)
+    end
+    
+    ##
+    # Returns the requested node as an IndexEntry. Takes either a string or
+    # a fixnum index value.
+    #
+    # @param [String, Fixnum] the index or node ID to look up in the revlog
+    # @return [IndexEntry] the requested index entry.
+    def [](idx)
+      if idx.is_a? String
+        return @index[@index.node_map[idx]]
+      elsif idx.is_a? Array
+        STDERR.puts idx.inspect # KILLME
+        idx
+      else
+        return @index[idx]
+      end
+    end
+    
+    ##
+    # Returns the unique node_id (a string) for a given revision at _index_.
+    # 
+    # @param [Fixnum] index the index into the list, from 0-(num_revisions - 1).
+    # @return [String] the node's ID
+    def node_id_for_index(index)
+      unless @index[index]
+        raise RevlogSupport::LookupError.new("Couldn't find node for id '#{index}'")
+      end
+      @index[index].node_id
+    end
+    
+    # @see node_id_for_index
+    alias_method :node, :node_id_for_index
+    
+    ##
+    # Returns the index number for the given node ID.
+    #
+    # @param [String] id the node_id to lookup
+    # @return [Integer] the index into the revision index where you can find
+    #   the requested node.
+    def revision_index_for_node(id)
+      unless @index.node_map[id]
+        p id
+        raise StandardError.new("Couldn't find node for id '#{id}'")
+      end
+      @index.node_map[id]
+    end
+    
+    ##
+    # @see revision_index_for_node
+    alias_method :rev, :revision_index_for_node
+    
+    ##
+    # Returns the "link revision" index for the given revision index
+    def link_revision_for_index(index)
+      self[index].link_rev
+    end
+    
+    ##
+    # Returns the node_id's of the parents (1 or 2) of the given node ID.
+    def parents_for_node(id)
+      #index = revision_index_for_node id
+      entry = self[id]
+      [ @index[entry.parent_one_rev].node_id , 
+        @index[entry.parent_two_rev].node_id ]
+    end
+    alias_method :parents, :parents_for_node
+    
+    ##
+    # Returns the indicies of the parents (1 or 2) of the node at _index_
+    def parent_indices_for_index(index)
+      [ self[index].parent_one_rev ,
+        self[index].parent_two_rev ]
+    end
+    
+    ##
+    # Returns the size of the data for the revision at _index_.
+    def data_size_for_index(index)
+      self[index].compressed_len
+    end
+    
+    ##
+    # Returns the uncompressed size of the data for the revision at _index_.
+    def uncompressed_size_for_index(index)
+      len = self[index].uncompressed_len
+      return len if len >= 0
+      
+      text = decompress_revision node_id_for_index(index)
+      return text.size
+    end
+    
+    ##
+    # Returns the offset where the data begins for the revision at _index_.
+    def data_start_for_index(index)
+      RevlogSupport::Support.get_offset self[index].offset_flags
+    end
+    
+    ##
+    # Returns the offset where the data ends for the revision at _index_.
+    def data_end_for_index(index)
+      data_start_for_index(index) + self[index].compressed_len
+    end
+    
+    ##
+    # Returns the "base revision" index for the revision at _index_. 
+    def base_revision_for_index(index)
+      self[index].base_rev
+    end
+    
+    ##
+    # Returns the node ID for the index's tip-most revision
+    def tip
+      node_id_for_index(@index.size - 2)
+    end
+    
+    ##
+    # Returns the number of entries in this revision log.
+    def size
+      @index.size - 1
+    end
+    alias_method :index_size, :size
+    
+    ##
+    # Returns true if size is 0
+    def empty?
+      index_size.zero?
+    end
+    
+    ##
+    # Returns each revision as a {Amp::RevlogSupport::IndexEntry}.
+    # Don't iterate over the extra revision -1!
+    def each(&b); @index[0..-2].each(&b); end
+    
+    ##
+    # Returns all of the indices for all revisions.
+    # 
+    # @return [Array] all indicies
+    def all_indices
+      (0..size).to_a
+    end
+    
+    ##
+    # Returns a hash of all _ancestral_ nodes that can be reached from
+    # the given node ID. Just do [node_id] on the result to check if it's
+    # reachable.
+    def reachable_nodes_for_node(node, stop=nil)
+      reachable = {}
+      to_visit = [node]
+      reachable[node] = true
+      stop_idx = stop ? revision_index_for_node(stop) : 0
+      
+      until to_visit.empty?
+        node = to_visit.shift
+        next if node == stop || node.null?
+        parents_for_node(node).each do |parent|
+          next if revision_index_for_node(parent) < stop_idx
+          unless reachable[parent]
+            reachable[parent] = true
+            to_visit << parent
+          end
+        end
+      end
+        
+      reachable
+    end
+    
+    ##
+    # Allows the user to operate on all the ancestors of the given revisions.
+    # One can pass a block, or just call it and get a Set.
+    def ancestors(revisions)
+      revisions = [revisions] unless revisions.kind_of? Array
+      to_visit = revisions.dup
+      seen = Set.new([NULL_REV])
+      until to_visit.empty?
+        parent_indices_for_index(to_visit.shift).each do |parent|
+          unless seen.include? parent
+            to_visit << parent
+            seen     << parent
+            yield parent if block_given?
+          end
+        end
+      end
+      seen.delete NULL_REV
+      seen
+    end
+    
+    ##
+    # Allows the user to operate on all the descendants of the given revisions.
+    # One can pass a block, or just call it and get a Set. Revisions are passed
+    # as indices.
+    def descendants(revisions)
+      seen = Set.new revisions
+      start = revisions.min + 1
+      start.upto self.size do |i|
+        parent_indices_for_index(i).each do |x|
+          if x != NULL_REV && seen.include?(x)
+            seen << i
+            yield i if block_given?
+            break 1
+          end
+        end
+      end
+      seen - revisions
+    end
+    
+    ##
+    # Returns the topologically sorted list of nodes from the set:
+    # missing = (ancestors(heads) \ ancestors(common))
+    def find_missing(common=[NULL_ID], heads=self.heads)
+      common.map! {|r| revision_index_for_node r}
+      heads.map!  {|r| revision_index_for_node r}
+      
+      has = {}
+      ancestors(common) {|a| has[a] = true}
+      has[NULL_REV] = true
+      common.each {|r| has[r] = true}
+      
+      missing = {}
+      to_visit = heads.reject {|r| has[r]}
+      until to_visit.empty?
+        r = to_visit.shift
+        next if missing.include? r
+        missing[r] = true
+        parent_indices_for_index(r).each do |p|
+          to_visit << p unless has[p]
+        end
+      end
+      
+      missing.keys.sort.map {|rev| node_id_for_index rev}
+    end
+    
+    ##
+    # Return a tuple containing three elements. Elements 1 and 2 contain
+    # a final list bases and heads after all the unreachable ones have been
+    # pruned.  Element 0 contains a topologically sorted list of all
+    # 
+    # nodes that satisfy these constraints:
+    # 1. All nodes must be descended from a node in roots (the nodes on
+    #    roots are considered descended from themselves).
+    # 2. All nodes must also be ancestors of a node in heads (the nodes in
+    #    heads are considered to be their own ancestors).
+    # 
+    # If roots is unspecified, nullid is assumed as the only root.
+    # If heads is unspecified, it is taken to be the output of the
+    # heads method (i.e. a list of all nodes in the repository that
+    # have no children).
+    # 
+    # @param  [Array<String>] roots
+    # @param  [Array<String>] heads
+    # @return [{:heads => Array<String>, :roots => Array<String>, :between => Array<String>}]
+    def nodes_between(roots=nil, heads=nil)
+      no_nodes = {:roots => [], :heads => [], :between => []}
+      return no_nodes if roots != nil && roots.empty?
+      return no_nodes if heads != nil && heads.empty?
+      
+      if roots.nil?
+        roots = [NULL_ID] # Everybody's a descendent of nullid
+        lowest_rev = NULL_REV
+      else
+        roots = roots.dup
+        lowest_rev = roots.map {|r| revision_index_for_node r}.min
+      end
+      
+      if lowest_rev == NULL_REV && heads.nil?
+        # We want _all_ the nodes!
+        return {:between => all_indices.map {|i| node_id_for_index i },
+                :roots => [NULL_ID], :heads => self.heads}
+      end
+      
+      if heads.nil?
+        # All nodes are ancestors, so the latest ancestor is the last
+        # node.
+        highest_rev = self.size - 1
+        # Set ancestors to None to signal that every node is an ancestor.
+        ancestors = nil
+        # Set heads to an empty dictionary for later discovery of heads
+        heads = {}
+      else
+        heads = heads.dup
+        ancestors = {}
+        
+        # Turn heads into a dictionary so we can remove 'fake' heads.
+        # Also, later we will be using it to filter out the heads we can't
+        # find from roots.
+        heads = Hash.with_keys heads, false
+        
+        # Start at the top and keep marking parents until we're done.
+        nodes_to_tag = heads.keys
+        highest_rev = nodes_to_tag.map {|r| revision_index_for_node r }.max
+        
+        until nodes_to_tag.empty?
+          # grab a node to tag
+          node = nodes_to_tag.pop
+          # Never tag nullid
+          next if node.null?
+          
+          # A node's revision number represents its place in a
+          # topologically sorted list of nodes.
+          r = revision_index_for_node node
+          if r >= lowest_rev
+            if !ancestors.include?(node)
+              # If we are possibly a descendent of one of the roots
+              # and we haven't already been marked as an ancestor
+              ancestors[node] = true # mark as ancestor
+              # Add non-nullid parents to list of nodes to tag.
+              nodes_to_tag += parents_for_node(node).reject {|p| p.null? }
+            elsif heads.include? node # We've seen it before, is it a fake head?
+              # So it is, real heads should not be the ancestors of
+              # any other heads.
+              heads.delete_at node
+            end
+          end
+        end
+        
+        return no_nodes if ancestors.empty?
+        
+        # Now that we have our set of ancestors, we want to remove any
+        # roots that are not ancestors.
+
+        # If one of the roots was nullid, everything is included anyway.
+        if lowest_rev > NULL_REV
+          # But, since we weren't, let's recompute the lowest rev to not
+          # include roots that aren't ancestors.
+
+          # Filter out roots that aren't ancestors of heads
+          roots = roots.select {|rev| ancestors.include? rev}
+          
+          return no_nodes if roots.empty? # No more roots?  Return empty list
+          
+          # Recompute the lowest revision
+          lowest_rev = roots.map {|rev| revision_index_for_node rev}.min
+        else
+          lowest_rev = NULL_REV
+          roots = [NULL_ID]
+        end
+      end
+      
+      # Transform our roots list into a 'set' (i.e. a dictionary where the
+      # values don't matter.
+      descendents = Hash.with_keys roots
+      
+      # Also, keep the original roots so we can filter out roots that aren't
+      # 'real' roots (i.e. are descended from other roots).
+      roots = descendents.dup
+      
+      # Our topologically sorted list of output nodes.
+      ordered_output = []
+      
+      # Don't start at nullid since we don't want nullid in our output list,
+      # and if nullid shows up in descedents, empty parents will look like
+      # they're descendents.
+      [lowest_rev, 0].max.upto(highest_rev) do |rev|
+        node = node_id_for_index rev
+        is_descendent = false
+        
+        if lowest_rev == NULL_REV # Everybody is a descendent of nullid
+          is_descendent = true
+        elsif descendents.include? node
+          # n is already a descendent
+          is_descendent = true
+          
+          # This check only needs to be done here because all the roots
+          # will start being marked is descendents before the loop.
+          if roots.include? node
+            # If n was a root, check if it's a 'real' root.
+            par = parents_for_node node
+            # If any of its parents are descendents, it's not a root.
+            if descendents.include?(par[0]) || descendents.include?(par[1])
+              roots.delete_at node
+            end
+          end
+        else
+          # A node is a descendent if either of its parents are
+          # descendents. (We seeded the dependents list with the roots
+          # up there, remember?)
+          par = parents_for_node node
+          if descendents.include?(par[0]) || descendents.include?(par[1])
+            descendents[node] = true
+            is_descendent     = true
+          end
+        end
+        
+        if is_descendent && (ancestors.nil? || ancestors.include?(node))
+          # Only include nodes that are both descendents and ancestors.
+          ordered_output << node
+          if !ancestors.nil? && heads.include?(node)
+            # We're trying to figure out which heads are reachable
+            # from roots.
+            # Mark this head as having been reached
+            heads[node] = true
+          elsif ancestors.nil?
+            # Otherwise, we're trying to discover the heads.
+            # Assume this is a head because if it isn't, the next step
+            # will eventually remove it.
+            heads[node] = true
+            
+            # But, obviously its parents aren't.
+            parents_for_node(node).each {|parent| heads.delete parent }
+          end
+        end
+      end
+      
+      heads = heads.keys.select {|k| heads[k] }
+      roots = roots.keys
+      {:heads => heads, :roots => roots, :between => ordered_output}
+    end
+    
+    ##
+    # Return the list of all nodes that have no children.
+    # 
+    # if start is specified, only heads that are descendants of
+    # start will be returned
+    # if stop is specified, it will consider all the revs from stop
+    # as if they had no children
+    def heads(start=nil, stop=nil)
+      if start.nil? && stop.nil?
+        count = self.size
+        return [NULL_ID] if count == 0
+        is_head = [true] * (count + 1)
+        count.times do |r|
+          e = @index[r]
+          is_head[e.parent_one_rev] = is_head[e.parent_two_rev] = false
+        end
+        return (0..(count-1)).to_a.select {|r| is_head[r]}.map {|r| node_id_for_index r}
+      end
+      start = NULL_ID if start.nil?
+      stop  = [] if stop.nil?
+      stop_revs = {}  
+      stop.each {|r| stop_revs[revision_index_for_node(r)] = true }
+      start_rev = revision_index_for_node start
+      reachable = {start_rev => 1}
+      heads     = {start_rev => 1}
+      (start_rev + 1).upto(self.size - 1) do |r|
+        parent_indices_for_index(r).each do |p|
+          if reachable[p]
+            reachable[r] = 1 unless stop_revs[r]
+            heads[r] = 1
+          end
+          heads.delete p if heads[p] && stop_revs[p].nil?
+        end
+      end
+      
+      heads.map {|k,v| node_id_for_index k}
+    end
+    
+    ##
+    # Returns the children of the node with ID _node_.
+    def children(node)
+      c = []
+      p = revision_index_for_node node
+      (p+1).upto(self.size - 1) do |r|
+        prevs = parent_indices_for_index(r).select {|pr| pr != NULL_REV}
+        prevs.each {|pr| c << node_id_for_index(r) if pr == p} if prevs.any?
+        c << node_id_for_index(r) if p == NULL_REV
+      end
+      c
+    end
+    
+    ##
+    # Tries to find an exact match for a node with ID _id_. If no match is,
+    # found, then the id is treated as an index number - if that doesn't work,
+    # the revlog will try treating the ID supplied as node_id in hex form.
+    def id_match(id)
+      return node_id_for_index(id) if id.is_a? Integer
+      return id if id.size == 20 && revision_index_for_node(id)
+      rev = id.to_i
+      rev = self.size + rev if rev < 0
+      if id.size == 40
+        node = id.unhexlify
+        r = revision_index_for_node node
+        return node if r
+      end
+      nil
+    end
+    
+    ##
+    # Tries to find a partial match for a node_id in hex form.
+    def partial_id_match(id)
+      return nil if id.size >= 40
+      l = id.size / 2
+      bin_id = id[0..(l*2 - 1)].unhexlify
+      nl = @index.node_map.keys.select {|k| k[0..(l-1)] == bin_id}
+      nl = nl.select {|n| n.hexlify =~ /^#{id}/}
+      return nl.first if nl.size == 1
+      raise RevlogSupport::LookupError.new("ambiguous ID #{id}") if nl.size > 1
+      nil
+    end
+    
+    ##
+    # This method will, given an id (or an index) or an ID in hex form,
+    # try to find the given node in the index.
+    def lookup_id(id)
+      n = id_match id
+      return n unless n.nil?
+      n = partial_id_match id
+      return n unless n.nil?
+      raise RevlogSupport::LookupError.new("no match found #{id}")
+    end
+    
+    ##
+    # Compares a node with the provided text, as a consistency check. Works
+    # using <=> semantics.
+    def cmp(node, text)
+      
+      p1, p2 = parents_for_node node
+      return RevlogSupport::Support.history_hash(text, p1, p2) != node
+    end
+    
+    ##
+    # Loads a block of data into the cache. 
+    def load_cache(data_file, start, cache_length)
+
+      if data_file.nil?
+        data_file = open(@index_file) if @index.inline?
+        data_file = open(@data_file)  unless @index.inline?
+      end
+      
+      # data_file.seek(start, IO::SEEK_SET)
+      # sz = data_file.read.length
+      # data_file.seek(0, IO::SEEK_SET)
+      # $zs = data_file.read.length
+      # puts(@index.inline? ? "------- INLINE" : "-------NOT INLINE") #killme
+      # puts "------- CACHE_LENGTH = #{cache_length}" # KILLME
+      # puts "===" # KILLME
+      # puts "We are going to read #{cache_length} bytes starting at #{start}" # KILLME
+      # puts "Wait a minute... on Ari's machine, there's only #{sz} bytes to read..." # KILLME
+      # puts "Filesize: #{$zs}" # KILLME
+      # puts "===" # KILLME
+      
+      data_file.seek(start, IO::SEEK_SET)
+      @chunk_cache = [start, data_file.read(cache_length)]
+      data_file
+    end
+    
+    ##
+    # Gets a chunk of data from the datafile (or, if inline, from the index
+    # file). Just give it a revision index and which data file to use
+    # 
+    # @param  [Fixnum] rev the revision index to extract
+    # @param  [IO] data_file The IO file descriptor for loading data
+    # @return [String] the raw data from the index (posssibly compressed)
+    def get_chunk(rev, data_file = nil)
+      begin
+        start, length = self.data_start_for_index(rev), self[rev].compressed_len
+      rescue
+        Amp::UI.debug "Failed get_chunk: #{@index_file}:#{rev}"
+        raise
+      end
+      
+      #puts "The starting point for the data is: #{data_start_for_index(rev)}"   # KILLME
+      #puts "We're reading #{length} bytes. Look at data_start_for_index" # KILLME
+      
+      start += ((rev + 1) * @index.entry_size) if @index.inline?
+      
+      endpt = start + length
+      offset = 0
+      if @chunk_cache.nil?
+        cache_length = [65536, length].max
+        data_file = load_cache data_file, start, cache_length
+      else
+        cache_start = @chunk_cache[0]
+        cache_length = @chunk_cache[1].size
+        cache_end = cache_start + cache_length
+        if start >= cache_start && endpt <= cache_end
+          offset = start - cache_start
+        else
+          cache_length = [65536, length].max
+          data_file = load_cache data_file, start, cache_length
+        end
+      end
+      
+      c = @chunk_cache[1]
+      return "" if c.nil? || c.empty? || length == 0
+      c = c[offset..(offset + length - 1)] if cache_length != length
+      
+      RevlogSupport::Support.decompress c
+    end
+    
+    ##
+    # Unified diffs 2 revisions, based on their indices. They are returned in a sexified
+    # unified diff format.
+    def unified_revision_diff(rev1, rev2)
+      Diffs::MercurialDiff.unified_diff( decompress_revision(self.node_id_for_index(rev1)),
+                                      decompress_revision(self.node_id_for_index(rev2)))
+    end
+    
+    ##
+    # Diffs 2 revisions, based on their indices. They are returned in
+    # BinaryDiff format.
+    # 
+    # @param [Fixnum] rev1 the index of the source revision
+    # @param [Fixnum] rev2 the index of the destination revision
+    # @return [String] The diff of the 2 revisions.
+    def revision_diff(rev1, rev2)
+      return get_chunk(rev2) if (rev1 + 1 == rev2) && 
+             self[rev1].base_rev == self[rev2].base_rev
+      Diffs::MercurialDiff.text_diff( decompress_revision(node_id_for_index(rev1)),
+                                      decompress_revision(node_id_for_index(rev2)))
+    end
+    
+    ##
+    # Given a node ID, extracts that revision and decompresses it. What you get
+    # back will the pristine revision data!
+    # 
+    # @param [String] node the Node ID of the revision to extract.
+    # @return [String] the pristine revision data.
+    def decompress_revision(node)
+      return "" if node.nil? || node.null?
+      return @index.cache[2] if @index.cache && @index.cache[0] == node
+      
+      
+      text = nil
+      rev = revision_index_for_node node
+      base = @index[rev].base_rev
+      
+      if @index[rev].offset_flags & 0xFFFF  > 0
+        raise RevlogSupport::RevlogError.new("incompatible revision flag %x" %
+                                        (self.index[rev].offset_flags & 0xFFFF))
+      end
+      data_file = nil
+      
+      if @index.cache && @index.cache[1].is_a?(Numeric) && @index.cache[1] >= base && @index.cache[1] < rev
+        base = @index.cache[1]
+        text = @index.cache[2]
+        # load the index if we're lazy (base, rev + 1)
+      end
+      data_file = open(@data_file) if !(@index.inline?) && rev > base + 1
+      text = get_chunk(base, data_file) if text.nil?
+      bins = ((base + 1)..rev).map {|r| get_chunk(r, data_file)}
+      text = Diffs::MercurialPatch.apply_patches(text, bins)
+      
+      p1, p2 = parents_for_node node
+      if node != RevlogSupport::Support.history_hash(text, p1, p2)
+        raise RevlogSupport::RevlogError.new("integrity check failed on %s:%d, data:%s" % 
+                                             [(@index.inline? ? @index_file : @data_file), rev, text.inspect])
+      end
+      @index.cache = [node, rev, text]
+      text
+    end
+    
+    ############ TODO
+    # @todo FINISH THIS METHOD
+    # @todo FIXME
+    # FINISH THIS METHOD
+    # TODO
+    # FIXME
+    def check_inline_size(tr, fp=nil)
+      return unless @index.inline?
+      if fp.nil?
+        fp = open(@index_file, "r")
+        fp.seek(0, IO::SEEK_END)
+      end
+      size = fp.tell
+      return if size < 131072
+      
+      trinfo = tr.find(@index_file)
+      if trinfo.nil?
+        raise RevlogSupport::RevlogError.new("#{@index_file} not found in the"+
+                                             "transaction")
+      end
+      trindex = trinfo[:data]
+      data_offset = data_start_for_index trindex
+      tr.add @data_file, data_offset
+      df = open(@data_file, 'w')
+      begin
+        calc = @index.entry_size
+        self.size.times do |r|
+          start = data_start_for_index(r) + (r + 1) * calc
+          length = self[r].compressed_len
+          fp.seek(start)
+          d = fp.read length
+          df.write d
+        end
+      ensure
+        df.close
+      end
+      fp.close
+      
+      ############ TODO
+      # FINISH THIS METHOD
+      ############ TODO
+    end
+    
+    ##
+    # add a revision to the log
+    # 
+    # @param [String] text the revision data to add
+    # @param transaction the transaction object used for rollback
+    # @param link the linkrev data to add
+    # @param [String] p1 the parent nodeids of the revision
+    # @param [String] p2 the parent nodeids of the revision
+    # @param d an optional precomputed delta
+    # @return [String] the digest ID referring to the node in the log
+    def add_revision(text, transaction, link, p1, p2, d=nil, index_file_handle=nil)
+      node = RevlogSupport::Support.history_hash(text, p1, p2)
+      return node if @index.node_map[node]
+      curr = index_size
+      prev = curr - 1
+      base = self[prev].base_rev
+      offset = data_end_for_index prev
+      if curr > 0
+        if d.nil? || d.empty?
+          ptext = decompress_revision node_id_for_index(prev)
+          d = Diffs::MercurialDiff.text_diff(ptext, text)
+        end
+        data = RevlogSupport::Support.compress d
+        len = data[:compression].size + data[:text].size
+        dist = len + offset - data_start_for_index(base)
+      end
+      # Compressed diff > size of actual file
+      if curr == 0 || dist > text.size * 2
+        data = RevlogSupport::Support.compress text
+        len = data[:compression].size + data[:text].size
+        base = curr
+      end
+      entry = RevlogSupport::IndexEntry.new(RevlogSupport::Support.offset_version(offset, 0), 
+                len, text.size, base, link, rev(p1), rev(p2), node)
+      @index << entry
+      @index.node_map[node] = curr
+      @index.write_entry(@index_file, entry, transaction, data, index_file_handle)
+      @index.cache = [node, curr, text]
+      node
+    end
+    
+    ##
+    # Finds the most-recent common ancestor for the two nodes.
+    def ancestor(a, b)
+      parent_func = proc do |rev| 
+        self.parent_indices_for_index(rev).select {|i| i != NULL_REV }
+      end
+      c = Graphs::AncestorCalculator.ancestors(revision_index_for_node(a),
+                                               revision_index_for_node(b),
+                                               parent_func)
+      return NULL_ID if c.nil?
+      node_id_for_index c
+    end
+    
+    ##
+    # Yields chunks of change-group data for writing to disk, given
+    # a nodelist, a method to lookup stuff. Given a list of changset
+    # revs, return a set of deltas and metadata corresponding to nodes.
+    # the first delta is parent(nodes[0]) -> nodes[0] the receiver is
+    # guaranteed to have this parent as it has all history before these
+    # changesets. parent is parent[0]
+    #
+    # FIXME -- could be the cause of our failures with #pre_push!
+    # @param [[String]] nodelist
+    # @param [Proc, #[], #call] lookup
+    # @param [Proc, #[], #call] info_collect can be left nil
+    def group(nodelist, lookup, info_collect=nil)
+      revs = nodelist.map {|n| rev n }
+
+      # if we don't have any revisions touched by these changesets, bail
+      if revs.empty?
+        yield RevlogSupport::ChangeGroup.closing_chunk
+        return
+      end
+      
+      # add the parent of the first rev
+      parent1 = parents_for_node(node(revs[0]))[0]
+      revs.unshift rev(parent1)
+      
+      # build deltas
+      0.upto(revs.size - 2) do |d|
+        a, b = revs[d], revs[d + 1]
+        nb = node b
+        
+        info_collect[nb] if info_collect
+        
+        p = parents(nb)
+        meta = nb + p[0] + p[1] + lookup[nb]
+        
+        if a == -1
+          data = decompress_revision nb
+          meta += Diffs::MercurialDiff.trivial_diff_header(d.size)
+        else
+          
+          data = revision_diff(a, b)
+        end
+        
+        yield RevlogSupport::ChangeGroup.chunk_header(meta.size + data.size)
+        yield meta
+        if data.size > 1048576
+          pos = 0
+          while pos < data.size
+            pos2 = pos + 262144
+            yield data[pos..(pos2-1)]
+            pos = pos2
+          end
+        else
+          yield data
+        end
+      end
+      yield RevlogSupport::ChangeGroup.closing_chunk
+    end
+    
+    # Adds a changelog to the index
+    # 
+    # @param [StringIO, #string] revisions something we can iterate over (Usually a StringIO)
+    # @param [Proc, #call, #[]] link_mapper
+    # @param [Amp::Journal] journal to start a transaction
+    def add_group(revisions, link_mapper, journal)
+      r = index_size
+      t = r - 1
+      node = nil
+      
+      base = prev = RevlogSupport::Node::NULL_REV
+      start = endpt = text_len = 0
+      endpt = data_end_for_index t if r != 0
+      
+      index_file_handle = open(@index_file, "a+")
+      index_size = r * @index.entry_size
+      if @index.inline?
+        journal << [@index_file, endpt + index_size, r]
+        data_file_handle = nil
+      else
+        journal << [@index_file, index_size, r]
+        journal << [@data_file, endpt]
+        data_file_handle = open(@data_file, "a")
+      end
+      
+      begin #errors abound here i guess
+        chain = nil
+        
+        Amp::RevlogSupport::ChangeGroup.each_chunk(revisions) do |chunk|
+          node, parent1, parent2, cs = chunk[0..79].unpack("a20a20a20a20")
+          link = link_mapper.call(cs)
+          
+          if @index.node_map[node]
+            chain = node
+            next
+          end
+          delta = chunk[80..-1]
+          [parent1, parent2].each do |parent|
+            unless @index.node_map[parent]
+              raise RevlogSupport::LookupError.new("unknown parent #{parent}"+
+                                                         " in #{@index_file}")
+            end
+          end
+          
+          unless chain
+            chain = parent1
+            unless @index.node_map[chain]
+              raise RevlogSupport::LookupError.new("unknown parent #{chain}"+
+                                          " from #{chain} in #{@index_file}")
+            end
+          end
+          
+          if chain == prev
+            cdelta = RevlogSupport::Support.compress delta
+            cdeltalen = cdelta[:compression].size + cdelta[:text].size
+            text_len = Diffs::MercurialPatch.patched_size text_len, delta
+          end
+          
+          if chain != prev || (endpt - start + cdeltalen) > text_len * 2
+            #flush our writes here so we can read it in revision
+            data_file_handle.flush if data_file_handle
+            index_file_handle.flush
+            text = decompress_revision(chain)
+            if text.size == 0
+              text = delta[12..-1]
+            else
+              text = Diffs::MercurialPatch.apply_patches(text, [delta])
+            end
+            chk = add_revision(text, journal, link, parent1, parent2, 
+                                  nil, index_file_handle)
+            # if (! data_file_handle) && (! @index.inline?)
+            #   data_file_handle = open(@data_file, "a")
+            #   index_file_handle = open(@index_file, "a")
+            # end
+            if chk != node
+              raise RevlogSupport::RevlogError.new("consistency error "+
+                        "adding group")
+            end
+            text_len = text.size
+          else
+            entry = RevlogSupport::IndexEntry.new(RevlogSupport::Support.offset_version(endpt, 0),
+                       cdeltalen,text_len, base, link, rev(parent1), rev(parent2), node)
+            @index << entry
+            @index.node_map[node] = r
+            @index.write_entry(@index_file, entry, journal, cdelta, index_file_handle)
+          end
+          
+          
+          t, r, chain, prev = r, r + 1, node, node
+          base  = self[t].base_rev
+          start = data_start_for_index base
+          endpt = data_end_for_index t
+        end
+      rescue Exception => e
+        puts e
+        puts e.backtrace
+      ensure
+        if data_file_handle && !(data_file_handle.closed?)
+          data_file_handle.close
+        end
+        index_file_handle.close
+      end
+      node
+    end
+    
+    ##
+    # Strips all revisions after (and including) a given link_index
+    def strip(min_link)
+      return if size == 0
+      
+      load_index_map if @index.is_a? RevlogSupport::LazyIndex
+      
+      rev = 0
+      all_indices.each {|_rev| rev = _rev; break if @index[rev].link_rev >= min_link }
+      return if rev > all_indices.max
+      
+      endpt = data_start_for_index rev
+      unless @index.inline?
+        df = File.open(@data_file, "a")
+        df.truncate(endpt)
+        endpt = rev * @index.entry_size
+      else
+        endpt += rev * @index.entry_size
+      end
+      
+      indexf = File.open(@index_file, "a")
+      indexf.truncate(endpt)
+      
+      @cache = @index.cache = nil
+      @chunk_cache = nil
+      rev.upto(self.size-1) {|x| @index.node_map.delete(self.node(x)) }
+      @index.index = @index.index[0..rev-1]
+    end
+    
+    ##
+    # Checks to make sure our data and index files are the right size.
+    # Returns the differences between expected and actual sizes.
+    def checksize
+      expected = 0
+      expected = [0, data_end_for_index(self.index_size - 1)].max if self.index_size > 0
+      
+      
+      
+      
+      f = open(@index_file)
+      f.seek(0, IO::SEEK_END)
+      actual = f.tell
+      s = @index.entry_size
+      i = [0, actual / s].max
+      di = actual - (i * s)
+      
+      if @index.inline?
+        databytes = 0
+        self.index_size.times do |r|
+          databytes += [0, self[r].compressed_len].max
+        end
+        dd = 0
+        di = actual - (self.index_size * s) - databytes
+      else
+        f = open(@data_file)
+        f.seek(0, IO::SEEK_END)
+        actual = f.tell
+        dd = actual - expected
+        f.close
+      end
+      
+      return {:data_diff => dd, :index_diff => di}
+    end
+    
+    ##
+    # Returns all the files this object is concerned with.
+    def files
+      res = [ @index_file ]
+      res << @data_file unless @index.inline?
+      res
+    end
+      
+  end
+end