rugged 0.1.2 → 0.16.0b1

data/test/fixtures/testrepo.git/refs/heads/new_name

@@ -0,0 +1 @@
+36060c58702ed4c2a40832c51758d5344201d89a

data/test/index_test.rb

@@ -5,60 +5,72 @@ require 'fileutils'
 
 def new_index_entry
     now = Time.now
-    e = Rugged::IndexEntry.new
-    e.path = "new_path"
-    e.sha = "d385f264afb75a56a5bec74243be9b367ba4ca08"
-    e.mtime = now
-    e.ctime = now
-    e.file_size = 1000
-    e.dev = 234881027
-    e.ino = 88888
-    e.mode = 33199
-    e.uid = 502
-    e.gid = 502
-    e.flags = 5
-    e.flags_extended = 5
-    e
+    {
+      :path => "new_path",
+      :oid => "d385f264afb75a56a5bec74243be9b367ba4ca08",
+      :mtime => now,
+      :ctime => now,
+      :file_size => 1000,
+      :dev => 234881027,
+      :ino => 88888,
+      :mode => 33199,
+      :uid => 502,
+      :gid => 502,
+      :stage => 3,
+    }
 end
 
 context "Rugged::Index reading stuff" do
   setup do
     path = File.dirname(__FILE__) + '/fixtures/testrepo.git/index'
     @index = Rugged::Index.new(path)
-    @index.refresh
+  end
+
+  test "can iterate through the index" do
+    enum = @index.each
+    assert enum.kind_of? Enumerable
+
+    i = 0
+    @index.each { |e| i += 1 }
+    assert_equal @index.count, i
   end
 
   test "can count index entries" do
-    assert_equal 2, @index.entry_count
+    assert_equal 2, @index.count
   end
 
   test "can clear the in-memory index" do
     @index.clear
-    assert_equal 0, @index.entry_count
+    assert_equal 0, @index.count
+  end
+
+  test "can remove entries from the index" do
+    @index.remove 0
+    assert_equal 1, @index.count
   end
 
   test "can get all data from an entry" do
     e = @index.get_entry(0)
-    assert_equal 'README', e.path
-    assert_equal '1385f264afb75a56a5bec74243be9b367ba4ca08', e.sha
-    assert_equal 1273360380, e.mtime.to_i
-    assert_equal 1273360380, e.ctime.to_i
-    assert_equal 4, e.file_size
-    assert_equal 234881026, e.dev 
-    assert_equal 6674088, e.ino 
-    assert_equal 33188, e.mode
-    assert_equal 501, e.uid
-    assert_equal 0, e.gid
-    assert_equal 6, e.flags
-    assert_equal 0, e.flags_extended
+    assert_equal 'README', e[:path]
+    assert_equal '1385f264afb75a56a5bec74243be9b367ba4ca08', e[:oid]
+    assert_equal 1273360380, e[:mtime].to_i
+    assert_equal 1273360380, e[:ctime].to_i
+    assert_equal 4, e[:file_size]
+    assert_equal 234881026, e[:dev]
+    assert_equal 6674088, e[:ino]
+    assert_equal 33188, e[:mode]
+    assert_equal 501, e[:uid]
+    assert_equal 0, e[:gid]
+    assert_equal false, e[:valid]
+    assert_equal 0, e[:stage]
 
     e = @index.get_entry(1)
-    assert_equal 'new.txt', e.path
-    assert_equal 'fa49b077972391ad58037050f2a75f74e3671e92', e.sha
+    assert_equal 'new.txt', e[:path]
+    assert_equal 'fa49b077972391ad58037050f2a75f74e3671e92', e[:oid]
   end
 
   test "can iterate over the entries" do
-    itr_test = @index.sort { |a, b| a.sha <=> b.sha }.map { |e| e.path }.join(':')
+    itr_test = @index.sort { |a, b| a[:oid] <=> b[:oid] }.map { |e| e[:path] }.join(':')
     assert_equal "README:new.txt", itr_test
   end
 
