ddollar-git-db 0.0.2

data/.document

@@ -0,0 +1,5 @@
+README.rdoc
+lib/**/*.rb
+bin/*
+features/**/*.feature
+LICENSE

data/.gitignore

@@ -0,0 +1,5 @@
+*.sw?
+.DS_Store
+coverage
+rdoc
+pkg

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2009 David Dollar
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.rdoc

@@ -0,0 +1,38 @@
+= git-db
+
+CouchDB-based git server, avoids the filesystem. (VERY ALPHA)
+
+== Installation
+
+* Install the gem
+
+  $ gem install ddollar-git-db
+
+* Create a <tt>git</tt> user. (Name can be whatever you like)
+* Set a home directory for the user.
+* Set up the <tt>git</tt> user's authorized_keys2 file: (modify the command to match your gem particulars)
+
+  # ~/.git/.ssh/authorized_keys2
+  command="/usr/bin/git-db david",no-port-forwarding,no-X11-forwarding,no-agent-forwarding,no-pty <your ssh public key>
+
+* Add your localhost as a remote to an existing project and push
+
+  $ git remote add test-git-db git@localhost:my-repo.git
+  $ git push test-git-db master
+
+* Please report any problems on the issue tracker.
+
+== Note on Patches/Pull Requests
+
+* Fork the project.
+* Make your feature addition or bug fix.
+* Add tests for it. This is important so I don't break it in a
+  future version unintentionally.
+* Commit, do not mess with rakefile, version, or history.
+  (if you want to have your own version, that is fine but
+   bump version in a commit by itself I can ignore when I pull)
+* Send me a pull request. Bonus points for topic branches.
+
+== Copyright
+
+Copyright (c) 2009 David Dollar. See LICENSE for details.

data/Rakefile

@@ -0,0 +1,57 @@
+require 'rubygems'
+require 'rake'
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |gem|
+    gem.name = "git-db"
+    gem.summary = %Q{Database-based git server}
+    gem.description = gem.summary
+    gem.email = "<ddollar@gmail.com>"
+    gem.homepage = "http://github.com/ddollar/git-db"
+    gem.authors = ["David Dollar"]
+    gem.add_development_dependency "rspec"
+    gem.add_development_dependency "yard"
+    gem.add_development_dependency "cucumber"
+    # gem is a Gem::Specification... see http://www.rubygems.org/read/chapter/20 for additional settings
+  end
+  Jeweler::GemcutterTasks.new
+rescue LoadError
+  puts "Jeweler (or a dependency) not available. Install it with: sudo gem install jeweler"
+end
+
+require 'spec/rake/spectask'
+Spec::Rake::SpecTask.new(:spec) do |spec|
+  spec.libs << 'lib' << 'spec'
+  spec.spec_files = FileList['spec/**/*_spec.rb']
+end
+
+Spec::Rake::SpecTask.new(:rcov) do |spec|
+  spec.libs << 'lib' << 'spec'
+  spec.pattern = 'spec/**/*_spec.rb'
+  spec.rcov = true
+end
+
+task :spec => :check_dependencies
+
+begin
+  require 'cucumber/rake/task'
+  Cucumber::Rake::Task.new(:features)
+
+  task :features => :check_dependencies
+rescue LoadError
+  task :features do
+    abort "Cucumber is not available. In order to run features, you must: sudo gem install cucumber"
+  end
+end
+
+task :default => :spec
+
+begin
+  require 'yard'
+  YARD::Rake::YardocTask.new
+rescue LoadError
+  task :yardoc do
+    abort "YARD is not available. In order to run yardoc, you must: sudo gem install yard"
+  end
+end

data/VERSION

@@ -0,0 +1 @@
+0.0.2

data/bin/git-db

@@ -0,0 +1,16 @@
+#!/usr/bin/env ruby
+
+$:.unshift('/Users/david/Code/git-db/lib')
+require 'git-db'
+include GitDB
+
+GitDB.log(ENV.inspect)
+
+git_command = ENV['SSH_ORIGINAL_COMMAND'].match(/git-(.+) '(.+)'/)
+
+if git_command
+  command    = git_command[1]
+  repository = git_command[2]
+
+  Git::Commands.execute(command, [repository])
+end

