rugged 0.18.0.gh.de28323 → 0.19.0

data/README.md

@@ -17,6 +17,12 @@ Rugged is a self-contained gem. You can install it by running:
 
     $ gem install rugged
 
+If you're using bundler and want to bundle libgit2 with rugged, you can use the `:submodules` option:
+
+```ruby
+gem 'rugged', git: 'git://github.com/libgit2/rugged.git', branch: 'development', submodules: true
+```
+
 To load Rugged, you'll usually want to add something like this:
 
 ```ruby
@@ -34,17 +40,16 @@ at each area individually.
 #### Instantiation
 
 The repository is naturally central to Git. Rugged has a `Repository` class that
-you can instantiate with a path:
+you can instantiate with a path to open an existing repository :
 
 ```ruby
 repo = Rugged::Repository.new('path/to/my/repository')
 # => #<Rugged::Repository:2228536260 {path: "path/to/my/repository/.git/"}>
 ```
 
-If you're working against a bare repository, you'll need to indicate that:
+You can create a new repository with `init_at`. Add a second parameter `:bare` to make a bare repository:
 
 ```ruby
-# Second parameter indicates whether the repo is a bare repository
 Rugged::Repository.init_at('.', :bare)
 ```
 
@@ -171,7 +176,7 @@ commit.tree
 # => #<Rugged::Tree:2245269740>
 
 commit.parents
-=> [#<Rugged::Commit:2245264600 {message: "Merge pull request #47 from isaac/remotes\n\nAdd Rugged::Repository#remotes", tree: #<Rugged::Tree:2245264240 {oid: 6a2aee58a41fa007d07aa55565e2231f9b39b4a9}>
+# => [#<Rugged::Commit:2245264600 {message: "Merge pull request #47 from isaac/remotes\n\nAdd Rugged::Repository#remotes", tree: #<Rugged::Tree:2245264240 {oid: 6a2aee58a41fa007d07aa55565e2231f9b39b4a9}>]
 ```
 
 You can also write new objects to the database this way:

data/Rakefile

@@ -30,7 +30,7 @@ Rake::Task[:clean].prerequisites << :embedded_clean
 
 desc "Open an irb session preloaded with Rugged"
 task :console do
-  sh "irb -rubygems -I lib -r ./lib/rugged"
+  exec "script/console"
 end
 
 #

data/ext/rugged/extconf.rb

@@ -1,5 +1,15 @@
 require 'mkmf'
 
+RbConfig::MAKEFILE_CONFIG['CC'] = ENV['CC'] if ENV['CC']
+
+$CFLAGS << " #{ENV["CFLAGS"]}"
+$CFLAGS << " -g"
+
+if RbConfig::MAKEFILE_CONFIG['CC'] =~ /gcc|clang/
+  $CFLAGS << " -O3" unless $CFLAGS[/-O\d/]
+  $CFLAGS << " -Wall"
+end
+
 def sys(cmd)
   puts " -- #{cmd}"
   unless ret = xsystem(cmd)

data/ext/rugged/rugged.c

@@ -25,21 +25,28 @@
 #include "rugged.h"
 
 const char *RUGGED_ERROR_NAMES[] = {
-	"NoMemError", /* GITERR_NOMEMORY, */
-	"OSError", /* GITERR_OS, */
-	"InvalidError", /* GITERR_INVALID, */
-	"ReferenceError", /* GITERR_REFERENCE, */
-	"ZlibError", /* GITERR_ZLIB, */
+	"NoMemError",      /* 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, */
+	"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, */
+	"SslError",        /* GITERR_SSL, */
+	"SubmoduleError",  /* GITERR_SUBMODULE, */
+	"ThreadError",     /* GITERR_THREAD, */
+	"StashError",      /* GITERR_STASH, */
+	"CheckoutError",   /* GITERR_CHECKOUT, */
+	"FetchheadError",  /* GITERR_FETCHHEAD, */
+	"MergeError",      /* GITERR_MERGE, */
 };
 
 #define RUGGED_ERROR_COUNT (int)((sizeof(RUGGED_ERROR_NAMES)/sizeof(RUGGED_ERROR_NAMES[0])))
