georgi-git_store 0.2.4 → 0.3

data/lib/git_store/blob.rb

@@ -4,60 +4,20 @@ class GitStore
   # deserialized data object.
   class Blob
 
-    attr_accessor :store, :id, :mode, :path, :data
+    attr_accessor :store, :id, :data, :mode, :object
 
-    # Initialize a Blob with default mode of '100644'.
-    def initialize(store)
+    # Initialize a Blob
+    def initialize(store, id = nil, data = nil)
       @store = store
-      @mode = '100644'
-    end
-
-    # Set all attributes at once.
-    def set(id, mode = nil, path = nil, data = nil, object = nil)
-      @id, @mode, @path, @data, @object = id, mode, path, data, object
-    end
-
-    # Returns the extension of the filename.
-    def extname
-      File.extname(path)[1..-1]
-    end
-
-    # Returns the handler for serializing the blob data.
-    def handler
-      Handler[extname]
-    end
-
-    # Returns true if data is new or hash value is different from current id.
-    def modified?
-      id.nil? || @modified
-    end
-
-    # Returns the data object.
-    def object
-      @object ||= handler.read(path, data)
-    end
-
-    # Set the data object.
-    def object=(value)
-      @modified = true
-      @object = value
-      @data = handler.respond_to?(:write) ? handler.write(path, value) : value
-    end
-
-    def load_from_disk
-      @object = nil
-      @data = open("#{store.path}/#{path}", 'rb') { |f| f.read }
+      @id = id || store.id_for('blob', data)
+      @data = data
+      @mode = "100644"
     end
 
     # Write the data to the git object store
-    def write_to_store      
-      if modified?
-        @modified = false
-        @id = store.put_object(data, 'blob')
-      else
-        @id
-      end
-    end   
+    def write
+      @id = store.put_object('blob', data)
+    end
 
   end
 

data/lib/git_store/commit.rb

@@ -0,0 +1,66 @@
+class GitStore
+
+  class Commit 
+    attr_accessor :store, :id, :data, :author, :committer, :tree, :parent, :message, :headers
+    attr_reader :author_name, :author_email, :author_time
+    attr_reader :committer_name, :committer_email, :committer_time
+
+    def initialize(store, id = nil, data = nil)
+      @store = store
+      @id = id
+      @parent = []
+
+      parse(data) if data
+
+      @author_name, @author_email, @author_time = parse_user(author) if author
+      @committer_name, @commiter_email, @committer_time = parse_user(committer) if committer
+    end
+
+    def parse_user(user)
+      if match = user.match(/(.*)<(.*)> (\d+) ([+-]\d+)/)
+        [ match[1].chomp,
+          match[2].chomp,
+          Time.at(match[3].to_i)]
+      end
+    end
+
+    def parse(data)
+      headers, @message = data.split(/\n\n/, 2)
+
+      headers.split(/\n/).each do |header|
+        key, value = header.split(/ /, 2)
+        if key == 'parent'
+          @parent << value
+        else
+          instance_variable_set "@#{key}", value
+        end
+      end
+
+      self
+    end
+
+    def diff(commit, path = nil)
+      commit = commit.id if Commit === commit
+      Diff.exec(store, "git diff --full-index #{commit} #{id} -- #{path}")
+    end
+
+    def diffs(path = nil)
+      diff(parent.first, path)
+    end
+
+    def write
+      @id = store.put_object('commit', dump)
+    end
+
+    def dump
+      [ "tree #@tree",
+        @parent.map { |parent| "parent #{parent}" },
+        "author #@author",
+        "committer #@committer",
+        '',
+        @message ].flatten.join("\n")
+    end
+    
+  end
+
+end

data/lib/git_store/diff.rb

@@ -0,0 +1,76 @@
+class GitStore
+
+  # adapted from Grit
+  class Diff
+    attr_reader :store
+    attr_reader :a_path, :b_path
+    attr_reader :a_blob, :b_blob
+    attr_reader :a_mode, :b_mode
+    attr_reader :new_file, :deleted_file
+    attr_reader :diff
+    
+    def initialize(store, a_path, b_path, a_blob, b_blob, a_mode, b_mode, new_file, deleted_file, diff)
+      @store = store
+      @a_path = a_path
+      @b_path = b_path
+      @a_blob = a_blob =~ /^0{40}$/ ? nil : store.get(a_blob)
+      @b_blob = b_blob =~ /^0{40}$/ ? nil : store.get(b_blob)
+      @a_mode = a_mode
+      @b_mode = b_mode
+      @new_file = new_file
+      @deleted_file = deleted_file
+      @diff = diff
+    end
+    
+    def self.exec(store, cmd)
+      list(store, IO.popen(cmd) { |io| io.read })
+    end
+    
+    def self.list(store, text)
+      lines = text.split("\n")
+      
+      diffs = []
+      
+      while !lines.empty?
+        m, a_path, b_path = *lines.shift.match(%r{^diff --git a/(.+?) b/(.+)$})
+        
+        if lines.first =~ /^old mode/
+          m, a_mode = *lines.shift.match(/^old mode (\d+)/)
+          m, b_mode = *lines.shift.match(/^new mode (\d+)/)
+        end
+        
+        if lines.empty? || lines.first =~ /^diff --git/
+          diffs << Diff.new(store, a_path, b_path, nil, nil, a_mode, b_mode, false, false, nil)
+          next
+        end
+        
+        new_file = false
+        deleted_file = false
+        
+        if lines.first =~ /^new file/
+          m, b_mode = lines.shift.match(/^new file mode (.+)$/)
+          a_mode = nil
+          new_file = true
+        elsif lines.first =~ /^deleted file/
+          m, a_mode = lines.shift.match(/^deleted file mode (.+)$/)
+          b_mode = nil
+          deleted_file = true
+        end
+        
+        m, a_blob, b_blob, b_mode = *lines.shift.match(%r{^index ([0-9A-Fa-f]+)\.\.([0-9A-Fa-f]+) ?(.+)?$})
+        b_mode.strip! if b_mode
+        
+        diff_lines = []
+        while lines.first && lines.first !~ /^diff/
+          diff_lines << lines.shift
+        end
+        diff = diff_lines.join("\n")
+        
+        diffs << Diff.new(store, a_path, b_path, a_blob, b_blob, a_mode, b_mode, new_file, deleted_file, diff)
+      end
+      
+      diffs
+    end
+  end
+
+end

