git-object-browser 0.0.2

data/htdocs/templates/ref.html

@@ -0,0 +1,12 @@
+<article>
+<h1><i data-entry-icon="'ref'"></i> {{path}} <small>Reference</small></h1>
+
+<table class="table">
+<tr data-ng-show="object.sha1">
+<th>sha1</th><td><a data-ref-href="object">{{object.sha1}}</a></td>
+</tr>
+<tr data-ng-show="object.ref">
+<th>ref</th><td><a  data-ref-href="object">{{object.ref}}</a></td>
+</tr>
+</table>
+</article>

data/lib/git-object-browser.rb

@@ -0,0 +1,37 @@
+# -*- coding: utf-8 -*-
+
+# http://book.git-scm.com/7_how_git_stores_objects.html
+# http://code.google.com/p/git-core/source/browse/Documentation/technical/index-format.txt
+
+require "git-object-browser/version"
+
+require 'zlib'
+require 'digest/sha1'
+require 'json'
+require 'time'
+require 'stringio'
+require 'optparse'
+
+require "git-object-browser/main"
+require "git-object-browser/models/ref"
+require "git-object-browser/models/bindata"
+require "git-object-browser/models/directory"
+require "git-object-browser/models/git_object"
+require "git-object-browser/models/index"
+require "git-object-browser/models/index_entry"
+require "git-object-browser/models/index_reuc_extension"
+require "git-object-browser/models/index_tree_extension"
+require "git-object-browser/models/info_refs"
+require "git-object-browser/models/pack_file"
+require "git-object-browser/models/pack_index"
+require "git-object-browser/models/packed_object"
+require "git-object-browser/models/packed_refs"
+require "git-object-browser/models/plain_file"
+require "git-object-browser/server/main"
+require "git-object-browser/server/git_servlet"
+
+require "git-object-browser/dumper"
+require "git-object-browser/object_dumper"
+require "git-object-browser/index_dumper"
+
+GitObjectBrowser::Main.new().execute if __FILE__ == $0

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

