rugged 0.19.0 → 0.21.0

data/ext/rugged/rugged_tree.c

@@ -1,7 +1,7 @@
 /*
  * The MIT License
  *
- * Copyright (c) 2013 GitHub, Inc
+ * 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
@@ -58,6 +58,10 @@ static VALUE rb_git_treeentry_fromC(const git_tree_entry *entry)
 			type = CSTR2SYM("blob");
 			break;
 
+		case GIT_OBJ_COMMIT:
+			type = CSTR2SYM("commit");
+			break;
+
 		default:
 			type = Qnil;
 			break;
@@ -143,7 +147,7 @@ static VALUE rb_git_tree_get_entry_by_oid(VALUE self, VALUE rb_oid)
 	Check_Type(rb_oid, T_STRING);
 	rugged_exception_check(git_oid_fromstr(&oid, StringValueCStr(rb_oid)));
 
-	return rb_git_treeentry_fromC(git_tree_entry_byoid(tree, &oid));
+	return rb_git_treeentry_fromC(git_tree_entry_byid(tree, &oid));
 }
 
 /*
@@ -270,16 +274,17 @@ static VALUE rb_git_tree_path(VALUE self, VALUE rb_path)
 
 /*
  *  call-seq:
- *    tree.diff(diffable[, options]) -> diff
+ *    Tree.diff(repo, tree, diffable[, options]) -> diff
  *
- *  Returns a diff between the tree and the diffable object that was given.
+ *  Returns a diff between the `tree` and the diffable object that was given.
  *  +diffable+ can either be a +Rugged::Commit+, a +Rugged::Tree+, a +Rugged::Index+,
  *  or +nil+.
  *
  *  The +tree+ object will be used as the "old file" side of the diff, while the
  *  parent tree or the +diffable+ object will be used for the "new file" side.
  *
- *  If +diffable+ is nil, it will be treated as an empty tree.
+ *  If +tree+ or +diffable+ are nil, they will be treated as an empty tree. Passing
+ *  both as `nil` will raise an exception.
  *
  *  The following options can be passed in the +options+ Hash:
  *
@@ -299,6 +304,14 @@ static VALUE rb_git_tree_path(VALUE self, VALUE rb_path)
  *    The maximum number of unchanged lines between hunk boundaries before the hunks
  *    will be merged into a one. The default is 0.
  *
+ *  :old_prefix ::
+ *    The virtual "directory" to prefix to old filenames in hunk headers.
+ *    The default is "a".
+ *
+ *  :new_prefix ::
+ *    The virtual "directory" to prefix to new filenames in hunk headers.
+ *    The default is "b".
+ *
  *  :reverse ::
  *    If true, the sides of the diff will be reversed.
  *
@@ -379,28 +392,38 @@ static VALUE rb_git_tree_path(VALUE self, VALUE rb_path)
  *    other_tree = Rugged::Tree.lookup(repo, "7a9e0b02e63179929fed24f0a3e0f19168114d10")
  *    diff = tree.diff(other_tree)
  */
