rugged 0.17.0.b7 → 0.18.0.b1

data/LICENSE

@@ -1,6 +1,6 @@
 The MIT License
 
-Copyright (c) 2010 Scott Chacon
+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

data/README.md

@@ -1,7 +1,7 @@
 # Rugged
 **libgit2 bindings in Ruby**
 
-Rugged is a library for accessing libgit2 in Ruby. It gives you the speed and
+Rugged is a library for accessing [libgit2](https://github.com/libgit2/libgit2) in Ruby. It gives you the speed and
 portability of libgit2 with the beauty of the Ruby language.
 
 ### libgit2
@@ -45,7 +45,7 @@ If you're working against a bare repository, you'll need to indicate that:
 
 ```ruby
 # Second parameter indicates whether the repo is a bare repository
-Rugged::Repository.init_at('.', true)
+Rugged::Repository.init_at('.', :bare)
 ```
 
 You can also let Rugged discover the path to the .git directory if you give it a
@@ -98,7 +98,7 @@ object = repo.read('a0ae5566e3c8a3bddffab21022056f0b5e03ef07')
 object.len
 # => 237
 object.data
-# => "tree 76f23f186076fc291742816721ea8c3e95567241\nparent 8e3c5c52b8f29da0adc7e8be8a037cbeaea6de6b\nauthor Vicent Mart\303\255 <tanoku@gmail.com> 1333859005 +0200\ncommitter Vicent Mart\303\255 <tanoku@gmail.com> 1333859005 +0200\n\nAdd `Repository#file_at`\n"
+# => "tree 76f23f186076fc291742816721ea8c3e95567241\nparent 8e3c5c52b8f29da0adc7e8be8a037cbeaea6de6b\nauthor Vicent Mart\303\255 <tanoku@gmail.com> 1333859005 +0200\ncommitter Vicent Mart\303\255 <tanoku@gmail.com> 1333859005 +0200\n\nAdd `Repository#blob_at`\n"
 object.type
 # => :commit
 ```
@@ -109,12 +109,28 @@ There's a few ways to write to a repository. To write directly from your
 instantiated repository object:
 
 ```ruby
-sha = repo.hash(content, type)
 sha = repo.write(content, type)
 ```
 
 You can also use the `Commit` object directly to craft a commit; this is a bit
-more high-level, so it may be preferable.
+more high-level, so it may be preferable:
+
+```ruby
+oid = repo.write("This is a blob.", :blob)
+index = Rugged::Index.new
+index.add(:path => "README.md", :oid => oid, :mode => 0100644)
+
+options = {}
+options[:tree] = index.write_tree(repo)
+
+options[:author] = { :email => "testuser@github.com", :name => 'Test Author', :time => Time.now }
+options[:committer] = { :email => "testuser@github.com", :name => 'Test Author', :time => Time.now }
+options[:message] ||= "Making a commit via Rugged!"
+options[:parents] = repo.empty? ? [] : [ repo.head.target ].compact
+options[:update_ref] = 'HEAD'
+
+Rugged::Commit.create(repo, options)
+```
 
 ---
 
@@ -143,7 +159,7 @@ commit = repo.lookup('a0ae5566e3c8a3bddffab21022056f0b5e03ef07')
 # => #<Rugged::Commit:2245304380>
 
 commit.message
-# => "Add `Repository#file_at`\n"
+# => "Add `Repository#blob_at`\n"
 
 commit.time
 # => Sat Apr 07 21:23:25 -0700 2012
@@ -168,7 +184,8 @@ Rugged::Commit.create(r,
 	:message => "Hello world\n\n",
 	:committer => author,
 	:parents => ["2cb831a8aea28b2c1b9c63385585b864e4d3bad1"],
-	:tree => some_tree) #=> "f148106ca58764adc93ad4e2d6b1d168422b9796"
+	:tree => some_tree,
+	:update_ref => "HEAD") #=> "f148106ca58764adc93ad4e2d6b1d168422b9796"
 ```
 
 ### Tag Objects
@@ -178,7 +195,7 @@ tag  = repo.lookup(tag_sha)
 
 object = tag.target
 sha    = tag.target.oid
-str    = tag.target_type # "commit", "tag", "blob"
+str    = tag.target_type # :commit, :tag, :blob
 str    = tag.name        # "v1.0"
 str    = tag.message
 person = tag.tagger
@@ -216,14 +233,20 @@ tree.each_blob { |entry| puts entry[:name] }  # list only files
 You can also write trees with the `TreeBuilder`:
 
 ```ruby
-entry = {:type => :blob,
-         :name => "README.txt",
-         :oid  => "1385f264afb75a56a5bec74243be9b367ba4ca08",
-         :filemode => 33188}
-
+oid = repo.write("This is a blob.", :blob)
 builder = Rugged::Tree::Builder.new
