git-object-browser 0.0.2

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

@@ -0,0 +1,239 @@
+# -*- coding: utf-8 -*-
+
+# https://github.com/git/git/blob/master/sha1_file.c
+# https://github.com/git/git/blob/master/patch-delta.c
+# https://github.com/git/git/blob/master/builtin/unpack-objects.c
+# https://github.com/mojombo/grit/blob/master/lib/grit/git-ruby/internal/pack.rb
+module GitObjectBrowser
+
+  module Models
+
+    class PackedObject < Bindata
+
+      attr_reader :header, :raw_data
+      attr_reader :object
+
+      TYPES = %w{
+        undefined
+        commit
+        tree
+        blob
+        tag
+        undefined
+        ofs_delta
+        ref_delta
+      }
+
+      def initialize(index, input)
+        super(input)
+        @index = index
+      end
+
+      def parse(offset)
+        parse_raw(offset)
+        input = "#{ @object_type } #{ @object_size }\0" + @raw_data
+        @object = GitObject.new(nil).parse_inflated(input)
+        self
+      end
+
+      def parse_raw(offset)
+        @offset = offset
+        @header = parse_header(offset)
+
+        if @header[:type] == 'ofs_delta'
+          obj_ofs_delta
+        elsif @header[:type] == 'ref_delta'
+          obj_ref_delta
+        else
+          @object_type = @header[:type]
+          @object_size = @header[:size]
+          @raw_data = zlib_inflate
+        end
+
+        [@object_type, @object_size]
+      end
+
+      def parse_header(offset)
+        seek(offset)
+        (type, size, header_size) = parse_type_and_size
+        type = TYPES[type]
+        { :type => type, :size => size, :header_size => header_size }
+      end
+
+      def parse_ofs_delta_header(offset, header)
+        (delta_offset, delta_header_size) = parse_delta_offset
+        header[:base_offset] = offset - delta_offset
+        header[:header_size] += delta_header_size
+        header
+      end
+
+      def parse_ref_delta_header(header)
+        header[:base_sha1]   = hex(20)
+        header[:header_size] += 20
+        header
+      end
+
+      def to_hash
+        return {
+          :offset => @offset,
+          :type => @header[:type], # commit, tree, blob, tag, ofs_delta, ref_delta
+          :size => @header[:size],
+          :header_size => @header[:header_size],
+          :base_offset => @header[:base_offset],
+          :delta_commands => @delta_commands,
+          :base_size => @base_size,
+          :object => @object.to_hash,
+        }
+      end
+
+      def self.path?(relpath)
+        return relpath =~ %r{\Aobjects/pack/pack-[0-9a-f]{40}.pack\z}
+      end
+
+      private
+
+      def obj_ofs_delta
+        parse_ofs_delta_header(@offset, @header)
+        load_base_and_patch_delta
+      end
+
+      def obj_ref_delta
+        parse_ref_delta_header(@header)
+        index_entry = @index.find(@header[:base_sha1])
+        @header[:base_offset] = index_entry[:offset]
+        load_base_and_patch_delta
+      end
+
+      def load_base_and_patch_delta
+        begin
+          pack = PackedObject.new(@index, @in)
+          (@object_type, _) = pack.parse_raw(@header[:base_offset])
+          @base = pack.raw_data
+        ensure
+          seek(@offset + @header[:header_size])
+        end
+
+        switch_source(StringIO.new(zlib_inflate)) { patch_delta }
+      end
+
+      def patch_delta
+        @base_size  = parse_size
+        if @base.size != @base_size
+          raise 'incollect base size'
+        end
+
+        @object_size = parse_size
+        @delta_commands = []
+        @raw_data = ''
+        while ! @in.eof?
+          delta_command
+        end
+        if @object_size != @raw_data.size
+          raise 'incollect delta size'
+        end
+      end
+
+      def delta_command
+        cmd = byte
+        data = nil
+        if cmd & 0b10000000 != 0
+          (offset, size) = parse_base_offset_and_size(cmd)
+          data = @base[offset, size]
+          @raw_data << data
+          @delta_commands << { :source => :base, :offset => offset, :size => size }
+        elsif cmd != 0
+          size = cmd
+          data = raw(size)
+          @raw_data << data
+          @delta_commands << { :source => :delta, :size => size }
+        else
+          raise 'delta command is 0'
+        end
+        @delta_commands.last[:data] = shorten_utf8(data, 2000)
+      end
+
+      def shorten_utf8(bin, length)
+        str = bin.force_encoding('UTF-8')
+        str = '(not UTF-8)' unless str.valid_encoding?
+        str = str[0, length] + '...' if str.length > length
+        str
+      end
+
+      def zlib_inflate
+        store = Zlib::Inflate.new
+        buffer = ''
+        while buffer.size < @header[:size]
+          rawdata = raw(4096)
+          if rawdata.size == 0
+            raise 'inflate error'
+          end
+          buffer << store.inflate(rawdata)
+        end
+        store.close
+        buffer
+      end
+
+      # sha1_file.c unpack_object_header_buffer
+      # unpack-objects.c unpack_one
+      def parse_type_and_size
+        hdr      = byte
+        hdr_size = 1
+        continue = (hdr & 0b10000000)
+        type     = (hdr & 0b01110000) >> 4
+        size     = (hdr & 0b00001111)
+        size_len = 4
+        while continue != 0
+          hdr        = byte
+          hdr_size  += 1
+          continue   = (hdr & 0b10000000)
+          size      += (hdr & 0b01111111) << size_len
+          size_len  += 7
+        end
+        return [type, size, hdr_size]
+      end
+
+      # delta.h get_delta_hdr_size
+      def parse_size
+        size     = 0
+        size_len = 0
+        begin
+          hdr       = byte
+          continue  = (hdr & 0b10000000)
+          size     += (hdr & 0b01111111) << size_len
+          size_len += 7
+        end while continue != 0
+        return size
+      end
+
+      # sha1_file.c get_delta_base
+      # unpack-objects.c unpack_delta_entry
+      def parse_delta_offset
+        offset   = -1
+        hdr_size = 0
+        begin
+          hdr        = byte
+          hdr_size  += 1
+          continue   = hdr & 0b10000000
+          low_offset = hdr & 0b01111111
+          offset     = ((offset + 1) << 7) | low_offset
+        end while continue != 0
+        return [offset, hdr_size]
+      end
+
+      # patch-delta.c
+      def parse_base_offset_and_size(cmd)
+        offset = size = 0
+        offset  = byte       if cmd & 0b00000001 != 0
+        offset |= byte << 8  if cmd & 0b00000010 != 0
+        offset |= byte << 16 if cmd & 0b00000100 != 0
+        offset |= byte << 24 if cmd & 0b00001000 != 0
+        size    = byte       if cmd & 0b00010000 != 0
+        size   |= byte << 8  if cmd & 0b00100000 != 0
+        size   |= byte << 16 if cmd & 0b01000000 != 0
+        size = 0x10000 if size == 0
+        return [offset, size]
+      end
+
+    end
+  end
+end

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

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

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

