rugged 0.16.0 → 0.17.0b1

data/ext/rugged/rugged.c

@@ -2,17 +2,17 @@
  * The MIT License
  *
  * Copyright (c) 2011 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
@@ -24,9 +24,42 @@
 
 #include "rugged.h"
 
+const char *RUGGED_ERROR_NAMES[] = {
+	NULL, /* GITERR_NOMEMORY, */
+	"OSError", /* GITERR_OS, */
+	"InvalidError", /* GITERR_INVALID, */
+	"ReferenceError", /* GITERR_REFERENCE, */
+	"ZlibError", /* GITERR_ZLIB, */
+	"RepositoryError", /* GITERR_REPOSITORY, */
+	"ConfigError", /* GITERR_CONFIG, */
+	"RegexError", /* GITERR_REGEX, */
+	"OdbError", /* GITERR_ODB, */
+	"IndexError", /* GITERR_INDEX, */
+	"ObjectError", /* GITERR_OBJECT, */
+	"NetworkError" /* GITERR_NET, */
+	"TagError", /* GITERR_TAG, */
+	"TreeError", /* GITERR_TREE, */
+	"IndexerError", /* GITERR_INDEXER, */
+};
+
+#define RUGGED_ERROR_COUNT ((sizeof(RUGGED_ERROR_NAMES)/sizeof(RUGGED_ERROR_NAMES[0])))
+
 VALUE rb_mRugged;
+VALUE rb_eRuggedError;
+VALUE rb_eRuggedErrors[RUGGED_ERROR_COUNT];
+
 static VALUE rb_mShutdownHook;
 
+/*
+ *	call-seq:
+ *		Rugged.hex_to_raw(oid) -> raw_buffer
+ *
+ *	Turn a string of 40 hexadecimal characters into the buffer of
+ *	20 bytes it represents.
+ *
+ *		Rugged.hex_to_raw('d8786bfc97485e8d7b19b21fb88c8ef1f199fc3f')
+ *		#=> "\330xk\374\227H^\215{\031\262\037\270\214\216\361\361\231\374?"
+ */
 static VALUE rb_git_hex_to_raw(VALUE self, VALUE hex)
 {
 	git_oid oid;
@@ -37,31 +70,30 @@ static VALUE rb_git_hex_to_raw(VALUE self, VALUE hex)
 	return rugged_str_ascii(oid.id, 20);
 }
 
+/*
+ *	call-seq:
+ *		Rugged.raw_to_hex(buffer) -> hex_oid
+ *
+ *	Turn a buffer of 20 bytes (representing a SHA1 OID) into its
+ *	readable hexadecimal representation.
+ *
+ *		Rugged.raw_to_hex("\330xk\374\227H^\215{\031\262\037\270\214\216\361\361\231\374?")
+ *		#=> "d8786bfc97485e8d7b19b21fb88c8ef1f199fc3f"
+ */
 static VALUE rb_git_raw_to_hex(VALUE self, VALUE raw)
 {
 	git_oid oid;
 	char out[40];
 
 	Check_Type(raw, T_STRING);
-	git_oid_fromraw(&oid, StringValueCStr(raw));
-	git_oid_fmt(out, &oid);
-
-	return rugged_str_new(out, 40, NULL);
-}
 
-static VALUE rb_git_type_to_string(VALUE self, VALUE type)
-{
-	const char *str;
+	if (RSTRING_LEN(raw) != GIT_OID_RAWSZ)
+		rb_raise(rb_eTypeError, "Invalid buffer size for an OID");
 
-	Check_Type(type, T_FIXNUM);
-	str = git_object_type2string(FIX2INT(type));
-	return str ? rugged_str_new2(str, NULL) : Qfalse;
-}
+	git_oid_fromraw(&oid, RSTRING_PTR(raw));
+	git_oid_fmt(out, &oid);
 
-static VALUE rb_git_string_to_type(VALUE self, VALUE string_type)
-{
-	Check_Type(string_type, T_STRING);
-	return INT2FIX(git_object_string2type(StringValueCStr(string_type)));
+	return rugged_str_new(out, 40, NULL);
 }
 
 static VALUE minimize_cb(VALUE rb_oid, git_oid_shorten *shortener)