@@ -51,15 +58,14 @@ VALUE rb_eRuggedErrors[RUGGED_ERROR_COUNT];
 static VALUE rb_mShutdownHook;
 
 /*
- *	call-seq:
- * 		Rugged.libgit2_version -> version
+ *  call-seq:
+ *     Rugged.libgit2_version -> version
  *
- *	Returns an array representing the current libgit2 version in use. Using
- *	the array makes it easier for the end-user to take conditional actions
- *	based on each respective version attribute: major, minor, rev.
+ *  Returns an array representing the current libgit2 version in use. Using
+ *  the array makes it easier for the end-user to take conditional actions
+ *  based on each respective version attribute: major, minor, rev.
  *
- *	Rugged.libgit2_version
- *		#=> [0, 17, 0]
+ *    Rugged.libgit2_version #=> [0, 17, 0]
  */
 static VALUE rb_git_libgit2_version(VALUE self)
 {
@@ -70,22 +76,21 @@ static VALUE rb_git_libgit2_version(VALUE self)
 	git_libgit2_version(&major, &minor, &rev);
 
 	// We return an array of three elements to represent the version components
-	return rb_ary_new3(3, INT2NUM(major), INT2NUM(minor), INT2NUM(rev)); 
+	return rb_ary_new3(3, INT2NUM(major), INT2NUM(minor), INT2NUM(rev));
 }
 
 /*
- *	call-seq:
- * 		Rugged.capabilities-> capabilities
+ *  call-seq:
+ *     Rugged.capabilities -> capabilities
  *
- *	Returns an array representing the 'capabilities' that libgit2 was compiled
- *	with — this includes GIT_CAP_THREADS (thread support) and GIT_CAP_HTTPS (https).
- *	This is implemented in libgit2 with simple bitwise ops; we offer Rubyland an array
- *	of symbols representing the capabilities.
+ *  Returns an array representing the 'capabilities' that libgit2 was compiled
+ *  with — this includes GIT_CAP_THREADS (thread support) and GIT_CAP_HTTPS (https).
+ *  This is implemented in libgit2 with simple bitwise ops; we offer Rubyland an array
+ *  of symbols representing the capabilities.
  *
- *	The possible capabilities are "threads" and "https".
+ *  The possible capabilities are "threads" and "https".
  *
- *	Rugged.capabilities
- *		#=> [:threads, :https]
+ *    Rugged.capabilities #=> [:threads, :https]
  */
 static VALUE rb_git_capabilities(VALUE self)
 {
@@ -103,14 +108,14 @@ static VALUE rb_git_capabilities(VALUE self)
 }
 
 /*
- *	call-seq:
- *		Rugged.hex_to_raw(oid) -> raw_buffer
+ *  call-seq:
+ *    Rugged.hex_to_raw(oid) -> raw_buffer
  *
- *	Turn a string of 40 hexadecimal characters into the buffer of
- *	20 bytes it represents.
+ *  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?"
+ *    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)
 {
@@ -119,18 +124,18 @@ static VALUE rb_git_hex_to_raw(VALUE self, VALUE hex)
 	Check_Type(hex, T_STRING);
 	rugged_exception_check(git_oid_fromstr(&oid, StringValueCStr(hex)));
 
-	return rugged_str_ascii((const char *)oid.id, 20);
+	return rb_str_new((const char *)oid.id, 20);
 }
 
 /*
- *	call-seq:
- *		Rugged.raw_to_hex(buffer) -> hex_oid
+ *  call-seq:
+ *    Rugged.raw_to_hex(buffer) -> hex_oid
  *
- *	Turn a buffer of 20 bytes (representing a SHA1 OID) into its
- *	readable hexadecimal representation.
+ *  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"
+ *    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)
 {
@@ -145,15 +150,15 @@ static VALUE rb_git_raw_to_hex(VALUE self, VALUE raw)
 	git_oid_fromraw(&oid, (const unsigned char *)RSTRING_PTR(raw));
 	git_oid_fmt(out, &oid);
 
-	return rugged_str_new(out, 40, NULL);
+	return rb_str_new(out, 40);
 }
 
 /*
- *	call-seq:
- *		Rugged.prettify_message(message, strip_comments) -> clean_message
+ *  call-seq:
+ *    Rugged.prettify_message(message, strip_comments) -> clean_message
  *
- *	Process a commit or tag message into standard form, by stripping trailing spaces and
- *	comments, and making sure that the message has a proper header line.
+ *  Process a commit or tag message into standard form, by stripping trailing spaces and
+ *  comments, and making sure that the message has a proper header line.
  */
 static VALUE rb_git_prettify_message(VALUE self, VALUE rb_message, VALUE rb_strip_comments)
 {
@@ -170,7 +175,7 @@ static VALUE rb_git_prettify_message(VALUE self, VALUE rb_message, VALUE rb_stri
 	message_len = git_message_prettify(message, message_len, StringValueCStr(rb_message), strip_comments);
 	rugged_exception_check(message_len);
 
-	result = rugged_str_new(message, message_len - 1, rb_utf8_encoding());
+	result = rb_enc_str_new(message, message_len - 1, rb_utf8_encoding());
 	xfree(message);
 
 	return result;
@@ -191,45 +196,45 @@ static VALUE minimize_yield(VALUE rb_oid, VALUE *data)
 }
 
 /*
- *	call-seq:
- *		Rugged.minimize_oid(oid_iterator, min_length = 7) { |short_oid| block }
- *		Rugged.minimize_oid(oid_iterator, min_length = 7) -> min_length
+ *  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.
+ *  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.
+ *  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:
+ *  If no +block+ is given, the function will return the minimal length as an
+ *  integer value:
  *
- *		oids = [
- *			'd8786bfc974aaaaaaaaaaaaaaaaaaaaaaaaaaaaa',
- *			'd8786bfc974bbbbbbbbbbbbbbbbbbbbbbbbbbbbb',
- *			'd8786bfc974ccccccccccccccccccccccccccccc',
- *			'68d041ee999cb07c6496fbdd4f384095de6ca9e1',
- *		]
+ *    oids = [
+ *      'd8786bfc974aaaaaaaaaaaaaaaaaaaaaaaaaaaaa',
+ *      'd8786bfc974bbbbbbbbbbbbbbbbbbbbbbbbbbbbb',
+ *      'd8786bfc974ccccccccccccccccccccccccccccc',
+ *      '68d041ee999cb07c6496fbdd4f384095de6ca9e1',
+ *    ]
  *
- *		Rugged.minimize_oids(oids) #=> 12
+ *    Rugged.minimize_oids(oids) #=> 12
  *
- *	If a +block+ is given, it will be called with each OID from +iterator+
- *	in its minified form:
+ *  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 }
+ *    Rugged.minimize_oid(oids) { |oid| puts oid }
  *
- *	produces:
+ *  produces:
  *
- *		d8786bfc974a
- *		d8786bfc974b
- *		d8786bfc974c
- *		68d041ee999c
+ *    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.
+ *  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
+ *    Rugged.minimize_oid(oids, 18) #=> 18
  */
 static VALUE rb_git_minimize_oid(int argc, VALUE *argv, VALUE self)
 {
@@ -251,20 +256,20 @@ static VALUE rb_git_minimize_oid(int argc, VALUE *argv, VALUE self)
 
 	rb_iterate(rb_each, rb_enum, &minimize_cb, (VALUE)shrt);
 	length = git_oid_shorten_add(shrt, NULL);
+
+	git_oid_shorten_free(shrt);
 	rugged_exception_check(length);
 
-	if (RTEST(rb_block)) {
+	if (!NIL_P(rb_block)) {
 		VALUE yield_data[2];
 
 		yield_data[0] = rb_block;
 		yield_data[1] = INT2FIX(length);
 
 		rb_iterate(rb_each, rb_enum, &minimize_yield, (VALUE)yield_data);
-		git_oid_shorten_free(shrt);
 		return Qnil;
 	}
 
-	git_oid_shorten_free(shrt);
 	return INT2FIX(length);
 }
 
@@ -274,10 +279,9 @@ static void cleanup_cb(void *unused)
 	git_threads_shutdown();
 }
 
-void rugged_exception_raise(int errorcode)
+void rugged_exception_raise(void)
 {
-	VALUE err_klass = rb_eRuggedError;
-	VALUE err_obj;
+	VALUE err_klass, err_obj;
 	const git_error *error;
 	const char *err_message;
 
@@ -296,7 +300,64 @@ void rugged_exception_raise(int errorcode)
 	rb_exc_raise(err_obj);
 }
 
-void Init_rugged()
+/*
+ *  call-seq:
+ *    Rugged.__cache_usage__ -> [current, max]
+ *
+ *  Returns an array representing the current bytes in the internal
+ *  libgit2 cache and the maximum size of the cache.
+ */
+static VALUE rb_git_cache_usage(VALUE self)
+{
+	int64_t used, max;
+	git_libgit2_opts(GIT_OPT_GET_CACHED_MEMORY, &used, &max);
+	return rb_ary_new3(2, LL2NUM(used), LL2NUM(max));
+}
+
+VALUE rugged_strarray_to_rb_ary(git_strarray *str_array)
+{
+	VALUE rb_array = rb_ary_new2(str_array->count);
+	size_t i;
+
+	for (i = 0; i < str_array->count; ++i) {
+		rb_ary_push(rb_array, rb_str_new_utf8(str_array->strings[i]));
+	}
+
+	return rb_array;
+}
+
+void rugged_rb_ary_to_strarray(VALUE rb_array, git_strarray *str_array)
+{
+	int i;
+
+	str_array->strings = NULL;
+	str_array->count = 0;
+
+	if (NIL_P(rb_array))
+		return;
+
+	if (TYPE(rb_array) == T_STRING) {
+		str_array->count = 1;
+		str_array->strings = xmalloc(sizeof(char *));
+		str_array->strings[0] = StringValueCStr(rb_array);
+		return;
+	}
+
+	Check_Type(rb_array, T_ARRAY);
+
+	for (i = 0; i < RARRAY_LEN(rb_array); ++i)
+		Check_Type(rb_ary_entry(rb_array, i), T_STRING);
+
+	str_array->count = RARRAY_LEN(rb_array);
+	str_array->strings = xmalloc(str_array->count * sizeof(char *));
+
+	for (i = 0; i < RARRAY_LEN(rb_array); ++i) {
+		VALUE rb_string = rb_ary_entry(rb_array, i);
+		str_array->strings[i] = StringValueCStr(rb_string);
+	}
+}
+
+void Init_rugged(void)
 {
 	rb_mRugged = rb_define_module("Rugged");
 
@@ -316,11 +377,12 @@ void Init_rugged()
 	}
 
 	rb_define_module_function(rb_mRugged, "libgit2_version", rb_git_libgit2_version, 0);
-	rb_define_module_function(rb_mRugged, "capabilities", rb_git_capabilities, 0);  
+	rb_define_module_function(rb_mRugged, "capabilities", rb_git_capabilities, 0);
 	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, "minimize_oid", rb_git_minimize_oid, -1);
 	rb_define_module_function(rb_mRugged, "prettify_message", rb_git_prettify_message, 2);
