rugged 0.19.0 → 0.28.0

data/ext/rugged/rugged.h

@@ -1,25 +1,8 @@
 /*
- * The MIT License
+ * Copyright (C) the Rugged contributors.  All rights reserved.
  *
- * Copyright (c) 2013 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.
+ * This file is part of Rugged, distributed under the MIT license.
+ * For full terms see the included LICENSE file.
  */
 
 #ifndef __H_RUGGED_BINDINGS__
@@ -37,9 +20,12 @@
 #include <ruby/encoding.h>
 #endif
 
+#include <ruby/util.h>
+
 #include <assert.h>
 #include <git2.h>
 #include <git2/odb_backend.h>
+#include <git2/sys/path.h>
 
 #define rb_str_new_utf8(str) rb_enc_str_new(str, strlen(str), rb_utf8_encoding())
 #define CSTR2SYM(s) (ID2SYM(rb_intern((s))))
@@ -49,23 +35,33 @@
  */
 void Init_rugged_object(void);
 void Init_rugged_branch(void);
+void Init_rugged_branch_collection(void);
 void Init_rugged_commit(void);
 void Init_rugged_tree(void);
 void Init_rugged_tag(void);
+void Init_rugged_tag_collection(void);
 void Init_rugged_blob(void);
 void Init_rugged_index(void);
 void Init_rugged_repo(void);
 void Init_rugged_revwalk(void);
 void Init_rugged_reference(void);
+void Init_rugged_reference_collection(void);
 void Init_rugged_config(void);
 void Init_rugged_remote(void);
+void Init_rugged_remote_collection(void);
 void Init_rugged_notes(void);
 void Init_rugged_settings(void);
+void Init_rugged_submodule(void);
+void Init_rugged_submodule_collection(void);
 void Init_rugged_diff(void);
-void Init_rugged_diff_patch(void);
+void Init_rugged_patch(void);
 void Init_rugged_diff_delta(void);
 void Init_rugged_diff_hunk(void);
 void Init_rugged_diff_line(void);
+void Init_rugged_blame(void);
+void Init_rugged_cred(void);
+void Init_rugged_backend(void);
+void Init_rugged_rebase(void);
 
 VALUE rb_git_object_init(git_otype type, int argc, VALUE *argv, VALUE self);
 
@@ -73,25 +69,37 @@ VALUE rugged_raw_read(git_repository *repo, const git_oid *oid);
 
 VALUE rugged_signature_new(const git_signature *sig, const char *encoding_name);
 
+VALUE rugged_repo_new(VALUE klass, git_repository *repo);
 VALUE rugged_index_new(VALUE klass, VALUE owner, git_index *index);
 VALUE rugged_config_new(VALUE klass, VALUE owner, git_config *cfg);
 VALUE rugged_object_new(VALUE owner, git_object *object);
 VALUE rugged_object_rev_parse(VALUE rb_repo, VALUE rb_spec, int as_obj);
 VALUE rugged_ref_new(VALUE klass, VALUE owner, git_reference *ref);
-VALUE rugged_diff_new(VALUE klass, VALUE owner, git_diff_list *diff);
-VALUE rugged_diff_patch_new(VALUE owner, git_diff_patch *patch);
+VALUE rugged_diff_new(VALUE klass, VALUE owner, git_diff *diff);
+VALUE rugged_patch_new(VALUE owner, git_patch *patch);
 VALUE rugged_diff_delta_new(VALUE owner, const git_diff_delta *delta);
-VALUE rugged_diff_hunk_new(VALUE owner, int hunk_idx, const git_diff_range *range, const char *header, size_t header_len, size_t lines_in_hunk);
-VALUE rugged_diff_line_new(VALUE owner, const char line_origin, const char *content, size_t content_len, int old_lineno, int new_lineno);
+VALUE rugged_diff_hunk_new(VALUE owner, size_t hunk_idx, const git_diff_hunk *hunk, size_t lines_in_hunk);
+VALUE rugged_diff_line_new(const git_diff_line *line);
+VALUE rugged_remote_new(VALUE owner, git_remote *remote);
+VALUE rb_git_delta_file_fromC(const git_diff_file *file);
+VALUE rb_merge_file_result_fromC(const git_merge_file_result *results);
 
 void rugged_parse_diff_options(git_diff_options *opts, VALUE rb_options);
