git-object-browser 0.0.6 → 0.0.7

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

@@ -6,17 +6,30 @@ module GitObjectBrowser
 
     class IndexDumper
 
-      def initialize(input, output)
-        @index = GitObjectBrowser::Models::Index.new(input)
-        @out = output
+      def initialize(root, outdir)
+        @root   = root
+        @outdir = outdir
       end
 
+
       def dump
-        @out << JSON.pretty_generate(@index.parse.to_hash)
+        index_file = File.join(@root, "index")
+        out_file   = File.join(@outdir, "index.json")
+
+        return unless File.exist?(index_file)
+
+        puts "Write: index\n"
+        File.open(index_file) do |input|
+          File.open(out_file, "w") do |output|
+            dump_object(input, output)
+          end
+        end
+      end
 
-        # template = File.join(GitObjectBrowser::Dumper::TEMPLATES_DIR, 'index.txt.erb')
-        # index = @index.parse.to_hash
-        # @out << ERB.new(File.read(template), nil, '-').result(binding)
+      def dump_object(input, output)
+        obj =  GitObjectBrowser::Models::Index.new(input).parse
+        wrapped = GitObjectBrowser::Models::WrappedObject.new(nil, 'index', obj)
+        output << JSON.pretty_generate(wrapped.to_hash)
       end
 
     end

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

@@ -0,0 +1,37 @@
+# -*- coding: utf-8 -*-
+
+module GitObjectBrowser
+
+  module Dumper
+
+    class InfoRefsDumper
+
+      def initialize(root, outdir)
+        @root   = root
+        @outdir = outdir
+      end
+
+      def dump
+        src_file = File.join(@root, "info/refs")
+        dst_file = File.join(@outdir, "info/refs.json")
+
+        return unless File.exist?(src_file)
+
+        puts "Write: info/refs\n"
+        File.open(src_file) do |input|
+          File.open(dst_file, "w") do |output|
+            dump_object(input, output)
+          end
+        end
+      end
+
+      def dump_object(input, output)
+        obj =  GitObjectBrowser::Models::InfoRefs.new(input)
+        wrapped = GitObjectBrowser::Models::WrappedObject.new(nil, 'info/refs', obj)
+        output << JSON.pretty_generate(wrapped.to_hash)
+      end
+
+    end
+  end
+end
+

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

@@ -1,124 +1,231 @@
 module GitObjectBrowser
   module Dumper
 
-    # TEMPLATES_DIR = File.join(File.dirname(__FILE__), '../../../templates/dumper')
+    HTDOCS_DIR = File.join(File.dirname(__FILE__), '../../../htdocs')
 
     class Main
 
-      def self.execute(target)
-        new(target).dump
+      def self.execute(target, outdir, step, diff_dir)
+        outdir = File.expand_path(outdir)
+
+        if outdir =~ %r{(?:^|/).git(?:/|$)} && outdir !~ %r{/.git/dump/?\z}
+          raise 'Dump directory must be .git/dump if you dump into the .git directory.'
+        end
+
+        if File.exist?(outdir)
+          Dir.chdir(outdir) do
+            if !Dir.glob('*').empty? &&  Dir.glob('json/**/_git.json').empty?
+              raise 'dump directory exists but it may not be the old dump directory. json/**/_git.json doesn\'t exist.'
+            end
+          end
+        end
+
+        if diff_dir
+          diff_dir = File.expand_path(diff_dir)
+          raise "#{ diff_dir } must be directory." unless File.directory?(diff_dir)
+          raise "#{ diff_dir }/_git.json doesn't exist" unless File.exist?(File.join(diff_dir, '_git.json'))
+        end
+
+        new(target, outdir, step, diff_dir).dump
       end
 
-      def initialize(target)
+      def initialize(target, outdir, step, diff_dir)
         @target = target
-        @outdir = File.join(target, "dump")
+        @outdir = outdir
+        @step = step
+        @diff_dir = diff_dir
+
+        if @step
+          (@diff_dir, @step) = find_next_dir if @step == :next
+          @json_dir = File.join(@outdir, 'json', @step)
+        else
+          @json_dir = File.join(@outdir, 'json')
+        end
       end
 
