git-db 0.1.2

data/lib/git-db/objects/commit.rb

@@ -0,0 +1,49 @@
+class GitDB::Objects::Commit < GitDB::Objects::Base
+  
+  def raw
+    "commit #{data.length}\000#{data}"
+  end
+
+  def type
+    GitDB::OBJ_COMMIT
+  end
+
+  def message
+    data.split("\n\n", 2).last
+  end
+
+  def author
+    attributes['author'].first
+  end
+
+  def committer
+    attributes['committer'].first
+  end
+
+  def tree
+    attributes['tree'].first
+  end
+
+  def parents
+    attributes['parent']
+  end
+
+  def properties
+    [:tree, :parents, :author, :committer, :message]
+  end
+
+private ######################################################################
+
+  def attributes
+    @attributes ||= begin
+      attributes = data.split("\n\n", 2).first
+      attributes.split("\n").inject({}) do |hash, line|
+        key, value = line.split(' ', 2)
+        hash[key] ||= []
+        hash[key]  << value
+        hash
+      end
+    end
+  end
+
+end

data/lib/git-db/objects/entry.rb

@@ -0,0 +1,27 @@
+require 'stringio'
+
+class GitDB::Objects::Entry < GitDB::Objects::Base
+
+  attr_reader :sha, :permissions, :name
+
+  def initialize(sha, permissions, name)
+    @sha = sha
+    @permissions = permissions
+    @name = name
+  end
+
+  def properties
+    [:permissions, :name]
+  end
+
+  def to_hash
+    { :sha => sha, :permissions => permissions, :name => name }
+  end
+
+  def to_json
+    to_hash.to_json
+  end
+
+private ######################################################################
+
+end

data/lib/git-db/objects/tag.rb

@@ -0,0 +1,7 @@
+class GitDB::Objects::Tag < GitDB::Objects::Base
+
+  def type
+    GitDB::OBJ_TAG
+  end
+
+end

data/lib/git-db/objects/tree.rb

@@ -0,0 +1,45 @@
+require 'stringio'
+
+class GitDB::Objects::Tree < GitDB::Objects::Base
+
+  # TODO: memoize entries
+
+  def entries
+    entries = []
+    stream = StringIO.new(data)
+    until stream.eof?
+      perms = read_until(stream, ' ').to_i
+      name  = read_until(stream, 0.chr)
+      sha   = GitDB.sha1_to_hex(stream.read(20))
+      entries << GitDB::Objects::Entry.new(sha, perms, name)
+    end
+    entries
+  end
+
+  def properties
+    [:entries]
+  end
+
+  def raw
+    "tree #{data.length}\000#{data}"
+  end
+
+  def type
+    GitDB::OBJ_TREE
+  end
+
+private ######################################################################
+
+  def read_until(stream, separator)
+    data = ""
+    char = ""
+    loop do
+      char = stream.read(1)
+      break if char.nil?
+      break if char == separator
+      data << char
+    end
+    data
+  end
+
+end

data/lib/git-db/objects.rb

@@ -0,0 +1,20 @@
+module GitDB::Objects; 
+
+  def self.new_from_type(type, data)
+    case type
+      when GitDB::OBJ_COMMIT then GitDB::Objects::Commit.new(data)
+      when GitDB::OBJ_TREE   then GitDB::Objects::Tree.new(data)
+      when GitDB::OBJ_BLOB   then GitDB::Objects::Blob.new(data)
+      when GitDB::OBJ_TAG    then GitDB::Objects::Tag.new(data)
+      else raise "Unknown object type: #{type}"
+    end
+  end
+
+end
+
+require 'git-db/objects/base'
+require 'git-db/objects/blob'
+require 'git-db/objects/commit'
+require 'git-db/objects/entry'
+require 'git-db/objects/tag'
+require 'git-db/objects/tree'

data/lib/git-db/pack.rb

