rugged 0.17.0.b6 → 0.17.0.b7

data/test/config_test.rb

@@ -17,7 +17,7 @@ context "Rugged::Config tests" do
   end
 
   test "can read the global config file" do
-    config = Rugged::Config.open_global
+    config = Rugged::Config.global
     assert_not_nil config['user.name']
     assert_nil config['core.bare']
   end

data/test/index_test.rb

@@ -184,3 +184,34 @@ context "Rugged::Index with working directory" do
     assert_equal e[:mode], 33199
   end
 end
+
+
+context "Rugged::Index with Rugged::Repository" do
+  setup do
+    @path = temp_repo("testrepo.git")
+    @repo = Rugged::Repository.new(@path)
+    @index = @repo.index
+  end
+
+  test "idempotent read_tree/write_tree" do
+    head_sha = Rugged::Reference.lookup(@repo,'HEAD').resolve.target
+    tree = @repo.lookup(head_sha).tree
+    @index.read_tree(tree)
+
+    index_tree_sha = @index.write_tree
+    index_tree = @repo.lookup(index_tree_sha)
+    assert_equal tree.oid, index_tree.oid
+  end
+
+
+  test "build tree from index on non-HEAD branch" do
+    head_sha = Rugged::Reference.lookup(@repo,'refs/remotes/origin/packed').resolve.target
+    tree = @repo.lookup(head_sha).tree
+    @index.read_tree(tree)
+    @index.remove('second.txt')
+
+    new_tree_sha = @index.write_tree
+    assert head_sha != new_tree_sha
+    assert_nil @repo.lookup(new_tree_sha)['second.txt']
+  end
+end

data/test/index_test.rb~

@@ -0,0 +1,218 @@
+require "test_helper"
+require 'base64'
+require 'tempfile'
+require 'fileutils'
+
+def new_index_entry
+    now = Time.now
+    {
+      :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)
+  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.count
+  end
+
+  test "can clear the in-memory index" do
+    @index.clear
+    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[: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[:oid]
+  end
+
+  test "can iterate over the entries" do
+    itr_test = @index.sort { |a, b| a[:oid] <=> b[:oid] }.map { |e| e[:path] }.join(':')
+    assert_equal "README:new.txt", itr_test
+  end
+
+  test "can update entries" do
+    now = Time.at Time.now.to_i
+    e = @index.get_entry(0)
+
+    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]]
+
+    # git only sets executable bit based on owner
+    e[:mode] = 33188
+    assert_equal e, new_e
+  end
+
+  test "can add new entries" do
+    e = new_index_entry
+    @index << e
+    assert_equal 3, @index.count
+    itr_test = @index.sort { |a, b| a[:oid] <=> b[:oid] }.map { |x| x[:path] }.join(':')
+    assert_equal "README:new_path:new.txt", itr_test
+  end
+end
+
+context "Rugged::Index writing stuff" do
+  setup do
+    path = File.dirname(__FILE__) + '/fixtures/testrepo.git/index'
+    @tmppath = Tempfile.new('index').path
+    FileUtils.copy(path, @tmppath)
+    @index = Rugged::Index.new(@tmppath)
+  end
+
+  test "add raises if it gets something weird" do
+    assert_raise TypeError do
+      @index.add(21)
+    end
+  end
+
+  test "can write a new index" do
+    e = new_index_entry
+    @index << e
+
+    e[:path] = "else.txt"
+    @index << e
+
+    @index.write
+
+    index2 = Rugged::Index.new(@tmppath)
+
+    itr_test = index2.sort { |a, b| a[:oid] <=> b[:oid] }.map { |x| x[:path] }.join(':')
+    assert_equal "README:else.txt:new_path:new.txt", itr_test
+    assert_equal 4, index2.count
+  end
+end
+
+context "Rugged::Index with working directory" do
+  setup do
+    @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
+
+    index2 = Rugged::Index.new(@tmppath + '/.git/index')
+    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
+
+    e = @index['new_path']
+    assert_equal e[:mode], 33199
+  end
+end
+
+
+context "Rugged::Index with Rugged::Repository" do
+  setup do
+    @path = temp_repo("testrepo.git")
+    @repo = Rugged::Repository.new(@path)
+    @index = @repo.index
+  end
+
+  test "idempotent read_tree/write_tree" do
+    head_sha = Rugged::Reference.lookup(@repo,'HEAD').resolve.target
+    tree = @repo.lookup(head_sha).tree
+    @index.read_tree(tree)
+
+    index_tree_sha = @index.write_tree
+    index_tree = @repo.lookup(index_tree_sha)
+    assert_equal tree.oid, index_tree.oid
+  end
+
+
+  test "build tree from index on non-HEAD branch" do
+    head_sha = Rugged::Reference.lookup(@repo,'refs/remotes/origin/packed').resolve.target
+    tree = @repo.lookup(head_sha).tree
+    @index.read_tree(tree)
+    @index.remove('second.txt')
+
+    new_tree_sha = @index.write_tree
+    assert head_sha != new_tree_sha
+    pp @repo.lookup(new_tree_sha)
+    assert_nil @repo.lookup(new_tree_sha)['second.txt']
+  end
+end