data/lib/git_store/handlers.rb

@@ -15,43 +15,22 @@ end
 class GitStore
 
   class DefaultHandler
-    def read(path, data)
+    def read(data)
       data
     end
     
-    def write(path, data)
+    def write(data)
       data.to_s
     end
   end
   
   class YAMLHandler    
-    def read(path, data)
+    def read(data)
       YAML.load(data)
     end
 
-    def write(path, data)
+    def write(data)
       data.to_yaml
-    end    
-  end
-
-  class RubyHandler
-    def read(path, data)
-      Object.module_eval(data)
     end
   end
-
-  class ERBHandler
-    def read(path, data)
-      ERB.new(data)
-    end
-  end
-
-  Handler = {
-    'yml' => YAMLHandler.new,
-    'rhtml' => ERBHandler.new,
-    'rxml' => ERBHandler.new,
-    'rb' => RubyHandler.new
-  }
-
-  Handler.default = DefaultHandler.new
 end

data/lib/git_store/tree.rb

@@ -1,42 +1,23 @@
 class GitStore
 
   class Tree
-    TYPE_CLASS = {
-      'tree' => Tree,
-      'blob' => Blob
-    }
-    
     include Enumerable
 
-    attr_reader :store
-    attr_accessor :id, :mode, :path, :data, :table
+    attr_reader :store, :table
+    attr_accessor :id, :data, :mode
 
-    # Initialize a tree with default mode '040000'
-    def initialize(store)
-      @store = store      
-      @mode ||= '040000'
-      @path = ''
+    # Initialize a tree
+    def initialize(store, id = nil, data = nil)
+      @store = store
+      @id = id
       @table = {}
-    end
-
-    # Set all attributes at once.
-    def set(id, mode = '040000', path = nil, data = nil)
-      @id, @mode, @path, @data = id, mode, path, data
-    end
-
-    # Does this tree exist in the repository?
-    def created?
-      not @id.nil?
+      @mode = "040000"
+      parse(data) if data
     end
 
     # Has this tree been modified?
     def modified?
-      @modified || (table && table.values.any? { |value| value.modified? })
-    end
-
-    # Path of a child element with specified name.
-    def child_path(name)
-      path.empty? ? name : "#{path}/#{name}"
+      @modified or @table.values.any? { |entry| Tree === entry and entry.modified? }
     end
 
     # Find or create a subtree with specified name.
@@ -44,157 +25,148 @@ class GitStore
       get(name) or put(name, Tree.new(store))
     end
 
-    # Load this tree from a real directory instead of a repository.
-    def load_from_disk
-      dir = File.join(store.path, self.path)
-      entries = Dir.entries(dir) - ['.', '..']
-
-      @table = entries.inject({}) do |hash, name|
-        if name[-1, 1] != '~' && name[0, 1] != '.'
-          path = "#{dir}/#{name}"
-          stat = File.stat(path)
-          mode = '%o' % stat.mode
-          klass = stat.directory? ? Tree : Blob
-          
-          child = table[name] ||= klass.new(store)
-          child.set(nil, mode, child_path(name), data)
-          child.load_from_disk
-          
-          hash[name] = child
-        end        
-        hash
-      end
-    end
-
     # Read the contents of a raw git object.
-    #
-    # Return an array of [mode, name, id] entries.
-    def read_contents(data)
-      contents = []
+    def parse(data)
+      @table.clear
 
       while data.size > 0
         mode, data = data.split(" ", 2)
         name, data = data.split("\0", 2)
         id = data.slice!(0, 20).unpack("H*").first