@@ -0,0 +1,24 @@
+
+module GitObjectBrowser
+
+  module Models
+
+    class PlainFile
+      def initialize(input)
+        @in = input
+      end
+
+      def parse
+        @content = @in.read(nil)
+        @content = @content.force_encoding('UTF-8')
+        @content = '(not UTF-8)' unless @content.valid_encoding?
+        @content = @content[0, 3000] + "\n..." if @content.length > 3000
+        self
+      end
+
+      def to_hash
+        return { 'content' => @content }
+      end
+    end
+  end
+end

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

@@ -0,0 +1,32 @@
+
+module GitObjectBrowser
+
+  module Models
+
+    class Ref
+      def initialize(input)
+        line = input.gets.to_s
+
+        if line =~ %r{\Aref:\s*(.+)}
+          @ref = $1
+        elsif line =~ %r{\A([0-9a-f]{40})}
+          @sha1 = $1
+        end
+      end
+
+      def to_hash
+        return {
+          "ref"  => @ref,
+          "sha1" => @sha1
+        }
+      end
+
+      def self.path?(relpath)
+        ref_names = %w{HEAD FETCH_HEAD ORIG_HEAD MERGE_HEAD CHERRY_PICK_HEAD}
+        return (ref_names.include?(relpath) || relpath =~ %r{\Arefs/})
+      end
+
+    end
+
+  end
+end