data/features/git-db.feature

@@ -0,0 +1,9 @@
+Feature: something something
+  In order to something something
+  A user something something
+  something something something
+
+  Scenario: something something
+    Given inspiration
+    When I create a sweet new gem
+    Then everyone should see how awesome I am

data/features/support/env.rb

@@ -0,0 +1,4 @@
+$LOAD_PATH.unshift(File.dirname(__FILE__) + '/../../lib')
+require 'git-db'
+
+require 'spec/expectations'

data/git-db.gemspec

@@ -0,0 +1,80 @@
+# Generated by jeweler
+# DO NOT EDIT THIS FILE
+# Instead, edit Jeweler::Tasks in Rakefile, and run `rake gemspec`
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{git-db}
+  s.version = "0.0.2"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["David Dollar"]
+  s.date = %q{2009-09-13}
+  s.default_executable = %q{git-db}
+  s.description = %q{Database-based git server}
+  s.email = %q{<ddollar@gmail.com>}
+  s.executables = ["git-db"]
+  s.extra_rdoc_files = [
+    "LICENSE",
+     "README.rdoc"
+  ]
+  s.files = [
+    ".document",
+     ".gitignore",
+     "LICENSE",
+     "README.rdoc",
+     "Rakefile",
+     "VERSION",
+     "bin/git-db",
+     "features/git-db.feature",
+     "features/step_definitions/git-db_steps.rb",
+     "features/support/env.rb",
+     "git-db.gemspec",
+     "lib/git-db.rb",
+     "lib/git.rb",
+     "lib/git/commands.rb",
+     "lib/git/commands/receive-pack.rb",
+     "lib/git/commands/upload-pack.rb",
+     "lib/git/objects.rb",
+     "lib/git/objects/base.rb",
+     "lib/git/objects/blob.rb",
+     "lib/git/objects/commit.rb",
+     "lib/git/objects/entry.rb",
+     "lib/git/objects/tag.rb",
+     "lib/git/objects/tree.rb",
+     "lib/git/pack.rb",
+     "lib/git/protocol.rb",
+     "lib/utility.rb",
+     "lib/utility/counting_io.rb",
+     "spec/git-db_spec.rb",
+     "spec/spec_helper.rb"
+  ]
+  s.homepage = %q{http://github.com/ddollar/git-db}
+  s.rdoc_options = ["--charset=UTF-8"]
+  s.require_paths = ["lib"]
+  s.rubygems_version = %q{1.3.5}
+  s.summary = %q{Database-based git server}
+  s.test_files = [
+    "spec/git-db_spec.rb",
+     "spec/spec_helper.rb"
+  ]
+
+  if s.respond_to? :specification_version then
+    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::RubyGemsVersion) >= Gem::Version.new('1.2.0') then
+      s.add_development_dependency(%q<rspec>, [">= 0"])
+      s.add_development_dependency(%q<yard>, [">= 0"])
+      s.add_development_dependency(%q<cucumber>, [">= 0"])
+    else
+      s.add_dependency(%q<rspec>, [">= 0"])
+      s.add_dependency(%q<yard>, [">= 0"])
+      s.add_dependency(%q<cucumber>, [">= 0"])
+    end
+  else
+    s.add_dependency(%q<rspec>, [">= 0"])
+    s.add_dependency(%q<yard>, [">= 0"])
+    s.add_dependency(%q<cucumber>, [">= 0"])
+  end
+end

data/lib/git/commands/receive-pack.rb