+	rb_define_module_function(rb_mRugged, "__cache_usage__", rb_git_cache_usage, 0);
 
 	Init_rugged_object();
 	Init_rugged_commit();
@@ -337,6 +399,11 @@ void Init_rugged()
 	Init_rugged_remote();
 	Init_rugged_notes();
 	Init_rugged_settings();
+	Init_rugged_diff();
+	Init_rugged_diff_patch();
+	Init_rugged_diff_delta();
+	Init_rugged_diff_hunk();
+	Init_rugged_diff_line();
 
 	/* Constants */
 	rb_define_const(rb_mRugged, "SORT_NONE", INT2FIX(0));

data/ext/rugged/rugged.h

@@ -31,34 +31,41 @@
 #define RSTRING_NOT_MODIFIED
 
 #include <ruby.h>
-
-#ifdef HAVE_RUBY_ENCODING_H
-#	include <ruby/encoding.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 Init_rugged_branch();
-void Init_rugged_commit();
-void Init_rugged_tree();
-void Init_rugged_tag();
-void Init_rugged_blob();
-void Init_rugged_index();
-void Init_rugged_repo();
-void Init_rugged_revwalk();
-void Init_rugged_reference();
-void Init_rugged_config();
-void Init_rugged_remote();
-void Init_rugged_notes();
-void Init_rugged_settings();
+void Init_rugged_object(void);
+void Init_rugged_branch(void);
+void Init_rugged_commit(void);
+void Init_rugged_tree(void);
+void Init_rugged_tag(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_config(void);
+void Init_rugged_remote(void);
+void Init_rugged_notes(void);
+void Init_rugged_settings(void);
+void Init_rugged_diff(void);
+void Init_rugged_diff_patch(void);
+void Init_rugged_diff_delta(void);
+void Init_rugged_diff_hunk(void);
+void Init_rugged_diff_line(void);
 
 VALUE rb_git_object_init(git_otype type, int argc, VALUE *argv, VALUE self);
 
@@ -69,14 +76,25 @@ VALUE rugged_signature_new(const git_signature *sig, const char *encoding_name);
 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_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);
