rugged 0.21.4 → 0.22.0b1

data/ext/rugged/rugged_submodule_collection.c

@@ -0,0 +1,236 @@
+/*
+ * The MIT License
+ *
+ * Copyright (c) 2014 GitHub, Inc
+ *
+ * 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.
+ */
+
+#include "rugged.h"
+
+extern VALUE rb_mRugged;
+extern VALUE rb_cRuggedSubmodule;
+VALUE rb_cRuggedSubmoduleCollection;
+
+/*
+ *  call-seq:
+ *    SubmoduleCollection.new(repo) -> submodules
+ *
+ *  Creates and returns a new collection of submodules for the given +repo+.
+ */
+static VALUE rb_git_submodule_collection_initialize(VALUE self, VALUE rb_repo)
+{
+	rugged_check_repo(rb_repo);
+	rugged_set_owner(self, rb_repo);
+	return self;
+}
+
+static void rb_git_submodule__free(git_submodule *submodule)
+{
+	git_submodule_free(submodule);
+}
+
+VALUE rugged_submodule_new(VALUE owner, git_submodule *submodule)
+{
+	VALUE rb_submodule;
+
+	rb_submodule = Data_Wrap_Struct(
+			rb_cRuggedSubmodule,
+			NULL,
+			&rb_git_submodule__free,
+			submodule);
+	rugged_set_owner(rb_submodule, owner);
+
+	return rb_submodule;
+}
+
+/*
+ *  call-seq:
+ *    submodules[name] -> submodule or nil
+ *
+ *  Lookup +submodule+ by +name+ or +path+ (they are usually the same) in
+ *  +repository+.
+ *
+ *  Returns +nil+ if submodule does not exist.
+ *
+ *  Raises <tt>Rugged::SubmoduleError</tt> if submodule exists only in working
+ *  directory (i.e. there is a subdirectory that is a valid self-contained git
+ *  repository) and is not mentioned in the +HEAD+, the index and the config.
+ */
+static VALUE rb_git_submodule_collection_aref(VALUE self, VALUE rb_name)
+{
+	git_repository *repo;
+	git_submodule *submodule;
+	int error;
+
+	VALUE rb_repo = rugged_owner(self);
+	Data_Get_Struct(rb_repo, git_repository, repo);
+
+	Check_Type(rb_name, T_STRING);
+
+	error = git_submodule_lookup(
+			&submodule,
+			repo,
+			StringValueCStr(rb_name)
+		);
+
+	if (error == GIT_ENOTFOUND)
+		return Qnil;
+
+	rugged_exception_check(error);
+
+	return rugged_submodule_new(rb_repo, submodule);
+}
+
+static int cb_submodule__each(git_submodule *submodule, const char *name, void *data)
+{
+	struct rugged_cb_payload *payload = data;
+	git_repository *repo;
+	git_submodule *dummy_sm;
+	VALUE rb_repo;
+
+	rb_repo = payload->rb_data;
+	Data_Get_Struct(rb_repo, git_repository, repo);
+
+	/* The submodule passed here has it's refcount decreased just after
+	 * the foreach finishes. The only way to increase that refcount is
+	 * to lookup the submodule.
+	 *
+	 * This should not return an error as the submodule name here is valid
+	 * and exists, as it was just passed to this callback.
+	 */
+	git_submodule_lookup(&dummy_sm, repo, git_submodule_name(submodule));
+
+	rb_protect(
+		rb_yield,
+		rugged_submodule_new(rb_repo, dummy_sm),
+		&payload->exception
+	);
+	return (payload->exception) ? GIT_ERROR : GIT_OK;
+}
+
+/*
+ *  call-seq:
+ *    submodules.each { |submodule| block }
+ *    submodules.each -> enumerator
+ *
+ *  Iterate through all the tracked submodules in the collection's +repository+.
+ *
+ *  The given +block+ will be called once with each +submodule+
+ *  as a Rugged::Submodule instance.
+ *  If no block is given, an enumerator will be returned.
+ */
+static VALUE rb_git_submodule_collection_each(VALUE self)
+{
+	git_repository *repo;
+	int error;
+	struct rugged_cb_payload payload;
+
+	VALUE rb_repo = rugged_owner(self);
+	Data_Get_Struct(rb_repo, git_repository, repo);
+
+	if (!rb_block_given_p())
+		return rb_funcall(self, rb_intern("to_enum"), 1, CSTR2SYM("each"));
+
+	payload.exception = 0;
+	payload.rb_data = rb_repo;
+
+	error = git_submodule_foreach(repo, &cb_submodule__each, &payload);
+
+	if (payload.exception)
+		rb_jump_tag(payload.exception);
+	rugged_exception_check(error);
+
+	return Qnil;
+}
+
+/*
+ *  call-seq:
+ *    submodules.setup_add(url, path[, options]) -> submodule
+ *
+ *  Setup a new +submodule+ for checkout in +repository+.
+ *
+ *  This does <tt>"git submodule add"</tt> up to the fetch and checkout of the
+ *  submodule contents.  It prepares a new submodule, creates an entry in
+ *  +.gitmodules+ and creates an empty initialized repository either at the
+ *  given +path+ in the working directory or in +.git/modules+ with a gitlink
+ *  from the working directory to the new repository.
+ *
+ *  To fully emulate <tt>"git submodule add"</tt> call this function, then open
+ *  the submodule repository and perform the clone step as needed.
+ *  Lastly, call Submodule#finalize_add to wrap up adding the new submodule and
+ *  +.gitmodules+ to the index to be ready to commit.
+ *
+ *  - +url+: URL for the submodule's remote
+ *  - +path+: path at which the submodule should be created
+ *
+ *  The following options can be passed in the +options+ Hash:
+ *  :gitlink ::
+ *    (defaults to +true+) should workdir contain a
+ *    gitlink to the repository in +.git/modules+ vs. repository
+ *    directly in workdir.
+ *
+ *  Returns the newly created +submodule+
+ */
+static VALUE rb_git_submodule_setup_add(int argc, VALUE *argv, VALUE self)
+{
+	git_submodule *submodule;
+	git_repository *repo;
+	int error;
+	int use_gitlink = 1;
+	VALUE rb_repo, rb_url, rb_path, rb_options;
+
+	rb_scan_args(argc, argv, "20:", &rb_url, &rb_path, &rb_options);
+
+	Check_Type(rb_url, T_STRING);
+	Check_Type(rb_path, T_STRING);
+
+	rb_repo = rugged_owner(self);
+	Data_Get_Struct(rb_repo, git_repository, repo);
+
+	if (!NIL_P(rb_options)) {
+		VALUE rb_val;
+
+		rb_val = rb_hash_aref(rb_options, CSTR2SYM("gitlink"));
+		use_gitlink = (rb_val != Qfalse);
+	}
+
+	error = git_submodule_add_setup(
+			&submodule,
+			repo,
+			StringValueCStr(rb_url),
+			StringValueCStr(rb_path),
+			use_gitlink
+		);
+
+	rugged_exception_check(error);
+
+	return rugged_submodule_new(rb_repo, submodule);
+}
+
+void Init_rugged_submodule_collection(void)
+{
+	rb_cRuggedSubmoduleCollection = rb_define_class_under(rb_mRugged, "SubmoduleCollection", rb_cObject);
+	rb_include_module(rb_cRuggedSubmoduleCollection, rb_mEnumerable);
+
+	rb_define_method(rb_cRuggedSubmoduleCollection, "initialize", rb_git_submodule_collection_initialize, 1);
+	rb_define_method(rb_cRuggedSubmoduleCollection, "[]",         rb_git_submodule_collection_aref, 1);
+	rb_define_method(rb_cRuggedSubmoduleCollection, "each",       rb_git_submodule_collection_each, 0);
+	rb_define_method(rb_cRuggedSubmoduleCollection, "setup_add",  rb_git_submodule_setup_add, -1);
+}