@@ -0,0 +1,101 @@
+require 'fileutils'
+require 'zlib'
+
+class GitDB::Git::Commands::ReceivePack
+
+  def execute(args)
+    repository = args.first
+    raise ArgumentError, "repository required" unless repository
+
+    needs_capabilities = true
+    each_git_ref do |ref, sha|
+      write_ref(ref, sha, needs_capabilities)
+      needs_capabilities = false
+    end
+    write_ref("capabilities^{}", null_sha1) if needs_capabilities
+    io.write_eof
+    
+    refs = []
+    new_shas = []
+    
+    while (data = io.read_command)
+      old_sha, new_sha, ref = data.split(' ')
+      ref, report = ref.split(0.chr)
+      refs << ref
+      new_shas << new_sha
+      if new_sha == null_sha1
+        delete_git_file(ref)
+      else
+        write_git_file(ref, new_sha)
+      end
+      # GitDB.log("OLDSHA: #{old_sha}")
+      # GitDB.log("NEWSHA: #{new_sha}")
+      # GitDB.log("REF: #{ref}")
+      # GitDB.log("REPORT: #{report}")
+    end
+    
+    unless new_shas.reject { |sha| sha == null_sha1 }.length.zero?
+      while (entries = io.read_pack)
+        GitDB.log("ENTRIES: #{entries.inspect}")
+        entries.each do |entry|
+          filename = "objects/#{entry.sha[0..1]}/#{entry.sha[2..-1]}"
+          write_git_file(filename, Zlib::Deflate.deflate(entry.raw))
+        end
+      end
+    end
+
+    io.write_command("unpack ok\n")
+    refs.each do |ref|
+      io.write_command("ok #{ref}\n")
+    end
+    io.write_eof
+  end
+
+private
+
+  def capabilities
+    " report-status delete-refs ofs-delta "
+  end
+
+  def io
+    @io ||= GitDB::Git::Protocol.new
+  end
+
+  def null_sha1
+    "0000000000000000000000000000000000000000"
+  end
+
+  def each_git_ref(&block)
+    Dir["/tmp/foo/.git/refs/*/*"].each do |ref|
+      sha = File.read(ref).strip
+      ref = ref.gsub('/tmp/foo/.git/', '')
+      yield ref, sha
+    end
+  end
+
+  def delete_git_file(filename)
+    filename = "/tmp/foo/.git/#{filename}"
+    GitDB.log("REMOVING: #{filename}")
+    FileUtils.rm_rf(filename)
+  end
+
+  def write_git_file(filename, data)
+    filename = "/tmp/foo/.git/#{filename}"
+    FileUtils.mkdir_p(File.dirname(filename))
+    File.open(filename, 'w') do |file|
+      file.print(data)
+    end
+  end
+
+  def write_ref(ref, sha, needs_capabilities=true)
+    if needs_capabilities
+      header = "%s %s\000%s\n" % [ sha, ref, capabilities ]
+      io.write_command(header)
+    else
+      header = "%s %s\n" % [ sha, ref ]
+    end
+  end
+
+end
+
+GitDB::Git::Commands.register 'receive-pack', GitDB::Git::Commands::ReceivePack

data/lib/git/commands/upload-pack.rb