-builder << entry
-sha = builder.write(repo)
+builder << { :type => :blob, :name => "README.md", :oid => oid, :filemode => 0100644 }
+
+options = {}
+options[:tree] = builder.write(repo)
+
+options[:author] = { :email => "testuser@github.com", :name => 'Test Author', :time => Time.now }
+options[:committer] = { :email => "testuser@github.com", :name => 'Test Author', :time => Time.now }
+options[:message] ||= "Making a commit via Rugged!"
+options[:parents] = repo.empty? ? [] : [ repo.head.target ].compact
+options[:update_ref] = 'HEAD'
+
+Rugged::Commit.create(repo, options)
 ```
 
 ---
@@ -271,10 +294,10 @@ index.entries
 index.each { |i| puts i.inspect }
 
 # Get a particular entry in the index.
-index.get_entry(path)
+index[path]
 
 # Unstage.
-index.remove(i/path)
+index.remove(path)
 
 # Stage. Also updates existing entry if there is one.
 index.add(ientry)
@@ -287,14 +310,14 @@ index.add(path)
 
 ### Refs
 
-The `RefList` class allows you to list, create and delete packed and loose refs.
+The `Rugged::Reference` class allows you to list, create and delete packed and loose refs.
 
 ```ruby
 ref = repo.head # or...
 ref = Rugged::Reference.lookup(repo, "refs/heads/master")
 
 sha = ref.target
-str = ref.type   # "commit"
+str = ref.type   # :direct
 str = ref.name   # "refs/heads/master"
 ```
 
@@ -319,7 +342,7 @@ It is also easy to create, update, rename or delete a reference:
 ```ruby
 ref = Rugged::Reference.create(repo, "refs/heads/unit_test", some_commit_sha)
 
-ref.target = new_sha
+ref.set_target(new_sha)
 
 ref.rename("refs/heads/blead")
 
@@ -331,14 +354,56 @@ Finally, you can access the reflog for any branch:
 ```ruby
 ref = Rugged::Reference.lookup(repo, "refs/heads/master")
 entry = ref.log.first
-sha   = entry[:oid_old]
-sha   = entry[:oid_new]
+sha   = entry[:id_old]
+sha   = entry[:id_new]
 str   = entry[:message]
 prsn  = entry[:committer]
 ```
 
 ---
 
+### Branches
+
+`Rugged::Branch` will help you with all of your branch-related needs.
+
+Iterate over all branches:
+
+```ruby
+Rugged::Branch.each_name(repo).sort
+# => ["master", "origin/HEAD", "origin/master", "origin/packed"]
+
+Rugged::Branch.each_name(repo, :local).sort
+# => ["master"]
+
+Rugged::Branch.each_name(repo, :remote).sort
+# => ["origin/HEAD", "origin/master", "origin/packed"]
+```
+
+Look up branches and get attributes:
+
+```ruby
+branch = Rugged::Branch.lookup(repo, "master")
+branch.name # => 'master'
+branch.canonical_name # => 'refs/heads/master'
+```
+
+Look up the oid for the tip of a branch:
+
+```ruby
+Rugged::Branch.lookup(repo, "master").tip.oid
+# => "36060c58702ed4c2a40832c51758d5344201d89a"
+```
+
+Creation and deletion:
+
+```ruby
+branch = repo.create_branch("test_branch")
+branch.move("new_branch")
+branch.delete!
+```
+
+---
+
 ### Config files
 
 It's also easy to read and manipulate the Git config file data with Rugged.
@@ -380,16 +445,7 @@ for the topic), send a pull request.
 
 ## Development
 
-First you need to install libgit2:
-
-    $ git clone https://github.com/libgit2/libgit2.git
-    $ cd libgit2
-    $ mkdir build && cd build
-    $ cmake ..
-    $ make
-    $ make install
-
-Now that those are installed, you can install Rugged:
+Simply clone and install:
 
     $ git clone https://github.com/libgit2/rugged.git
     $ cd rugged

data/ext/rugged/extconf.rb

@@ -8,7 +8,9 @@ def sys(cmd)
   ret
 end
 
-if `which make`.strip.empty?
+MAKE_PROGRAM = find_executable('gmake') || find_executable('make')
+
+if MAKE_PROGRAM.nil?
   STDERR.puts "ERROR: GNU make is required to build Rugged"
   exit(1)
 end
@@ -27,7 +29,7 @@ else
 
   if !File.exists?(LIBGIT2_LIB_PATH)
     Dir.chdir(LIBGIT2_DIR) do
-      sys("make -f Makefile.embed")
+      sys("#{MAKE_PROGRAM} -f Makefile.embed")
       FileUtils.cp 'libgit2.a', LIBGIT2_LIB_PATH
     end
   end

data/ext/rugged/rugged.c

@@ -1,7 +1,7 @@
 /*
  * The MIT License
  *
- * Copyright (c) 2011 GitHub, Inc
+ * 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
@@ -25,7 +25,7 @@
 #include "rugged.h"
 
 const char *RUGGED_ERROR_NAMES[] = {
-	NULL, /* GITERR_NOMEMORY, */
+	"NoMemError", /* GITERR_NOMEMORY, */
 	"OSError", /* GITERR_OS, */
 	"InvalidError", /* GITERR_INVALID, */
 	"ReferenceError", /* GITERR_REFERENCE, */