+void rugged_parse_merge_options(git_merge_options *opts, VALUE rb_options);
+void rugged_parse_checkout_options(git_checkout_options *opts, VALUE rb_options);
+void rugged_parse_merge_file_options(git_merge_file_options *opts, VALUE rb_options);
+
+void rugged_cred_extract(git_cred **cred, int allowed_types, VALUE rb_credential);
 
 VALUE rugged_otype_new(git_otype t);
 git_otype rugged_otype_get(VALUE rb_type);
 
-git_signature *rugged_signature_get(VALUE rb_person);
+git_signature *rugged_signature_get(VALUE rb_person, git_repository *repo);
 git_object *rugged_object_get(git_repository *repo, VALUE object_value, git_otype type);
 int rugged_oid_get(git_oid *oid, git_repository *repo, VALUE p);
+const char * rugged_refname_from_string_or_ref(VALUE rb_name_or_ref);
+
+VALUE rugged_signature_from_buffer(const char *buffer, const char *encoding_name);
 
 void rugged_rb_ary_to_strarray(VALUE rb_array, git_strarray *str_array);
 VALUE rugged_strarray_to_rb_ary(git_strarray *str_array);
@@ -124,11 +132,31 @@ static inline int rugged_parse_bool(VALUE boolean)
 
 extern VALUE rb_cRuggedRepo;
 