+      def find_next_dir
+        json_dir = File.join(@outdir, 'json')
+        FileUtils.mkdir_p(json_dir) unless File.exist?(json_dir)
+        dir = Dir.open(json_dir).map do |dir|
+          if dir =~ /\Astep(\d+)\z/
+            [dir, $1.to_i]
+          else
+            nil
+          end
+        end.compact.sort {|a,b| a[1] <=> b[1] }.last
+        if dir
+          return [File.join(json_dir, dir[0]), "step#{dir[1] + 1}"]
+        else
+          return [nil, "step1"]
+        end
+      end
+      private :find_next_dir
+
       def dump
-        Dir.mkdir(@outdir) unless File.exist?(@outdir)
-        dump_index
         dump_objects
-        dump_packed
+        copy_htdocs
+        create_config
+        create_diff_data
+        create_note
+        if @step
+          puts "-- Complete: #{ @step }"
+        else
+          puts "-- Complete"
+        end
       end
 
-      def dump_index
-        index_file = File.join(@target, "index")
-        out_file   = File.join(@outdir, "index")
+      def create_config
+        puts "-- Create config files"
+        unless File.exist?(File.join(@outdir, 'config.js'))
+          puts "Write: config.js"
+          FileUtils.copy_entry(File.join(HTDOCS_DIR, 'config.js'),
+                               File.join(@outdir, 'config.js'))
+        end
 
-        return unless File.exist?(index_file)
+        puts "Write: default.js"
+        default_file = File.join(@outdir, 'default.js')
+        if File.exist?(default_file)
+          conf = File.read(default_file)
+          create = false
+        else
+          conf = File.read(File.join(HTDOCS_DIR, 'default.js'))
+          create = true
+        end
+        if conf =~ /var config = (\{.+\});/m
+          json = $1
+        else
+          json = '{}'
+        end
+        conf = JSON.parse(json)
+        if create
+          conf['loadNote'] = true
+          conf['loadDiff'] = true
+        end
+        conf['steps'] = [] unless conf['steps'].is_a? Array
+        conf['steps'] << { 'name' => @step, 'label' => @step }
 
-        STDERR << "Write: .git/dump/index\n"
-        File.open(index_file) do |input|
-          File.open(out_file, "w") do |output|
-            dumper = GitObjectBrowser::Dumper::IndexDumper.new(input, output)
-            dumper.dump
-          end
+        File.open(default_file, 'w') do |io|
+          io << "// Edit config.js instead of this file.\n"
+          io << "// This file will be rewritten by git object-browser command.\n"
+          io << "var config = " + JSON.pretty_generate(conf) + ";\n"
         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}$}
+      def create_diff_data
+        return unless @step
+        unless @diff_dir
+          puts "-- Create empty diff data"
+          puts "Write: _diff.json"
+          File.open(File.join(@json_dir, '_diff.json'), 'w') do |io|
+            io << '[]'
           end
+          return
         end
-        return if obj_files.empty?
 
-        obj_dir = File.join(@outdir, "objects")
-        Dir.mkdir(obj_dir) unless File.exist?(obj_dir)
+        puts "-- Create diff data"
+        old_files = []
+        Dir.chdir(@diff_dir) do
+          Dir.glob("**/*").each do |file|
+            next unless File.file?(file)
+            next if File.directory?(file.sub(/\.json\z/, ''))
+            next if %w{_git.json _diff.json}.include?(file)
+            old_files << file
+          end
+        end
 
-        obj_files.each do |path|
-          outfile = File.join(@outdir, path)
-          next if File.exist?(outfile)
+        new_files = []
+        Dir.chdir(@json_dir) do
+          Dir.glob("**/*").each do |file|
+            next unless File.file?(file)
+            next if File.directory?(file.sub(/\.json\z/, ''))
+            next if %w{_git.json _diff.json}.include?(file)
+            new_files << file
+          end
+        end
 
-          parent = File.dirname(outfile)
-          Dir.mkdir(parent) unless File.exist?(parent)
+        diff_files = []
 