@@ -36,7 +36,7 @@ const char *RUGGED_ERROR_NAMES[] = {
 	"OdbError", /* GITERR_ODB, */
 	"IndexError", /* GITERR_INDEX, */
 	"ObjectError", /* GITERR_OBJECT, */
-	"NetworkError" /* GITERR_NET, */
+	"NetworkError", /* GITERR_NET, */
 	"TagError", /* GITERR_TAG, */
 	"TreeError", /* GITERR_TREE, */
 	"IndexerError", /* GITERR_INDEXER, */
@@ -50,6 +50,58 @@ VALUE rb_eRuggedErrors[RUGGED_ERROR_COUNT];
 
 static VALUE rb_mShutdownHook;
 
+/*
+ *	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.
+ *
+ *	Rugged.libgit2_version
+ *		#=> [0, 17, 0]
+ */
+static VALUE rb_git_libgit2_version(VALUE self)
+{
+	int major;
+	int minor;
+	int rev;
+
+	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)); 
+}
+
+/*
+ *	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.
+ *
+ *	The possible capabilities are "threads" and "https".
+ *
+ *	Rugged.capabilities
+ *		#=> [:threads, :https]
+ */
+static VALUE rb_git_capabilities(VALUE self)
+{
+	VALUE ret_arr = rb_ary_new();
+
+	int caps = git_libgit2_capabilities();
+
+	if (caps & GIT_CAP_THREADS)
+		rb_ary_push(ret_arr, CSTR2SYM("threads"));
+
+	if (caps & GIT_CAP_HTTPS)
+		rb_ary_push(ret_arr, CSTR2SYM("https"));
+
+	return ret_arr;
+}
+
 /*
  *	call-seq:
  *		Rugged.hex_to_raw(oid) -> raw_buffer
@@ -227,16 +279,19 @@ void rugged_exception_raise(int errorcode)
 	VALUE err_klass = rb_eRuggedError;
 	VALUE err_obj;
 	const git_error *error;
+	const char *err_message;
 
 	error = giterr_last();
 
-	if (!error)
-		return;
-
-	if (error->klass >= 0 && error->klass < RUGGED_ERROR_COUNT)
+	if (error && error->klass >= 0 && error->klass < RUGGED_ERROR_COUNT) {
 		err_klass = rb_eRuggedErrors[error->klass];
+		err_message = error->message;
+	} else {
+		err_klass = rb_eRuggedErrors[2]; /* InvalidError */
+		err_message = "Unknown Error";
+	}
 
-	err_obj = rb_exc_new2(err_klass, error->message);
+	err_obj = rb_exc_new2(err_klass, err_message);
 	giterr_clear();
 	rb_exc_raise(err_obj);
 }
@@ -250,13 +305,18 @@ void Init_rugged()
 		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[0] = rb_define_class_under(rb_mRugged, RUGGED_ERROR_NAMES[0], rb_eNoMemError);
+		rb_eRuggedErrors[1] = rb_define_class_under(rb_mRugged, RUGGED_ERROR_NAMES[1], rb_eIOError);
+		rb_eRuggedErrors[2] = rb_define_class_under(rb_mRugged, RUGGED_ERROR_NAMES[2], rb_eArgError);
+
+		for (i = 3; 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, "libgit2_version", rb_git_libgit2_version, 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);
@@ -275,6 +335,8 @@ void Init_rugged()
 	Init_rugged_branch();
 	Init_rugged_config();
 	Init_rugged_remote();
+	Init_rugged_notes();
+	Init_rugged_settings();
 
 	/* Constants */
 	rb_define_const(rb_mRugged, "SORT_NONE", INT2FIX(0));

data/ext/rugged/rugged.h

@@ -1,7 +1,7 @@
 /*
  * The MIT License
  *
- * Copyright (c) 2011 GitHub, Inc
+ * 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
@@ -57,6 +57,8 @@ void Init_rugged_revwalk();
 void Init_rugged_reference();
 void Init_rugged_config();
 void Init_rugged_remote();
+void Init_rugged_notes();
+void Init_rugged_settings();
 
 VALUE rb_git_object_init(git_otype type, int argc, VALUE *argv, VALUE self);
 
@@ -65,15 +67,16 @@ 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_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);
+VALUE rugged_object_new(VALUE owner, git_object *object);
 VALUE rugged_ref_new(VALUE klass, VALUE owner, git_reference *ref);
 
 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);
+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);
 
 static inline void rugged_set_owner(VALUE object, VALUE owner)
 {
@@ -101,6 +104,14 @@ static inline int rugged_parse_bool(VALUE boolean)
 	return boolean ? 1 : 0;
 }
 
+extern VALUE rb_cRuggedRepo;
+
+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)
@@ -120,11 +131,4 @@ static inline VALUE rugged_create_oid(const git_oid *oid)
 	return rugged_str_new(out, 40, NULL);
 }
 
-#define RUGGED_UNPACK_REFERENCE(_rb_obj, _rugged_obj) {\
-	if (DATA_PTR(_rb_obj) == NULL)\
-		rb_raise(rb_eRuntimeError,\
-			"This Git Reference has been deleted and no longer exists on the repository");\
-	Data_Get_Struct(_rb_obj, git_reference, _rugged_obj);\
-}
-
 #endif