data/ext/rugged/rugged_tag_collection.c

@@ -177,6 +177,73 @@ static VALUE rb_git_tag_collection_create(int argc, VALUE *argv, VALUE self)
 	return rb_git_tag_collection_aref(self, rb_name);
 }
 
+/*
+ *  call-seq:
+ *    tags.create_annotation(name, target, annotation) -> annotation
+ *
+ *  Create a new annotated tag object with the specified +name+ on +target+ in
+ *  +repo+.
+ *
+ *  Unlike the +create+ method, +create_annotation+ simply creates a tag
+ *  object. It does not write a tag ref.
+ *
+ *  +annotation+ must have the following keys:
+ *
+ *  :tagger ::
+ *    An optional Hash containing a git signature. Defaults to the signature
+ *    from the configuration if only `:message` is given. Will cause the
+ *    creation of an annotated tag object if present.
+ *
+ *  :message ::
+ *    An optional string containing the message for the new tag.
+ *
+ *  Returns an instance of Rugged::Tag::Annotation representing the newly
+ *  created annotation.
+ */
+static VALUE rb_git_tag_collection_create_annotation(VALUE self, VALUE rb_name, VALUE rb_target, VALUE rb_annotation)
+{
+	git_oid tag_oid;
+	git_repository *repo = NULL;
+	git_object *target = NULL, *tag = NULL;
+	git_signature *tagger = NULL;
+	VALUE rb_message;
+	int error;
+
+	VALUE rb_repo = rugged_owner(self);
+	rugged_check_repo(rb_repo);
+	Data_Get_Struct(rb_repo, git_repository, repo);
+
+	Check_Type(rb_name, T_STRING);
+
+	target = rugged_object_get(repo, rb_target, GIT_OBJ_ANY);
+
+	rb_message = rb_hash_aref(rb_annotation, CSTR2SYM("message"));
+	Check_Type(rb_message, T_STRING);
+
+	tagger = rugged_signature_get(
+		rb_hash_aref(rb_annotation, CSTR2SYM("tagger")), repo
+	);
+
+	error = git_tag_annotation_create(
+		&tag_oid,
+		repo,
+		StringValueCStr(rb_name),
+		target,
+		tagger,
+		StringValueCStr(rb_message)
+	);
+
+	git_object_free(target);
+	git_signature_free(tagger);
+
+	rugged_exception_check(error);
+
+	error = git_object_lookup(&tag, repo, &tag_oid, GIT_OBJ_TAG);
+	rugged_exception_check(error);
+
+	return rugged_object_new(rb_repo, tag);
+}
+
 static VALUE each_tag(int argc, VALUE *argv, VALUE self, int tag_names_only)
 {
 	git_repository *repo;
@@ -269,8 +336,9 @@ void Init_rugged_tag_collection(void)
 
 	rb_define_method(rb_cRuggedTagCollection, "initialize", rb_git_tag_collection_initialize, 1);
 
-	rb_define_method(rb_cRuggedTagCollection, "create",     rb_git_tag_collection_create, -1);
-	rb_define_method(rb_cRuggedTagCollection, "[]",         rb_git_tag_collection_aref, 1);
+	rb_define_method(rb_cRuggedTagCollection, "create",            rb_git_tag_collection_create, -1);
+	rb_define_method(rb_cRuggedTagCollection, "create_annotation", rb_git_tag_collection_create_annotation, 3);
+	rb_define_method(rb_cRuggedTagCollection, "[]",                rb_git_tag_collection_aref, 1);
 
 	rb_define_method(rb_cRuggedTagCollection, "each",       rb_git_tag_collection_each, -1);
 	rb_define_method(rb_cRuggedTagCollection, "each_name",  rb_git_tag_collection_each_name, -1);

data/ext/rugged/rugged_tree.c

@@ -188,14 +188,26 @@ static VALUE rb_git_tree_each(VALUE self)
 	return Qnil;
 }
 