@@ -0,0 +1,182 @@
+require 'digest/sha1'
+require 'stringio'
+require 'zlib'
+
+class GitDB::Pack
+
+  PackObject = Struct.new(:type, :offset, :data)
+
+  attr_reader :io
+
+  def initialize(io)
+    @io = GitDB::Utility::CountingIO.new(io)
+  end
+
+  def read
+    header = io.read(12)
+    return nil unless header
+
+    signature, version, entries = header.unpack("a4NN")
+    raise 'invalid pack signature' unless signature == 'PACK'
+    raise 'invalid version'        unless version   == 2
+
+    objects = {}
+
+    1.upto(entries) do
+      object_offset = io.offset
+
+      type, size = unpack_pack_header(io)
+
+      object = case type
+        when 1 then
+          GitDB::Objects::Commit.new(read_compressed(io))
+        when 2 then
+          GitDB::Objects::Tree.new(read_compressed(io))
+        when 3 then
+          GitDB::Objects::Blob.new(read_compressed(io))
+        when 4 then
+          GitDB::Objects::Tag.new(read_compressed(io))
+        when 5 then
+          raise 'Invalid Type: 5'
+        when 6 then
+          offset = object_offset - unpack_delta_size(io)
+          patch  = read_compressed(io)
+          base   = objects[offset]
+          base.class.new(apply_patch(base.data, patch))
+        when 7 then
+          # TODO
+          sha = io.read(20)
+          # base = lookup_by_sha(sha)
+          patch = read_compressed(io)
+          # base.class.new(apply_patch(base.data, patch))
+          nil
+      end
+
+      objects[object_offset] = object
+    end
+
+    GitDB.log(objects.values.map { |o| o.inspect })
+
+    io.read(20)
+
+    objects.values.compact
+  end
+
+  def write(entries)
+    buffer = ""
+    signature = ["PACK", 2, entries.length].pack("a4NN")
+    #GitDB.log("SIGNATURE: #{signature}")
+    io.write(signature)
+    buffer << signature
+    
+    entries.each do |entry|
+      header = pack_pack_header(entry.type, entry.data.length)
+      #GitDB.log("HEADER: #{header.inspect}")
+      io.write(header)
+      buffer << header
+      compressed = Zlib::Deflate.deflate(entry.data)
+      io.write(compressed)
+      buffer << compressed
+    end
+    
+    #GitDB.log("BUFFER: #{buffer.inspect}")
+    signature = GitDB::hex_to_sha1(Digest::SHA1.hexdigest(buffer))
+    #GitDB.log("SIGNATURE: #{signature.inspect}")
+    io.write(signature)
+    io.flush
+  end
+
+private ######################################################################
+
+  def apply_patch(original, patch)
+    patch_stream = StringIO.new(patch)
+    source_size = unpack_size(patch_stream)
+    destination_size = unpack_size(patch_stream)
+
+    data = ""
+
+    until patch_stream.eof?
+      offset = size = 0
+      cmd = patch_stream.read(1)[0]
+      if (cmd & 0x80) != 0
+        offset  = (patch_stream.read(1)[0])       if (cmd & 0x01) != 0
+        offset |= (patch_stream.read(1)[0] << 8)  if (cmd & 0x02) != 0
+        offset |= (patch_stream.read(1)[0] << 16) if (cmd & 0x04) != 0
+        offset |= (patch_stream.read(1)[0] << 24) if (cmd & 0x08) != 0
+        size    = (patch_stream.read(1)[0])       if (cmd & 0x10) != 0
+        size   |= (patch_stream.read(1)[0] << 8)  if (cmd & 0x20) != 0
+        size   |= (patch_stream.read(1)[0] << 16) if (cmd & 0x40) != 0
+        size    = 0x10000                         if size == 0
+
+        if ((offset + size) < size) ||
+           ((offset + size) > source_size) ||
+           (size > destination_size)
+           break
+        end
+        data += original[offset,size]
+      elsif (cmd != 0)
+        data += patch_stream.read(cmd)
+      end
+    end
+
+    data
+  end
+
+  def read_compressed(stream)
+    zstream = Zlib::Inflate.new
+    data = ""
+    loop do
+      data += zstream.inflate(stream.read(1))
+      break if zstream.finished?
+    end
+    data
+  end
+
+  def pack_pack_header(type, size)
+    data = ""
+    c = (type << 4) | (size & 15);
+    size >>= 4;
+    while (size > 0)
+      data << (c | 0x80).chr
+      c = size & 0x7f;
+      size >>= 7;
+    end
+    data << c.chr
+  end
+
+  def unpack_delta_size(stream)
+    c = stream.read(1)[0]
+    size = (c & 127)
+    while (c & 128) != 0
+      size += 1
+      c = stream.read(1)[0]
+      size = (size << 7) + (c & 127)
+    end
+    size
+  end
+
+  def unpack_pack_header(stream)
+    c = stream.read(1)[0]
+    type = (c >> 4) & 7
+    size = (c & 15)
+    shift = 4
+    while ((c & 0x80) != 0)
+      c = stream.read(1)[0]
+      size += ((c & 0x7f) << shift)
+      shift += 7
+    end
+    [type, size]
+  end
+
+  def unpack_size(stream)
+    size = shift = 0
+    loop do
+      c = stream.read(1)[0]
+      size += (c & 127) << shift
+      shift += 7
+      break if (c & 128) == 0
+    end
+    size
+  end
+
+end