@@ -0,0 +1,62 @@
+module GitObjectBrowser
+
+  class Dumper
+
+    def initialize(target)
+      @target = target
+      @outdir = File.join(@target, "plain")
+    end
+
+    def dump
+      Dir.mkdir(@outdir) unless File.exist?(@outdir)
+      dump_index
+      dump_objects
+    end
+
+    def dump_index
+      index_file = File.join(@target, "index")
+      out_file   = File.join(@outdir, "index")
+
+      return unless File.exist?(index_file)
+
+      STDERR << "Write: .git/plain/index\n"
+      File.open(index_file) do |input|
+        File.open(out_file, "w") do |output|
+          dumper = GitObjectBrowser::IndexDumper.new(input, output)
+          dumper.dump
+        end
+      end
+    end
+
+    def dump_objects
+      obj_files = []
+      Dir.chdir(@target) do
+        Dir.glob("objects/**/*") do |path|
+          obj_files << path if File.file?(path) && path =~ %r{/[a-z0-9]{38}$}
+        end
+      end
+      return if obj_files.empty?
+
+      obj_dir = File.join(@outdir, "objects")
+      Dir.mkdir(obj_dir) unless File.exist?(obj_dir)
+
+      obj_files.each do |path|
+        outfile = File.join(@outdir, path)
+        next if File.exist?(outfile)
+
+        parent = File.dirname(outfile)
+        Dir.mkdir(parent) unless File.exist?(parent)
+
+        STDERR << "Write: .git/plain/#{path}\n"
+        obj_file = File.join(@target, path)
+        File.open(obj_file) do |input|
+          File.open(outfile, "w") do |output|
+            dumper = GitObjectBrowser::ObjectDumper.new(input, output)
+            dumper.dump
+          end
+        end
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,77 @@
+# -*- coding: utf-8 -*-
+
+module GitObjectBrowser
+
+  class IndexDumper
+
+    def initialize(input, output)
+      @index = Models::Index.new(input)
+      @out = output
+    end
+
+    def dump
+      @out << "----------------------------------------------------------------\n"
+      @out << "header\n"
+      @out << "----------------------------------------------------------------\n"
+      @out << "version: #{@index.version}\n"
+      @out << "entries: #{@index.entry_count}\n"
+      @out << "\n"
+
+      @index.entries.each_with_index do |entry, i|
+        @out << "----------------------------------------------------------------\n"
+        @out << "entry: #{i+1}\n"
+        @out << "----------------------------------------------------------------\n"
+        @out << "            ctime: #{entry.ctime}\n"
+        @out << "       ctime nano: #{entry.cnano}\n"
+        @out << "            mtime: #{entry.mtime}\n"
+        @out << "       mtime nano: #{entry.mnano}\n"
+        @out << "              dev: #{entry.dev}\n"
+        @out << "              ino: #{entry.ino}\n"
+        @out << "      object_type: #{entry.object_type}\n"
+        @out << "  unix_permission: #{entry.unix_permission}\n"
+        @out << "              uid: #{entry.uid}\n"
+        @out << "              gid: #{entry.gid}\n"
+        @out << "             size: #{entry.size}\n"
+        @out << "             sha1: #{entry.sha1}\n"
+        if @version == 2
+          @out << "assume_valid_flag: #{entry.assume_valid_flag}\n"
+          @out << "    extended_flag: #{entry.extended_flag}\n"
+          @out << "            stage: #{entry.stage}\n"
+        elsif @version == 3
+          @out << "    skip_worktree: #{entry.skip_worktree}\n"
+          @out << "    intent_to_add: #{entry.intent_to_add}\n"
+        end
+        @out << "      name_length: #{entry.name_length}\n"
+        @out << "             path: #{entry.path}\n"
+        @out << "\n"
+      end
+
+      @index.extensions.each do |extension|
+        @out << "----------------------------------------------------------------\n"
+        @out << "extension: #{extension.signature}\n"
+        @out << "----------------------------------------------------------------\n"
+        if extension.signature == "TREE"
+          dump_tree_extension(extension)
+        elsif extension.signature == "REUC"
+          dump_reuc_extension
+        end
+      end
+      
+      @out << "----------------------------------------------------------------\n"
+      @out << "checksum\n"
+      @out << "----------------------------------------------------------------\n"
+      @out << "sha1: #{@index.sha1}\n"
+    end
+
+    def dump_tree_extension(tree_extension)
+      tree_extension.entries.each do |entry|
+        @out << "   path_component: #{entry[:path_component]}\n"
+        @out << "      entry_count: #{entry[:entry_count]}\n"
+        @out << "    subtree_count: #{entry[:subtree_count]}\n"
+        @out << "             sha1: #{entry[:sha1]}\n\n"
+      end
+    end
+
+  end
+
+end

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

@@ -0,0 +1,63 @@
+# -*- coding: utf-8 -*-
+module GitObjectBrowser
+  class Main
+    def execute
+      host = '127.0.0.1'
+      port = 8080
+      opts = OptionParser.new do |opts|
+        opts.on('-p', '--port=PORT', 'port number') do |value|
+          port = value.to_i if 0 < value.to_i
+        end
+        opts.on('-b', '--bind=HOST', 'address to bind') do |value|
+          host = value
+        end
+        opts.on('-d', '--dump', 'dump objects') do
+          puts 'not implemented yet'
+          exit
+        end
+        opts.on_tail("-h", "--help", "show this help.") do
+          puts opts
+          exit
+        end
+        opts.on_tail("-v", "--version", "show version.") do
+          puts "git-object-browser " + VERSION
+          exit
+        end
+        opts.parse!(ARGV)
+      end
+
+      target = find_target(ARGV[0])
+      Server::Main.execute(target, host, port)
+    end
+
+    def find_target(target = nil, git_dir_name = '.git')
+      target ||= Dir::pwd
+      return target if git_dir?(target)
+
+      if File.directory?(target)
+        dir = parent_git_dir(target, git_dir_name)
+        return dir if dir
+      end
+
+      raise 'Git directory not found'
+    end
+
+    def git_dir?(dir)
+      return false unless File.directory?(dir)
+      return false unless File.directory?(File.join(dir, 'objects'))
+      return false unless File.file?(File.join(dir, 'HEAD'))
+      true
+    end
+
+    def parent_git_dir(target, git_dir_name)
+      begin
+        gitdir = File.join(target, git_dir_name)
+        return gitdir if git_dir?(gitdir)
+        lastdir = target
+        target = File.dirname(target)
+      end while lastdir != target
+      nil
+    end
+    private :parent_git_dir
+  end
+end

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