-          STDERR << "Write: .git/dump/objects/#{path}\n"
-          obj_file = File.join(@target, path)
-          File.open(obj_file) do |input|
-            File.open(outfile, "w") do |output|
-              dumper = GitObjectBrowser::Dumper::ObjectDumper.new(input, output)
-              dumper.dump
-            end
+        common_files = old_files & new_files
+        common_files.each do |file|
+          a = File.join(@diff_dir, file)
+          b = File.join(@json_dir, file)
+          unless FileUtils.cmp(a, b)
+            diff_files << file.sub(/\.json\z/, '')
           end
         end
 
+        removed_files = old_files - new_files
+        removed_files.each do |file|
+          diff_files << file.sub(/\.json\z/, '')
+        end
+
+        added_files = new_files - old_files
+        added_files.each do |file|
+          diff_files << file.sub(/\.json\z/, '')
+        end
+
+        puts "Write: _diff.json"
+        File.open(File.join(@json_dir, '_diff.json'), 'w') do |io|
+          io << JSON.pretty_generate(diff_files)
+        end
       end
 
-      def dump_packed
-        files = []
-        Dir.chdir(@target) do
-          Dir.glob("objects/pack/*.idx") do |path|
-            files << path
+      def dump_objects
+        if File.exist?(@json_dir)
+          puts "-- Remove old JSON files"
+          if @step
+            puts "Remove: json/#{ @step }"
+          else
+            puts "Remove: json/*"
           end
+          FileUtils.rm_r(@json_dir)
         end
-        return if files.empty?
-
-        obj_dir = File.join(@outdir, "objects")
-        Dir.mkdir(obj_dir) unless File.exist?(obj_dir)
-        pack_dir = File.join(@outdir, "objects/pack")
-        Dir.mkdir(pack_dir) unless File.exist?(pack_dir)
-
-        files.each do |path|
-          outfile = File.join(@outdir, path)
-          packpath = path.gsub(/\.idx\z/, '.pack')
-
-          STDERR << "Write: .git/dump/#{path}\n"
-          index_file = File.join(@target, path)
-          File.open(index_file) do |input|
-            File.open(outfile, "w") do |output|
-              dumper = GitObjectBrowser::Dumper::PackIndexDumper.new(input, output)
-              dumper.dump
-              index = dumper.pack_index
-              entries = index.to_hash[:entries]
-
-              File.open(File.join(@target, packpath)) do |pack_input|
-                object_dumper = GitObjectBrowser::Dumper::PackedObjectDumper.new(pack_input, index)
-                entries.each do |entry|
-                  dump_packed_object(object_dumper, entry)
-                end
-              end
+        puts "-- Dump objects"
+        FileUtils.mkdir_p(@json_dir)
+        [IndexDumper,
+         ObjectsDumper,
+         RefsDumper,
+         DirectoriesDumper,
+         PlainFilesDumper,
+         PackIndexesDumper,
+         PackedRefsDumper,
+         InfoRefsDumper,
+        ].each do |dumper|
+          dumper.new(@target, @json_dir).dump
+        end
+      end
+      private :dump_objects
+
+      def copy_htdocs
+        puts "-- Copy htdocs"
+        Dir.chdir(HTDOCS_DIR) do
+          Dir.glob('*').each do |file|
+            next if %w{config.js default.js}.include?(file)
+            if File.directory?(file)
+              puts "Copy: #{file}/*"
+            else
+              puts "Copy: #{file}"
             end
+            FileUtils.copy_entry(file, File.join(@outdir, file))
           end
         end
       end
 
-      def dump_packed_object(dumper, entry)
-        sha1_1 = entry[:sha1][0..1]
-        sha1_2 = entry[:sha1][2..-1]
-        obj_dir = File.join(@outdir, "objects", sha1_1)
-        Dir.mkdir(obj_dir) unless File.exist?(obj_dir)
-
-        outfile = File.join(obj_dir,  sha1_2)
-        STDERR << "Write: .git/dump/objects/#{sha1_1}/#{sha1_2}\n"
-
-        File.open(outfile, "w") do |output|
-          dumper.dump(output, entry[:offset])
+      def create_note
+        if @step
+          FileUtils.mkdir_p(File.join(@outdir, 'notes'))
+          path = File.join(@outdir, 'notes', "#{ @step }.html")
+          msg = "Create: notes/#{ @step }.html"
+        else
+          path = File.join(@outdir, 'note.html')
+          msg = "Create: note.html"
+        end
+        unless File.exist?(path)
+          puts "-- Create note"
+          puts msg
+          File.open(path, 'w') {}
         end
       end