data/test/lib_test.rb

@@ -37,4 +37,26 @@ context "Rugged::Lib stuff" do
     hex2 = raw.unpack("H*")[0]
     assert_equal hex1, hex2
   end
+
+  test "prettifies commit messages properly" do
+    message = <<-MESSAGE
+Testing this whole prettify business    
+
+with newlines and stuff  
+# take out this line haha
+# and this one
+
+not this one    
+MESSAGE
+  
+    clean_message = <<-MESSAGE
+Testing this whole prettify business
+
+with newlines and stuff
+
+not this one
+MESSAGE
+
+    assert_equal clean_message, Rugged::prettify_message(message, true)
+  end
 end

data/test/reference_test.rb

@@ -2,6 +2,8 @@
 require File.expand_path "../test_helper", __FILE__
 
 context "Rugged::Reference stuff" do
+  UNICODE_REF_NAME = "A\314\212ngstro\314\210m"
+
   setup do
     @path = File.dirname(__FILE__) + '/fixtures/testrepo.git'
     @repo = Rugged::Repository.new(@path)
@@ -9,7 +11,7 @@ context "Rugged::Reference stuff" do
 
   teardown do
     FileUtils.remove_entry_secure(@path + '/refs/heads/unit_test', true)
-    FileUtils.remove_entry_secure(@path + '/refs/heads/Ångström', true)
+    FileUtils.remove_entry_secure(@path + "/refs/heads/#{UNICODE_REF_NAME}", true)
   end
 
   test "can list references" do
@@ -18,9 +20,9 @@ context "Rugged::Reference stuff" do
   end
 
   test "can list references with non 7-bit ASCII characters" do
-    Rugged::Reference.create(@repo, "refs/heads/Ångström", "refs/heads/master")
+    Rugged::Reference.create(@repo, "refs/heads/#{UNICODE_REF_NAME}", "refs/heads/master")
     refs = @repo.refs.map { |r| r.name.gsub("refs/", '') }.sort.join(':')
-    assert_equal "heads/master:heads/packed:heads/Ångström:tags/v0.9:tags/v1.0", refs
+    assert_equal "heads/#{UNICODE_REF_NAME}:heads/master:heads/packed:tags/v0.9:tags/v1.0", refs
   end
 
   test "can list filtered references from regex" do

data/vendor/libgit2/Makefile.embed

@@ -15,7 +15,7 @@ INCLUDES= -I. -Isrc -Iinclude -Ideps/http-parser -Ideps/zlib
 DEFINES= $(INCLUDES) -DNO_VIZ -DSTDC -DNO_GZIP -D_FILE_OFFSET_BITS=64 -D_GNU_SOURCE $(EXTRA_DEFINES)
 CFLAGS= -g $(DEFINES) -Wall -Wextra -O2 $(EXTRA_CFLAGS)
 
