git-object-browser 0.0.6 → 0.0.7

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

@@ -87,7 +87,7 @@ module GitObjectBrowser
       end
 
       def self.path?(relpath)
-        return relpath =~ %r{\Aobjects/pack/pack-[0-9a-f]{40}.pack\z}
+        return relpath =~ %r{\Aobjects/pack/pack-[0-9a-f]{40}\.pack\z}
       end
 
       private

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

@@ -0,0 +1,54 @@
+
+module GitObjectBrowser
+
+  module Models
+
+    class Reflog
+      def initialize(input)
+        @in = input
+      end
+
+      def parse
+        @entries = []
+        @content = @in.read(nil)
+        @content = @content.force_encoding('UTF-8')
+        unless @content.valid_encoding?
+          @content = '(not UTF-8)'
+          return self
+        end
+        parse_logs
+        self
+      end
+
+      def parse_logs
+        @content.split(/\n/).each do |line|
+          log = {}
+          (data, log[:message]) = line.split(/\t/, 2)
+          if data.to_s =~ /\A([0-9a-f]{40}) ([0-9a-f]{40}) (.+)/
+            log[:sha1_from] = $1
+            log[:sha1_to]   = $2
+            data = $3
+            if data =~ /(.*) <(.*)> (\d+)(?: ((?:(?:\+|-)(?:\d{4}|\d{2}:\d{2}))|Z))?\z/
+              log[:name]  = $1
+              log[:email] = $2
+              log[:unixtime] = $3
+              log[:timezone] = $4
+              log[:date] = GitDate.new($3, $4).to_s
+            end
+          end
+          @entries << log
+        end
+      end
+      private :parse_logs
+
+      def to_hash
+        return { :content => @content, :entries => @entries }
+      end
+
+      def self.path?(relpath)
+        return relpath =~ %r{\Alogs/.+}
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,40 @@
+
+module GitObjectBrowser
+
+  module Models
+
+    class WrappedObject < Hash
+
+      def initialize(root, path, obj)
+        super()
+        self[:type] = {
+          Directory    => 'directory',
+          PlainFile    => 'file',
+          Index        => 'index',
+          GitObject    => 'object',
+          Ref          => 'ref',
+          Reflog       => 'reflog',
+          PackIndex    => 'pack_index',
+          PackFile     => 'pack_file',
+          PackedObject => 'packed_object',
+          InfoRefs     => 'info_refs',
+          PackedRefs   => 'packed_refs',
+        }[obj.class]
+
+        self[:object] = obj.to_hash
+        self[:root] = root
+        self[:path] = path
+        self[:working_dir] = File.basename(File.dirname(root.to_s))
+
+        case(self[:type])
+        when 'packed_object'
+          sha1 = self[:object][:object][:sha1]
+          unpacked_file = File.join(root.to_s, 'objects', sha1[0..1], sha1[2..-1]).to_s
+          self[:unpacked] = File.exist?(unpacked_file)
+        when 'pack_index'
+          self.merge!(obj.page_data)
+        end
+      end
+    end
+  end
+end

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

@@ -1,49 +1,76 @@
-
 module GitObjectBrowser
 
   module Server
 
     class GitServlet < WEBrick::HTTPServlet::AbstractServlet
+
+      SEARCH_PACKED_OBJECT = true
+
       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(?:/(.*))?}
+        @params = parse_params(request, response)
+        unless @params
           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)
+        unless File.exist?(@params[:abspath])
+          not_found unless redirect_to_packed_object
           return
         end
 