-
     end
   end
 end

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

@@ -0,0 +1,46 @@
+# -*- coding: utf-8 -*-
+
+module GitObjectBrowser
+
+  module Dumper
+
+    class ObjectsDumper
+
+      def initialize(root, outdir)
+        @root   = root
+        @outdir = outdir
+      end
+
+      def dump
+        obj_files = []
+        Dir.chdir(@root) 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_files.each do |path|
+          outfile = File.join(@outdir, "#{ path }.json")
+          next if File.exist?(outfile)
+
+          FileUtils.mkdir_p(File.dirname(outfile))
+
+          puts "Write: #{path}\n"
+          obj_file = File.join(@root, path)
+          File.open(obj_file) do |input|
+            File.open(outfile, "w") do |output|
+              dump_object(input, output, path)
+            end
+          end
+        end
+      end
+
+      def dump_object(input, output, path)
+        obj =  GitObjectBrowser::Models::GitObject.new(input).parse
+        wrapped = GitObjectBrowser::Models::WrappedObject.new(nil, path, obj)
+        output << JSON.pretty_generate(wrapped.to_hash)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,85 @@
+# -*- coding: utf-8 -*-
+
+module GitObjectBrowser
+
+  module Dumper
+
+    class PackIndexesDumper
+
+      def initialize(root, outdir)
+        @root   = root
+        @outdir = outdir
+      end
+
+      def dump
+        index_files = []
+        Dir.chdir(@root) do
+          Dir.glob('objects/pack/pack-*.idx') do |path|
+            next unless path =~ %r{/pack-[0-9a-f]{40}\.idx}
+            index_files << path
+          end
+        end
+        return if index_files.empty?
+
+        # digest, sha1 order, offset order
+        index_files.each do |path|
+          dump_digest(path)
+          dump_ordered(path, 'sha1')
+          dump_ordered(path, 'offset')
+        end
+      end
+
+      def dump_digest(path)
+        outfile = File.join(@outdir, "#{ path }.json")
+        infile  = File.join(@root, path)
+        FileUtils.mkdir_p(File.dirname(outfile))
+        puts "Write: #{path}\n"
+
+        File.open(infile) do |input|
+          File.open(outfile, 'w') do |output|
+            dump_object(input, output, path, 'digest', nil)
+          end
+        end
+      end
+
+      def dump_object(input, output, path, order, page)
+        obj =  GitObjectBrowser::Models::PackIndex.new(input).parse(order, page)
+        wrapped = GitObjectBrowser::Models::WrappedObject.new(nil, path, obj)
+        output << JSON.pretty_generate(wrapped.to_hash)
+      end
+
+      def dump_ordered(path, order)
+        FileUtils.mkdir_p(File.join(@outdir, "#{ path }/#{ order }"))
+        page = 1
+        loop do
+          outfile = File.join(@outdir, "#{ path }/#{ order }/#{ page }.json")
+          infile  = File.join(@root, path)
+          obj = nil
+          File.open(infile) do |input|
+            obj =  GitObjectBrowser::Models::PackIndex.new(input).parse(order, page)
+          end
+          break if obj.empty?
+
+          packpath = path.sub(/\.idx\z/, '.pack')
+          packfile = File.join(@root, packpath)
+          File.open(packfile) do |input|
+            obj.load_object_types(input)
+          end
+
+          puts "Write: #{ path }/#{ order }/#{ page }\n"
+          File.open(outfile, 'w') do |output|
+            wrapped = GitObjectBrowser::Models::WrappedObject.new(nil, path, obj)
+            output << JSON.pretty_generate(wrapped.to_hash)
+          end
+
+          if order == 'offset'
+            dumper = GitObjectBrowser::Dumper::PackedObjectsDumper.new(@root, @outdir)
+            dumper.dump(packpath, obj)
+          end
+          page += 1
+        end
+      end
+    end
+  end
+end
+