git-object-browser 0.0.2

data/lib/git-object-browser/models/index.rb

@@ -0,0 +1,77 @@
+module GitObjectBrowser
+
+  module Models
+
+    # Parse .git/index file
+    class Index < Bindata
+
+      attr_reader :version, :entry_count, :entries, :extensions, :sha1
+
+      def initialize(input)
+        super(input)
+      end
+
+      def parse
+        dirc = raw(4)
+        if dirc != "DIRC"
+          throw Exception.new("Illegal format.")
+        end
+
+        @version     = int
+        @entry_count = int
+        @entries     = parse_entries
+        @extensions  = parse_extensions
+        @sha1        = hex(20)
+
+        self
+      end
+
+      def parse_entries
+        entries = []
+        @entry_count.times do |i|
+          entries << IndexEntry.new(@in, @version)
+        end
+        return entries
+      end
+
+      def parse_extensions
+        extensions = []
+        while signature = peek(4)
+          if signature == "TREE"
+            extensions << IndexTreeExtension.new(@in).parse
+          elsif  signature == "REUC"
+            extensions << IndexReucExtension.new(@in).parse
+          else
+            break
+          end
+        end
+        return extensions
+      end
+
+      def to_hash
+        entries = []
+        @entries.each do |entry|
+          entries << entry.to_hash
+        end
+
+        extensions = []
+        @extensions.each do |extension|
+          extensions << extension.to_hash
+        end
+
+        return {
+          "version"      => @version,
+          "entry_count"  => @entry_count,
+          "entries"      => entries,
+          "extensions"   => extensions,
+          "sha1"         => @sha1,
+        }
+      end
+
+      def self.path?(relpath)
+        relpath == "index"
+      end
+
+    end
+  end
+end

data/lib/git-object-browser/models/index_entry.rb

@@ -0,0 +1,95 @@
+module GitObjectBrowser
+
+  module Models
+
+    class IndexEntry < Bindata
+
+      attr_reader :version, :ctime, :cnano, :mtime, :mnano, :dev, :ino
+      attr_reader :object_type, :unix_permission
+      attr_reader :uid, :gid, :size, :sha1, :path
+      attr_reader :assume_valid_flag, :extended_flag, :stage
+      attr_reader :skip_worktree, :intent_to_add
+      attr_reader :name_length
+
+      def initialize(input, version)
+        super(input)
+        @version = version
+        parse
+      end
+
+      def parse
+        @ctime = int
+        @cnano = int
+        @mtime = int
+        @mnano = int # 16 byte
+        @dev   = int
+        @ino   = int
+
+        mode   = binstr(4)
+        @object_type     = mode[16..19]
+        unused           = mode[20..22]
+        @unix_permission = sprintf('%o', mode[23..31].to_i(2))
+
+        @uid   = int # 32 bytes
+        @gid   = int
+        @size  = int
+        @sha1  = hex(20)
+        parse_flags # 62 bytes
+        @path  = parse_path
+      end
+
+      def parse_flags
+        flags  = binstr(2)
+        if @version == 2
+          @assume_valid_flag = flags[0..0]
+          @extended_flag     = flags[1..1]
+          @stage             = flags[2..3]
+        elsif @version == 3
+          reserved           = flags[0..0]
+          @skip_worktree     = flags[1..1]
+          @intent_to_add     = flags[2..2]
+        end
+        @name_length = ["0000" + flags[4..15]].pack("B*").unpack("n")[0]
+      end
+
+      # path: 2 + 8 * n bytes (nul pannding)
+      def parse_path
+        token = raw(2) # 64 bytes
+        path = ""
+        begin
+          path += token.unpack("Z*").first
+          break if token.unpack("C*").last == 0
+        end while(token = raw(8))
+        return path
+      end
+
+
+      def to_hash
+        return {
+          "ctime" => @ctime,
+          "cnano" => @cnano,
+          "mtime" => @mtime,
+          "mnano" => @mnano,
+          "dev"   => @dev,
+          "ino"   => @ino,
+          "object_type"       => @object_type,
+          "unix_permission"   => @unix_permission,
+
+          "uid"   => @uid,
+          "gid"   => @gid,
+          "size"  => @size,
+          "sha1"  => @sha1,
+          "path"  => @path,
+
+          "assume_valid_flag" => @assume_valid_flag,
+          "extended_flag"     => @extended_flag,
+          "stage"             => @stage,
+          "skip_worktree"     => @skip_worktree,
+          "intent_to_add"     => @intent_to_add,
+          "name_length"       => @name_length,
+        }
+      end
+
+    end
+  end
+end