-        contents << [ mode, name, id ]
-      end
-
-      contents
-    end
-
-    # Load this tree from a git repository.
-    def load_from_store
-      @table = read_contents(data).inject({}) do |hash, (mode, name, id)|
-        content, type = store.get_object(id)
-
-        child = table[name] || TYPE_CLASS[type].new(store)
-        child.set(id, mode, child_path(name), content)
-        child.load_from_store if Tree === child
-
-        hash[name] = child
-        hash
+        
+        @table[name] = store.get(id)
       end
     end
-
+    
     # Write this tree back to the git repository.
     #
     # Returns the object id of the tree.
-    def write_to_store
+    def write
       return id if not modified?
       
-      contents = table.map do |name, entry|
-        entry.write_to_store
-        "%s %s\0%s" % [entry.mode, name, [entry.id].pack("H*")]
+      contents = @table.map do |name, entry|
+        "#{ entry.mode } #{ name }\0#{ [entry.write].pack("H*") }"
       end
 
       @modified = false
-      @id = store.put_object(contents.join, 'tree')
+      @id = store.put_object('tree', contents.join)
     end
-    
+
     # Read entry with specified name.
     def get(name)
-      name = name.to_s
-      entry = table[name]
+      entry = @table[name]
       
       case entry
-      when Blob; entry.object
-      when Tree; entry
+      when Blob
+        entry.object ||= handler_for(name).read(entry.data)
+          
+      when Tree
+        entry
       end
     end
 
+    def handler_for(name)
+      store.handler_for(name)
+    end    
+
     # Write entry with specified name.
     def put(name, value)
       @modified = true
-      name = name.to_s
       
       if value.is_a?(Tree)
-        value.path = child_path(name)
-        table[name] = value
+        @table[name] = value
       else
-        blob = table[name]
-        blob = Blob.new(store) if not blob.is_a?(Blob)
-        blob.path = child_path(name)
-        blob.object = value
-        table[name] = blob          
+        @table[name] = Blob.new(store, nil, handler_for(name).write(value))
       end
-
+     
       value
     end
 
     # Remove entry with specified name.
     def remove(name)
       @modified = true
-      table.delete(name.to_s)
+      @table.delete(name.to_s)
     end
 
     # Does this key exist in the table?
     def has_key?(name)
-      table.has_key?(name)
+      @table.has_key?(name.to_s)
     end
 
+    def normalize_path(path)
+      (path[0, 1] == '/' ? path[1..-1] : path).split('/')
+    end    
+
     # Read a value on specified path.
-    #
-    # Use an argument list or a string with slashes.
-    def [](*args)
-      args = args.first.to_s.split('/') if args.size == 1
-      args.inject(self) { |tree, key| tree.get(key) or return nil }
+    def [](path)
+      normalize_path(path).inject(self) do |tree, key|
+        tree.get(key) or return nil
+      end
     end
 
     # Write a value on specified path.
-    #
-    # Use an argument list or a string with slashes.
-    def []=(*args)
-      value = args.pop
-      args = args.first.to_s.split('/') if args.size == 1
-      tree = args[0..-2].to_a.inject(self) { |tree, name| tree.tree(name) }
-      tree.put(args.last, value)
+    def []=(path, value)
+      list = normalize_path(path)
+      tree = list[0..-2].to_a.inject(self) { |tree, name| tree.tree(name) }
+      tree.put(list.last, value)
     end
 
     # Delete a value on specified path.
-    #
-    # Use an argument list or a string with slashes.
-    def delete(*args)
-      args = args.first.to_s.split('/') if args.size == 1
-      tree = args[0..-2].to_a.inject(self) do |tree, key|
+    def delete(path)
+      list = normalize_path(path)
+      
+      tree = list[0..-2].to_a.inject(self) do |tree, key|
         tree.get(key) or return
       end
-      tree.remove(args.last)
+      
+      tree.remove(list.last)
     end
 
     # Iterate over all objects found in this subtree.
-    def each(&block)
-      table.sort.each do |name, entry|
+    def each(path = [], &block)
+      @table.sort.each do |name, entry|
+        child_path = path + [name]
+        case entry
+        when Blob
+          entry.object ||= handler_for(name).read(entry.data)
+          yield child_path.join("/"), entry.object
+          
+        when Tree
+          entry.each(child_path, &block)
+        end
+      end
+    end
+
+    def each_blob(path = [], &block)
+      @table.sort.each do |name, entry|
+        child_path = path + [name]
+
         case entry
-        when Blob; yield entry.object
-        when Tree; entry.each(&block)
+        when Blob
+          yield child_path.join("/"), entry
+          
+        when Tree
+          entry.each_blob(child_path, &block)
         end
       end
     end
 
+    def paths
+      map { |path, data| path }
+    end
+
+    def values
+      map { |path, data| data }
+    end
+
     # Convert this tree into a hash object.
     def to_hash
-      table.inject({}) do |hash, (name, entry)|
-        hash[name] = entry.is_a?(Tree) ? entry.to_hash : entry.object
+      @table.inject({}) do |hash, (name, entry)|
+        if entry.is_a?(Tree) 
+          hash[name] = entry.to_hash
+        else
+          hash[name] = entry.object ||= handler_for(name).read(entry.data)
+        end
         hash
       end
     end