git-ds 0.9.2

data/lib/git-ds/shared.rb

@@ -0,0 +1,17 @@
+#!/usr/bin/env ruby
+# :title: Git-DS::Shared
+=begin rdoc
+
+Copyright 2010 Thoughtgang <http://www.thoughtgang.org>
+=end
+
+module GitDS
+
+# =============================================================================
+=begin rdoc
+Exception raised when a repo-backed object does not exist
+=end
+  class ObjectNotFound < NameError
+  end
+
+end

data/lib/git-ds/transaction.rb

@@ -0,0 +1,77 @@
+#!/usr/bin/env ruby
+# :title: Git-DS::Transaction
+=begin rdoc
+
+Copyright 2010 Thoughtgang <http://www.thoughtgang.org>
+=end
+
+require 'git-ds/shared'
+require 'git-ds/exec_cmd'
+
+module GitDS
+
+=begin rdoc
+Exception raised to rollback a transaction.
+=end
+  class TransactionRollback < RuntimeError
+  end
+
+=begin rdoc
+A Transaction takes a code block and guarantees that all of its commands, or
+none, are executed. Transactions can be nested.
+
+Usage:
+   db.transaction { |trans, idx| ... }
+=end
+  class Transaction < ExecCmd
+
+    attr_reader :propagate_exceptions
+
+=begin rdoc
+A transaction is considered successful if the transaction block executes with
+no exceptions. If a block must exit prematurely and abort the transaction,
+it should use the rollback method.
+
+Note that exceptions are propagated to the parent if transaction is nested;
+this permits an inner transaction to abort an outer transaction when
+rollback() is called.
+=end
+    def perform
+      @propagate_exceptions = false # propagation off by default
+      rv = true
+      begin
+        instance_eval(&self.block)
+      rescue Exception => e
+        raise e if self.nested
+        raise e if (not e.kind_of? TransactionRollback) && @propagate_exceptions
+              
+        rv = false
+      end
+
+      if rv
+        self.index.build  # required during nesting to support merge_and_branch
+        commit if not @nested
+      end
+
+      rv
+    end
+
+=begin rdoc
+Throw all non-rollback exceptions after aborting the transaction. This is
+useful for debugging transaction blocks.
+
+By default, all exceptions are caught and discarded.
+=end
+    def propagate
+      @propagate_exceptions = true
+    end
+
+=begin rdoc
+Abort the transaction.
+=end
+    def rollback
+      raise TransactionRollback.new
+    end
+
+  end
+end

data/tests/ut_database.rb