-struct rugged_cb_payload {
+VALUE rugged__block_yield_splat(VALUE args);
+
+struct rugged_cb_payload
+{
     VALUE rb_data;
     int exception;
 };
 
+struct rugged_remote_cb_payload
+{
+	VALUE progress;
+	VALUE completion;
+	VALUE transfer_progress;
+	VALUE update_tips;
+	VALUE credentials;
+	VALUE certificate_check;
+	VALUE result;
+	int exception;
+};
+
+void rugged_remote_init_callbacks_and_payload_from_options(
+	VALUE rb_options,
+	git_remote_callbacks *callbacks,
+	struct rugged_remote_cb_payload *payload);
+
 static inline void rugged_check_repo(VALUE rb_repo)
 {
 	if (!rb_obj_is_kind_of(rb_repo, rb_cRuggedRepo))
@@ -139,7 +167,15 @@ static inline VALUE rugged_create_oid(const git_oid *oid)
 {
 	char out[40];
 	git_oid_fmt(out, oid);
-	return rb_str_new(out, 40);
+	return rb_usascii_str_new(out, 40);
 }
 
+
+typedef struct _rugged_backend {
+  int (* odb_backend)(git_odb_backend **backend_out, struct _rugged_backend *backend, const char* path);
+  int (* refdb_backend)(git_refdb_backend **backend_out, struct _rugged_backend *backend, const char* path);
+} rugged_backend;
+
+extern void rugged_set_allocator(void);
+
 #endif

data/ext/rugged/rugged_allocator.c

@@ -0,0 +1,89 @@
+/*
+ * Copyright (C) the Rugged contributors.  All rights reserved.
+ *
+ * This file is part of Rugged, distributed under the MIT license.
+ * For full terms see the included LICENSE file.
+ */
+
+#include "rugged.h"
+#include <git2/sys/alloc.h>
+
+static void *rugged_gmalloc(size_t n, const char *file, int line)
+{
+	return xmalloc(n);
+}
+
+static void *rugged_gcalloc(size_t nelem, size_t elsize, const char *file, int line)
+{
+	return xcalloc(nelem, elsize);
+}
+
+static char *rugged_gstrdup(const char *str, const char *file, int line)
+{
+	return ruby_strdup(str);
+}
+
+static char *rugged_gstrndup(const char *str, size_t n, const char *file, int line)
+{
+	size_t len;
+	char *newstr;
+
+	len = strnlen(str, n);
+	if (len < n)
+		n = len;
+
+	newstr = xmalloc(n+1);
+	memcpy(newstr, str, n);
+	newstr[n] = '\0';
+
+	return newstr;
+}
+
+static char *rugged_gsubstrdup(const char *str, size_t n, const char *file, int line)
+{
+	char *newstr;
+
+	newstr = xmalloc(n+1);
+	memcpy(newstr, str, n);
+	newstr[n] = '\0';
+
+	return newstr;
+}
+
+static void *rugged_grealloc(void *ptr, size_t size, const char *file, int line)
+{
+	return xrealloc(ptr, size);
+}
+
+static void *rugged_greallocarray(void *ptr, size_t nelem, size_t elsize, const char *file, int line)
+{
+	return xrealloc2(ptr, nelem, elsize);
+}
+
+static void *rugged_gmallocarray(size_t nelem, size_t elsize, const char *file, int line)
+{
+	return xmalloc2(nelem, elsize);
+}
+
+static void rugged_gfree(void *ptr)
+{
+	xfree(ptr);
+}
+
+void rugged_set_allocator(void)
+{
+	git_allocator allocator;
+
+	allocator.gmalloc = rugged_gmalloc;
+	allocator.gcalloc = rugged_gcalloc;
+	allocator.gstrdup = rugged_gstrdup;
+	allocator.gstrndup = rugged_gstrndup;
+	allocator.gstrndup = rugged_gstrndup;
+	allocator.gsubstrdup = rugged_gsubstrdup;
+	allocator.grealloc = rugged_grealloc;
+	allocator.greallocarray = rugged_greallocarray;
+	allocator.gmallocarray = rugged_gmallocarray;
+	allocator.gfree = rugged_gfree;
+
+	git_libgit2_opts(GIT_OPT_SET_ALLOCATOR, &allocator);
+}

data/ext/rugged/rugged_backend.c

@@ -0,0 +1,17 @@
+/*
+ * Copyright (C) the Rugged contributors.  All rights reserved.
+ *
+ * This file is part of Rugged, distributed under the MIT license.
+ * For full terms see the included LICENSE file.
+ */
+
+#include "rugged.h"
+
+extern VALUE rb_mRugged;
+
+VALUE rb_cRuggedBackend;
+
+void Init_rugged_backend(void)
+{
+	rb_cRuggedBackend = rb_define_class_under(rb_mRugged, "Backend", rb_cObject);
+}

data/ext/rugged/rugged_blame.c

@@ -0,0 +1,278 @@
+/*
+ * Copyright (C) the Rugged contributors.  All rights reserved.
+ *
+ * This file is part of Rugged, distributed under the MIT license.
+ * For full terms see the included LICENSE file.
+ */
+
+#include "rugged.h"
+
+extern VALUE rb_mRugged;
+VALUE rb_cRuggedBlame;
+
+static VALUE rb_git_blame_hunk_fromC(const git_blame_hunk *hunk)
+{
+	VALUE rb_hunk;
+	if (!hunk)  {
+		return Qnil;
+	}
+
+	rb_hunk = rb_hash_new();
+	rb_hash_aset(rb_hunk, CSTR2SYM("lines_in_hunk"), UINT2NUM(hunk->lines_in_hunk));
+
+	rb_hash_aset(rb_hunk, CSTR2SYM("final_commit_id"), rugged_create_oid(&(hunk->final_commit_id)));
+	rb_hash_aset(rb_hunk, CSTR2SYM("final_start_line_number"), UINT2NUM(hunk->final_start_line_number));
+	rb_hash_aset(rb_hunk, CSTR2SYM("final_signature"), hunk->final_signature ? rugged_signature_new(hunk->final_signature, NULL) : Qnil);
+
+	rb_hash_aset(rb_hunk, CSTR2SYM("orig_commit_id"), rugged_create_oid(&(hunk->orig_commit_id)));
+	rb_hash_aset(rb_hunk, CSTR2SYM("orig_path"), hunk->orig_path ? rb_str_new2(hunk->orig_path) : Qnil);
+	rb_hash_aset(rb_hunk, CSTR2SYM("orig_start_line_number"), UINT2NUM(hunk->orig_start_line_number));
+	rb_hash_aset(rb_hunk, CSTR2SYM("orig_signature"), hunk->orig_signature ? rugged_signature_new(hunk->orig_signature, NULL) : Qnil);
+
+	rb_hash_aset(rb_hunk, CSTR2SYM("boundary"), hunk->boundary ? Qtrue : Qfalse);
+
+	return rb_hunk;
+}
+
+static void rugged_parse_blame_options(git_blame_options *opts, git_repository *repo, VALUE rb_options)
+{
+	if (!NIL_P(rb_options)) {
+		VALUE rb_value;
+		Check_Type(rb_options, T_HASH);
+
+		rb_value = rb_hash_aref(rb_options, CSTR2SYM("min_line"));
+		if (!NIL_P(rb_value)) {
+			Check_Type(rb_value, T_FIXNUM);
+			opts->min_line = FIX2UINT(rb_value);
+		}
+
+		rb_value = rb_hash_aref(rb_options, CSTR2SYM("max_line"));
+		if (!NIL_P(rb_value)) {
+			Check_Type(rb_value, T_FIXNUM);
+			opts->max_line = FIX2UINT(rb_value);
+		}
+
+		rb_value = rb_hash_aref(rb_options, CSTR2SYM("newest_commit"));
+		if (!NIL_P(rb_value)) {
+			int error = rugged_oid_get(&opts->newest_commit, repo, rb_value);
+			rugged_exception_check(error);
+		}
+
+		rb_value = rb_hash_aref(rb_options, CSTR2SYM("oldest_commit"));
+		if (!NIL_P(rb_value)) {
+			int error = rugged_oid_get(&opts->oldest_commit, repo, rb_value);
+			rugged_exception_check(error);
+		}
+
+		if (RTEST(rb_hash_aref(rb_options, CSTR2SYM("track_copies_same_file")))) {
+			opts->flags |= GIT_BLAME_TRACK_COPIES_SAME_FILE;
+		}
+
+		if (RTEST(rb_hash_aref(rb_options, CSTR2SYM("track_copies_same_commit_moves")))) {
+			opts->flags |= GIT_BLAME_TRACK_COPIES_SAME_COMMIT_MOVES;
+		}
+
+		if (RTEST(rb_hash_aref(rb_options, CSTR2SYM("track_copies_same_commit_copies")))) {
+			opts->flags |= GIT_BLAME_TRACK_COPIES_SAME_COMMIT_COPIES;
+		}
+
+		if (RTEST(rb_hash_aref(rb_options, CSTR2SYM("track_copies_any_commit_copies")))) {
+			opts->flags |= GIT_BLAME_TRACK_COPIES_ANY_COMMIT_COPIES;
+		}
+	}
+}
+
+/*
+ *  call-seq:
+ *    Blame.new(repo, path, options = {}) -> blame
+ *
+ *  Get blame data for the file at +path+ in +repo+.
+ *
+ *  The following options can be passed in the +options+ Hash:
+ *
+ *  :newest_commit ::
+ *    The ID of the newest commit to consider in the blame. Defaults to +HEAD+.
+ *    This can either be a Rugged::Object instance, or a full or abbreviated
+ *    SHA1 id.
+ *
+ *  :oldest_commit ::
+ *    The id of the oldest commit to consider. Defaults to the first commit
+ *    encountered with a NULL parent. This can either be a Rugged::Object
+ *    instance, or a full or abbreviated SHA1 id.
+ *
+ *  :min_line ::
+ *    The first line in the file to blame. Line numbers start with 1.
+ *    Defaults to +1+.
+ *
+ *  :max_line ::
+ *    The last line in the file to blame. Defaults to the last line in
+ *    the file.
+ *
+ *  :track_copies_same_file ::
+ *    If this value is +true+, lines that have moved within a file will be
+ *    tracked (like `git blame -M`).
+ *
+ *  :track_copies_same_commit_moves ::
+ *    If this value is +true+, lines that have moved across files in the same
+ *    commit will be tracked (like `git blame -C`).
+ *
+ *  :track_copies_same_commit_copies ::
+ *    If this value is +true+, lines that have been copied from another file
+ *    that exists in the same commit will be tracked (like `git blame -CC`).
+ *
+ *  :track_copies_any_commit_copies ::
+ *    If this value is +true+, lines that have been copied from another file
+ *    that exists in *any* commit will be tracked (like `git blame -CCC`).
+ *
+ */
+static VALUE rb_git_blame_new(int argc, VALUE *argv, VALUE klass)
+{
+	VALUE rb_repo, rb_path, rb_options;
+	git_repository *repo;
+	git_blame *blame;
+	git_blame_options opts = GIT_BLAME_OPTIONS_INIT;
+
+	rb_scan_args(argc, argv, "20:", &rb_repo, &rb_path, &rb_options);
+
+	rugged_check_repo(rb_repo);
+	Data_Get_Struct(rb_repo, git_repository, repo);
+
+	Check_Type(rb_path, T_STRING);
+
+	rugged_parse_blame_options(&opts, repo, rb_options);
+
+	rugged_exception_check(git_blame_file(
+		&blame, repo, StringValueCStr(rb_path), &opts
+	));
+
+	return Data_Wrap_Struct(klass, NULL, &git_blame_free, blame);
+}
+
+/*
+ *  call-seq:
+ *    blame.for_line(line_no) -> hunk
+ *
+ *  Returns the blame hunk data for the given +line_no+ in +blame+.
+ *  Line number counting starts with +1+.
+ */
+static VALUE rb_git_blame_for_line(VALUE self, VALUE rb_line_no)
+{
+	git_blame *blame;
+	int line_no;
+
+	Data_Get_Struct(self, git_blame, blame);
+	Check_Type(rb_line_no, T_FIXNUM);
+
+	line_no = NUM2INT(rb_line_no);
+
+	if (line_no < 0) {
+		rb_raise(rb_eArgError, "line number can't be negative");
+	}
+
+	return rb_git_blame_hunk_fromC(
+		git_blame_get_hunk_byline(blame, (uint32_t)line_no)
+	);
+}
+
+/*
+ *  call-seq:
+ *    blame.count -> count
+ *    blame.size -> count
+ *
+ *  Returns the total +count+ of blame hunks in +blame+.
+ */
+static VALUE rb_git_blame_count(VALUE self)
+{
+	git_blame *blame;
+	Data_Get_Struct(self, git_blame, blame);
+	return UINT2NUM(git_blame_get_hunk_count(blame));
+}
+
+static VALUE rugged_blame_enum_size(VALUE rb_blame, VALUE rb_args, VALUE rb_eobj)
+{
+	return rb_git_blame_count(rb_blame);
+}
+
+/*
+ *  call-seq:
+ *    blame[index] -> hunk
+ *
+ *  Returns the blame hunk data at the given +index+ in +blame+.
+ *
+ *  Negative indices count backward from the end of the blame hunks (-1 is the last
+ *  element).
+ *
+ *  Returns +nil+ if no blame hunk exists at the given +index+.
+ */
+static VALUE rb_git_blame_get_by_index(VALUE self, VALUE rb_index)
+{
+	git_blame *blame;
+	int index;
+	uint32_t blame_count;
+
+	Data_Get_Struct(self, git_blame, blame);
+	Check_Type(rb_index, T_FIXNUM);
+
+	index = NUM2INT(rb_index);
+	blame_count = git_blame_get_hunk_count(blame);
+
+	if (index < 0) {
+		if ((uint32_t)(-index) > blame_count) {
+			return Qnil;
+		}
+
+		return rb_git_blame_hunk_fromC(
+			git_blame_get_hunk_byindex(blame, (uint32_t)(blame_count + index))
+		);
+	}
+
+	if ((uint32_t)index > blame_count)
+		return Qnil;
+
+	return rb_git_blame_hunk_fromC(
+		git_blame_get_hunk_byindex(blame, (uint32_t)index)
+	);
+}
+
+/*
+ *  call-seq:
+ *    blame.each { |hunk| ... } -> blame
+ *    blame.each -> enumerator
+ *
+ *  If given a block, yields each +hunk+ that is part of +blame+.
+ *  If no block is given, an enumerator will be returned.
+ */
+static VALUE rb_git_blame_each(VALUE self)
+{
+	git_blame *blame;
+	uint32_t i, blame_count;
+
+	RETURN_SIZED_ENUMERATOR(self, 0, 0, rugged_blame_enum_size);
+
+	Data_Get_Struct(self, git_blame, blame);
+
+	blame_count = git_blame_get_hunk_count(blame);
+	for (i = 0; i < blame_count; ++i) {
+		rb_yield(rb_git_blame_hunk_fromC(
+			git_blame_get_hunk_byindex(blame, i)
+		));
+	}
+
+	return self;
+}
+
+void Init_rugged_blame(void)
+{
+	rb_cRuggedBlame = rb_define_class_under(rb_mRugged, "Blame", rb_cObject);
+	rb_include_module(rb_cRuggedBlame, rb_mEnumerable);
+
+	rb_define_singleton_method(rb_cRuggedBlame, "new", rb_git_blame_new, -1);
+
+	rb_define_method(rb_cRuggedBlame, "[]", rb_git_blame_get_by_index, 1);
+	rb_define_method(rb_cRuggedBlame, "for_line", rb_git_blame_for_line, 1);
+
+	rb_define_method(rb_cRuggedBlame, "count", rb_git_blame_count, 0);
+	rb_define_method(rb_cRuggedBlame, "size", rb_git_blame_count, 0);
+
+	rb_define_method(rb_cRuggedBlame, "each", rb_git_blame_each, 0);
+}