-        if path =~ /\.\./
-          not_found(response)
-          return
+        [:response_directory,
+         :response_index,
+         :response_object,
+         :response_ref,
+         :response_reflog,
+         :response_packed_object,
+         :response_pack_file,
+         :response_pack_index,
+         :response_info_refs,
+         :response_packed_refs,
+         :response_file
+        ].each { |action| return if send(action) }
+      end
+
+
+      private
+
+      def parse_params(request, response)
+        params = { :request => request, :response => response }
+
+        path = request.path
+        return nil unless path =~ %r{\A/json/(.+)\.json\z}
+        params[:relpath] = $1.to_s
+
+        pack_rex = 'objects/pack/pack-[0-9a-f]{40}'
+        if params[:relpath] == '_git'
+          params[:relpath] = ''
+        elsif params[:relpath] =~ %r{\A(#{ pack_rex }\.pack)/\d{2}/\d{2}/(\d+)\z}
+          params[:relpath] = $1
+          params[:offset]  = $2.to_i
+        elsif params[:relpath] =~ %r{\A(#{ pack_rex }\.idx)\z}
+          params[:relpath] = $1
+          params[:order]   = 'digest'
+        elsif params[:relpath] =~ %r{\A(#{ pack_rex }\.idx)/(sha1|offset)/(\d+)\z}
+          params[:relpath] = $1
+          params[:order]   = $2
+          params[:page]    = $3.to_i
         end
+        return nil if params[:relpath] =~ /\.\./
 
-        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)
+        params[:abspath] = File.join(@target, params[:relpath])
 
-        response_file(response)
+        return params
       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')
+      def redirect_to_packed_object
+        return false unless SEARCH_PACKED_OBJECT
+        return false unless GitObjectBrowser::Models::GitObject.path?(@params[:relpath])
+        sha1 = @params[: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|
@@ -52,8 +79,9 @@ module GitObjectBrowser
               result = index.find(sha1)
               unless result.nil?
                 packfile = path.sub(/\.idx\z/, '.pack')
-                response.status = 302
-                response["Location"] = "/.git/#{ packfile }?offset=#{ result[:offset] }"
+                @params[:response].status = 302
+                ostr = "0000#{ result[:offset] }"
+                @params[:response]['Location'] = "/json/#{ packfile }/#{ ostr[-2,2] }/#{ ostr[-4,2] }/#{ result[:offset] }.json"
                 return true
               end
             end
@@ -62,153 +90,155 @@ module GitObjectBrowser
         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))
-
-        if type == 'packed_object'
-          sha1 = hash[:object][:object][:sha1]
-          hash[:unpacked] = File.exist?(File.join(@target, 'objects', sha1[0..1], sha1[2..-1]).to_s)
-        end
-
-        response.body = ::JSON.generate(hash)
-      end
-
-      def response_directory(response)
-        return false unless File.directory?(File.join(@target, @relpath))
+      def response_directory
+        return false unless File.directory?(@params[:abspath])
 
-        obj = GitObjectBrowser::Models::Directory.new(@target, @relpath)
-        response_wrapped_object(response, "directory", obj)
+        obj = GitObjectBrowser::Models::Directory.new(@target, @params[:relpath])
+        response_wrapped_object(obj)
         return true
       end
 
-      def response_index(response)
-        return false unless @relpath == "index"
+      def response_index
+        return false unless @params[:relpath] == 'index'
 
         obj = {}
-        File.open(File.join(@target, @relpath)) do |input|
+        File.open(@params[:abspath]) do |input|
           obj = GitObjectBrowser::Models::Index.new(input).parse
         end
-        response_wrapped_object(response, "index", obj)
+        response_wrapped_object(obj)
         return true
       end
 
-      def response_object(response)
-        return false unless GitObjectBrowser::Models::GitObject.path?(@relpath)
+      def response_object
+        return false unless GitObjectBrowser::Models::GitObject.path?(@params[:relpath])
 
         obj = {}
-        File.open(File.join(@target, @relpath)) do |input|
+        File.open(@params[:abspath]) do |input|
           obj = GitObjectBrowser::Models::GitObject.new(input).parse
         end
-        response_wrapped_object(response, "object", obj)
+        response_wrapped_object(obj)
         return true
       end
 
-      def response_ref(response)
-        return false unless GitObjectBrowser::Models::Ref.path?(@relpath)
+      def response_ref
+        return false unless GitObjectBrowser::Models::Ref.path?(@params[:relpath])
 
         obj = {}
-        File.open(File.join(@target, @relpath)) do |input|
+        File.open(@params[:abspath]) do |input|
           obj = GitObjectBrowser::Models::Ref.new(input)
         end
-        response_wrapped_object(response, "ref", obj)
+        response_wrapped_object(obj)
         return true
       end
 
-      def response_pack_index(response)
-        return false unless GitObjectBrowser::Models::PackIndex.path?(@relpath)
+      def response_reflog
+        return false unless GitObjectBrowser::Models::Reflog.path?(@params[: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)
+        File.open(@params[:abspath]) do |input|
+          obj = GitObjectBrowser::Models::Reflog.new(input).parse
         end
-        response_wrapped_object(response, "pack_index", obj)
+        response_wrapped_object(obj)
         return true
       end
 
-      def response_pack_file(response)
-        return false unless GitObjectBrowser::Models::PackFile.path?(@relpath)
+      def response_pack_index
+        return false unless GitObjectBrowser::Models::PackIndex.path?(@params[:relpath])
         obj = {}
-        File.open(File.join(@target, @relpath)) do |input|
-          obj = GitObjectBrowser::Models::PackFile.new(input).parse
+        File.open(@params[:abspath]) do |input|
+          obj = GitObjectBrowser::Models::PackIndex.new(input).parse(@params[:order], @params[:page])
         end
-        response_wrapped_object(response, 'pack_file', obj)
+        if @params[:order] != 'digest'
+          File.open(index_to_pack_path) do |input|
+            obj.load_object_types(input)
+          end
+        end
+        response_wrapped_object(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'))
+      def response_pack_file
+        return false unless GitObjectBrowser::Models::PackFile.path?(@params[:relpath])
+        obj = {}
+        File.open(@params[:abspath]) do |input|
+          obj = GitObjectBrowser::Models::PackFile.new(input).parse
+        end
+        response_wrapped_object(obj)
+        return true
       end
 
-      def response_packed_object(response, offset)
-        return false if offset.nil?
-        return false unless GitObjectBrowser::Models::PackedObject.path?(@relpath)
+      def response_packed_object
+        return false if @params[:offset].nil?
+        return false unless GitObjectBrowser::Models::PackedObject.path?(@params[: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)
+          File.open(@params[:abspath]) do |input|
+            obj = GitObjectBrowser::Models::PackedObject.new(index, input).parse(@params[:offset])
           end
         end
-        response_wrapped_object(response, "packed_object", obj)
+        response_wrapped_object(obj)
         return true
       end
 
-      def response_info_refs(response)
-        return false unless GitObjectBrowser::Models::InfoRefs.path?(@relpath)
+      def response_info_refs
+        return false unless GitObjectBrowser::Models::InfoRefs.path?(@params[:relpath])
 
         obj = {}
-        File.open(File.join(@target, @relpath)) do |input|
+        File.open(@params[:abspath]) do |input|
           obj = GitObjectBrowser::Models::InfoRefs.new(input)
         end
-        response_wrapped_object(response, "info_refs", obj)
+        response_wrapped_object(obj)
         return true
       end
 
-      def response_packed_refs(response)
-        return false unless GitObjectBrowser::Models::PackedRefs.path?(@relpath)
+      def response_packed_refs
+        return false unless GitObjectBrowser::Models::PackedRefs.path?(@params[:relpath])
 
         obj = {}
-        File.open(File.join(@target, @relpath)) do |input|
+        File.open(@params[:abspath]) do |input|
           obj = GitObjectBrowser::Models::PackedRefs.new(input)
         end
-        response_wrapped_object(response, "packed_refs", obj)
+        response_wrapped_object(obj)
         return true
       end
 
-      def response_file(response)
-        path = File.join(@target, @relpath)
+      def response_file
         obj = {}
-        File.open(path) do |input|
+        File.open(@params[:abspath]) do |input|
           obj = GitObjectBrowser::Models::PlainFile.new(input).parse
         end
-        response_wrapped_object(response, "file", obj)
+        response_wrapped_object(obj)
         return true
       end
 
-      def ok(response)
+
+      def response_wrapped_object(obj)
+        wrapped = GitObjectBrowser::Models::WrappedObject.new(@target, @params[:relpath], obj)
+        @params[:response].body = ::JSON.generate(wrapped)
+        ok
+      end
+
+      def ok(response = nil)
+        response ||= @params[:response]
         response.status = 200
         response['Content-Type'] = 'application/json'
       end
 
-      def not_found(response)
+      def not_found(response = nil)
+        response ||= @params[:response]
         response.status = 404
         response['Content-Type'] = 'application/json'
         response.body = '{}'
       end
+
+      def index_to_pack_path
+        File.join(@target, @params[:relpath].sub(/\.idx\z/, '.pack'))
+      end
+
+      def pack_to_index_path
+        File.join(@target, @params[:relpath].sub(/\.pack\z/, '.idx'))
+      end
     end
   end
 end
-

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

@@ -15,7 +15,7 @@ module GitObjectBrowser
         root = File.expand_path(File.join(root, "htdocs"))
         opts = { :BindAddress => host, :Port => port, :DocumentRoot => root }
         server = WEBrick::HTTPServer.new(opts)
-        server.mount('/.git', GitServlet, @target)
+        server.mount('/json', GitServlet, @target)
         trap 'INT' do
           server.shutdown
         end