@@ -78,6 +110,47 @@ static VALUE minimize_yield(VALUE rb_oid, VALUE *data)
 	return Qnil;
 }
 
+/*
+ *	call-seq:
+ *		Rugged.minimize_oid(oid_iterator, min_length = 7) { |short_oid| block }
+ *		Rugged.minimize_oid(oid_iterator, min_length = 7) -> min_length
+ *
+ *	Iterate through +oid_iterator+, which should yield any number of SHA1 OIDs
+ *	(represented as 40-character hexadecimal strings), and tries to minify them.
+ *
+ *	Minifying a set of a SHA1 strings means finding the shortest root substring
+ *	for each string that uniquely identifies it.
+ *
+ *	If no +block+ is given, the function will return the minimal length as an
+ *	integer value:
+ *
+ *		oids = [
+ *			'd8786bfc974aaaaaaaaaaaaaaaaaaaaaaaaaaaaa',
+ *			'd8786bfc974bbbbbbbbbbbbbbbbbbbbbbbbbbbbb',
+ *			'd8786bfc974ccccccccccccccccccccccccccccc',
+ *			'68d041ee999cb07c6496fbdd4f384095de6ca9e1',
+ *		]
+ *
+ *		Rugged.minimize_oids(oids) #=> 12
+ *
+ *	If a +block+ is given, it will be called with each OID from +iterator+
+ *	in its minified form:
+ *
+ *		Rugged.minimize_oids(oids) { |oid| puts oid }
+ *
+ *	produces:
+ *
+ *		d8786bfc974a
+ *		d8786bfc974b
+ *		d8786bfc974c
+ *		68d041ee999c
+ *
+ *	The optional +min_length+ argument allows you to specify a lower bound for
+ *	the minified strings; returned strings won't be shorter than the given value,
+ *	even if they would still be uniquely represented.
+ *
+ *		Rugged.minimize_oids(oids, 18) #=> 18
+ */
 static VALUE rb_git_minimize_oid(int argc, VALUE *argv, VALUE self)
 {
 	git_oid_shorten *shrt;
@@ -121,14 +194,43 @@ static void cleanup_cb(void *unused)
 	git_threads_shutdown();
 }
 
