georgi-git_store 0.1.1 → 0.2

data/lib/git_store/pack.rb

@@ -0,0 +1,417 @@
+#
+# converted from the gitrb project
+#
+# authors: 
+#    Matthias Lederhofer <matled@gmx.net>
+#    Simon 'corecode' Schubert <corecode@fs.ei.tum.de>
+#    Scott Chacon <schacon@gmail.com>
+#
+# provides native ruby access to git objects and pack files
+#
+
+require 'zlib'
+
+class GitStore
+  PACK_SIGNATURE = "PACK" 
+  PACK_IDX_SIGNATURE = "\377tOc" 
+
+  class Mmap
+    def initialize(file, version = 1)
+      @file = file
+      @offset = nil
+      if version == 2
+        @global_offset = 8
+      else
+        @global_offset = 0
+      end
+    end
+
+    def unmap
+      @file = nil
+    end
+
+    def [](*idx)
+      idx = idx[0] if idx.length == 1
+      case idx
+      when Range
+        offset = idx.first
+        len = idx.last - idx.first + idx.exclude_end? ? 0 : 1
+      when Fixnum
+        offset = idx
+        len = nil
+      when Array
+        offset, len = idx
+      else
+        raise RuntimeError, "invalid index param: #{idx.class}"
+      end
+      if @offset != offset
+        @file.seek(offset + @global_offset)
+      end
+      @offset = offset + len ? len : 1
+      if not len
+        @file.read(1)[0]
+      else
+        @file.read(len)
+      end
+    end
+  end
+  
+  class PackFormatError < StandardError
+  end
+
+  class PackStorage
+    OBJ_OFS_DELTA = 6
+    OBJ_REF_DELTA = 7
+
+    FanOutCount = 256
+    SHA1Size = 20
+    IdxOffsetSize = 4
+    OffsetSize = 4
+    CrcSize = 4
+    OffsetStart = FanOutCount * IdxOffsetSize
+    SHA1Start = OffsetStart + OffsetSize
+    EntrySize = OffsetSize + SHA1Size
+    EntrySizeV2 = SHA1Size + CrcSize + OffsetSize
+
+    def initialize(file)
+      if file =~ /\.idx$/
+        file = file[0...-3] + 'pack'
+      end
+      @name = file
+      @cache = {}
+      init_pack
+    end
+    
+    def with_idx(index_file = nil)
+      if !index_file
+        index_file = @name
+        idxfile = File.open(@name[0...-4]+'idx')
+      else
+        idxfile = File.open(index_file)
+      end
+      
+      # read header
+      sig = idxfile.read(4)
+      ver = idxfile.read(4).unpack("N")[0]
+      
+      if sig == PACK_IDX_SIGNATURE
+        if(ver != 2)
+          raise PackFormatError, "pack #@name has unknown pack file version #{ver}"
+        end            
+        @version = 2
+      else
+        @version = 1
+      end
+      
+      idx = Mmap.new(idxfile, @version)
+      yield idx
+      idx.unmap
+      idxfile.close
+    end
+    
+    def with_packfile
+      packfile = File.open(@name)
+      yield packfile
+      packfile.close
+    end
+    
+    def cache_objects
+      @cache = {}
+      with_packfile do |packfile|          
+        each_entry do |sha, offset|
+          data, type = unpack_object(packfile, offset, {:caching => true})
+          if data
+            @cache[sha] = [type, data]
+          end
+        end
+      end
+    end
+
+    def name
+      @name
+    end
+    
+    def close
+      # shouldnt be anything open now
+    end
+
+    # given an index file, list out the shas that it's packfile contains
+    def get_shas
+      shas = []
+      each_sha1 { |sha| shas << sha.unpack("H*")[0] }
+      shas
+    end
+    
+    def [](sha1)
+      if obj = @cache[sha1]
+        return obj 
+      end
+      
+      offset = find_object(sha1)
+      return nil if !offset
+      @cache[sha1] = obj = parse_object(offset)
+      return obj
+    end
+
+    def init_pack
+      with_idx do |idx|
+        @offsets = [0]
+        FanOutCount.times do |i|
+          pos = idx[i * IdxOffsetSize,IdxOffsetSize].unpack('N')[0]
+          if pos < @offsets[i]
+            raise PackFormatError, "pack #@name has discontinuous index #{i}"
+          end
+          @offsets << pos
+        end
+        @size = @offsets[-1]
+      end
+    end
+    
+    def each_entry
+      with_idx do |idx|
+        if @version == 2
+          data = read_data_v2(idx)
+          data.each do |sha1, crc, offset|
+            yield sha1, offset
+          end
+        else
+          pos = OffsetStart
+          @size.times do
+            offset = idx[pos,OffsetSize].unpack('N')[0]
+            sha1 = idx[pos+OffsetSize,SHA1Size]
+            pos += EntrySize
+            yield sha1, offset
+          end
+        end
+      end
+    end
+    
+    def read_data_v2(idx)
+      data = []
+      pos = OffsetStart
+      @size.times do |i|
+        data[i] = [idx[pos,SHA1Size], 0, 0]
+        pos += SHA1Size
+      end
+      @size.times do |i|
+        crc = idx[pos,CrcSize]
+        data[i][1] = crc
+        pos += CrcSize
+      end
+      @size.times do |i|
+        offset = idx[pos,OffsetSize].unpack('N')[0]
+        data[i][2] = offset
+        pos += OffsetSize
+      end
+      data
+    end
+    private :read_data_v2
+    
+    def each_sha1
+      with_idx do |idx|
+        if @version == 2
+          data = read_data_v2(idx)
+          data.each do |sha1, crc, offset|
+            yield sha1
+          end
+        else
+          pos = SHA1Start
+          @size.times do
+            sha1 = idx[pos,SHA1Size]
+            pos += EntrySize
+            yield sha1
+          end
+        end
+      end
+    end
+
+    def find_object_in_index(idx, sha1)
+      slot = sha1[0]
+      return nil if !slot
+      first, last = @offsets[slot,2] 
+      while first < last
+        mid = (first + last) / 2
+        if @version == 2
+          midsha1 = idx[OffsetStart + (mid * SHA1Size), SHA1Size]
+          cmp = midsha1 <=> sha1
+
+          if cmp < 0
+            first = mid + 1
+          elsif cmp > 0
+            last = mid
+          else
+            pos = OffsetStart + (@size * (SHA1Size + CrcSize)) + (mid * OffsetSize)
+            offset = idx[pos, OffsetSize].unpack('N')[0]
+            return offset
+          end
+        else
+          midsha1 = idx[SHA1Start + mid * EntrySize,SHA1Size]
+          cmp = midsha1 <=> sha1
+
+          if cmp < 0
+            first = mid + 1
+          elsif cmp > 0
+            last = mid
+          else
+            pos = OffsetStart + mid * EntrySize
+            offset = idx[pos,OffsetSize].unpack('N')[0]
+            return offset
+          end
+        end
+      end
+      nil
+    end
+    
+    def find_object(sha1)
+      obj = nil
+      with_idx do |idx|
+        obj = find_object_in_index(idx, sha1)
+      end
+      obj
+    end    
+    private :find_object
+    
+    def parse_object(offset)
+      obj = nil
+      with_packfile do |packfile|
+        data, type = unpack_object(packfile, offset)
+        obj = RawObject.new(OBJ_TYPES[type], data)
+      end
+      obj
+    end
+    protected :parse_object
+
+    def unpack_object(packfile, offset, options = {})
+      obj_offset = offset
+      packfile.seek(offset)
+
+      c = packfile.read(1)[0]
+      size = c & 0xf
+      type = (c >> 4) & 7
+      shift = 4
+      offset += 1
+      while c & 0x80 != 0
+        c = packfile.read(1)[0]
+        size |= ((c & 0x7f) << shift)
+        shift += 7
+        offset += 1
+      end
+      
+      return [false, false] if !(type == OBJ_COMMIT || type == OBJ_TREE) && options[:caching]
+      
+      case type
+      when OBJ_OFS_DELTA, OBJ_REF_DELTA
+        data, type = unpack_deltified(packfile, type, offset, obj_offset, size, options)
+        #puts type
+      when OBJ_COMMIT, OBJ_TREE, OBJ_BLOB, OBJ_TAG
+        data = unpack_compressed(offset, size)
+      else
+        raise PackFormatError, "invalid type #{type}"
+      end
+      [data, type]
+    end
+    private :unpack_object
+
+    def unpack_deltified(packfile, type, offset, obj_offset, size, options = {})
+      packfile.seek(offset)
+      data = packfile.read(SHA1Size)
+
+      if type == OBJ_OFS_DELTA
+        i = 0
+        c = data[i]
+        base_offset = c & 0x7f
+        while c & 0x80 != 0
+          c = data[i += 1]
+          base_offset += 1
+          base_offset <<= 7
+          base_offset |= c & 0x7f
+        end
+        base_offset = obj_offset - base_offset
+        offset += i + 1
+      else
+        base_offset = find_object(data)
+        offset += SHA1Size
+      end
+
+      base, type = unpack_object(packfile, base_offset)
+      
+      return [false, false] if !(type == OBJ_COMMIT || type == OBJ_TREE) && options[:caching]
+      
+      delta = unpack_compressed(offset, size)
+      [patch_delta(base, delta), type]
+    end
+    private :unpack_deltified
+
+    def unpack_compressed(offset, destsize)
+      outdata = ""
+      with_packfile do |packfile|
+        packfile.seek(offset)
+        zstr = Zlib::Inflate.new
+        while outdata.size < destsize
+          indata = packfile.read(4096)
+          if indata.size == 0
+            raise PackFormatError, 'error reading pack data'
+          end
+          outdata += zstr.inflate(indata)
+        end
+        if outdata.size > destsize
+          raise PackFormatError, 'error reading pack data'
+        end
+        zstr.close
+      end
+      outdata
+    end
+    private :unpack_compressed
+
+    def patch_delta(base, delta)
+      src_size, pos = patch_delta_header_size(delta, 0)
+      if src_size != base.size
+        raise PackFormatError, 'invalid delta data'
+      end
+
+      dest_size, pos = patch_delta_header_size(delta, pos)
+      dest = ""
+      while pos < delta.size
+        c = delta[pos]
+        pos += 1
+        if c & 0x80 != 0
+          pos -= 1
+          cp_off = cp_size = 0
+          cp_off = delta[pos += 1] if c & 0x01 != 0
+          cp_off |= delta[pos += 1] << 8 if c & 0x02 != 0
+          cp_off |= delta[pos += 1] << 16 if c & 0x04 != 0
+          cp_off |= delta[pos += 1] << 24 if c & 0x08 != 0
+          cp_size = delta[pos += 1] if c & 0x10 != 0
+          cp_size |= delta[pos += 1] << 8 if c & 0x20 != 0
+          cp_size |= delta[pos += 1] << 16 if c & 0x40 != 0
+          cp_size = 0x10000 if cp_size == 0
+          pos += 1
+          dest += base[cp_off,cp_size]
+        elsif c != 0
+          dest += delta[pos,c]
+          pos += c
+        else
+          raise PackFormatError, 'invalid delta data'
+        end
+      end
+      dest
+    end
+    private :patch_delta
+
+    def patch_delta_header_size(delta, pos)
+      size = 0
+      shift = 0
+      begin
+        c = delta[pos]
+        if c == nil
+          raise PackFormatError, 'invalid delta header'
+        end
+        pos += 1
+        size |= (c & 0x7f) << shift
+        shift += 7
+      end while c & 0x80 != 0
+      [size, pos]
+    end
+    private :patch_delta_header_size
+  end
+end