@@ -0,0 +1,204 @@
+require 'fileutils'
+require 'zlib'
+
+class GitDB::Git::Commands::UploadPack
+
+  def execute(args)
+    repository = args.first
+    raise ArgumentError, "repository required" unless repository
+
+    #execute_transcript
+    execute_real
+  end
+
+  def execute_transcript
+    cmd = GitDB::Git::Protocol.new(IO.popen("/opt/local/bin/git-upload-pack '/tmp/foo'", 'r+'))
+
+    while (data = cmd.read_command)
+      GitDB.log("CMD COMMAND: #{data}")
+      io.write_command(data)
+    end
+    io.write_eof
+
+    while (data = io.read_command)
+      GitDB.log("IO COMMAND: #{data}")
+      cmd.write_command(data)
+    end
+    cmd.write_eof
+
+    while (data = io.read_command)
+      cmd.write_command(data)
+      data = data.strip
+      break if data == 'done'
+      GitDB.log("READ FROM IO #{data}")
+    end
+    
+    while (data = cmd.read_command)
+      GitDB.log("GOT COMMAND DATA: #{data.inspect}")
+    end
+
+    # data = io.reader.read(9)
+    # GitDB.log("READ FROM IO: #{data.inspect}")
+    # cmd.writer.write(data)
+
+    # while (data = cmd.read_command)
+    #   GitDB.log("CMD COMMAND: #{data.inspect}")
+    #   io.write_command(data)
+    #   GitDB.log('weee')
+    #   if data[0] == 1
+    #     GitDB.log("ITS A PACK!")
+    #     pack = data[1..-1]
+    #     unpacker = GitDB::Git::Pack.new(StringIO.new(pack))
+    #     unpacker.read
+    #   end
+    # end
+    # io.write_eof
+
+    # while (data = cmd.read_command)
+    #   GitDB.log("CMD COMMAND: #{data}")
+    #   io.write_command(data)
+    # end
+    # io.write_eof
+  end
+
+  def execute_real
+    head_ref do |ref, sha|
+      write_ref(ref, sha)
+    end
+    each_git_ref do |ref, sha|
+      write_ref(ref, sha)
+      #write_ref(ref, sha.gsub('9', '1'))
+    end
+    io.write_eof
+
+    shas_to_read   = []
+    shas_to_ignore = []
+
+    while (data = io.read_command)
+      GitDB.log("GOT COMMAND: #{data.inspect}")
+      command, sha, options = data.split(' ', 3)
+      shas_to_read << sha
+    end
+
+    while (data = io.read_command)
+      data = data.strip
+      break if data == 'done'
+      command, sha = data.split(" ", 2)
+      case command
+        when 'have' then 
+          shas_to_ignore << sha
+        else
+          raise "Unknown SHA command: #{command}"
+      end
+    end
+
+    if shas_to_ignore.length.zero?
+      io.write_command("NAK\n")
+    else
+      io.write_command("ACK #{shas_to_ignore.last}\n")
+    end
+
+    shas_to_ignore, _ = load_entries(shas_to_ignore, false)
+    # GitDB.log("SHAS_TO_READ: #{shas_to_read.inspect}")
+    # GitDB.log("SHAS_READ: #{shas_read.inspect}")
+
+    shas, entries = load_entries(shas_to_read, true, shas_to_ignore)
+
+    GitDB.log(entries.map { |e| e.inspect })
+
+    io.write_pack(entries)
+  end
+
+private
+
+  def load_entries(shas_to_read, keep_entries, shas_to_ignore=[])
+    entries = []
+    shas    = []
+
+    while sha = shas_to_read.shift
+      next if shas_to_ignore.include?(sha)
+      shas_to_ignore << sha
+
+      shas << sha
+
+      raw_data = read_git_object(sha)
+      type = raw_data.split(" ").first
+      data = raw_data.split("\000", 2).last
+
+      #GitDB.log("SHADATA: #{data.inspect}")
+      case type
+        when 'commit' then
+          commit = GitDB::Git::Objects::Commit.new(data)
+          shas_to_read << commit.tree
+          shas_to_read += commit.parents if commit.parents
+          entries << commit if keep_entries
+        when 'tree' then
+          tree = GitDB::Git::Objects::Tree.new(data)
+          shas_to_read += tree.entries.map { |e| e.sha }
+          entries << tree if keep_entries
+        when 'blob' then
+          blob = GitDB::Git::Objects::Blob.new(data)
+          entries << blob if keep_entries
+        else
+          raise "UNKNOWN TYPE!! #{type}"
+      end
+    end
+
+    [shas, entries]
+  end
+
+  def capabilities
+    " shallow include-tag"
+  end
+
+  def io
+    @io ||= GitDB::Git::Protocol.new
+  end
+
+  def null_sha1
+    "0000000000000000000000000000000000000000"
+  end
+
+  def each_git_ref(&block)
+    Dir["/tmp/foo/.git/refs/*/*"].each do |ref|
+      sha = File.read(ref).strip
+      ref = ref.gsub('/tmp/foo/.git/', '')
+      yield ref, sha
+    end
+  end
+
+  def head_ref(&block)
+    sha = File.read("/tmp/foo/.git/HEAD").strip
+    if sha =~ /ref: (.+)/
+      sha = File.read("/tmp/foo/.git/#{$1}")
+    end
+    yield "HEAD", sha
+  end
+
+  def delete_git_file(filename)
+    filename = "/tmp/foo/.git/#{filename}"
+    GitDB.log("REMOVING: #{filename}")
+    FileUtils.rm_rf(filename)
+  end
+
+  def read_git_object(sha)
+    filename = "/tmp/foo/.git/objects/#{sha[0..1]}/#{sha[2..-1]}"
+    data = Zlib::Inflate.inflate(File.read(filename))
+  end
+
+  def write_git_file(filename, data)
+    filename = "/tmp/foo/.git/#{filename}"
+    FileUtils.mkdir_p(File.dirname(filename))
+    File.open(filename, 'w') do |file|
+      file.print(data)
+    end
+  end
+
+  def write_ref(ref, sha, needs_capabilities=true)
+    header = "%s %s\000%s\n" % [ sha, ref, capabilities ]
+    io.write_command(header)
+  end
+
+end
+
+GitDB::Git::Commands.register 'upload-pack', GitDB::Git::Commands::UploadPack