@@ -66,42 +78,30 @@ context "Rugged::Index reading stuff" do
     now = Time.now
     e = @index.get_entry(0)
 
-    e.path = "new_path"
-    e.sha = "12ea3153a78002a988bb92f4123e7e831fd1138a"
-    e.mtime = now
-    e.ctime = now
-    e.file_size = 1000
-    e.dev = 234881027
-    e.ino = 88888
-    e.mode = 33199
-    e.uid = 502
-    e.gid = 502
-    e.flags = 5
-    e.flags_extended = 5
-
-    assert_equal 'new_path', e.path
-    assert_equal '12ea3153a78002a988bb92f4123e7e831fd1138a', e.sha
-    assert_equal now.to_i, e.mtime.to_i
-    assert_equal now.to_i, e.ctime.to_i
-    assert_equal 1000, e.file_size
-    assert_equal 234881027, e.dev 
-    assert_equal 88888, e.ino 
-    assert_equal 33199, e.mode
-    assert_equal 502, e.uid
-    assert_equal 502, e.gid
-    assert_equal 5, e.flags
-    assert_equal 5, e.flags_extended
+    e[:oid] = "12ea3153a78002a988bb92f4123e7e831fd1138a"
+    e[:mtime] = now
+    e[:ctime] = now
+    e[:file_size] = 1000
+    e[:dev] = 234881027
+    e[:ino] = 88888
+    e[:mode] = 33199
+    e[:uid] = 502
+    e[:gid] = 502
+    e[:stage] = 3
+
+    @index.add(e)
+    new_e = @index[e[:path]]
+
+    assert_equal e, new_e
   end
 
   test "can add new entries" do
     e = new_index_entry
-    @index.add(e)
-    assert_equal 3, @index.entry_count
-    itr_test = @index.sort { |a, b| a.sha <=> b.sha }.map { |e| e.path }.join(':')
+    @index << e
+    assert_equal 3, @index.count
+    itr_test = @index.sort { |a, b| a[:oid] <=> b[:oid] }.map { |e| e[:path] }.join(':')
     assert_equal "README:new_path:new.txt", itr_test
   end
-
-
 end
 
 context "Rugged::Index writing stuff" do
@@ -110,7 +110,6 @@ context "Rugged::Index writing stuff" do
     @tmppath = Tempfile.new('index').path
     FileUtils.copy(path, @tmppath)
     @index = Rugged::Index.new(@tmppath)
-    @index.refresh
   end
 
   test "add raises if it gets something weird" do
@@ -121,41 +120,65 @@ context "Rugged::Index writing stuff" do
 
   test "can write a new index" do
     e = new_index_entry
-    @index.add(e)
-    e.path = "else.txt"
-    @index.add(e)
+    @index << e
+
+    e[:path] = "else.txt"
+    @index << e
+
     @index.write
 
     index2 = Rugged::Index.new(@tmppath)
-    index2.refresh
 
-    itr_test = index2.sort { |a, b| a.sha <=> b.sha }.map { |e| e.path }.join(':')
+    itr_test = index2.sort { |a, b| a[:oid] <=> b[:oid] }.map { |e| e[:path] }.join(':')
     assert_equal "README:else.txt:new_path:new.txt", itr_test
-    assert_equal 4, index2.entry_count
+    assert_equal 4, index2.count
   end
 end
 
 context "Rugged::Index with working directory" do
   setup do
-    @tmppath = Tempfile.new('index').path + '_dir'
-    FileUtils.mkdir(@tmppath)
-    Dir.chdir(@tmppath) do
-      `git init`
-    end
-    @repo = Rugged::Repository.new(@tmppath + '/.git')
+    @tmppath = Dir.mktmpdir
+    @repo = Rugged::Repository.init_at(@tmppath, false)
     @index = @repo.index
   end
 