-SRCS = $(wildcard src/*.c) $(wildcard src/transports/*.c) $(wildcard src/xdiff/*.c) $(wildcard deps/http-parser/*.c) $(wildcard deps/zlib/*.c)
+SRCS = $(wildcard src/*.c) $(wildcard src/transports/*.c) $(wildcard src/xdiff/*.c) $(wildcard deps/http-parser/*.c) $(wildcard deps/zlib/*.c) $(wildcard src/sha1/*.c)
 
 ifeq ($(PLATFORM),Msys)
 	SRCS += $(wildcard src/win32/*.c) $(wildcard src/compat/*.c) deps/regex/regex.c

data/vendor/libgit2/include/git2.h

@@ -51,5 +51,6 @@
 #include "git2/notes.h"
 #include "git2/reset.h"
 #include "git2/message.h"
+#include "git2/pack.h"
 
 #endif

data/vendor/libgit2/include/git2/branch.h

@@ -8,6 +8,7 @@
 #define INCLUDE_git_branch_h__
 
 #include "common.h"
+#include "oid.h"
 #include "types.h"
 
 /**
@@ -55,21 +56,13 @@ GIT_EXTERN(int) git_branch_create(
 /**
  * Delete an existing branch reference.
  *
- * @param repo Repository where lives the branch.
+ * If the branch is successfully deleted, the passed reference
+ * object will be freed and invalidated.
  *
- * @param branch_name Name of the branch to be deleted;
- * this name is validated for consistency.
- *
- * @param branch_type Type of the considered branch. This should
- * be valued with either GIT_BRANCH_LOCAL or GIT_BRANCH_REMOTE.
- *
- * @return 0 on success, GIT_ENOTFOUND if the branch
- * doesn't exist or an error code.
+ * @param branch A valid reference representing a branch
+ * @return 0 on success, or an error code.
  */
-GIT_EXTERN(int) git_branch_delete(
-		git_repository *repo,
-		const char *branch_name,
-		git_branch_t branch_type);
+GIT_EXTERN(int) git_branch_delete(git_reference *branch);
 
 /**
  * Loop over all the branches and issue a callback for each one.
@@ -155,6 +148,17 @@ GIT_EXTERN(int) git_branch_tracking(
 		git_reference **tracking_out,
 		git_reference *branch);
 
+/**
+ * Determine if the current local branch is pointed at by HEAD.
+ *
+ * @param branch Current underlying reference of the branch.
+ *
+ * @return 1 if HEAD points at the branch, 0 if it isn't,
+ * error code otherwise.
+ */
+GIT_EXTERN(int) git_branch_is_head(
+		git_reference *branch);
+
 /** @} */
 GIT_END_DECL
 #endif

data/vendor/libgit2/include/git2/checkout.h

@@ -10,7 +10,7 @@
 #include "common.h"
 #include "types.h"
 #include "indexer.h"
-
+#include "strarray.h"
 
 /**
  * @file git2/checkout.h
@@ -21,45 +21,106 @@
  */
 GIT_BEGIN_DECL
 
+/**
+ * Checkout behavior flags
+ *
+ * These flags control what checkout does with files.  Pass in a
+ * combination of these values OR'ed together.
+ */
+typedef enum {
+	/** Checkout does not update any files in the working directory. */
+	GIT_CHECKOUT_DEFAULT            = (1 << 0),
+
+	/** When a file exists and is modified, replace it with new version. */
+	GIT_CHECKOUT_OVERWRITE_MODIFIED = (1 << 1),
+
+	/** When a file does not exist in the working directory, create it. */
+	GIT_CHECKOUT_CREATE_MISSING     = (1 << 2),
 
-#define GIT_CHECKOUT_OVERWRITE_EXISTING 0 /* default */
-#define GIT_CHECKOUT_SKIP_EXISTING 1
+	/** If an untracked file in found in the working dir, delete it. */
+	GIT_CHECKOUT_REMOVE_UNTRACKED   = (1 << 3),
+} git_checkout_strategy_t;
 
-/* Use zeros to indicate default settings */
+/**
+ * Checkout options structure
+ *
+ * Use zeros to indicate default settings.
+ */
 typedef struct git_checkout_opts {
-	int existing_file_action; /* default: GIT_CHECKOUT_OVERWRITE_EXISTING */
-	int disable_filters;
-	int dir_mode; /* default is 0755 */
-	int file_mode; /* default is 0644 */
-	int file_open_flags; /* default is O_CREAT | O_TRUNC | O_WRONLY */
+	unsigned int checkout_strategy; /** default: GIT_CHECKOUT_DEFAULT */
+	int disable_filters; /** don't apply filters like CRLF conversion */
+	int dir_mode;		 /** default is 0755 */
+	int file_mode;		 /** default is 0644 or 0755 as dictated by blob */
+	int file_open_flags; /** default is O_CREAT | O_TRUNC | O_WRONLY */
+
+	/** Optional callback to notify the consumer of files that
+	 * haven't be checked out because a modified version of them
+	 * exist in the working directory.
+	 *
+	 * When provided, this callback will be invoked when the flag
+	 * GIT_CHECKOUT_OVERWRITE_MODIFIED isn't part of the checkout strategy.
+	 */
+	int (* skipped_notify_cb)(
+		const char *skipped_file,
+		const git_oid *blob_oid,
+		int file_mode,
+		void *payload);
+
+	void *notify_payload;
+
+	/** When not NULL, array of fnmatch patterns specifying
+	 * which paths should be taken into account
+	 */
+	git_strarray paths; 
 } git_checkout_opts;
 
 /**
- * Updates files in the working tree to match the commit pointed to by HEAD.
+ * Updates files in the index and the working tree to match the content of the
+ * commit pointed at by HEAD.
  *
  * @param repo repository to check out (must be non-bare)
  * @param opts specifies checkout options (may be NULL)
  * @param stats structure through which progress information is reported
- * @return 0 on success, GIT_ERROR otherwise (use giterr_last for information about the error)
+ * @return 0 on success, GIT_EORPHANEDHEAD when HEAD points to a non existing
+ * branch, GIT_ERROR otherwise (use giterr_last for information
+ * about the error)
  */
-GIT_EXTERN(int) git_checkout_head(git_repository *repo,
-											 git_checkout_opts *opts,
-											 git_indexer_stats *stats);
-
-
+GIT_EXTERN(int) git_checkout_head(
+	git_repository *repo,
+	git_checkout_opts *opts,
+	git_indexer_stats *stats);
 
 /**
- * Updates files in the working tree to match a commit pointed to by a ref.
+ * Updates files in the working tree to match the content of the index.
  *
- * @param ref reference to follow to a commit
+ * @param repo repository to check out (must be non-bare)
  * @param opts specifies checkout options (may be NULL)
  * @param stats structure through which progress information is reported
- * @return 0 on success, GIT_ERROR otherwise (use giterr_last for information about the error)
+ * @return 0 on success, GIT_ERROR otherwise (use giterr_last for information
+ * about the error)
  */
-GIT_EXTERN(int) git_checkout_reference(git_reference *ref,
-													git_checkout_opts *opts,
-													git_indexer_stats *stats);
+GIT_EXTERN(int) git_checkout_index(
+	git_repository *repo,
+	git_checkout_opts *opts,
+	git_indexer_stats *stats);
 
+/**
+ * Updates files in the index and working tree to match the content of the
+ * tree pointed at by the treeish.
+ *
+ * @param repo repository to check out (must be non-bare)
+ * @param treeish a commit, tag or tree which content will be used to update
+ * the working directory
+ * @param opts specifies checkout options (may be NULL)
+ * @param stats structure through which progress information is reported
+ * @return 0 on success, GIT_ERROR otherwise (use giterr_last for information
+ * about the error)
+ */
+GIT_EXTERN(int) git_checkout_tree(
+	git_repository *repo,
+	git_object *treeish,
+	git_checkout_opts *opts,
+	git_indexer_stats *stats);
 
 /** @} */
 GIT_END_DECL