@@ -0,0 +1,304 @@
+#!/usr/bin/env ruby
+# Copyright 2010 Thoughtgang <http://www.thoughtgang.org>
+# Unit test for Git-DS Database class
+
+require 'test/unit'
+require 'fileutils'
+
+require 'git-ds/database'
+
+# StageIndex that tracks the number of writes made
+class TestStageIndex < GitDS::StageIndex
+  attr_reader :write_count
+
+  def commit(msg, author=nil)
+    @write_count ||= 0
+    @write_count += 1
+    super
+  end
+
+  def clear_write_count
+    @write_count = 0
+  end
+end
+
+class TC_GitDatabaseTest < Test::Unit::TestCase
+  TMP = File.dirname(__FILE__) + File::SEPARATOR + 'tmp'
+
+  attr_reader :db
+
+  def setup
+    FileUtils.remove_dir(TMP) if File.exist?(TMP)
+    Dir.mkdir(TMP)
+
+    path = TMP + File::SEPARATOR + 'db_test'
+    @db = GitDS::Database.new(path)
+  end
+
+  def teardown
+    FileUtils.remove_dir(TMP) if File.exist?(TMP)
+  end
+
+  def test_connect
+    path = TMP + File::SEPARATOR + 'test-db-conn'
+
+    # no-create should refuse to create the database
+    GitDS::Database.connect(path, false)
+    assert( (not File.exist?(path + File::SEPARATOR + '.git')), 
+            "Repo #{path} incorrectly created by connect" ) 
+
+    # ...otherwise connect should create the db
+    db = GitDS::Database.connect(path)
+    assert( File.exist?(path + File::SEPARATOR + '.git'), 
+            "Repo #{path} not created by connect" ) 
+
+    # verify that closing the DB works.
+    db.close
+
+    # verify that a closed database cannot be acted on
+    # NOTE: this should verify every method 
+    assert_raise( GitDS::InvalidDbError ) { db.exec }
+    assert_raise( GitDS::InvalidDbError ) { db.head }
+    assert_raise( GitDS::InvalidDbError ) { db.tree }
+    assert_raise( GitDS::InvalidDbError ) { db.index }
+    assert_raise( GitDS::InvalidDbError ) { db.transaction }
+    assert_raise( GitDS::InvalidDbError ) { db.purge }
+    assert_raise( GitDS::InvalidDbError ) { db.close }
+  end
+
+  def test_create_delete
+    path = TMP + File::SEPARATOR + 'test-db'
+
+    # test that ctor creates a database by default
+    GitDS::Database.new(path)
+    assert( File.exist?(path + File::SEPARATOR + '.git'), 
+            "Repo #{path} not created via new" )
+
+    # test that connecting to an existing database works
+    db = GitDS::Database.connect(path, false)
+    assert_not_nil( db, 'Connect to existing DB failed' )
+
+    # test that deleting a database works
+    db.purge
+    assert( (not File.exist?(path + File::SEPARATOR + '.git')),
+            "Repo #{path} did not get deleted" )
+  end
+
+  def test_config
+    cfg = GitDS::RepoConfig.new(@db)
+    assert_equal('misc.stuff', cfg.path('stuff'), 'Default path is wrong')
+
+    cfg = GitDS::RepoConfig.new(@db, 'a_b c?d')
+    assert_equal('a-b-c-d.stuff', cfg.path('stuff'), 'Cleaned path is wrong')
+
+    cfg = GitDS::RepoConfig.new(@db, 'test')
+    cfg['stuff'] = '123456'
+    assert_equal('123456', cfg['stuff'], 'Could not write to section')
+
+    assert_equal('', @db.config['a test entry'], 'Test cfg entry not empty')
+    assert_equal('git-ds.a-test-entry', @db.config.path('a test entry'), 
+                 'Config object generated wrong path')
+    @db.config['a test entry'] = 'abcdef'
+    assert_equal('abcdef', @db.config['a test entry'], 'Cfg string incorrect')
+  end
+
+  def test_staging
+    assert((not @db.staging?), 'db.staging not nil by default')
+
+    index = GitDS::StageIndex.new(@db)
+    @db.staging = index
+    assert_equal(index, @db.staging, 'db.staging= method failed')
+
+    @db.staging = nil
+    assert((not @db.staging?), 'db.staging=nil method failed')
+  end
+
+  def test_exec
+    assert((not @db.staging?), 'db.staging not nil by default')
+
+    # test with no index
+    fname, data = 'a_test_file', '123456'
+    @db.exec { index.add(fname, data)  }
+    assert( (not @db.staging?), 'exec created current index!')
+
+    # verify that exceptions do not break anything
+    assert_raises(RuntimeError, 'ExecCmd did not propagate error') {
+      @db.exec {
+        raise RuntimeError
+      }
+    }
+
+    # Verify that the exec worked
+    index = TestStageIndex.new(@db)
+    blob = index.current_tree./(fname)
+    assert_not_nil(blob, "db.exec did not create '#{fname}' in staging")
+    assert_equal(data, blob.data, "BLOB data for '#{fname}' does not match")
+
+    # test exec with staging set
+    @db.staging = index
+    @db.exec { index.delete(fname) }
+    index.build
+    blob = index.current_tree./(fname)
+    assert_equal(index, @db.staging, 'db.exec clobbered staging')
+    assert_nil(blob, "db.exec did not delete '#{fname}' in staging")
+
+    # test nested exec
+    name1, data1 = 'test1', '!!##$$@@^^**&&%%'
+    name2, data2 = 'test2', '_-_-_-'
+    @db.staging.clear_write_count
+    @db.exec {
+      index.add(name1, data1)
+      database.exec { index.add(name2, data2) }
+    }
+    @db.staging.commit('etc')
+    assert_equal(index, @db.staging, 
+                 'nested db.exec clobbered staging')
+    assert_equal(1, @db.staging.write_count, 
+                 'Nested exec caused > 1 write!')
+
+    # verify that both files in nested exec were created
+    blob = index.current_tree./(name1)
+    assert_not_nil(blob, "nested db.exec did not create '#{name1}' in staging")
+    assert_equal(data1, blob.data, "BLOB data for '#{name1}' does not match")
+
+    blob = index.current_tree./(name2)
+    assert_not_nil(blob, "nested db.exec did not create '#{name2}' in staging")
+    assert_equal(data2, blob.data, "BLOB data for '#{name2}' does not match")
+
+    # cleanup
+    index.delete(name1)
+    index.delete(name2)
+    @db.staging = nil
+
+    # test commits
+    num_commits = @db.commits.count
+    @db.exec { 
+      index.add('exec-nested-commit-file-1', 'zaazza') 
+      database.exec {
+        index.add('exec-nested-commit-file-2', 'plplpl')
+        commit
+      }
+    }
+    assert_equal(num_commits + 2, @db.commits.count, 'Nested commits failed')
+  end
+
+  def test_transaction
+    assert((not @db.staging?), 'db.staging not nil by default')
+
+    # test with no index
+    fname, data = 'test_file_1', 'abcdef'
+    @db.transaction { index.add(fname, data)  }
+    assert( (not @db.staging?), 'transaction created current index!')
+
+    # Verify that the transaction worked
+    index = TestStageIndex.new(@db)
+    blob = index.current_tree./(fname)
+    assert_not_nil(blob, "db.exec did not create '#{fname}' in staging")
+    assert_equal(data, blob.data, "BLOB data for '#{fname}' does not match")
+    
+    # test rollback method
+    name1, data1 = 'test_file_2', '54321'
+    @db.transaction {
+      index.add(name1, data1)
+      rollback
+    }
+    blob = index.current_tree./(name1)
+    assert_nil(blob, "rollback still created '#{name1}' in staging")
+
+    # test nested rollback
+    @db.transaction {
+      index.add(name1, data1)
+      database.transaction { rollback }
+    }
+    blob = index.current_tree./(name1)
+    assert_nil(blob, "rollback still created '#{name1}' in staging")
+    
+    # test rollback on raise
+    @db.transaction {
+      index.add(name1, data1)
+      raise "ROLLBACK!"
+    }
+    blob = index.current_tree./(name1)
+    assert_nil(blob, "transaction raise still created '#{name1}' in staging")
+
+    assert_raises(RuntimeError, 'Transaction did not propagate error') {
+      @db.transaction {
+        propagate
+        raise RuntimeError
+      }
+    }
+
+    # test commit
+    msg = 'SUCCESS'
+    name, email = 'me', 'myself@i.com'
+    @db.transaction { 
+      author name, email
+      message(msg)
+      index.add('test-commit-file', 'zyxwvu')
+    }
+    cmt = @db.commits.last
+    assert_not_nil(cmt, "transaction did not create commit")
+    assert_equal(msg, cmt.message, "transaction commit has wrong message")
+    assert_equal(name, cmt.author.name, "transaction commit has wrong author")
+    assert_equal(email, cmt.author.email, "transaction commit has wrong email")
+
+    # test commits in nested transaction
+    num_commits = @db.commits.count
+    @db.transaction { 
+      index.add('trans-nested-commit-file-1', '223344')
+      database.transaction {
+        index.add('trans-nested-commit-file-2', 'ccddff')
+        commit
+      }
+    }
+    assert_equal(num_commits + 2, @db.commits.count, 'Nested commits failed')
+
+    # test transaction with staging set
+    @db.staging = index
+    @db.transaction { index.delete(fname) }
+    blob = index.current_tree./(fname)
+    assert_equal(index, @db.staging, 'db.exec clobbered staging')
+
+    # test nested transactions
+    name2, data2 = 'xtest2', '~~~~~~~'
+    @db.staging.clear_write_count
+    @db.transaction {
+      index.add(name1, data1)
+      database.transaction { index.add(name2, data2) }
+    }
+    index.commit('etc') # existing index means both transactions are nested
+    assert_equal(index, @db.staging, 'nested transaction clobbered staging')
+    assert_equal(1, @db.staging.write_count, 
+                 'Nested transaction caused > 1 write!')
+
+    # verify that both files in nested exec were created
+    blob = index.current_tree./(name1)
+    assert_not_nil(blob, "nested db.exec did not create '#{name1}' in staging")
+    assert_equal(data1, blob.data, "BLOB data for '#{name1}' does not match")
+
+    blob = index.current_tree./(name2)
+    assert_not_nil(blob, "nested db.exec did not create '#{name2}' in staging")
+    assert_equal(data2, blob.data, "BLOB data for '#{name2}' does not match")
+  end
+
+  def test_branch
+
+    num = @db.heads.count
+    @db.branch_and_merge {
+      index.add('tmp/1', '1')
+    }
+    assert_equal(num+1, @db.heads.count, 'Anon Branch&Merge failed!')
+
+    name = 'named branch'
+    num = @db.heads.count
+    @db.branch_and_merge(name) {
+      database.index.add('tmp/2', '2')
+    }
+    assert_equal(num+1, @db.heads.count, 'Named Branch&Merge failed!')
+    assert_equal(1, @db.heads.select{ |h| h.name == @db.clean_tag(name)}.count,
+                 'Named Branch not present!')
+
+  end
+
+end
+

