rdavila-rugged 0.24.0b13

data/ext/rugged/rugged.h

@@ -0,0 +1,185 @@
+/*
+ * 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.
+ */
+
+#ifndef __H_RUGGED_BINDINGS__
+#define __H_RUGGED_BINDINGS__
+
+// tell rbx not to use it's caching compat layer
+// by doing this we're making a promize to RBX that
+// we'll never modify the pointers we get back from RSTRING_PTR
+#define RSTRING_NOT_MODIFIED
+
+#include <ruby.h>
+#ifndef HAVE_RUBY_ENCODING_H
+#error "Rugged requires Ruby 1.9+ to build"
+#else
+#include <ruby/encoding.h>
+#endif
+
+#include <assert.h>
+#include <git2.h>
+#include <git2/odb_backend.h>
+
+#define rb_str_new_utf8(str) rb_enc_str_new(str, strlen(str), rb_utf8_encoding())
+#define CSTR2SYM(s) (ID2SYM(rb_intern((s))))
+
+/*
+ * Initialization functions
+ */
+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_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);
+
+VALUE rb_git_object_init(git_otype type, int argc, VALUE *argv, VALUE self);
+
+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 *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, 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);
+
+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_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_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);
+
+void rugged_rb_ary_to_strarray(VALUE rb_array, git_strarray *str_array);
+VALUE rugged_strarray_to_rb_ary(git_strarray *str_array);
+
+static inline void rugged_set_owner(VALUE object, VALUE owner)
+{
+	rb_iv_set(object, "@owner", owner);
+}
+
+static inline VALUE rugged_owner(VALUE object)
+{
+	return rb_iv_get(object, "@owner");
+}
+
+extern void rugged_exception_raise(void);
+
+static inline void rugged_exception_check(int errorcode)
+{
+	if (errorcode < 0)
+		rugged_exception_raise();
+}
+
+static inline int rugged_parse_bool(VALUE boolean)
+{
+	if (TYPE(boolean) != T_TRUE && TYPE(boolean) != T_FALSE)
+		rb_raise(rb_eTypeError, "Expected boolean value");
+
+	return boolean ? 1 : 0;
+}
+
+extern VALUE rb_cRuggedRepo;
+
+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 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))
+		rb_raise(rb_eTypeError, "Expecting a Rugged Repository");
+}
+
+static inline VALUE rugged_create_oid(const git_oid *oid)
+{
+	char out[40];
+	git_oid_fmt(out, oid);
+	return rb_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;
+
+#endif

data/ext/rugged/rugged_backend.c

@@ -0,0 +1,34 @@
+/*
+ * 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;
+
+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,292 @@
+/*
+ * 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;
+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));
+}
+
+/*
+ *  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;
+
+	if (!rb_block_given_p()) {
+		return rb_funcall(self, rb_intern("to_enum"), 1, CSTR2SYM("each"), self);
+	}
+
+	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);
+}