@@ -0,0 +1,68 @@
+module GitObjectBrowser
+
+  module Models
+
+    class Bindata
+
+      def initialize(input)
+        @in = input
+      end
+
+      def switch_source(input)
+        tmp = @in
+        @in = input
+        yield
+      ensure
+        @in = tmp
+      end
+
+      def raw(bytes)
+        @in.read(bytes)
+      end
+
+      def bytes(bytes)
+        @in.read(bytes).unpack('C*')
+      end
+
+      def byte
+        bytes(1).first
+      end
+
+      def int
+        @in.read(4).unpack('N').first.to_i
+      end
+
+      def hex(bytes)
+        @in.read(bytes).unpack('H*').first
+      end
+
+      def binstr(bytes)
+        @in.read(bytes).unpack('B*').first
+      end
+
+      def find_char(char)
+        buf = ''
+        loop do
+          c = @in.read(1)
+          return buf if c.nil? || c == char
+          buf += c
+        end
+      end
+
+      def skip(bytes)
+        @in.seek(bytes, IO::SEEK_CUR)
+      end
+
+      def seek(bytes)
+        @in.seek(bytes)
+      end
+
+      def peek(bytes)
+        result = raw(bytes)
+        @in.seek(bytes * -1, IO::SEEK_CUR)
+        result
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,61 @@
+
+module GitObjectBrowser
+
+  module Models
+
+    class Directory
+      def initialize(root, path)
+        @root = root
+        @path = path
+        @entries = read_entries
+      end
+
+      def read_entries
+        entries = []
+        Dir.chdir(File.join(@root, @path)) do
+          files = Dir.glob("*")
+          files.each do |file|
+            relpath = File.join(@path, file).gsub(%r{\A/}, '')
+            entry = {}
+            if File.directory?(file)
+              entry[:type] = "directory"
+            elsif File.symlink?(file)
+              entry[:type] = "symlink"
+            elsif Ref::path?(relpath)
+              entry[:type] = 'ref'
+            elsif InfoRefs::path?(relpath)
+              entry[:type] = 'info_refs'
+            elsif PackedRefs::path?(relpath)
+              entry[:type] = 'packed_refs'
+            elsif Index::path?(relpath)
+              entry[:type] = 'index'
+            elsif GitObject::path?(relpath)
+              entry[:type] = 'object'
+            else
+              entry[:type] = "file"
+            end
+            entry[:basename] = file
+            entry[:mtime] = File.mtime(file).to_i
+            entry[:size] = File.size(file)
+            entries << entry
+          end
+        end
+        order = %w{directory ref info_refs packed_refs index object file symlink}
+        entries.sort do |a,b|
+          (order.index(a[:type]) <=> order.index(b[:type])).nonzero? ||
+            a[:basename] <=> b[:basename]
+        end
+      end
+
+      def to_hash
+        return {
+          "type" => "directory",
+          "path" => @path,
+          "entries" => @entries
+        }
+      end
+
+    end
+
+  end
+end

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