data/lib/git-object-browser/models/index_reuc_extension.rb

@@ -0,0 +1,31 @@
+module GitObjectBrowser
+
+  module Models
+
+    class IndexReucExtension < Bindata
+
+      attr_reader :signature, :total_length
+
+      def initialize(input)
+        super(input)
+      end
+
+      def parse
+        @signature = raw(4) # REUC
+        @total_length = int
+
+        data = raw(@total_length) # TODO
+
+        self
+      end
+
+      def to_hash
+        return {
+          "signature" => @signature,
+          "total_length" => @total_length,
+        }
+      end
+
+    end
+  end
+end

data/lib/git-object-browser/models/index_tree_extension.rb

@@ -0,0 +1,52 @@
+module GitObjectBrowser
+
+  module Models
+
+    class IndexTreeExtension < Bindata
+
+      attr_reader :signature, :total_length, :entries
+
+      def initialize(input)
+        super(input)
+      end
+
+      def parse
+        @signature = raw(4) # TREE
+        @total_length = int
+        @entries = []
+
+        length = 0
+        while (length < @total_length)
+          entry = {}
+          entry['path_component'] = find_char "\0"
+          entry['entry_count']    = find_char " "
+          entry['subtree_count']  = find_char "\n"
+
+          length += entry['path_component'].bytesize + 1
+          length += entry['entry_count'].bytesize + 1
+          length += entry['subtree_count'].bytesize + 1
+
+          entry['entry_count']    = entry['entry_count'].to_i
+          entry['subtree_count']  = entry['subtree_count'].to_i
+
+          if 0 <= entry['entry_count']
+            entry['sha1'] = hex(20)
+            length += 20
+          end
+          @entries << entry
+        end
+
+        self
+      end
+
+      def to_hash
+        return {
+          "signature" => @signature,
+          "total_length" => @total_length,
+          "entries" => @entries
+        }
+      end
+
+    end
+  end
+end

data/lib/git-object-browser/models/info_refs.rb

@@ -0,0 +1,32 @@
+
+module GitObjectBrowser
+
+  module Models
+
+    class InfoRefs
+      def initialize(input)
+        @entries = []
+        while (line = input.gets) do
+          next if line =~ /\A\s*#/
+          next unless line =~ /([0-9a-f]{40})\s*(.*)/
+          entry = {}
+          entry[:sha1] = $1
+          entry[:ref]  = $2
+          @entries << entry
+        end
+      end
+
+      def to_hash
+        return {
+          :entries => @entries
+        }
+      end
+
+      def self.path?(relpath)
+        return relpath == "info/refs"
+      end
+
+    end
+
+  end
+end

data/lib/git-object-browser/models/pack_file.rb

@@ -0,0 +1,40 @@
+# -*- coding: utf-8 -*-
+
+
+module GitObjectBrowser
+
+  module Models
+
+    #   signature          4bytes PACK
+    #   version            4bytes
+    #   objects number     4bytes
+    #   object entries     -> packed_object.rb
+    #
+    # https://github.com/git/git/blob/master/Documentation/technical/pack-format.txt
+    class PackFile < Bindata
+      def initialize(input)
+        super(input)
+      end
+
+      def self.path?(relpath)
+        return relpath =~ %r{\Aobjects/pack/pack-[0-9a-f]{40}.pack\z}
+      end
+
+      def parse
+        signature = raw(4)
+        raise 'wrong signature' if signature != 'PACK'
+        @version       = int
+        @object_number = int
+        self
+      end
+
+      def to_hash
+        return {
+          :version => @version,
+          :object_number => @object_number
+        }
+      end
+
+    end
+  end
+end