data/lib/git/commands.rb

@@ -0,0 +1,17 @@
+module GitDB::Git::Commands
+
+  def self.execute(command, args=[])
+    return unless @commands
+    raise ArgumentError, "Unknown command: #{command}" unless @commands[command]
+    @commands[command].execute(args)
+  end
+
+  def self.register(command, klass)
+    @commands ||= {}
+    @commands[command] = klass.new
+  end
+
+end
+
+require 'git/commands/receive-pack'
+require 'git/commands/upload-pack'

data/lib/git/objects/base.rb

@@ -0,0 +1,29 @@
+class GitDB::Git::Objects::Base
+
+  attr_reader :data
+
+  def initialize(data)
+    @data = data
+  end
+
+  def inspect
+    %{#<#{self.class} #{inspect_arguments_as_string}>}
+  end
+
+  def sha
+    Digest::SHA1.hexdigest(raw)
+  end
+
+private ######################################################################
+
+  def inspect_arguments
+    [:data]
+  end
+
+  def inspect_arguments_as_string
+    inspect_arguments.unshift(:sha).map do |argument|
+      "#{argument}=#{self.send(argument).inspect}"
+    end.join(' ')
+  end
+
+end

data/lib/git/objects/blob.rb

@@ -0,0 +1,11 @@
+class GitDB::Git::Objects::Blob < GitDB::Git::Objects::Base
+
+  def raw
+    "blob #{data.length}\000#{data}"
+  end
+
+  def type
+    Git::OBJ_BLOB
+  end
+
+end

data/lib/git/objects/commit.rb

@@ -0,0 +1,49 @@
+class GitDB::Git::Objects::Commit < GitDB::Git::Objects::Base
+  
+  def raw
+    "commit #{data.length}\000#{data}"
+  end
+
+  def type
+    Git::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
+
+private ######################################################################
+
+  def inspect_arguments
+    [:tree, :parents, :author, :committer, :message]
+  end
+
+  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/objects/entry.rb

@@ -0,0 +1,19 @@
+require 'stringio'
+
+class GitDB::Git::Objects::Entry < GitDB::Git::Objects::Base
+
+  attr_reader :sha, :permissions, :name
+
+  def initialize(sha, permissions, name)
+    @sha = sha
+    @permissions = permissions
+    @name = name
+  end
+
+private ######################################################################
+
+  def inspect_arguments
+    [:permissions, :name]
+  end
+
+end

data/lib/git/objects/tag.rb

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

data/lib/git/objects/tree.rb

@@ -0,0 +1,45 @@
+require 'stringio'
+
+class GitDB::Git::Objects::Tree < GitDB::Git::Objects::Base
+
+  def entries
+    @entries ||= begin
+      entries = []
+      stream = StringIO.new(data)
+      until stream.eof?
+        perms = read_until(stream, ' ').to_i
+        name  = read_until(stream, 0.chr)
+        sha   = Git.sha1_to_hex(stream.read(20))
+        entries << GitDB::Git::Objects::Entry.new(sha, perms, name)
+      end
+      entries
+    end
+  end
+
+  def raw
+    "tree #{data.length}\000#{data}"
+  end
+
+  def type
+    Git::OBJ_TREE
+  end
+
+private ######################################################################
+
+  def inspect_arguments
+    [:entries]
+  end
+
+  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/objects.rb

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

data/lib/git/pack.rb

@@ -0,0 +1,182 @@
+require 'digest/sha1'
+require 'stringio'
+require 'zlib'
+
+class GitDB::Git::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::Git::Objects::Commit.new(read_compressed(io))
+        when 2 then
+          GitDB::Git::Objects::Tree.new(read_compressed(io))
+        when 3 then
+          GitDB::Git::Objects::Blob.new(read_compressed(io))
+        when 4 then
+          GitDB::Git::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 = Git::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/protocol.rb

@@ -0,0 +1,73 @@
+class GitDB::Git::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::Git::Pack.new(reader).read
+  end
+
+  def write_pack(entries)
+    GitDB::Git::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.rb

@@ -0,0 +1,16 @@
+require 'logger'
+
+module GitDB;
+
+  def self.logger
+    @logger ||= File.open("/tmp/git-db.log", "w")
+    #@logger ||= STDERR
+  end
+
+  def self.log(message)
+    logger.puts message
+  end
+end
+
+require 'git'
+require 'utility'

data/lib/git.rb

@@ -0,0 +1,39 @@
+module GitDB::Git; 
+
+  # 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
+  
+  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
+
+end
+
+require 'git/commands'
+require 'git/objects'
+require 'git/pack'
+require 'git/protocol'

data/lib/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/utility.rb

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

data/spec/git-db_spec.rb

@@ -0,0 +1,7 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+describe "GitDb" do
+  it "fails" do
+    fail "hey buddy, you should probably rename this file and start specing for real"
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,9 @@
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+require 'git-db'
+require 'spec'
+require 'spec/autorun'
+
+Spec::Runner.configure do |config|
+  
+end

metadata

@@ -0,0 +1,113 @@
+--- !ruby/object:Gem::Specification 
+name: ddollar-git-db
+version: !ruby/object:Gem::Version 
+  version: 0.0.2
+platform: ruby
+authors: 
+- David Dollar
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-09-13 00:00:00 -07:00
+default_executable: git-db
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: rspec
+  type: :development
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: yard
+  type: :development
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: cucumber
+  type: :development
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+    version: 
+description: Database-based git server
+email: <ddollar@gmail.com>
+executables: 
+- git-db
+extensions: []
+
+extra_rdoc_files: 
+- LICENSE
+- README.rdoc
+files: 
+- .document
+- .gitignore
+- LICENSE
+- README.rdoc
+- Rakefile
+- VERSION
+- bin/git-db
+- features/git-db.feature
+- features/step_definitions/git-db_steps.rb
+- features/support/env.rb
+- git-db.gemspec
+- lib/git-db.rb
+- lib/git.rb
+- lib/git/commands.rb
+- lib/git/commands/receive-pack.rb
+- lib/git/commands/upload-pack.rb
+- lib/git/objects.rb
+- lib/git/objects/base.rb
+- lib/git/objects/blob.rb
+- lib/git/objects/commit.rb
+- lib/git/objects/entry.rb
+- lib/git/objects/tag.rb
+- lib/git/objects/tree.rb
+- lib/git/pack.rb
+- lib/git/protocol.rb
+- lib/utility.rb
+- lib/utility/counting_io.rb
+- spec/git-db_spec.rb
+- spec/spec_helper.rb
+has_rdoc: false
+homepage: http://github.com/ddollar/git-db
+licenses: 
+post_install_message: 
+rdoc_options: 
+- --charset=UTF-8
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.5
+signing_key: 
+specification_version: 3
+summary: Database-based git server
+test_files: 
+- spec/git-db_spec.rb
+- spec/spec_helper.rb