@@ -0,0 +1,127 @@
+# -*- coding: utf-8 -*-
+module GitObjectBrowser
+
+  module Models
+
+    class GitObject < Bindata
+
+      attr_reader :sha1, :type, :size, :entries, :contents
+      attr_reader :properties, :message
+
+      def initialize(input)
+        super(input)
+      end
+
+      def parse
+        content = Zlib::Inflate.inflate(@in.read(nil))
+        parse_inflated(content)
+        self
+      end
+
+      def parse_inflated(content)
+        @sha1 = Digest::SHA1.hexdigest(content)
+        @in   = StringIO.new(content)
+
+        @type = find_char ' '
+        @size = find_char "\0"
+
+        @type = type
+        @size = size
+
+        if @type == 'tree'
+          @entries = parse_tree_entries
+        else
+          @content = @in.read(nil)
+          if @type == 'commit' or @type == 'tag'
+            (@properties, @message) = parse_contents
+          end
+
+          @content = @content.force_encoding('UTF-8')
+          @content = '(not UTF-8)' unless @content.valid_encoding?
+          @content = @content[0, 3000] + "\n..." if @content.length > 3000
+        end
+
+        self
+      end
+
+
+      def to_hash
+        return {
+          'type' => @type,
+          'sha1' => @sha1,
+          'size' => @size,
+          'entries' => @entries,
+          'content' => @content,
+          'properties' => @properties,
+          'message' => @message,
+        }
+      end
+
+      def self.path?(relpath)
+        relpath =~ %r{\Aobjects/[0-9a-f]{2}/[0-9a-f]{38}\z}
+      end
+
+
+      private
+
+      def parse_tree_entries
+        entries = []
+        loop do
+          entry = {}
+          entry[:mode]     = find_char ' '
+          break if entry[:mode].empty?
+          entry[:filename] = find_char "\0"
+          entry[:sha1]     = hex(20)
+          entries << entry
+        end
+        return entries
+      end
+
+      def parse_contents
+        lines = @content.split /\n/
+        line = ''
+        properties = []
+        message = ''
+        while ! lines.empty?
+          line = lines.shift
+          break if line.empty?
+          prop = {}
+          (prop['key'], prop['value']) = line.split(/ /, 2)
+          if prop['value'] =~ /\A([0-9a-f]{2})([0-9a-f]{38})\z/
+            prop['type'] = 'sha1'
+            prop['path'] = "objects/#{ $1 }/#{ $2 }"
+          elsif %w{author committer tagger}.include?(prop['key']) &&
+              # couldn't find the spec...
+              prop['value'].to_s =~ /\A(.*) <(.*)> (\d+)(?: ((?:(?:\+|-)(?:\d{4}|\d{2}:\d{2}))|Z))?\z/
+            prop['type']  = 'user'
+            prop['name']  = $1.force_encoding("UTF-8")
+            prop['name']  = '(not UTF-8)' unless prop['name'].valid_encoding?
+            prop['email'] = $2.force_encoding("UTF-8")
+            prop['email'] = '(not UTF-8)' unless prop['email'].valid_encoding?
+            prop['unixtime'] = $3
+            prop['timezone'] = $4
+            prop['date'] = epoch($3.to_i, $4).iso8601
+          else
+            prop['type'] = 'text'
+          end
+          properties << prop
+        end
+        message = lines.join("\n").force_encoding("UTF-8")
+        message = '(not UTF-8)' unless message.valid_encoding?
+
+        [properties, message]
+      end
+
+      def epoch(sec, timezone)
+        DateTime.strptime(sec.to_s, '%s').new_offset(parse_timezone(timezone))
+      end
+
+      def parse_timezone(timezone)
+        timezone = '+00:00' if timezone == 'Z'
+        return Rational(0, 24) unless timezone =~ /(\+|-)?(\d\d):?(\d\d)/
+        Rational($2.to_i, 24) + Rational($3, 60) * (($1 == '-') ? -1 : 1)
+      end
+
+    end
+  end
+end