data/tests/ut_git_grit_equiv.rb

@@ -0,0 +1,195 @@
+#!/usr/bin/env ruby
+# Copyright 2011 Thoughtgang <http://www.thoughtgang.org>
+# Unit tests to ensure that assumptions about Grit behaving like Git still hold.
+# Note: This is used to verify that Grit can be made to act like the Git
+#       command line, and to determine what Grit methods correspond to 
+#       Git commands.
+
+require 'test/unit'
+require 'fileutils'
+
+require 'rubygems'
+require 'grit'
+require 'grit/git-ruby'
+
+# NOTES:
+#   `git read-tree --prefix=path #{sha}` will read SHA object into git at the
+#   specified path. git-write-tree can then be used to create the tree object
+#   for the entire index. NOTE: `export GIT_INDEX_FILE=/tmp/index` can be used
+#   to specify an index that is NOT the staging index. IMPORTANT!
+# git-update-index --force-remove 
+# git-update-index --add --cacheinfo 100644 `echo '#{data}' | git-hash-object --stdin` #{path}
+# echo '#{msg}' | git commit-tree #{sha}
+# git-ls-files --stage #{path}
+# git rev-parse --show-toplevel
+# git rev-parse --show-prefix : path of curr dir from top_level. cdup = inverse.
+
+# Grit:Git methods:
+# object_exists? sha
+# git_dir, work_tree
+# fs_exist? path [on fs, in git dir]. fs_read|write|delete|move|mkdir|chmod
+# commit_from_sha sha
+# raw_git(command, index_filename) : note this is exec_in_git!
+# get_object_by_sha1 sha
+# object_exists? sha
+# cat_file_type sha
+# cat_file_size sha
+# cat_file sha
+# list_tree sha => ['blob'|'tree']['NAME'] = { :mode, :sha }
+# ls_tree sha, paths, recursive = false -> cat-file output
+# ls_tree_path(sha, path, append=nil) -> array of tree entries
+# get_subtree(commit_sha, path) -> tree sha (or parent of, or /)
+ 
+class TC_GitGritEquivalenceTest < Test::Unit::TestCase
+  TMP = File.dirname(__FILE__) + File::SEPARATOR + 'tmp'
+  GIT_REPO = 'git_repo'
+  GRIT_REPO = 'grit_repo'
+
+  attr_reader :repo # grit repo object
+
+  def exec_in_dir(dir, &block)
+    curr = Dir.getwd
+    Dir.chdir dir 
+    result = yield
+    Dir.chdir curr
+    result
+  end
+
+  def git_exec(&block)
+    exec_in_dir(TMP + File::SEPARATOR + GIT_REPO, &block)
+  end
+
+  # this allows mimics Grit's use of anonymous (non-stage) indexes
+  def git_index_exec(filename, &block)
+    old_index = ENV[GIT_INDEX_FILE]
+    ENV[GIT_INDEX_FILE] = TMP + File::SEPARATOR + filename
+    rv = git_exec(&block)
+    ENV[GIT_INDEX_FILE] = old_index
+    rv
+  end
+
+  # Create a Git repo and a Grit repo in a temporary directory
+  def setup
+    FileUtils.remove_dir(TMP) if File.exist?(TMP)
+    Dir.mkdir(TMP)
+
+    # init git repo
+    exec_in_dir(TMP) { `git init #{GIT_REPO}` }
+    @git_path = TMP + File::SEPARATOR + GIT_REPO
+
+    # init grit repo
+    @grit_path = TMP + File::SEPARATOR + GRIT_REPO
+    @repo = Grit::Repo.init(@grit_path)
+  end
+
+  # Delete all repos
+  def teardown
+    FileUtils.remove_dir(TMP) if File.exist?(TMP)
+  end
+
+  # Test that initializing a repository produces the same results
+  def test_init
+    sep = File::SEPARATOR
+    assert( File.exist?(TMP + sep + GIT_REPO + sep + '.git'),
+            'git repo was not created!')
+    assert( File.exist?(TMP + sep + GRIT_REPO + sep + '.git'),
+            'Grit repo was not created!')
+  end
+
+  # Test that generating an object SHA produces the same results
+  def test_object_sha
+    data = '01020304050607080900!@#$%^&*()_+='
+    git_sha = git_exec { `echo -n '#{data}' | git hash-object --stdin` }.chomp
+    grit_sha = Grit::GitRuby::Internal::LooseStorage.calculate_sha(data, 'blob')
+    assert_equal( git_sha, grit_sha, 'Git and Grit SHA differ')
+  end
+
+  # Test that adding a Blob object produces the same results
+  def test_add_blob_to_object_database
+    data = '7654321098!@$#%^&*()_-=+'
+    git_sha = git_exec {`echo -n '#{data}' | git hash-object -w --stdin`}.chomp
+    blob_data = git_exec { `git cat-file -p #{git_sha}` }
+    assert_equal(data, blob_data, 'Git cat-file does not match input')
+
+
+    grit_sha = @repo.git.put_raw_object(data, 'blob')
+    assert(@repo.git.object_exists?(grit_sha), 'Grit fails object_exists? call')
+    assert_equal(data, @repo.git.ruby_git.cat_file(grit_sha),
+                 'Grit cat_file does not match input')
+
+    assert_equal( git_sha, grit_sha, 'Git and Grit SHA differ')
+
+    sep = File::SEPARATOR
+    path = sep + '.git' + sep + 'objects' + sep + git_sha[0,2] + sep + 
+           git_sha[2..-1]
+    assert(File.exist?(@git_path + path), 'Git did not add blob to object DB')
+    assert(File.exist?(@grit_path + path), 'Grit did not add blob to object DB')
+  end
+
+  # Test that adding a Tree object produces the same results
+  def test_add_path_to_object_database
+    bdata = "123454321"
+    bsha = git_exec {`echo -n '#{bdata}' | git hash-object -w --stdin`}.chomp
+    grit_bsha = @repo.git.put_raw_object(bdata, 'blob')
+
+    tdata1 = "100644 blob #{bsha}\ttest_blob"
+    git_sha = git_exec {`echo -n '#{tdata1}' | git mktree`}.chomp
+
+    # Note the different format needed for Grit!
+    tdata1 = "100644 test_blob\0#{[bsha].pack('H*')}"
+    grit_sha = @repo.git.put_raw_object(tdata1, 'tree')
+    assert(@repo.git.object_exists?(grit_sha), 'Grit fails object_exists? call')
+    assert_not_nil( @repo.tree(grit_sha), 'Grit did not create valid tree')
+
+    assert_equal( git_sha, grit_sha, 'Git and Grit SHA differ')
+  end
+
+  # Test that adding a Blob to the (staging) index produces the same results
+  def test_add_blob_to_index
+    data = '....****....'
+    fname = 'test_add_blob'
+
+    # Add BLOB to Git object database
+    git_sha = git_exec {`echo -n '#{data}' | git hash-object -w --stdin`}.chomp
+    # Add BLOB to Git index
+    git_exec {`git update-index --add --cacheinfo 100644 #{git_sha} #{fname}`}
+    # Get SHA for filename in index
+    mode, sha, junk = git_exec { `git ls-files -s #{fname}` }.split(/\s/)
+    assert_equal(git_sha, sha, 'SHA in staging does not match input SHA')
+
+    idx = @repo.index
+    # Add BLOB to Grit index
+    idx.add( fname, data)
+    # Add BLOB to Grit object database and re-read
+    idx.read_tree(idx.write_tree(idx.tree))
+    # Get SHA for filename in index
+    blob = idx.current_tree/fname
+    assert_equal(data, blob.data, 'Grit index data does not match input data')
+
+    assert_equal( git_sha, blob.id, 'Git and Grit SHA differ')
+  end
+
+  def test_add_path_to_index
+  end
+
+  def test_remove_file_from_object_database
+  end
+
+  def test_remove_path_from_object_database
+  end
+
+  def test_remove_file_from_index
+  end
+
+  def test_remove_path_from_index
+  end
+
+  def test_list_tree_in_object_database
+  end
+
+  def test_list_tree_in_index
+  end
+
+  # TODO: branch, commit, ref.
+end
+