data/lib/git-db/protocol.rb

@@ -0,0 +1,73 @@
+class GitDB::Protocol
+
+  attr_reader :reader
+  attr_reader :writer
+
+  def initialize(io=nil)
+    if io
+      @reader = io
+      @writer = io
+    else
+      @reader = STDIN
+      @writer = STDOUT
+    end
+  end
+
+## commands ##################################################################
+
+  def flush
+    writer.flush
+  end
+
+  def read_command
+    length = reader.read(4)
+    return nil unless length
+    length = length.to_i(16) - 4
+    if (length == -4)
+      GitDB.log('GOT EOF')
+      return
+    end
+    data = reader.read(length)
+    GitDB.log("GOT DATA: #{data.inspect}")
+    data
+  end
+
+  def write_command(command)
+    raw_command = encode_command(command)
+    GitDB.log("WWRITING COMMAND: #{raw_command.inspect}")
+    writer.print raw_command
+    writer.flush
+  end
+
+  def write(data)
+    writer.write data
+    writer.flush
+  end
+
+  def write_eof
+    #GitDB.log("WRITING EOF")
+    writer.print '0000'
+    writer.flush
+  end
+
+## packs #####################################################################
+
+  def read_pack
+    GitDB::Pack.new(reader).read
+  end
+
+  def write_pack(entries)
+    GitDB::Pack.new(writer).write(entries)
+  end
+
+private ######################################################################
+
+  def encode_command(command)
+    length_as_hex(command) << command
+  end
+
+  def length_as_hex(command)
+    hex = (command.length + 4).to_s(16).rjust(4, '0')
+  end
+
+end

data/lib/git-db/utility/counting_io.rb

@@ -0,0 +1,24 @@
+class GitDB::Utility::CountingIO
+
+  attr_reader :io, :offset
+
+  def initialize(io)
+    @io = io
+    @offset = 0
+  end
+
+  def flush
+    io.flush
+  end
+
+  def read(n)
+    data = io.read(n)
+    @offset += n
+    data
+  end
+
+  def write(data)
+    io.write(data)
+  end
+
+end

data/lib/git-db/utility.rb

@@ -0,0 +1,3 @@
+module GitDB::Utility; end
+
+require 'git-db/utility/counting_io'

data/lib/git-db.rb

@@ -0,0 +1,68 @@
+require 'base64'
+require 'couchrest'
+require 'logger'
+
+module GitDB;
+
+## git constants #############################################################
+
+  OBJ_NONE      = 0
+  OBJ_COMMIT    = 1
+  OBJ_TREE      = 2
+  OBJ_BLOB      = 3
+  OBJ_TAG       = 4
+  OBJ_OFS_DELTA = 6
+  OBJ_REF_DELTA = 7
+  
+## git utility ###############################################################
+
+  def self.sha1_to_hex(sha)
+    hex = ""
+    sha.split('').each do |char|
+      val = char[0]
+      hex << (val >>  4).to_s(16)
+      hex << (val & 0xf).to_s(16)
+    end
+    hex
+  end
+
+  def self.hex_to_sha1(hex)
+    sha = ""
+    len = 0
+    until (len == hex.length)
+      val = (hex[len,   1].to_i(16) << 4)
+      val += hex[len+1, 1].to_i(16)
+      sha << val.chr
+      len += 2
+    end
+    sha
+  end
+
+  def self.null_sha1
+    "0000000000000000000000000000000000000000"
+  end
+
+## logging ###################################################################
+
+  def self.logger
+    @logger ||= STDERR
+  end
+
+  def self.log(message)
+    logger.puts message
+  end
+
+## database ##################################################################
+
+  def self.database(repository)
+    GitDB::Database.database(repository)
+  end
+    
+end
+
+require 'git-db/commands'
+require 'git-db/database'
+require 'git-db/objects'
+require 'git-db/pack'
+require 'git-db/protocol'
+require 'git-db/utility'

data/spec/git-db/commands_spec.rb