-static int rugged__treewalk_cb(const char *root, const git_tree_entry *entry, void *proc)
+static int rugged__treewalk_cb(const char *root, const git_tree_entry *entry, void *payload)
 {
-	rb_funcall((VALUE)proc, rb_intern("call"), 2,
-		rb_str_new_utf8(root),
-		rb_git_treeentry_fromC(entry)
-	);
+	int *exception = (int *)payload;
 
-	return GIT_OK;
+	VALUE rb_result, rb_args = rb_ary_new2(2);
+
+	rb_ary_push(rb_args, rb_str_new_utf8(root));
+	rb_ary_push(rb_args, rb_git_treeentry_fromC(entry));
+
+	rb_result = rb_protect(rb_yield_splat, rb_args, exception);
+
+	if (*exception)
+		return -1;
+
+	/* skip entry when 'false' is returned */
+	if (TYPE(rb_result) == T_FALSE)
+		return 1;
+
+	/* otherwise continue normal iteration */
+	return 0;
 }
 
 /*
@@ -208,6 +220,9 @@ static int rugged__treewalk_cb(const char *root, const git_tree_entry *entry, vo
  *  also takes a +root+, the relative path in the traversal, starting from the root
  *  of the original tree.
  *
+ *  If the +block+ returns a falsy value, that entry and its sub-entries (in the case
+ *  of a folder) will be skipped for the iteration.
+ *
  *  If no +block+ is given, an +Iterator+ is returned instead.
  *
  *    tree.walk(:postorder) { |root, entry| puts "#{root}#{entry[:name]} [#{entry[:oid]}]" }
@@ -223,7 +238,7 @@ static int rugged__treewalk_cb(const char *root, const git_tree_entry *entry, vo
 static VALUE rb_git_tree_walk(VALUE self, VALUE rb_mode)
 {
 	git_tree *tree;
-	int error, mode = 0;
+	int error, mode = 0, exception = 0;
 	ID id_mode;
 
 	Data_Get_Struct(self, git_tree, tree);
@@ -242,7 +257,11 @@ static VALUE rb_git_tree_walk(VALUE self, VALUE rb_mode)
 		rb_raise(rb_eTypeError,
 				"Invalid iteration mode. Expected `:preorder` or `:postorder`");
 
-	error = git_tree_walk(tree, mode, &rugged__treewalk_cb, (void *)rb_block_proc());
+	error = git_tree_walk(tree, mode, &rugged__treewalk_cb, (void *)&exception);
+
+	if (exception)
+		rb_jump_tag(exception);
+
 	rugged_exception_check(error);
 
 	return Qnil;
@@ -454,7 +473,7 @@ static VALUE rb_git_tree_diff_(int argc, VALUE *argv, VALUE self)
 	xfree(opts.pathspec.strings);
 	rugged_exception_check(error);
 
-	return rugged_diff_new(rb_cRuggedDiff, self, diff);
+	return rugged_diff_new(rb_cRuggedDiff, rb_repo, diff);
 }
 
 /*
@@ -489,7 +508,7 @@ static VALUE rb_git_tree_diff_workdir(int argc, VALUE *argv, VALUE self)
 	xfree(opts.pathspec.strings);
 	rugged_exception_check(error);
 
-	return rugged_diff_new(rb_cRuggedDiff, self, diff);
+	return rugged_diff_new(rb_cRuggedDiff, owner, diff);
 }
 
 void rugged_parse_merge_options(git_merge_options *opts, VALUE rb_options)

data/lib/rugged.rb

@@ -18,3 +18,6 @@ require 'rugged/diff'
 require 'rugged/patch'
 require 'rugged/remote'
 require 'rugged/credentials'
+require 'rugged/attributes'
+require 'rugged/blob'
+require 'rugged/submodule_collection'

data/lib/rugged/attributes.rb

@@ -0,0 +1,41 @@
+module Rugged
+  class Repository
+    def attributes(path, options = {})
+      Attributes.new(self, path, options)
+    end
+
+    class Attributes
+      include Enumerable
+
+      LOAD_PRIORITIES = {
+        [:file, :index] => 0,
+        [:index, :file] => 1,
+        [:index] => 2,
+      }
+
+      def self.parse_opts(opt)
+        flags = LOAD_PRIORITIES[opt[:priority]] || 0
+        flags |= 4 if opt[:skip_system]
+        flags
+      end
+
+      def initialize(repository, path, options = {})
+        @repository = repository
+        @path = path
+        @load_flags = Attributes.parse_opts(options)
+      end
+
+      def [](attribute)
+        @repository.fetch_attributes(@path, attribute, @load_flags)
+      end
+
+      def to_h
+        @hash ||= @repository.fetch_attributes(@path, nil, @load_flags)
+      end
+
+      def each(&block)
+        to_h.each(&block)
+      end
+    end
+  end
+end