data/lib/git_store/tree.rb

@@ -0,0 +1,207 @@
+require 'strscan'
+
+class GitStore
+
+  class Tree
+    TYPE_CLASS = {
+      'tree' => Tree,
+      'blob' => Blob
+    }
+    
+    include Enumerable
+
+    attr_reader :store
+    attr_accessor :id, :mode, :path, :data, :table
+
+    # Initialize a tree with default mode '040000'
+    def initialize(store)
+      @store = store      
+      @mode ||= '040000'
+      @path = ''
+      @table = {}
+    end
+
+    # Set all attributes at once.
+    def set(id, mode = '040000', path = nil, data = nil)
+      @id, @mode, @path, @data = id, mode, path, data
+    end
+
+    # Does this tree exist in the repository?
+    def created?
+      not @id.nil?
+    end
+
+    # Has this tree been modified?
+    def modified?
+      @modified || (table && table.values.any? { |value| value.modified? })
+    end
+
+    # Path of a child element with specified name.
+    def child_path(name)
+      path.empty? ? name : "#{path}/#{name}"
+    end
+
+    # Find or create a subtree with specified name.
+    def tree(name)
+      get(name) or put(name, Tree.new(store))
+    end
+
+    # Load this tree from a real directory instead of a repository.
+    def load_from_disk
+      dir = File.join(store.path, self.path)
+      entries = Dir.entries(dir) - ['.', '..']
+      @table = entries.inject({}) do |hash, name|
+        if name[-1, 1] != '~' && name[0, 1] != '.'
+          path = "#{dir}/#{name}"
+          stat = File.stat(path)
+          mode = '%o' % stat.mode
+          klass = stat.directory? ? Tree : Blob
+          
+          child = table[name] ||= klass.new(store)
+          child.set(nil, mode, child_path(name), data)
+          child.load_from_disk
+          
+          hash[name] = child
+        end        
+        hash
+      end
+    end
+
+    # Read the contents of a raw git object.
+    #
+    # Return an array of [mode, name, id] entries.
+    def read_contents(data)
+      scanner = StringScanner.new(data)
+      contents = []
+      
+      while scanner.scan(/(.*?) (.*?)\0(.{20})/m)
+        contents << [scanner[1], scanner[2], scanner[3].unpack("H*").first]
+      end
+
+      contents
+    end
+
+    # Load this tree from a git repository.
+    def load_from_store
+      @table = read_contents(data).inject({}) do |hash, (mode, name, id)|
+        content, type = store.get_object(id)
+
+        child = table[name] || TYPE_CLASS[type].new(store)
+        child.set(id, mode, child_path(name), content)
+        child.load_from_store if Tree === child
+
+        hash[name] = child
+        hash
+      end
+    end
+
+    # Write this tree back to the git repository.
+    #
+    # Returns the object id of the tree.
+    def write_to_store
+      return id if not modified?
+      
+      contents = table.map do |name, entry|
+        entry.write_to_store
+        "%s %s\0%s" % [entry.mode, name, [entry.id].pack("H*")]
+      end
+
+      @modified = false
+      @id = store.put_object(contents.join, 'tree')
+    end
+    
+    # Read entry with specified name.
+    def get(name)
+      name = name.to_s
+      entry = table[name]
+      
+      case entry
+      when Blob; entry.object
+      when Tree; entry
+      end
+    end
+
+    # Write entry with specified name.
+    def put(name, value)
+      @modified = true
+      name = name.to_s
+      
+      if value.is_a?(Tree)
+        value.path = child_path(name)
+        table[name] = value
+      else
+        blob = table[name]
+        blob = Blob.new(store) if not blob.is_a?(Blob)
+        blob.path = child_path(name)
+        blob.object = value
+        table[name] = blob          
+      end
+
+      value
+    end
+
+    # Remove entry with specified name.
+    def remove(name)
+      @modified = true
+      table.delete(name.to_s)
+    end
+
+    # Does this key exist in the table?
+    def has_key?(name)
+      table.has_key?(name)
+    end
+
+    # Read a value on specified path.
+    #
+    # Use an argument list or a string with slashes.
+    def [](*args)
+      args = args.first.to_s.split('/') if args.size == 1
+      args.inject(self) { |tree, key| tree.get(key) or return nil }
+    end
+
+    # Write a value on specified path.
+    #
+    # Use an argument list or a string with slashes.
+    def []=(*args)
+      value = args.pop
+      args = args.first.to_s.split('/') if args.size == 1
+      tree = args[0..-2].to_a.inject(self) { |tree, name| tree.tree(name) }
+      tree.put(args.last, value)
+    end
+
+    # Delete a value on specified path.
+    #
+    # Use an argument list or a string with slashes.
+    def delete(*args)
+      args = args.first.to_s.split('/') if args.size == 1
+      tree = args[0..-2].to_a.inject(self) do |tree, key|
+        tree.get(key) or return
+      end
+      tree.remove(args.last)
+    end
+
+    # Iterate over all objects found in this subtree.
+    def each(&block)
+      table.sort.each do |name, entry|
+        case entry
+        when Blob; yield entry.object
+        when Tree; entry.each(&block)
+        end
+      end
+    end
+
+    # Convert this tree into a hash object.
+    def to_hash
+      table.inject({}) do |hash, (name, entry)|
+        hash[name] = entry.is_a?(Tree) ? entry.to_hash : entry.object
+        hash
+      end
+    end
+
+    def inspect
+      "#<GitStore::Tree #{id} #{mode} #{to_hash.inspect}>"
+    end
+    
+  end
+
+end