@@ -0,0 +1,23 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+describe "GitDB::Commands" do
+
+  it "has a receive-pack command" do
+    GitDB::Commands.commands['receive-pack'].should_not be_nil
+  end
+
+  it "has an upload-pack command" do
+  end
+
+  it "executes a command" do
+    @command = mock
+    @name    = 'command'
+    @args    = ['Test Repository']
+
+    GitDB::Commands.should_receive(:commands).at_least(:once).and_return({ @name => @command })
+    @command.should_receive(:execute).with(@args)
+    
+    GitDB::Commands.execute(@name, @args)
+  end
+
+end

data/spec/git-db/objects/base_spec.rb

@@ -0,0 +1,27 @@
+require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
+
+describe "GitDB::Objects::Base" do
+
+  before(:each) do
+    @data = "Test Data"
+    @base = GitDB::Objects::Base.new(@data)
+  end
+
+  it "initializes with data" do
+    @base.data.should == @data
+  end
+
+  it "inspects its own properties" do
+    @base.should_receive(:properties).and_return([:data])
+    @base.inspect
+  end
+
+  it "has default properties" do
+    @base.properties.should == [:data]
+  end
+
+  it "has default raw" do
+    @base.raw.should == @data
+  end
+
+end

data/spec/git-db/objects/entry_spec.rb

@@ -0,0 +1,25 @@
+require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
+
+describe "GitDB::Objects::Entry" do
+
+  before(:each) do
+    @sha   = "1111111111111111111111111111111111111111"
+    @perms = 100644
+    @name  = "test name"
+    @entry = GitDB::Objects::Entry.new(@sha, @perms, @name)
+  end
+
+  it "has properties" do
+    @entry.properties.should == [:permissions, :name]
+  end
+
+  it "converts to a hash" do
+    @entry.to_hash[:sha].should         == @sha
+    @entry.to_hash[:permissions].should == @perms
+    @entry.to_hash[:name].should        == @name
+  end
+
+  it "converts to json" do
+    @entry.to_json.should == @entry.to_hash.to_json
+  end
+end

data/spec/git-db/objects/tag_spec.rb

@@ -0,0 +1,14 @@
+require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
+
+describe "GitDB::Objects::Tag" do
+
+  before(:each) do
+    # TODO: real tag data
+    @data = "test-tag"
+    @tag  = GitDB::Objects::Tag.new(@data)
+  end
+
+  it "has a type" do
+    @tag.type.should == GitDB::OBJ_TAG
+  end
+end

data/spec/git-db/objects/tree_spec.rb

@@ -0,0 +1,42 @@
+require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
+
+describe "GitDB::Objects::Tree" do
+
+  class TreeEntry
+    attr_reader :perms, :name, :sha
+
+    def initialize(perms, name, sha)
+      @perms = perms
+      @name  = name
+      @sha   = sha
+    end
+
+    def to_entry
+      "#{perms} #{name}\000#{GitDB.hex_to_sha1(sha)}"
+    end
+  end
+
+  before(:each) do
+    @entry1 = TreeEntry.new(100644, "entry1", "1111111111111111111111111111111111111111")
+    @entry2 = TreeEntry.new(100444, "entry2", "2222222222222222222222222222222222222222")
+    @data   = [ @entry1.to_entry, @entry2.to_entry ].join('')
+    @tree   = GitDB::Objects::Tree.new(@data)
+  end
+
+  it "has entries" do
+    @tree.entries.first.name.should == @entry1.name
+    @tree.entries.last.name.should  == @entry2.name
+  end
+
+  it "has properties" do
+    @tree.properties.should == [:entries]
+  end
+
+  it "has a raw value" do
+    @tree.raw.should == "tree #{@data.length}\000#{@data}"
+  end
+
+  it "has a type" do
+    @tree.type.should == GitDB::OBJ_TREE
+  end
+end

data/spec/git-db/utility/counting_io_spec.rb

@@ -0,0 +1,30 @@
+require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
+
+describe "GitDB::Utility::CountingIO" do
+
+  before(:each) do
+    @base = StringIO.new
+    @io   = GitDB::Utility::CountingIO.new(@base)
+  end
+
+  it "can flush" do
+    @base.should_receive(:flush)
+    @io.flush
+  end
+
+  it "can read" do
+    @data  = "00000"
+    @bytes = @data.length
+
+    @base.should_receive(:read).with(@bytes).and_return(@data)
+    @io.read(@bytes).should == @data
+  end
+
+  it "can write" do
+    @data = "00000"
+
+    @base.should_receive(:write).with(@data)
+    @io.write(@data)
+  end
+
+end