+void rugged_exception_raise(int errorcode)
+{
+	VALUE err_klass = rb_eRuggedError;
+	VALUE err_obj;
+	const git_error *error;
+
+	error = giterr_last();
+
+	if (!error)
+		return;
+
+	if (error->klass >= 0 && error->klass < RUGGED_ERROR_COUNT)
+		err_klass = rb_eRuggedErrors[error->klass];
+
+	err_obj = rb_exc_new2(err_klass, error->message);
+	giterr_clear();
+	rb_exc_raise(err_obj);
+}
+
 void Init_rugged()
 {
 	rb_mRugged = rb_define_module("Rugged");
 
+	/* Initialize the Error classes */
+	{
+		int i;
+
+		rb_eRuggedError = rb_define_class_under(rb_mRugged, "Error", rb_eStandardError);
+		rb_eRuggedErrors[0] = rb_eNoMemError;
+
+		for (i = 1; i < RUGGED_ERROR_COUNT; ++i) {
+			rb_eRuggedErrors[i] = rb_define_class_under(rb_mRugged, RUGGED_ERROR_NAMES[i], rb_eRuggedError);
+		}
+	}
+
 	rb_define_module_function(rb_mRugged, "hex_to_raw", rb_git_hex_to_raw, 1);
 	rb_define_module_function(rb_mRugged, "raw_to_hex", rb_git_raw_to_hex, 1);
-	rb_define_module_function(rb_mRugged, "type_to_string", rb_git_type_to_string, 1);
-	rb_define_module_function(rb_mRugged, "string_to_type", rb_git_string_to_type, 1);
 	rb_define_module_function(rb_mRugged, "minimize_oid", rb_git_minimize_oid, -1);
 
 	Init_rugged_object();
@@ -150,16 +252,6 @@ void Init_rugged()
 	rb_define_const(rb_mRugged, "SORT_DATE", INT2FIX(2));
 	rb_define_const(rb_mRugged, "SORT_REVERSE", INT2FIX(4));
 
-	rb_define_const(rb_mRugged, "OBJ_ANY", INT2FIX(GIT_OBJ_ANY));
-	rb_define_const(rb_mRugged, "OBJ_BAD", INT2FIX(GIT_OBJ_BAD));
-	rb_define_const(rb_mRugged, "OBJ_COMMIT", INT2FIX(GIT_OBJ_COMMIT));
-	rb_define_const(rb_mRugged, "OBJ_TREE", INT2FIX(GIT_OBJ_TREE));
-	rb_define_const(rb_mRugged, "OBJ_BLOB", INT2FIX(GIT_OBJ_BLOB));
-	rb_define_const(rb_mRugged, "OBJ_TAG", INT2FIX(GIT_OBJ_TAG));
-
-	rb_define_const(rb_mRugged, "REF_OID", INT2FIX(GIT_REF_OID));
-	rb_define_const(rb_mRugged, "REF_SYMBOLIC", INT2FIX(GIT_REF_SYMBOLIC));
-
 	/* Initialize libgit2 */
 	git_threads_init();
 

data/ext/rugged/rugged.h

@@ -2,17 +2,17 @@
  * The MIT License
  *
  * Copyright (c) 2011 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
@@ -40,8 +40,10 @@
 #include <git2.h>
 #include <git2/odb_backend.h>
 
+#define CSTR2SYM(s) (ID2SYM(rb_intern((s))))
+
 /*
- * Initialization functions 
+ * Initialization functions
  */
 void Init_rugged_object();
 void Init_rugged_commit();
@@ -65,13 +67,12 @@ VALUE rugged_index_new(VALUE klass, VALUE owner, git_index *index);
 VALUE rugged_object_new(VALUE owner, git_object *object);
 VALUE rugged_config_new(VALUE klass, VALUE owner, git_config *cfg);
 
-git_otype rugged_get_otype(VALUE rb_type);
+VALUE rugged_otype_new(git_otype t);
+git_otype rugged_otype_get(VALUE rb_type);
 
 git_signature *rugged_signature_get(VALUE rb_person);
 git_object *rugged_object_load(git_repository *repo, VALUE object_value, git_otype type);
 
-#define CSTR2SYM(s) (ID2SYM(rb_intern((s))))
-
 static inline void rugged_set_owner(VALUE object, VALUE owner)
 {
 	rb_iv_set(object, "@owner", owner);
@@ -82,12 +83,12 @@ static inline VALUE rugged_owner(VALUE object)
 	rb_iv_get(object, "@owner");
 }
 
+extern void rugged_exception_raise(int errorcode);
+
 static inline void rugged_exception_check(int errorcode)
 {
 	if (errorcode < 0)
-		rb_raise(rb_eRuntimeError, "%s\n(error code %d)", git_lasterror(), errorcode);
-
-	git_clearerror();
+		rugged_exception_raise(errorcode);
 }
 
 static inline int rugged_parse_bool(VALUE boolean)

data/ext/rugged/rugged_blob.c

@@ -2,17 +2,17 @@
  * The MIT License
  *
  * Copyright (c) 2011 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
@@ -30,14 +30,101 @@ extern VALUE rb_cRuggedRepo;
 
 VALUE rb_cRuggedBlob;
 
-static VALUE rb_git_blob_content_GET(VALUE self)
+/*
+ *	call-seq:
+ *		blob.text(max_lines = -1, encoding = Encoding.default_external) -> String
+ *
+ *	Return up to +max_lines+ of text from a blob as a +String+.
+ *
+ *	In Ruby 1.9.x, the string is created with the given +encoding+,
+ *	defaulting to Encoding.default_external.
+ *
+ *	In previous versions, the +encoding+ argument is dummy and has no
+ *	effect on the returned string.
+ *
+ *	When limiting the size of the text with +max_lines+, the string is
+ *	expected to have an ASCII-compatible encoding, and is checked
+ *	for the newline +\n+ character.
+ */
+static VALUE rb_git_blob_text_GET(int argc, VALUE *argv, VALUE self)
 {
+#ifdef HAVE_RUBY_ENCODING_H
+	rb_encoding *encoding = rb_default_external_encoding();
+#endif
+
 	git_blob *blob;
 	size_t size;
+	const char *content;
+	VALUE rb_max_lines, rb_encoding;
 
 	Data_Get_Struct(self, git_blob, blob);
-	
+	rb_scan_args(argc, argv, "02", &rb_max_lines, &rb_encoding);
+
+	content = git_blob_rawcontent(blob);
 	size = git_blob_rawsize(blob);
+
+	if (!NIL_P(rb_max_lines)) {
+		size_t i = 0;
+		int lines = 0, maxlines;
+
+		Check_Type(rb_max_lines, T_FIXNUM);
+		maxlines = FIX2INT(rb_max_lines);
+
+		if (maxlines >= 0) {
+			while (i < size && lines < maxlines) {
+				if (content[i++] == '\n')
+					lines++;
+			}
+		}
+
+		size = (size_t)i;
+	}
+
+#ifdef HAVE_RUBY_ENCODING_H
+	if (!NIL_P(rb_encoding)) {
+		encoding = rb_to_encoding(rb_encoding);
+	}
+#endif
+
+	if (size == 0)
+		return rugged_str_new("", 0, encoding);
+
+	return rugged_str_new(content, size, encoding);
+}
+
+/*
+ *	call-seq:
+ *		blob.content(max_bytes=-1) -> String
+ *
+ *	Return up to +max_bytes+ from the contents of a blob as bytes +String+.
+ *	If max_bytes is less than 0, the full string is returned.
+ *
+ *	In Ruby 1.9.x, this string is tagged with the ASCII-8BIT encoding: the
+ *	bytes are returned as-is, since Git is encoding agnostic.
+ */
+static VALUE rb_git_blob_content_GET(int argc, VALUE *argv, VALUE self)
+{
+	git_blob *blob;
+	size_t size;
+	const char *content;
+	VALUE rb_max_bytes;
+
+	Data_Get_Struct(self, git_blob, blob);
+	rb_scan_args(argc, argv, "01", &rb_max_bytes);
+
+	content = git_blob_rawcontent(blob);
+	size = git_blob_rawsize(blob);
+
+	if (!NIL_P(rb_max_bytes)) {
+		int maxbytes;
+
+		Check_Type(rb_max_bytes, T_FIXNUM);
+		maxbytes = FIX2INT(rb_max_bytes);
+
+		if (maxbytes >= 0 && (size_t)maxbytes < size)
+			size = (size_t)maxbytes;
+	}
+
 	if (size == 0)
 		return rugged_str_ascii("", 0);
 
@@ -50,9 +137,17 @@ static VALUE rb_git_blob_content_GET(VALUE self)
 	 * eventually end up converted to Encoding.default_internal because this
 	 * string could very well be binary data
 	 */
-	return rugged_str_ascii(git_blob_rawcontent(blob), size);
+	return rugged_str_ascii(content, size);
 }
 
+/*
+ *	call-seq:
+ *		blob.rawsize -> int
+ *
+ *	Return the size in bytes of the blob. This is the real,
+ *	uncompressed size and the length of +blob.content+, not
+ *	the compressed size.
+ */
 static VALUE rb_git_blob_rawsize(VALUE self)
 {
 	git_blob *blob;
@@ -61,39 +156,107 @@ static VALUE rb_git_blob_rawsize(VALUE self)
 	return INT2FIX(git_blob_rawsize(blob));
 }
 
-static VALUE rb_git_blob_create(int argc, VALUE *argv, VALUE self)
+/*
+ *	call-seq:
+ *		Blob.create(repository, bytes) -> oid
+ *
+ *	Write a blob to +repository+ with the contents specified
+ *	in +buffer+. In Ruby 1.9.x, the encoding of +buffer+ is
+ *	ignored and bytes are copied as-is.
+ */
+static VALUE rb_git_blob_create(VALUE self, VALUE rb_repo, VALUE rb_buffer)
 {
 	int error;
 	git_oid oid;
 	git_repository *repo;
 
-	VALUE rb_buffer, rb_repo, rb_is_buffer = Qfalse;
-
-	rb_scan_args(argc, argv, "21", &rb_repo, &rb_buffer, &rb_is_buffer);
-
 	Check_Type(rb_buffer, T_STRING);
 	if (!rb_obj_is_instance_of(rb_repo, rb_cRuggedRepo))
 		rb_raise(rb_eTypeError, "Expecting a Rugged Repository");
 
 	Data_Get_Struct(rb_repo, git_repository, repo);
 
-	if (rugged_parse_bool(rb_is_buffer)) {
-		error = git_blob_create_frombuffer(&oid, repo, RSTRING_PTR(rb_buffer), RSTRING_LEN(rb_buffer));
-	} else {
-		error = git_blob_create_fromfile(&oid, repo, StringValueCStr(rb_buffer));
-	}
+	error = git_blob_create_frombuffer(&oid, repo, RSTRING_PTR(rb_buffer), RSTRING_LEN(rb_buffer));
+	rugged_exception_check(error);
+
+	return rugged_create_oid(&oid);
+}
 
+/*
+ *	call-seq:
+ *		Blob.write_file(repository, file_path) -> oid
+ *
+ *	Write the file specified in +file_path+ to a blob in +repository+.
+ *	+file_path+ must be relative to the repository's working folder.
+ *
+ *		Blob.write_file(repo, 'src/blob.h') #=> '9d09060c850defbc7711d08b57def0d14e742f4e'
+ */
+static VALUE rb_git_blob_writefile(VALUE self, VALUE rb_repo, VALUE rb_path)
+{
+	int error;
+	git_oid oid;
+	git_repository *repo;
+
+	Check_Type(rb_path, T_STRING);
+	if (!rb_obj_is_instance_of(rb_repo, rb_cRuggedRepo))
+		rb_raise(rb_eTypeError, "Expecting a Rugged Repository");
+
+	Data_Get_Struct(rb_repo, git_repository, repo);
+
+	error = git_blob_create_fromfile(&oid, repo, StringValueCStr(rb_path));
 	rugged_exception_check(error);
 
 	return rugged_create_oid(&oid);
 }
 
+/*
+ *	call-seq:
+ *		blob.sloc -> Integer
+ *
+ *	Return the number of non-empty code lines for the blob,
+ *	assuming the blob is plaintext (i.e. not binary)
+ */
+static VALUE rb_git_blob_sloc(VALUE self)
+{
+	git_blob *blob;
+	const char *data, *data_end;
+	size_t sloc = 0;
+
+	Data_Get_Struct(self, git_blob, blob);
+
+	data = git_blob_rawcontent(blob);
+	data_end = data + git_blob_rawsize(blob);
+
+	if (data == data_end)
+		return INT2FIX(0);
+
+	/* go through the whole blob, counting lines
+	 * that are not empty */
+	while (data < data_end) {
+		if (*data++ == '\n') {
+			while (data < data_end && isspace(*data))
+				data++;
+
+			sloc++;
+		}
+	}
+
+	/* last line without trailing '\n'? */
+	if (data[-1] != '\n')
+		sloc++;
+
+	return INT2FIX(sloc);
+}
+
 void Init_rugged_blob()
 {
 	rb_cRuggedBlob = rb_define_class_under(rb_mRugged, "Blob", rb_cRuggedObject);
 
 	rb_define_method(rb_cRuggedBlob, "size", rb_git_blob_rawsize, 0);
-	rb_define_method(rb_cRuggedBlob, "content", rb_git_blob_content_GET, 0);
+	rb_define_method(rb_cRuggedBlob, "content", rb_git_blob_content_GET, -1);
+	rb_define_method(rb_cRuggedBlob, "text", rb_git_blob_text_GET, -1);
+	rb_define_method(rb_cRuggedBlob, "sloc", rb_git_blob_sloc, 0);
 
-	rb_define_singleton_method(rb_cRuggedBlob, "create", rb_git_blob_create, -1);
+	rb_define_singleton_method(rb_cRuggedBlob, "create", rb_git_blob_create, 2);
+	rb_define_singleton_method(rb_cRuggedBlob, "write_file", rb_git_blob_writefile, 2);
 }