data/lib/git-object-browser/object_dumper.rb

@@ -0,0 +1,31 @@
+# -*- coding: utf-8 -*-
+
+module GitObjectBrowser
+
+  class ObjectDumper
+
+    def initialize(input, output)
+      @object = Models::GitObject.new(input)
+      @out = output
+    end
+
+    def dump
+      @out << "type: #{@object.type}\n"
+      @out << "size: #{@object.size}\n"
+      @out << "sha1: #{@object.sha1}\n"
+      @out << "\n"
+      if @object.type == "tree"
+        dump_tree_entries
+      else
+        @out << @object.contents
+      end
+    end
+
+    # man git-ls-tree
+    def dump_tree_entries
+      @object.entries.each do |entry|
+        @out << "#{entry[:mode]} #{entry[:sha1]} #{entry[:filename]}\n"
+      end
+    end
+  end
+end

data/lib/git-object-browser/server/git_servlet.rb

@@ -0,0 +1,209 @@
+
+module GitObjectBrowser
+
+  module Server
+
+    class GitServlet < WEBrick::HTTPServlet::AbstractServlet
+      def initialize(server, target)
+        @target = File.expand_path(target)
+      end
+
+      def do_GET(request, response)
+        # status, content_type, body = do_stuff_with request
+        path = request.path
+        unless path =~ %r{/.git(?:/(.*))?}
+          not_found(response)
+          return
+        end
+
+        @relpath = $1.to_s
+        path = File.join(@target, @relpath)
+        unless File.exist?(path)
+          not_found(response) unless redirect_to_packed_object(response)
+          return
+        end
+
+        if path =~ /\.\./
+          not_found(response)
+          return
+        end
+
+        return if response_directory(response)
+        return if response_index(response)
+        return if response_object(response)
+        return if response_ref(response)
+        return if response_packed_object(response, request.query["offset"])
+        return if response_pack_file(response)
+        return if response_pack_index(response)
+        return if response_info_refs(response)
+        return if response_packed_refs(response)
+
+        response_file(response)
+      end
+
+      def redirect_to_packed_object(response)
+        return false unless GitObjectBrowser::Models::GitObject.path?(@relpath)
+        sha1 = @relpath.gsub(%r{\A.*/([0-9a-f]{2})/([0-9a-f]{38})\z}, '\1\2')
+
+        Dir.chdir(@target) do
+          Dir.glob('objects/pack/*.idx') do |path|
+            File.open(path) do |input|
+              index = GitObjectBrowser::Models::PackIndex.new(input)
+              result = index.find(sha1)
+              unless result.nil?
+                packfile = path.sub(/\.idx\z/, '.pack')
+                response.status = 302
+                response["Location"] = "/.git/#{ packfile }?offset=#{ result[:offset] }"
+                return true
+              end
+            end
+          end
+        end
+        false
+      end
+
+      def response_wrapped_object(response, type, obj)
+        ok(response)
+        hash = {}
+        hash["type"] = type
+        hash["object"] = obj.to_hash
+        hash["root"] = @target
+        hash["path"] = @relpath
+        hash["wroking_dir"] = File.basename(File.dirname(@target))
+
+        response.body = ::JSON.generate(hash)
+      end
+
+      def response_directory(response)
+        return false unless File.directory?(File.join(@target, @relpath))
+
+        obj = GitObjectBrowser::Models::Directory.new(@target, @relpath)
+        response_wrapped_object(response, "directory", obj)
+        return true
+      end
+
+      def response_index(response)
+        return false unless @relpath == "index"
+
+        obj = {}
+        File.open(File.join(@target, @relpath)) do |input|
+          obj = GitObjectBrowser::Models::Index.new(input).parse
+        end
+        response_wrapped_object(response, "index", obj)
+        return true
+      end
+
+      def response_object(response)
+        return false unless GitObjectBrowser::Models::GitObject.path?(@relpath)
+
+        obj = {}
+        File.open(File.join(@target, @relpath)) do |input|
+          obj = GitObjectBrowser::Models::GitObject.new(input).parse
+        end
+        response_wrapped_object(response, "object", obj)
+        return true
+      end
+
+      def response_ref(response)
+        return false unless GitObjectBrowser::Models::Ref.path?(@relpath)
+
+        obj = {}
+        File.open(File.join(@target, @relpath)) do |input|
+          obj = GitObjectBrowser::Models::Ref.new(input)
+        end
+        response_wrapped_object(response, "ref", obj)
+        return true
+      end
+
+      def response_pack_index(response)
+        return false unless GitObjectBrowser::Models::PackIndex.path?(@relpath)
+        obj = {}
+        File.open(File.join(@target, @relpath)) do |input|
+          obj = GitObjectBrowser::Models::PackIndex.new(input).parse
+        end
+        File.open(index_to_pack_path) do |input|
+          obj.load_object_types(input)
+        end
+        response_wrapped_object(response, "pack_index", obj)
+        return true
+      end
+
+      def response_pack_file(response)
+        return false unless GitObjectBrowser::Models::PackFile.path?(@relpath)
+        obj = {}
+        File.open(File.join(@target, @relpath)) do |input|
+          obj = GitObjectBrowser::Models::PackFile.new(input).parse
+        end
+        response_wrapped_object(response, 'pack_file', obj)
+        return true
+      end
+
+      def index_to_pack_path
+        File.join(@target, @relpath.sub(/\.idx\z/, '.pack'))
+      end
+
+      def pack_to_index_path
+        File.join(@target, @relpath.sub(/\.pack\z/, '.idx'))
+      end
+
+      def response_packed_object(response, offset)
+        return false if offset.nil?
+        return false unless GitObjectBrowser::Models::PackedObject.path?(@relpath)
+        obj = {}
+
+        File.open(pack_to_index_path) do |index_input|
+          index = GitObjectBrowser::Models::PackIndex.new(index_input)
+          File.open(File.join(@target, @relpath)) do |input|
+            obj = GitObjectBrowser::Models::PackedObject.new(index, input).parse(offset.to_i)
+          end
+        end
+        response_wrapped_object(response, "packed_object", obj)
+        return true
+      end
+
+      def response_info_refs(response)
+        return false unless GitObjectBrowser::Models::InfoRefs.path?(@relpath)
+
+        obj = {}
+        File.open(File.join(@target, @relpath)) do |input|
+          obj = GitObjectBrowser::Models::InfoRefs.new(input)
+        end
+        response_wrapped_object(response, "info_refs", obj)
+        return true
+      end
+
+      def response_packed_refs(response)
+        return false unless GitObjectBrowser::Models::PackedRefs.path?(@relpath)
+
+        obj = {}
+        File.open(File.join(@target, @relpath)) do |input|
+          obj = GitObjectBrowser::Models::PackedRefs.new(input)
+        end
+        response_wrapped_object(response, "packed_refs", obj)
+        return true
+      end
+
+      def response_file(response)
+        path = File.join(@target, @relpath)
+        obj = {}
+        File.open(path) do |input|
+          obj = GitObjectBrowser::Models::PlainFile.new(input).parse
+        end
+        response_wrapped_object(response, "file", obj)
+        return true
+      end
+
+      def ok(response)
+        response.status = 200
+        response['Content-Type'] = 'application/json'
+      end
+
+      def not_found(response)
+        response.status = 404
+        response['Content-Type'] = 'application/json'
+        response.body = '{}'
+      end
+    end
+  end
+end
+