data/lib/git-object-browser/models/pack_index.rb

@@ -0,0 +1,146 @@
+# -*- coding: utf-8 -*-
+module GitObjectBrowser
+
+  module Models
+
+    # v2
+    #   signature  4bytes
+    #   version    4bytes
+    #   fanout     4bytes * 256
+    #   sha1      20bytes * fanout[255]
+    #   crc        4bytes * fanout[255]
+    #   offset     4bytes * fanout[255]
+    class PackIndex < Bindata
+
+      def initialize(input)
+        super(input)
+      end
+
+      def parse
+        parse_fanout
+
+        @entries = []
+        @fanout[255].times do |i|
+          entry = {}
+          entry[:sha1] = hex(20)
+          @entries << entry
+        end
+
+        @fanout[255].times do |i|
+          @entries[i][:crc32] = hex(4)
+        end
+
+        @fanout[255].times do |i|
+          @entries[i][:offset] = int
+        end
+
+        # XXX Doesn't support packfile >= 2 GiB
+        # x.times do |i|
+        #   puts "offset[#{ i }] = #{ hex(8) }"
+        # end
+
+        @packfile_sha1 = hex(20)
+        @index_sha1 = hex(20)
+
+        self
+      end
+
+      def parse_fanout
+        return if @fanout
+
+        seek(0)
+        signature = raw(4)
+        signature_v2 = [255, 'tOc'].pack('Ca*')
+
+        raise "FIXME" if signature != signature_v2
+        @version = int
+        raise "FIXME" if @version != 2
+
+        @fanout = []
+        256.times do |i|
+          @fanout << int
+        end
+      end
+
+      def find(sha1_hex)
+        parse_fanout
+        sha1 = [sha1_hex].pack("H*")
+        fanout_idx = sha1.unpack("C").first
+
+        lo = fanout_idx == 0 ? 0 : @fanout[fanout_idx - 1]
+        hi = @fanout[fanout_idx]
+
+        while lo < hi
+          mid = (lo + hi) / 2
+          mid_sha1 = get_sha1(mid)
+          if mid_sha1 == sha1
+            return {
+              :sha1   => sha1_hex,
+              :crc    => get_crc_hex(mid),
+              :offset => get_offset(mid)
+            }
+          elsif sha1 < mid_sha1
+            hi = mid
+          else
+            lo = mid + 1
+          end
+        end
+        nil
+      end
+
+      def get_sha1(pos)
+        if @version == 2
+          seek(4 + 4 + 4 * 256 + 20 * pos)
+        else
+          raise "FIXME version 1"
+        end
+        raw(20)
+      end
+
+      def get_crc_hex(pos)
+        if @version == 2
+          seek(4 + 4 + 4 * 256 + 20 * @fanout[255] + 4 * pos)
+        else
+          raise "FIXME version 1"
+        end
+        hex(4)
+      end
+
+      def get_offset(pos)
+        if @version == 2
+          seek(4 + 4 + 4 * 256 + 20 * @fanout[255] + 4 * @fanout[255] + 4 * pos)
+        else
+          raise "FIXME version 1"
+        end
+        int
+      end
+
+      def self.path?(relpath)
+        return relpath =~ %r{\Aobjects/pack/pack-[0-9a-f]{40}.idx\z}
+      end
+
+      def to_hash
+        return {
+          :fanout => @fanout,
+          :entries => @entries,
+          :packfile_sha1 => @packfile_sha1,
+          :index_sha1 => @index_sha1,
+        }
+      end
+
+      def load_object_types(input)
+        obj = PackedObject.new(self, input)
+        @entries.each do |entry|
+          header = obj.parse_header(entry[:offset])
+          if header[:type] == 'ofs_delta'
+            obj.parse_ofs_delta_header(entry[:offset], header)
+          elsif header[:type] == 'ref_delta'
+            obj.parse_ref_delta_header(header)
+          end
+          entry.merge!(header)
+        end
+      end
+
+    end
+  end
+end