amp 0.5.2 → 0.5.3

data/lib/amp/revlogs/file_log.rb

@@ -1,165 +0,0 @@
-module Amp
-  ##
-  # = FileLog
-  # A FileLog is the revision log that stores revision history for
-  # each individual file tracked by the system. It stores special meta-data
-  # for handling files that have been copied over their history.
-  #
-  class FileLog < Revlog
-    ##
-    # Initializes the revision log, being sure to encode directories
-    # to avoid naming conflicts
-    # @param [Opener] opener the opener to use for opening the file
-    # @param [String] path the path to the file, excluding "data".
-    #
-    def initialize(opener, path)
-      super(opener, ["data", encode_dir(path + ".i")].join("/"))
-    end
-    
-    ##
-    # Encodes the directory to avoid naming conflicts
-    # @param [String] path the path to encode for naming conflict issues
-    # @return [String] the encoded directory path
-    #
-    def encode_dir(path)
-      path.gsub(".hg/",".hg.hg/").gsub(".i/",".i.hg/").gsub(".d/",".d.hg/")
-    end
-    
-    ##
-    # Decodes the directory to avoid naming conflicts
-    # @param [String] path the path to decode for naming conflict issues
-    # @return [String] the decoded directory path
-    #
-    def decode_dir(path)
-      path.gsub(".d.hg/",".d/").gsub(".i.hg/",".i/").gsub(".hg.hg/",".hg/")
-    end
-    
-    ##
-    # Reads the data of the revision, ignoring the meta data for copied files
-    # @param [String] node the node_id to read
-    # @return [String] the data of the revision
-    #
-    def read(node)
-      t = decompress_revision(node)
-      return t unless t.start_with?("\1\n")
-
-      start = t.index("\1\n", 2)
-      t[(start+2)..-1]
-    end
-    
-    ##
-    # Reads the meta data in the node
-    # @param [String] node the node_id to read the meta of
-    # @return [Hash] the meta data in this revision. Could be empty hash.
-    #
-    def read_meta(node)
-      t = decompress_revision(node)
-      return {} unless t.start_with?("\1\n")
-      
-      start = t.index("\1\n", 2)
-      mt = t[2..(start-1)]
-      m = {}
-      mt.split("\n").each do |l|
-        k, v = l.split(": ", 2)
-        m[k] = v
-      end
-      m
-    end
-    
-    ##
-    # Adds a revision to the file's history. Overridden for special metadata
-    # 
-    # @param [String] text the new text of the file
-    # @param [Hash] meta the meta data to use (if we copied)
-    # @param [Journal] journal for aborting transaction
-    # @param [Integer] link the revision number this is linked to
-    # @param [Integer] p1 (nil) the first parent of this new revision
-    # @param [Integer] p2 (nil) the second parent of this new revision
-    # @param [String] digest referring to the node this makes
-    def add(text, meta, journal, link, p1=nil, p2=nil)
-      if (meta && meta.any?) || text.start_with?("\1\n")
-        mt = ""
-        mt = meta.map {|k, v| "#{k}: #{v}\n"} if meta
-        text = "\1\n" + mt.join + "\1\n" + text
-      end
-      add_revision(text, journal, link, p1, p2)
-    end
-    
-    ##
-    # Returns whether or not the file at _node_ has been renamed or
-    # copied.
-    # 
-    # @param [String] node the node_id of the revision
-    # @return [Boolean] has the file been renamed or copied at this
-    #   revision?
-    def renamed(node)
-      return false if parents_for_node(node).first != NULL_ID
-      
-      m = read_meta node
-      
-      if m.any? && m["copy"]
-        return [m["copy"], m["copyrev"].unhexlify]
-      end
-      
-      false
-    end
-    alias_method :renamed?, :renamed
-    
-    ##
-    # Yields a block for every revision, while being sure to follow copies.
-    def each(&block)
-      if @index[0].parent_one_rev == NULL_REV
-        meta_info = renamed(@index[0].node_id)
-        if meta_info
-          copied_log = FileLog.new(@opener, meta_info.first)
-          copied_log.each(&block)
-        end
-      end
-      super(&block)
-    end
-    
-    ##
-    # Unified diffs 2 revisions, based on their indices. They are returned in a sexified
-    # unified diff format.
-    def unified_revision_diff(rev1, old_date, rev2, new_date, path1, path2, opts={})
-      opts = Diffs::MercurialDiff::DEFAULT_OPTIONS.merge(opts)
-      version_1 = rev1 ? read(self.node_id_for_index(rev1)) : nil
-      version_2 = rev2 ? read(self.node_id_for_index(rev2)) : nil
-      
-      Diffs::MercurialDiff.unified_diff( version_1, old_date, version_2, new_date,
-                                      path1, path2, false, opts)
-    end
-    
-    ##
-    # Gets the size of the file. Overridden because of the metadata for
-    # copied files.
-    # 
-    # @param [Integer] rev the number of the revision to lookup
-    # @return [String] the file's data
-    def size(rev)
-      node = self.node rev
-      if renamed? node
-        read(node).size
-      else
-        self[rev].compressed_len
-      end
-    end
-    
-    ##
-    # Converts a given node in this revision with the text provided.
-    # overridden because it handles renamed files.
-    # 
-    # @param [String] thenode the node ID to use
-    # @param [String] text the text to compare against
-    # @return [Boolean] true if they're different, false if not. silly, isn't
-    #   it?
-    def cmp(thenode, text)
-      if renamed? thenode
-        t2 = read thenode
-        return t2 != text
-      end
-      super(thenode, text)
-    end
-  end # class FileLog
-  
-end # module Amp