+  teardown do
+    FileUtils.remove_entry_secure(@tmppath)
+  end
+
   test "can add from a path" do
     File.open(File.join(@tmppath, 'test.txt'), 'w') do |f|
       f.puts "test content"
     end
     @index.add('test.txt')
-	@index.write
+    @index.write
 
     index2 = Rugged::Index.new(@tmppath + '/.git/index')
-    index2.refresh
+    assert_equal index2.get_entry(0)[:path], 'test.txt'
+  end
+
+  test "can reload the index" do
+    File.open(File.join(@tmppath, 'test.txt'), 'w') do |f|
+      f.puts "test content"
+    end
+    @index.add('test.txt', 2)
+    @index.write
+
+    sleep(1) # we need this sleep to sync at the FS level
+    # most FSs have 1s granularity on mtimes
+
+    rindex = Rugged::Index.new(File.join(@tmppath, '/.git/index'))
+    e = rindex['test.txt']
+    assert_equal 2, e[:stage]
+
+    rindex << new_index_entry
+    rindex.write
+
+    assert_equal 1, @index.count
+    @index.reload
+    assert_equal 2, @index.count
 
-	assert_equal index2.get_entry(0).path, 'test.txt'
+    e = @index['new_path']
+    assert_equal e[:mode], 33199
   end
 end

data/test/lib_test.rb

@@ -5,26 +5,26 @@ context "Rugged::Lib stuff" do
   setup do
   end
 
-  test "can convert hex into raw sha" do
+  test "can convert hex into raw oid" do
     raw = Rugged::hex_to_raw("ce08fe4884650f067bd5703b6a59a8b3b3c99a09")
     b64raw = Base64.encode64(raw).strip
     assert_equal "zgj+SIRlDwZ71XA7almos7PJmgk=", b64raw
   end
 
-  test "converts hex into raw sha correctly" do
+  test "converts hex into raw oid correctly" do
     hex = "ce08fe4884650f067bd5703b6a59a8b3b3c99a09"
     raw1 = Rugged::hex_to_raw(hex)
     raw2 = [hex].pack("H*")
     assert_equal raw1, raw2
   end
 
-  test "can convert raw sha into hex" do
+  test "can convert raw oid into hex" do
     raw = Base64.decode64("FqASNFZ4mrze9Ld1ITwjqL109eA=")
     hex = Rugged::raw_to_hex(raw)
     assert_equal "16a0123456789abcdef4b775213c23a8bd74f5e0", hex
   end
 
-  test "converts raw into hex sha correctly" do
+  test "converts raw into hex oid correctly" do
     raw = Rugged::hex_to_raw("ce08fe4884650f067bd5703b6a59a8b3b3c99a09")
     hex1 = Rugged::raw_to_hex(raw)
     hex2 = raw.unpack("H*")[0]

data/test/object_test.rb

@@ -9,14 +9,14 @@ context "Rugged::Object stuff" do
 
   test "cannot lookup a non-existant object" do
     assert_raise RuntimeError do 
-		obj = @repo.lookup("a496071c1b46c854b31185ea97743be6a8774479")
-	end
+      obj = @repo.lookup("a496071c1b46c854b31185ea97743be6a8774479")
+    end
   end
 
   test "can lookup an object" do
     obj = @repo.lookup("8496071c1b46c854b31185ea97743be6a8774479")
     assert_equal 'commit', obj.type
-    assert_equal '8496071c1b46c854b31185ea97743be6a8774479', obj.sha
+    assert_equal '8496071c1b46c854b31185ea97743be6a8774479', obj.oid
   end
 
   test "same looked up objects are the same" do

data/test/reference_test.rb