-static VALUE rb_git_tree_diff(int argc, VALUE *argv, VALUE self)
+static VALUE rb_git_tree_diff_(int argc, VALUE *argv, VALUE self)
 {
-	git_tree *tree;
+	git_tree *tree = NULL;
 	git_diff_options opts = GIT_DIFF_OPTIONS_INIT;
-	git_repository *repo;
-	git_diff_list *diff = NULL;
-	VALUE owner, rb_other, rb_options;
+	git_repository *repo = NULL;
+	git_diff *diff = NULL;
+	VALUE rb_self, rb_repo, rb_other, rb_options;
 	int error;
 
-	rb_scan_args(argc, argv, "10:", &rb_other, &rb_options);
+	rb_scan_args(argc, argv, "22", &rb_repo, &rb_self, &rb_other, &rb_options);
 	rugged_parse_diff_options(&opts, rb_options);
 
-	Data_Get_Struct(self, git_tree, tree);
-	owner = rugged_owner(self);
-	Data_Get_Struct(owner, git_repository, repo);
+	Data_Get_Struct(rb_repo, git_repository, repo);
+
+	if (!NIL_P(rb_self)) {
+		if (!rb_obj_is_kind_of(rb_self, rb_cRuggedTree))
+			rb_raise(rb_eTypeError,
+				"At least a Rugged::Tree object is required for diffing");
+
+		Data_Get_Struct(rb_self, git_tree, tree);
+	}
 
 	if (NIL_P(rb_other)) {
+		if (tree == NULL) {
+			xfree(opts.pathspec.strings);
+			rb_raise(rb_eTypeError, "Need 'old' or 'new' for diffing");
+		}
+
 		error = git_diff_tree_to_tree(&diff, repo, tree, NULL, &opts);
 	} else {
-		if (TYPE(rb_other) == T_STRING) {
-			rb_other = rugged_object_rev_parse(owner, rb_other, 1);
-		}
+		if (TYPE(rb_other) == T_STRING)
+			rb_other = rugged_object_rev_parse(rb_repo, rb_other, 1);
 
 		if (rb_obj_is_kind_of(rb_other, rb_cRuggedCommit)) {
 			git_tree *other_tree;
@@ -450,7 +473,7 @@ static VALUE rb_git_tree_diff_workdir(int argc, VALUE *argv, VALUE self)
 	git_tree *tree;
 	git_diff_options opts = GIT_DIFF_OPTIONS_INIT;
 	git_repository *repo;
-	git_diff_list *diff;
+	git_diff *diff;
 	VALUE owner, rb_options;
 	int error;
 
@@ -469,6 +492,119 @@ static VALUE rb_git_tree_diff_workdir(int argc, VALUE *argv, VALUE self)
 	return rugged_diff_new(rb_cRuggedDiff, self, diff);
 }
 
+void rugged_parse_merge_options(git_merge_options *opts, 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("rename_threshold"));
+		if (!NIL_P(rb_value)) {
+			Check_Type(rb_value, T_FIXNUM);
+			opts->rename_threshold = FIX2UINT(rb_value);
+		}
+
+		rb_value = rb_hash_aref(rb_options, CSTR2SYM("target_limit"));
+		if (!NIL_P(rb_value)) {
+			Check_Type(rb_value, T_FIXNUM);
+			opts->target_limit = FIX2UINT(rb_value);
+		}
+
+		rb_value = rb_hash_aref(rb_options, CSTR2SYM("favor"));
+		if (!NIL_P(rb_value)) {
+			ID id_favor;
+
+			Check_Type(rb_value, T_SYMBOL);
+			id_favor = SYM2ID(rb_value);
+
+			if (id_favor == rb_intern("normal")) {
+				opts->file_favor = GIT_MERGE_FILE_FAVOR_NORMAL;
+			} else if (id_favor == rb_intern("ours")) {
+				opts->file_favor = GIT_MERGE_FILE_FAVOR_OURS;
+			} else if (id_favor == rb_intern("theirs")) {
+				opts->file_favor = GIT_MERGE_FILE_FAVOR_THEIRS;
+			} else if (id_favor == rb_intern("union")) {
+				opts->file_favor = GIT_MERGE_FILE_FAVOR_UNION;
+			} else {
+				rb_raise(rb_eTypeError,
+					"Invalid favor mode. Expected `:normal`, `:ours`, `:theirs` or `:union`");
+			}
+		}
+
+		if (RTEST(rb_hash_aref(rb_options, CSTR2SYM("renames")))) {
+			opts->flags |= GIT_MERGE_TREE_FIND_RENAMES;
+		}
+	}
+}
+
+/*
+ *  tree.merge(other_tree[, ancestor_tree[, options]]) -> Rugged::Index
+ *  tree.merge(other_tree[, options]) -> Rugged::Index
+ *
+ *  Merges two trees and returns the a Rugged::Index object that reflects
+ *  the result of the merge.
+ *
+ *  The following options can be passed in the +options+ Hash:
+ *
+ *  :renames ::
+ *    If true, looking for renames will be enabled (`--find-renames`).
+ *
+ *  :rename_threshold ::
+ *    An integer specifying the minimum similarity of a file to be
+ *    seen as an eligible rename source (default 50).
+ *
+ *  :target_limit ::
+ *    An integer specifying the maximum byte size of a file before a it will
+ *    be treated as binary. The default value is 512MB.
+ *
+ *  :favor ::
+ *    Specifies how and if conflicts are auto-resolved by favoring a specific
+ *    file output. Can be one of `:normal`, `:ours`, `:theirs` or `:union`.
+ *
+ */
+static VALUE rb_git_tree_merge(int argc, VALUE *argv, VALUE self)
+{
+	VALUE rb_other_tree, rb_ancestor_tree, rb_options;
+	VALUE rb_repo = rugged_owner(self);
+
+	git_tree *tree, *other_tree, *ancestor_tree;
+	git_repository *repo;
+	git_index *index;
+	git_merge_options opts = GIT_MERGE_OPTIONS_INIT;
+	int error;
+
+	if (rb_scan_args(argc, argv, "12", &rb_other_tree, &rb_ancestor_tree, &rb_options) == 2) {
+		if (TYPE(rb_ancestor_tree) == T_HASH) {
+			rb_options = rb_ancestor_tree;
+			rb_ancestor_tree = Qnil;
+		}
+	}
+
+	if (!NIL_P(rb_options)) {
+		Check_Type(rb_options, T_HASH);
+		rugged_parse_merge_options(&opts, rb_options);
+	}
+
+	if (!rb_obj_is_kind_of(rb_other_tree, rb_cRuggedTree))
+		rb_raise(rb_eTypeError, "Expecting a Rugged::Tree instance");
+	else if (!NIL_P(rb_ancestor_tree) && !rb_obj_is_kind_of(rb_ancestor_tree, rb_cRuggedTree))
+		rb_raise(rb_eTypeError, "Expecting a Rugged::Tree instance");
+
+	Data_Get_Struct(self, git_tree, tree);
+	Data_Get_Struct(rb_repo, git_repository, repo);
+	Data_Get_Struct(rb_other_tree, git_tree, other_tree);
+
+	if (!NIL_P(rb_ancestor_tree))
+		Data_Get_Struct(rb_ancestor_tree, git_tree, ancestor_tree);
+	else
+		ancestor_tree = NULL;
+
+	error = git_merge_trees(&index, repo, ancestor_tree, tree, other_tree, &opts);
+	rugged_exception_check(error);
+
+	return rugged_index_new(rb_cRuggedIndex, rb_repo, index);
+}
+
 static void rb_git_treebuilder_free(git_treebuilder *bld)
 {
 	git_treebuilder_free(bld);
@@ -616,11 +752,10 @@ static VALUE rb_git_treebuilder_write(VALUE self, VALUE rb_repo)
 	git_oid written_id;
 	int error;
 
-	if (!rb_obj_is_kind_of(rb_repo, rb_cRuggedRepo))
-		rb_raise(rb_eTypeError, "Expecting a Rugged::Repository instance");
+	rugged_check_repo(rb_repo);
+	Data_Get_Struct(rb_repo, git_repository, repo);
 
 	Data_Get_Struct(self, git_treebuilder, builder);
-	Data_Get_Struct(rb_repo, git_repository, repo);
 
 	error = git_treebuilder_write(&written_id, repo, builder);
 	rugged_exception_check(error);
@@ -664,11 +799,13 @@ void Init_rugged_tree(void)
 	rb_define_method(rb_cRuggedTree, "get_entry", rb_git_tree_get_entry, 1);
 	rb_define_method(rb_cRuggedTree, "get_entry_by_oid", rb_git_tree_get_entry_by_oid, 1);
 	rb_define_method(rb_cRuggedTree, "path", rb_git_tree_path, 1);
-	rb_define_method(rb_cRuggedTree, "diff", rb_git_tree_diff, -1);
 	rb_define_method(rb_cRuggedTree, "diff_workdir", rb_git_tree_diff_workdir, -1);
 	rb_define_method(rb_cRuggedTree, "[]", rb_git_tree_get_entry, 1);
 	rb_define_method(rb_cRuggedTree, "each", rb_git_tree_each, 0);
 	rb_define_method(rb_cRuggedTree, "walk", rb_git_tree_walk, 1);
+	rb_define_method(rb_cRuggedTree, "merge", rb_git_tree_merge, -1);
+
+	rb_define_singleton_method(rb_cRuggedTree, "diff", rb_git_tree_diff_, -1);
 
 	rb_cRuggedTreeBuilder = rb_define_class_under(rb_cRuggedTree, "Builder", rb_cObject);
 	rb_define_alloc_func(rb_cRuggedTreeBuilder, rb_git_treebuilder_allocate);

data/lib/rugged/branch.rb

@@ -1,28 +1,19 @@
 module Rugged
   class Branch < Rugged::Reference
-
-    # The object pointed at by the tip of this branch
-    def tip
-      @owner.lookup(self.resolve.target)
-    end
-
     def ==(other)
       other.instance_of?(Rugged::Branch) &&
         other.canonical_name == self.canonical_name
     end
-
-    # The full name of the branch, as a fully-qualified reference
-    # path.
+    
+    # Get the remote the branch belongs to.
     #
-    # This is the same as calling Reference#name for the reference behind
-    # the path
-    alias_method 'canonical_name', 'name'
-
-    # The name of the branch, without a fully-qualified reference path
+    # If the branch is remote returns the remote it belongs to.
+    # In case of local branch, it returns the remote of the branch
+    # it tracks or nil if there is no tracking branch.
     #
-    # E.g. 'master' instead of 'refs/heads/master'
-    def name
-      super.gsub(%r{^(refs/heads/|refs/remotes/)}, '')
+    def remote
+      remote_name = self.remote_name
+      @owner.remotes[remote_name] if remote_name
     end
   end
 end

data/lib/rugged/credentials.rb

@@ -0,0 +1,43 @@
+module Rugged
+  module Credentials
+    # A plain-text username and password credential object.
+    class UserPassword
+      def initialize(options)
+        @username, @password = options[:username], options[:password]
+      end
+
+      def call(url, username_from_url, allowed_types)
+        self
+      end
+    end
+
+    # A ssh key credential object that can optionally be passphrase-protected
+    class SshKey
+      def initialize(options)
+        @username, @publickey, @privatekey, @passphrase = options[:username], options[:publickey], options[:privatekey], options[:passphrase]
+      end
+
+      def call(url, username_from_url, allowed_types)
+        self
+      end
+    end
+
+    class SshKeyFromAgent
+      def initialize(options)
+        @username = options[:username]
+      end
+
+      def call(url, username_from_url, allowed_types)
+        self
+      end
+    end
+
+    # A "default" credential usable for Negotiate mechanisms like NTLM or
+    # Kerberos authentication
+    class Default
+      def call(url, username_from_url, allowed_types)
+        self
+      end
+    end
+  end
+end

data/lib/rugged/diff/delta.rb

@@ -1,8 +1,6 @@
 module Rugged
   class Diff
     class Delta
-      include Enumerable
-
       attr_reader :owner
       alias diff owner
 
@@ -10,6 +8,7 @@ module Rugged
       attr_reader :new_file
       attr_reader :similarity
       attr_reader :status
+      attr_reader :status_char
       attr_reader :binary
 
       alias binary? binary

data/lib/rugged/diff/hunk.rb

@@ -1,17 +1,12 @@
 module Rugged
   class Diff
     class Hunk
-      include Enumerable
-      alias each each_line
-
-      attr_reader :line_count, :header, :range, :owner
-
-      alias size line_count
-      alias count line_count
-      alias delta owner
+      def delta
+        @owner
+      end
 
       def inspect
-        "#<#{self.class.name}:#{object_id} {header: #{header.inspect}, range: #{range.inspect}>"
+        "#<#{self.class.name}:#{object_id} {header: #{header.inspect}, count: #{count.inspect}}>"
       end
 
       # Returns an Array containing all lines of the hunk.

data/lib/rugged/diff/line.rb

@@ -1,7 +1,7 @@
 module Rugged
   class Diff
     class Line
-      attr_reader :line_origin, :content, :owner, :old_lineno, :new_lineno
+      attr_reader :line_origin, :content, :owner, :old_lineno, :new_lineno, :content_offset
 
       alias hunk owner
 
@@ -17,8 +17,28 @@ module Rugged
         @line_origin == :deletion
       end
 
-      def eof_newline?
-        @line_origin == :eof_newline
+      def eof_no_newline?
+        @line_origin == :eof_no_newline
+      end
+
+      def eof_newline_added?
+        @line_origin == :eof_newline_added
+      end
+
+      def eof_newline_removed?
+        @line_origin == :eof_newline_removed
+      end
+
+      def file_header?
+        @line_origin == :file_header
+      end
+
+      def hunk_header?
+        @line_origin == :hunk_header
+      end
+
+      def binary?
+        @line_origin == :binary
       end
 
       def inspect

data/lib/rugged/diff.rb

@@ -1,4 +1,3 @@
-require 'rugged/diff/patch'
 require 'rugged/diff/hunk'
 require 'rugged/diff/line'
 require 'rugged/diff/delta'
@@ -8,6 +7,9 @@ module Rugged
     include Enumerable
     alias each each_patch
 
+    attr_reader :owner
+    alias tree owner
+
     def patches
       each_patch.to_a
     end

data/lib/rugged/patch.rb

@@ -0,0 +1,26 @@
+module Rugged
+  class Patch
+    include Enumerable
+    alias each each_hunk
+
+    alias size hunk_count
+    alias count hunk_count
+
+    attr_accessor :owner
+    alias diff owner
+
+    def inspect
+      "#<#{self.class.name}:#{object_id}>"
+    end
+
+    # Returns the number of changes in the patch.
+    def changes
+      stat.reduce { |t,v| t + v }
+    end
+
+    # Returns an Array containing all hunks of the patch.
+    def hunks
+      each_hunk.to_a
+    end
+  end
+end

data/lib/rugged/reference.rb

@@ -1,9 +1,7 @@
 module Rugged
   class Reference
-
     def inspect
-      "#<Rugged::Reference:#{object_id} {name: #{name.inspect}, target: #{target.inspect}}>"
+      "#<#{self.class}:#{object_id} {name: #{name.inspect}, target: #{target.inspect}}>"
     end
-
   end
 end

data/lib/rugged/remote.rb

@@ -1,13 +1,4 @@
 module Rugged
   class Remote
-    # Push a list of refspecs to the given remote.
-    #
-    # refspecs - A list of refspecs that should be pushed to the remote.
-    #
-    # Returns a hash containing the pushed refspecs as keys and
-    # any error messages or +nil+ as values.
-    def push(refspecs)
-      @owner.push(self, refspecs)
-    end
   end
 end

data/lib/rugged/repository.rb

@@ -14,7 +14,38 @@ module Rugged
     #
     # Returns a Rugged::Commit object.
     def last_commit
-      self.lookup self.head.target
+      self.head.target
+    end
+
+    # Checkout the specified branch, reference or commit.
+    #
+    # target - A revparse spec for the branch, reference or commit to check out.
+    # options - Options passed to #checkout_tree.
+    def checkout(target, options = {})
+      options[:strategy] ||= :safe
+      options.delete(:paths)
+
+      return checkout_head(options) if target == "HEAD"
+
+      if target.kind_of?(Rugged::Branch)
+        branch = target
+      else
+        branch = branches[target]
+      end
+
+      if branch
+        self.checkout_tree(branch.target, options)
+
+        if branch.remote?
+          references.create("HEAD", branch.target_id, force: true)
+        else
+          references.create("HEAD", branch.canonical_name, force: true)
+        end
+      else
+        commit = Commit.lookup(self, self.rev_parse_oid(target))
+        references.create("HEAD", commit.oid, force: true)
+        self.checkout_tree(commit, options)
+      end
     end
 
     def diff(left, right, opts = {})
@@ -92,37 +123,41 @@ module Rugged
     #
     # Returns a Rugged::Reference.
     def ref(ref_name)
-      Rugged::Reference.lookup(self, ref_name)
+      references[ref_name]
     end
 
     def refs(glob = nil)
-      Rugged::Reference.each(self, glob)
+      references.each(glob)
+    end
+
+    def references
+      @references ||= ReferenceCollection.new(self)
     end
 
     def ref_names(glob = nil)
-      Rugged::Reference.each_name(self, glob)
+      references.each_name(glob)
     end
 
     # All the tags in the repository.
     #
-    # Returns an Enumerable::Enumerator containing all the String tag names.
-    def tags(pattern="")
-      Rugged::Tag.each(self, pattern)
+    # Returns an TagCollection containing all the tags.
+    def tags
+      @tags ||= TagCollection.new(self)
     end
 
     # All the remotes in the repository.
     #
-    # Returns an Enumerable::Enumerator containing all the Rugged::Remotes in
-    # the repository.
+    # Returns a Rugged::RemoteCollection containing all the Rugged::Remote objects
+    # in the repository.
     def remotes
-      Rugged::Remote.each(self)
+      @remotes ||= RemoteCollection.new(self)
     end
 
     # All the branches in the repository
     #
-    # Returns an Enumerable::Enumerator containing Rugged::Branch objects
+    # Returns an BranchCollection containing Rugged::Branch objects
     def branches
-      Rugged::Branch.each(self)
+      @branches ||= BranchCollection.new(self)
     end
 
     # Create a new branch in the repository
@@ -140,7 +175,7 @@ module Rugged
         target = rev_parse_oid(sha_or_ref)
       end
 
-      Branch.create(self, name, target)
+      branches.create(name, target)
     end
 
     # Get the blob at a path for a specific revision.
@@ -159,5 +194,27 @@ module Rugged
       blob = Rugged::Blob.lookup(self, blob_data[:oid])
       (blob.type == :blob) ? blob : nil
     end
+
+    def fetch(remote_or_url, *args)
+      unless remote_or_url.kind_of? Remote
+        remote_or_url = remotes[remote_or_url] || remotes.create_anonymous(remote_or_url)
+      end
+
+      remote_or_url.fetch(*args)
+    end
+
+    # Push a list of refspecs to the given remote.
+    #
+    # refspecs - A list of refspecs that should be pushed to the remote.
+    #
+    # Returns a hash containing the pushed refspecs as keys and
+    # any error messages or +nil+ as values.
+    def push(remote_or_url, *args)
+      unless remote_or_url.kind_of? Remote
+        remote_or_url = remotes[remote_or_url] || remotes.create_anonymous(remote_or_url)
+      end
+
+      remote_or_url.push(*args)
+    end
   end
 end

data/lib/rugged/tag.rb

@@ -1,26 +1,31 @@
 module Rugged
-  class Tag
-
-    def self.prettify_message(msg, strip_comments = true)
-      Rugged::prettify_message(msg, strip_comments)
+  class Tag < Rugged::Reference
+    def name
+      canonical_name.sub(%r{^refs/tags/}, "")
     end
 
-    def inspect
-      "#<Rugged::Tag:#{object_id} {name: #{name.inspect}, message: #{message.inspect}, target: #{target.inspect}>"
-    end
+    class Annotation
+      def self.prettify_message(msg, strip_comments = true)
+        Rugged::prettify_message(msg, strip_comments)
+      end
 
-    def to_hash
-      {
-        :message => message,
-        :name => name,
-        :target => target,
-        :tagger => tagger,
-      }
-    end
+      def inspect
+        "#<Rugged::Tag::Annotation:#{object_id} {name: #{name.inspect}, message: #{message.inspect}, target: #{target.inspect}>"
+      end
+
+      def to_hash
+        {
+          :message => message,
+          :name => name,
+          :target => target,
+          :tagger => tagger,
+        }
+      end
 
-    def modify(new_args, force=True)
-      args = self.to_hash.merge(new_args)
-      Tag.create(args, force)
+      def modify(new_args, force=True)
+        args = self.to_hash.merge(new_args)
+        Tag.create(args, force)
+      end
     end
   end
 end