data/lib/amp/revlogs/index.rb

@@ -1,493 +0,0 @@
-module Amp
-  module RevlogSupport
-    include Node
-    
-    ##
-    # This class represents one revision entry in the index.
-    #
-    # Format on disk (in BitStruct notation):
-    #
-    #       default_options :endian => :network
-    #       
-    #       signed :offset_flags, 64
-    #       signed :compressed_len, 32
-    #       signed :uncompressed_len, 32
-    #       signed :base_rev, 32
-    #       signed :link_rev, 32
-    #       signed :parent_one_rev, 32
-    #       signed :parent_two_rev, 32
-    #       char :node_id, 160
-    #       pad  :padding, 96
-    #
-    # [offset_flags] - this is a double-word (8 bytes) - that combines the offset into the data file
-    # and any flags about the entry
-    # [compressed_len] - this is the length of the data when compressed
-    # [uncompresed_len] - length of the data uncompresed
-    # [base_rev] - the revision of the filelog
-    # [link_rev] - the revision of the whole repo where this was attached
-    # [parent_one_rev] - the parent revision the revision. Even if it's not a merge,
-    # it will have at least this parent entry
-    # [parent_two_rev] - if the revision is a merge, then it will have a second parent.
-    class IndexEntry < Struct.new(:offset_flags, :compressed_len, :uncompressed_len, :base_rev,
-                                  :link_rev, :parent_one_rev, :parent_two_rev, :node_id)
-      include Comparable
-      INDEX_FORMAT_NG = "Q NNNNNN a20 x12"
-      BLOCK_SIZE = 64
-      def initialize(*args)
-        if args.size == 1 && args[0].respond_to?(:read)
-          super(*(args[0].read(BLOCK_SIZE).unpack(INDEX_FORMAT_NG)))
-        else
-          super(*args)
-        end
-      end
-      
-      def to_s
-        fix_signs
-        ret = self.to_a.pack(INDEX_FORMAT_NG)
-        fix_signs
-        ret
-      end
-      
-      # Fixes the values to force them to be signed (possible to be negative)
-      def fix_signs
-        require 'amp/dependencies/amp_support/ruby_amp_support'
-
-        self.offset_flags     = self.offset_flags.byte_swap_64
-        self.compressed_len   = self.compressed_len.to_signed_32
-        self.uncompressed_len = self.uncompressed_len.to_signed_32
-        self.base_rev         = self.base_rev.to_signed_32
-        self.link_rev         = self.link_rev.to_signed_32
-        self.parent_one_rev   = self.parent_one_rev.to_signed_32
-        self.parent_two_rev   = self.parent_two_rev.to_signed_32
-        
-        self
-      end
-      
-      # Compares this entry to another
-      def <=> other_entry
-        this.base_rev <=> other_entry.base_rev
-      end
-      
-      # Gives a hash value so we can stick these entries into a hash
-      def hash
-        node_id.hash
-      end
-    end
-    
-    ##
-    # = Index
-    # The Index is a file that keeps track of the revision data. All revisions
-    # go through an index. This class, {Index}, is the most basic class. It
-    # provides an Index.parse method so that you can read a file in, and
-    # the class will figure out which version it is, and all that jazz.
-    #
-    class Index
-      include Amp::RevlogSupport::Support
-      include Enumerable
-      
-      # This is the packed format of the version number of the index.
-      VERSION_FORMAT = "N"
-      # The version (either {REVLOG_VERSION_0} or {REVLOG_VERSION_NG})
-      attr_reader :version
-      # The actual lookup array. Each revision has an index in this list, and
-      # that list also happens to be relatively chronological.
-      attr_reader :index
-      # This node_map lets you look up node_id's (NOT INDEX-NUMBERS),
-      # which are strings, and get the index into @index of the
-      # node you're looking up.
-      attr_reader :node_map
-      # This allows a couple neat caching tricks to speed up acces and cut
-      # down on IO.
-      attr_reader :chunk_cache
-      # This is the path to the index file. Can be a URL. I don't care and
-      # neither should you.
-      attr_reader :indexfile
-      # This is the raw cache data. Another helpful bit.
-      attr_accessor :cache
-      
-      ##
-      # This method will parse the file at the provided path and return
-      # an appropriate Index object. The object will be of the class that
-      # fits the file provided, based on version and whether
-      # it is inline.
-      # 
-      # @param [String] inputfile the filepath to load and parse
-      # @return [Index] Some subclassed version of Index that's parsed the file
-      def self.parse(opener, inputfile)
-        versioninfo = REVLOG_DEFAULT_VERSION
-        i = ""
-        begin
-          opener.open(inputfile) do |f|
-            i = f.read(4)
-          end
-          versioninfo = i.unpack(VERSION_FORMAT).first if i.size > 0
-          # Check if the data is with the index info.
-          inline = (versioninfo & REVLOG_NG_INLINE_DATA > 0) 
-          # Get the version number of the index file.
-          version = Support.get_version versioninfo
-        rescue
-          inline = true
-          version = REVLOG_VERSION_NG
-        end
-        
-        # Pick a subclass for the version and in-line-icity we found.
-        case [version, inline]
-        when [REVLOG_VERSION_0, false]
-          IndexVersion0.new opener, inputfile
-        when [REVLOG_VERSION_NG, false]
-          IndexVersionNG.new opener, inputfile
-        when [REVLOG_VERSION_NG, true]
-          IndexInlineNG.new opener, inputfile
-        else
-          raise RevlogError.new("Invalid format: #{version} flags: #{get_flags(versioninfo)}")
-        end
-      end
-      
-      ##
-      # Returns whether a given node ID exists, without throwing a lookup error.
-      #
-      # @param [String] node the node_id to lookup. 20 bytes, binary.
-      # @return [Boolean] is the node in the index?
-      def has_node?(node)
-        @node_map[node]
-      end
-      
-      ##
-      # This provides quick lookup into the index, based on revision
-      # number. NOT ID's, index numbers.
-      # 
-      # @param [Fixnum] index the index to look up
-      # @return [IndexEntry] the revision requested
-      def [](index)
-        @index[index]
-      end
-      ##
-      # This method writes the index to file. Pretty 1337h4><.
-      #
-      # @param [String] index_file the path to the index file.
-      def write_entry(index_file, journal) 
-        raise abort("Use a concrete class. Yeah, I called it a concrete class. I hate" +
-                             " Java too, but you tried to use an abstract class.")
-      end
-      
-      ##
-      # Adds an item to the index safely. DO NOT USE some_index.index <<. It's
-      # some_index << entry.
-      # 
-      # @param [[Integer, Integer, Integer, Integer, Integer, Integer,
-      #   Integer, Integer]] item the data to enter as an entry. See the spec fo
-      #   {IndexEntry}.
-      def <<(item)
-        @index.insert(-2, IndexEntry.new(*item)) if item.is_a? Array
-        @index.insert(-2, item) if item.is_a? IndexEntry
-        # leave the terminating entry intact
-      end
-      
-      # Returns the number of entries in the index, including the null revision
-      def size
-        @index.size
-      end
-      
-      # Iterates over each entry in the index, including the null revision
-      def each(&b)
-        @index.each(&b)
-      end
-    end
-    
-    ##
-    # = IndexVersion0
-    # This handles old versions of the index file format.
-    # These are apparently so old they were version 0.
-    class IndexVersion0 < Index
-      # Binary data format for each revision entry
-      INDEX_FORMAT_V0 = "N4 a20 a20 a20"
-      # The size of each revision entry
-      BLOCK_SIZE = (4 * 4) + (3 * 20)
-      # The offset into the entry where the SHA1 is stored for validation
-      SHA1_OFFSET = 56
-      
-      # Return the size of 1 entry
-      def entry_size; BLOCK_SIZE; end
-      # Return what version this index is
-      def version; REVLOG_VERSION_0; end
-      # Does the index store the data with the revision index entries?
-      def inline?; false; end
-      
-      # Initializes the index by reading from the provided filename. Users probably
-      # don't need this because {Index}#{parse} will do this for you.
-      # 
-      # @param [String] inputfile the path to the index file
-      def initialize(opener, inputfile)
-        @opener = opener
-        @indexfile = inputfile
-        @node_map  = {Node::NULL_ID => Node::NULL_REV}
-        @index = []
-        n = offset = 0
-        if File.exists?(opener.join(inputfile))
-          opener.open(inputfile) do |f|
-            
-            while !f.eof?
-              current = f.read(BLOCK_SIZE)
-              entry = current.unpack(INDEX_FORMAT_V0)
-              new_entry = IndexEntry.new(offset_version(entry[0],0), entry[1], -1, entry[2], entry[3],
-                                         (@node_map[entry[4]] || nullrev), (@node_map[entry[5]] || nullrev), 
-                                         entry[6])
-              @index << new_entry.fix_signs
-              @node_map[entry[6]] = n
-              n += 1
-            end
-          end
-        end
-        @cache = nil
-        self
-      end
-      
-      ##
-      # This method writes the index to file. Pretty 1337h4><.
-      #
-      # @param [String] index_file the path to the index file.
-      def write_entry(index_file, entry, journal, data)
-        curr = self.size - 1
-        
-        node_map[entry.last] = curr
-        
-        link = entry[4]
-        data_file = index_file[0..-3] + ".d"
-        
-        entry = pack_entry entry, link
-        
-        data_file_handle = open(data_file, "a")
-        index_file_handle = open(index_file, "a+")
-        
-        journal << [data_file, offset]
-        journal << [index_file, curr * entry.size]
-        
-        data_file_handle.write data[:compression] if data[:compression].any?
-        data_file_handle.write data[:text]
-        
-        data_file_handle.flush
-        index_file_handle.write entry
-      end
-      ##
-      # This takes an entry and packs it into binary data for writing to
-      # the file.
-      # 
-      # @param [IndexEntry] entry the revision entry to pack up for writing
-      # @param rev unused by version 0. Kept to make the interface uniform
-      # @return [String] the Binary data packed up for writing.
-      def pack_entry(entry, rev)
-        entry = IndexEntry.new(*entry) if entry.kind_of? Array
-        entry.fix_signs
-        e2 = [RevlogSupport::Support.offset_type(entry.offset_flags), 
-              entry.compressed_len, entry.base_rev, entry.link_rev,
-              @index[entry.parent_one_rev].node_id, 
-              @index[entry.parent_two_rev].node_id, entry.node_id]
-        e2.pack(INDEX_FORMAT_V0)
-      end
-    end
-    
-    ##
-    # = IndexVersionNG
-    # This is the current version of the index. I'm not sure why they call
-    # it Version 'NG' but they do. An index of this type is *not* inline.
-    class IndexVersionNG < Index
-      VERSION_FORMAT = "N"
-      # The binary format used for pack/unpack
-      INDEX_FORMAT_NG = "Q NNNNNN a20 x12"
-      # The distance into the entry to go to find the SHA1 hash
-      SHA1_OFFSET = 32
-      # The size of a single block in the index
-      BLOCK_SIZE = 8 + (6 * 4) + 20 + 12
-      
-      ##
-      # Initializes the index by parsing the given file.
-      # 
-      # @param [String] inputfile the path to the index file.
-      def initialize(opener, inputfile)
-        @opener = opener
-        @indexfile = inputfile
-        @cache = nil
-        @index = []
-        @node_map = {Node::NULL_ID => Node::NULL_REV}
-                
-        opened = parse_file
-        
-        if opened
-          first_entry = @index[0]
-          type = get_version(first_entry.offset_flags)
-          first_entry.offset_flags = offset_version(0, type) #turn off inline
-          @index[0] = first_entry
-        end
-        
-        @index << IndexEntry.new(0,0,0,-1,-1,-1,-1,Node::NULL_ID)
-      end
-      
-      ##
-      # returns the size of 1 block in this type of index
-      def entry_size; BLOCK_SIZE; end
-      
-      # returns the version number of the index
-      def version; REVLOG_VERSION_NG; end
-      # returns whether or not the index stores data with revision info
-      def inline?; false; end
-      
-      ##
-      # Parses each index entry. Internal use only.
-      #
-      # @return [Boolean] whether the file was opened
-      def parse_file
-        n = 0
-        begin
-          @opener.open(@indexfile,"r") do |f|
-            until f.eof?
-              # read the entry
-              entry = IndexEntry.new(f).fix_signs
-              # store it in the map
-              @node_map[entry.node_id] = n
-              # add it to the index
-              @index << entry
-              n += 1
-            end
-          end
-          return true
-        rescue Errno::ENOENT
-          return false
-        end
-      end
-      
-      ##
-      # Packs up the revision entry for writing to the binary file.
-      # 
-      # @param [IndexEntry] entry this is the entry that has to be formatted
-      #   into binary.
-      # @param [Fixnum] rev this is the index number of the entry - if it's
-      #   the first revision (rev == 0) then we treat it slightly differently.
-      # @return [String] the entry converted into binary suitable for writing.
-      def pack_entry(entry, rev)
-        entry = IndexEntry.new(*entry) if entry.kind_of? Array
-        p = entry.to_s
-        if rev == 0 || rev == 1
-          p = [version].pack(VERSION_FORMAT) + p[4..-1] # initial entry
-        end
-        p
-      end
-      
-      ##
-      # This method writes the index to file. Pretty 1337h4><.
-      #
-      # @param [String] index_file the path to the index file.
-      def write_entry(index_file, entry, journal, data, index_file_handle = nil)
-        curr = self.size - 1
-        
-        link = (entry.is_a? Array) ? entry[4] : entry.link_rev
-        data_file = index_file[0..-3] + ".d"
-        
-        entry = pack_entry entry, link
-        
-        @opener.open(data_file, "a+") do |data_file_handle|
-          data_file_handle.write data[:compression] if data[:compression].any?
-          data_file_handle.write data[:text]
-          
-          data_file_handle.flush
-        end
-        
-        index_file_handle ||= (opened = true && @opener.open(index_file, "a+"))
-        
-        index_file_handle.write entry
-        index_file_handle.close if opened
-        
-        #journal << [data_file, offset]
-        #journal << [index_file, curr * entry.size]
-      end
-
-    end
-    
-    ##
-    # = LazyIndex
-    # When this gets filled in, this class will let us access an index without loading
-    # every entry first. This is handy because index files can get pretty fuckin big.
-    class LazyIndex < Index
-      
-    end
-    
-    ##
-    # = IndexInlineNG
-    # This is a variant of the current version of the index format, in which the data
-    # is stored in the actual index file itself, right after the little revision
-    # entry block (see {IndexEntry}). This means less IO, which is good.
-    #
-    class IndexInlineNG < IndexVersionNG
-      VERSION_FORMAT = "N"
-      # We're inline!
-      INDEX_FORMAT_NG = "Q NNNNNN a20 x12"
-      # The distance into the entry to go to find the SHA1 hash
-      SHA1_OFFSET = 32
-      # The size of a single block in the index
-      BLOCK_SIZE = 8 + (6 * 4) + 20 + 12
-      
-      def inline?; true; end
-      def version; REVLOG_VERSION_NG | REVLOG_NG_INLINE_DATA; end
-      def pack_entry(entry, rev)
-        entry = IndexEntry.new(*entry) if entry.kind_of? Array
-        p = entry.to_s
-        if rev == 0 || rev == 1
-          p = [version].pack(VERSION_FORMAT) + p[4..-1] # initial entry
-        end
-        p
-      end
-      
-      
-      ##
-      # @todo "not sure what the 0 is for yet or i'd make this a hash" (see code)
-      # This method overrides the parent class' method that reads entries sequentially
-      # from the index file. Each entry is followed by the data for that revision
-      # so we have to skip over that data for our purposes.
-      def parse_file
-        n = offset = 0
-        begin
-          @opener.open(@indexfile,"r") do |f|
-            return false if f.eof?
-            while !f.eof?
-              # read 1 entry
-              entry = IndexEntry.new(f).fix_signs
-              # store it in the map
-              @node_map[entry.node_id] = n
-              # add it to the index
-              @index << entry
-              n += 1
-              break if entry.compressed_len < 0
-              
-              # skip past the data, too!
-              f.seek(entry.compressed_len, IO::SEEK_CUR)
-            end
-          end
-          return true
-        rescue Errno::ENOENT
-          return false
-        end
-      end
-      
-      ##
-      # This method writes the index to file. Pretty 1337h4><.
-      #
-      # @param [String] index_file the path to the index file.
-      def write_entry(index_file, entry, journal, data, index_file_handle = nil)
-        curr = self.size - 1
-        link = (entry.is_a? Array) ? entry[4] : entry.link_rev
-        
-        entry = pack_entry entry, curr
-        
-        index_file_handle ||= (opened = true && @opener.open(index_file, "a+"))
-        
-        index_file_handle.write entry
-        index_file_handle.write data[:compression] if data[:compression].any?
-        index_file_handle.write data[:text]
-        
-        index_file_handle.close if opened
-        
-      end
-      
-
-    end
-  end
-end