+
+void rugged_parse_diff_options(git_diff_options *opts, VALUE rb_options);
 
 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_get(git_repository *repo, VALUE object_value, git_otype type);
-void rugged_oid_get(git_oid *oid, git_repository *repo, VALUE p);
+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)
 {
@@ -88,12 +106,12 @@ static inline VALUE rugged_owner(VALUE object)
 	return rb_iv_get(object, "@owner");
 }
 
-extern void rugged_exception_raise(int errorcode);
+extern void rugged_exception_raise(void);
 
 static inline void rugged_exception_check(int errorcode)
 {
 	if (errorcode < 0)
-		rugged_exception_raise(errorcode);
+		rugged_exception_raise();
 }
 
 static inline int rugged_parse_bool(VALUE boolean)
@@ -106,29 +124,22 @@ static inline int rugged_parse_bool(VALUE boolean)
 
 extern VALUE rb_cRuggedRepo;
 
+struct rugged_cb_payload {
+    VALUE rb_data;
+    int exception;
+};
+
 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");
 }
 
-/* support for string encodings in 1.9 */
-#ifdef HAVE_RUBY_ENCODING_H
-#	define rugged_str_new(str, len, enc) rb_enc_str_new(str, len, enc)
-#	define rugged_str_new2(str, enc) rb_enc_str_new(str, strlen(str), enc)
-#	define rugged_str_ascii(str, len) rb_enc_str_new(str, len, rb_ascii8bit_encoding());
-
-#else
-#	define rugged_str_new(str, len, rb_enc)  rb_str_new(str, len)
-#	define rugged_str_new2(str, rb_enc) rb_str_new2(str)
-#	define rugged_str_ascii(str, len) rb_str_new(str, len)
-#endif
-
 static inline VALUE rugged_create_oid(const git_oid *oid)
 {
 	char out[40];
 	git_oid_fmt(out, oid);
-	return rugged_str_new(out, 40, NULL);
+	return rb_str_new(out, 40);
 }
 
 #endif