@@ -0,0 +1,75 @@
+require File.expand_path "../test_helper", __FILE__
+
+context "Rugged::Reference stuff" do
+  setup do
+    @path = File.dirname(__FILE__) + '/fixtures/testrepo.git'
+    @repo = Rugged::Repository.new(@path)
+  end
+
+  teardown do
+    FileUtils.remove_entry_secure(@path + '/refs/heads/unit_test', true)
+  end
+
+  test "can open reference" do
+    ref = Rugged::Reference.lookup(@repo, "refs/heads/master")
+    assert_equal "36060c58702ed4c2a40832c51758d5344201d89a", ref.target
+    assert_equal "commit", ref.type
+    assert_equal "refs/heads/master", ref.name
+  end
+
+  test "can open packed reference" do
+    ref = Rugged::Reference.lookup(@repo, "refs/heads/packed")
+    assert_equal "41bc8c69075bbdb46c5c6f0566cc8cc5b46e8bd9", ref.target
+    assert_equal "commit", ref.type
+    assert_equal "refs/heads/packed", ref.name
+  end
+
+  test "can create reference from symbolic reference" do
+    ref = Rugged::Reference.create(@repo, "refs/heads/unit_test", "refs/heads/master")
+    assert_equal "refs/heads/master", ref.target
+    assert_equal "tree", ref.type
+    assert_equal "refs/heads/unit_test", ref.name
+    ref.delete!
+  end
+
+  test "can create reference from oid" do
+    ref = Rugged::Reference.create(@repo, "refs/heads/unit_test", "36060c58702ed4c2a40832c51758d5344201d89a")
+    assert_equal "36060c58702ed4c2a40832c51758d5344201d89a", ref.target
+    assert_equal "commit", ref.type
+    assert_equal "refs/heads/unit_test", ref.name
+    ref.delete!
+  end
+
+  test "can rename ref" do
+    ref = Rugged::Reference.create(@repo, "refs/heads/unit_test", "36060c58702ed4c2a40832c51758d5344201d89a")
+    assert_equal "36060c58702ed4c2a40832c51758d5344201d89a", ref.target
+    assert_equal "commit", ref.type
+    assert_equal "refs/heads/unit_test", ref.name
+
+    ref.rename "refs/heads/rug_new_name"
+    assert_equal "refs/heads/rug_new_name", ref.name
+    ref.delete!
+  end
+
+  test "can set target on reference" do
+    ref = Rugged::Reference.create(@repo, "refs/heads/unit_test", "36060c58702ed4c2a40832c51758d5344201d89a")
+    assert_equal "36060c58702ed4c2a40832c51758d5344201d89a", ref.target
+    assert_equal "commit", ref.type
+    assert_equal "refs/heads/unit_test", ref.name
+
+    ref.target = "5b5b025afb0b4c913b4c338a42934a3863bf3644"
+    assert_equal "5b5b025afb0b4c913b4c338a42934a3863bf3644", ref.target
+    ref.delete!
+  end
+
+  test "can resolve head" do
+    ref = Rugged::Reference.lookup(@repo, "HEAD")
+    assert_equal "refs/heads/master", ref.target
+    assert_equal "tree", ref.type
+
+    head = ref.resolve
+    assert_equal "36060c58702ed4c2a40832c51758d5344201d89a", head.target
+    assert_equal "commit", head.type
+  end
+
+end

data/test/remote_test.rb

@@ -0,0 +1,19 @@
+require File.expand_path "../test_helper", __FILE__
+
+context "Rugged::Tag tests" do
+  setup do
+    @path = File.dirname(__FILE__) + '/fixtures/testrepo.git/'
+    @repo = Rugged::Repository.new(@path)
+  end
+
+  test "test remote connection" do
+    remote = Rugged::Remote.new(@repo, "git://github.com/libgit2/libgit2.git")
+
+    remote.connect(:fetch) do |r|
+      assert r.connected?
+    end
+
+    assert (not remote.connected?)
+  end
+
+end

data/test/repo_pack_test.rb

@@ -13,10 +13,10 @@ context "Rugged::Repository packed stuff" do
   end
 
   test "can read a packed object from the db" do
-    data, len, type = @repo.read("41bc8c69075bbdb46c5c6f0566cc8cc5b46e8bd9")
-    assert_match 'tree f82a8eb4cb20e88d1030fd10d89286215a715396', data
-    assert_equal 230, len
-    assert_equal "commit", type
+    rawobj = @repo.read("41bc8c69075bbdb46c5c6f0566cc8cc5b46e8bd9")
+    assert_match 'tree f82a8eb4cb20e88d1030fd10d89286215a715396', rawobj.data
+    assert_equal 230, rawobj.len
+    assert_equal Rugged::OBJ_COMMIT, rawobj.type
   end
 
 end

data/test/repo_test.rb

@@ -5,6 +5,19 @@ context "Rugged::Repository stuff" do
   setup do
     @path = File.dirname(__FILE__) + '/fixtures/testrepo.git/'
     @repo = Rugged::Repository.new(@path)
+
+    @test_content = "my test data\n"
+    @test_content_type = 'blob'
+  end
+
+  test "fails to open unexisting repositories" do
+    assert_raise RuntimeError do
+      repo = Rugged::Repository.new("fakepath/123/")
+    end
+
+    assert_raise RuntimeError do
+      repo = Rugged::Repository.new("/home/")
+    end
   end
 
   test "can tell if an object exists or not" do
@@ -15,31 +28,47 @@ context "Rugged::Repository stuff" do
   end
 
   test "can read an object from the db" do
-    data, len, type = @repo.read("8496071c1b46c854b31185ea97743be6a8774479")
-    assert_match 'tree 181037049a54a1eb5fab404658a3a250b44335d7', data
-    assert_equal 172, len
-    assert_equal "commit", type
+    rawobj = @repo.read("8496071c1b46c854b31185ea97743be6a8774479")
+    assert_match 'tree 181037049a54a1eb5fab404658a3a250b44335d7', rawobj.data
+    assert_equal 172, rawobj.len
+    assert_equal Rugged::OBJ_COMMIT, rawobj.type
   end
 
-  test "checks that reading fails on unexistang objects" do
+  test "checks that reading fails on unexisting objects" do
     assert_raise RuntimeError do 
-		@repo.read("a496071c1b46c854b31185ea97743be6a8774471")
-	end
+      @repo.read("a496071c1b46c854b31185ea97743be6a8774471")
+    end
   end
 
   test "can hash data" do
-    content = "my test data\n"
-    sha = @repo.hash(content, "blob")
-    assert_equal "76b1b55ab653581d6f2c7230d34098e837197674", sha
-    assert !@repo.exists("76b1b55ab653581d6f2c7230d34098e837197674")
+    oid = Rugged::Repository::hash(@test_content, @test_content_type)
+    assert_equal "76b1b55ab653581d6f2c7230d34098e837197674", oid
   end
 
   test "can write to the db" do
-    content = "my test data\n"
-    sha = @repo.write(content, "blob")
-    assert_equal "76b1b55ab653581d6f2c7230d34098e837197674", sha
+    oid = @repo.write(@test_content, @test_content_type)
+    assert_equal "76b1b55ab653581d6f2c7230d34098e837197674", oid
     assert @repo.exists("76b1b55ab653581d6f2c7230d34098e837197674")
-    rm_loose("76b1b55ab653581d6f2c7230d34098e837197674")
+
+    rm_loose(oid)
+  end
+
+  test "can use the builtin walk method" do
+    oid = "a4a7dce85cf63874e984719f4fdd239f5145052f"
+    list = []
+    @repo.walk(oid) { |c| list << c }
+    assert list.map {|c| c.oid[0,5] }.join('.'), "a4a7d.c4780.9fd73.4a202.5b5b0.84960"
+  end
+
+  test "can lookup head from repo" do
+    head = @repo.head
+    assert_equal "36060c58702ed4c2a40832c51758d5344201d89a", head.target
+    assert_equal "commit", head.type
+  end
+
+  test "garbage collection methods don't crash" do
+    Rugged::Repository.new(@path)
+    ObjectSpace.garbage_collect
   end
 
 end