rugged 0.19.0 → 0.28.0

data/lib/rugged/repository.rb

@@ -1,3 +1,8 @@
+# Copyright (C) the Rugged contributors.  All rights reserved.
+#
+# This file is part of Rugged, distributed under the MIT license.
+# For full terms see the included LICENSE file.
+
 module Rugged
   # Repository is an interface into a Git repository on-disk. It's the primary
   # interface between your app and the main Git objects Rugged makes available
@@ -14,7 +19,81 @@ 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
+
+    ###
+    #  call-seq:
+    #    repo.status { |file, status_data| block }
+    #    repo.status(path) -> status_data
+    #
+    #  Returns the status for one or more files in the working directory
+    #  of the repository. This is equivalent to the +git status+ command.
+    #
+    #  The returned +status_data+ is always an array containing one or more
+    #  status flags as Ruby symbols. Possible flags are:
+    #
+    #  - +:index_new+: the file is new in the index
+    #  - +:index_modified+: the file has been modified in the index
+    #  - +:index_deleted+: the file has been deleted from the index
+    #  - +:worktree_new+: the file is new in the working directory
+    #  - +:worktree_modified+: the file has been modified in the working directory
+    #  - +:worktree_deleted+: the file has been deleted from the working directory
+    #
+    #  If a +block+ is given, status information will be gathered for every
+    #  single file on the working dir. The +block+ will be called with the
+    #  status data for each file.
+    #
+    #    repo.status { |file, status_data| puts "#{file} has status: #{status_data.inspect}" }
+    #
+    #  results in, for example:
+    #
+    #    src/diff.c has status: [:index_new, :worktree_new]
+    #    README has status: [:worktree_modified]
+    #
+    #  If a +path+ is given instead, the function will return the +status_data+ for
+    #  the file pointed to by path, or raise an exception if the path doesn't exist.
+    #
+    #  +path+ must be relative to the repository's working directory.
+    #
+    #    repo.status('src/diff.c') #=> [:index_new, :worktree_new]
+    def status(file = nil, &block)
+      if file
+        file_status file
+      else
+        each_status(&block)
+      end
     end
 
     def diff(left, right, opts = {})
@@ -92,37 +171,48 @@ 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 a 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 a BranchCollection containing Rugged::Branch objects
     def branches
-      Rugged::Branch.each(self)
+      @branches ||= BranchCollection.new(self)
+    end
+
+    # All the submodules in the repository
+    #
+    # Returns a SubmoduleCollection containing Rugged::Submodule objects
+    def submodules
+      @submodules ||= SubmoduleCollection.new(self)
     end
 
     # Create a new branch in the repository
@@ -140,7 +230,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.
@@ -148,7 +238,7 @@ module Rugged
     # revision - The String SHA1.
     # path     - The String file path.
     #
-    # Returns a String.
+    # Returns a Rugged::Blob object
     def blob_at(revision, path)
       tree = Rugged::Commit.lookup(self, revision).tree
       begin
@@ -159,5 +249,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/submodule_collection.rb

@@ -0,0 +1,53 @@
+# Copyright (C) the Rugged contributors.  All rights reserved.
+#
+# This file is part of Rugged, distributed under the MIT license.
+# For full terms see the included LICENSE file.
+
+module Rugged
+  class SubmoduleCollection
+
+    # call-seq:
+    #   submodules.setup_add(url, path[, options]) -> submodule
+    #
+    # Add a new +submodule+.
+    #
+    # This does <tt>"git submodule add"</tt> incuding fetch and checkout of the
+    # submodule contents.
+    #
+    # - +url+: URL for the submodule's remote
+    # - +path+: path at which the submodule should be created
+    #
+    # The +options+ hash accepts all options supported by Rugged::Remote#fetch
+    # and the following:
+    # :gitlink ::
+    #   (defaults to +true+) should workdir contain a
+    #   gitlink to the repository in +.git/modules+ vs. repository
+    #   directly in workdir.
+    #
+    # Returns the newly created +submodule+
+    def add(url, path, options = {})
+      submodule = setup_add(url, path, options)
+      clone_submodule(submodule.repository, options)
+      submodule.finalize_add
+    end
+
+    private
+    # currently libgit2's `git_submodule_add_setup` initializes a repo
+    # with a workdir for the submodule. libgit2's `git_clone` however
+    # requires the target for the clone to be an empty dir.
+    #
+    # This provides a ghetto clone implementation that:
+    # 1. fetches the remote
+    # 2. sets up a master branch to be tracking origin/master
+    # 3. checkouts the submodule
+    def clone_submodule(repo, fetch_options)
+      # the remote was just added by setup_add, no need to check presence
+      repo.remotes['origin'].fetch(fetch_options)
+
+      repo.branches.create('master','origin/master')
+      repo.branches['master'].upstream = repo.branches['origin/master']
+
+      repo.checkout_head(strategy: :force)
+    end
+  end
+end

data/lib/rugged/tag.rb

@@ -1,26 +1,55 @@
+# Copyright (C) the Rugged contributors.  All rights reserved.
+#
+# This file is part of Rugged, distributed under the MIT license.
+# For full terms see the included LICENSE file.
+
 module Rugged
-  class Tag
+  class Tag < Rugged::Reference
+    GPG_SIGNATURE_PREFIX = "-----BEGIN PGP SIGNATURE-----".freeze
 
-    def self.prettify_message(msg, strip_comments = true)
-      Rugged::prettify_message(msg, strip_comments)
-    end
+    def self.extract_signature(repo, oid, prefix=GPG_SIGNATURE_PREFIX)
+      object = repo.read(oid)
+
+      unless object.type == :tag
+        raise GitRPC::InvalidObject, "Invalid object type #{object.type}, expected tag"
+      end
 
-    def inspect
-      "#<Rugged::Tag:#{object_id} {name: #{name.inspect}, message: #{message.inspect}, target: #{target.inspect}>"
+      if index = object.data.index(prefix)
+        [
+          object.data.byteslice(index..-1),
+          object.data.byteslice(0...index)
+        ]
+      else
+        nil
+      end
     end
 
-    def to_hash
-      {
-        :message => message,
-        :name => name,
-        :target => target,
-        :tagger => tagger,
-      }
+    def name
+      canonical_name.sub(%r{^refs/tags/}, "")
     end
 
-    def modify(new_args, force=True)
-      args = self.to_hash.merge(new_args)
-      Tag.create(args, force)
+    class Annotation
+      def self.prettify_message(msg, strip_comments = true)
+        Rugged::prettify_message(msg, strip_comments)
+      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)
+      end
     end
   end
 end

data/lib/rugged/tree.rb

@@ -1,7 +1,169 @@
+# Copyright (C) the Rugged contributors.  All rights reserved.
+#
+# This file is part of Rugged, distributed under the MIT license.
+# For full terms see the included LICENSE file.
+
 module Rugged
   class Tree
+    ##
+    # call-seq:
+    #   Tree.diff(repo, tree, diffable[, options]) -> diff
+    #
+    # 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 +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:
+    #
+    # :paths ::
+    #   An array of paths / fnmatch patterns to constrain the diff to a specific
+    #   set of files. Also see +:disable_pathspec_match+.
+    #
+    # :max_size ::
+    #   An integer specifying the maximum byte size of a file before a it will
+    #   be treated as binary. The default value is 512MB.
+    #
+    # :context_lines ::
+    #   The number of unchanged lines that define the boundary of a hunk (and
+    #   to display before and after the actual changes). The default is 3.
+    #
+    # :interhunk_lines ::
+    #   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.
+    #
+    # :force_text ::
+    #   If true, all files will be treated as text, disabling binary attributes & detection.
+    #
+    # :ignore_whitespace ::
+    #   If true, all whitespace will be ignored.
+    #
+    # :ignore_whitespace_change ::
+    #   If true, changes in amount of whitespace will be ignored.
+    #
+    # :ignore_whitespace_eol ::
+    #   If true, whitespace at end of line will be ignored.
+    #
+    # :ignore_submodules ::
+    #   if true, submodules will be excluded from the diff completely.
+    #
+    # :patience ::
+    #   If true, the "patience diff" algorithm will be used (currenlty unimplemented).
+    #
+    # :include_ignored ::
+    #   If true, ignored files will be included in the diff.
+    #
+    # :include_untracked ::
+    #  If true, untracked files will be included in the diff.
+    #
+    # :include_unmodified ::
+    #   If true, unmodified files will be included in the diff.
+    #
+    # :recurse_untracked_dirs ::
+    #   Even if +:include_untracked+ is true, untracked directories will only be
+    #   marked with a single entry in the diff. If this flag is set to true,
+    #   all files under ignored directories will be included in the diff, too.
+    #
+    # :disable_pathspec_match ::
+    #   If true, the given +:paths+ will be applied as exact matches, instead of
+    #   as fnmatch patterns.
+    #
+    # :deltas_are_icase ::
+    #   If true, filename comparisons will be made with case-insensitivity.
+    #
+    # :include_untracked_content ::
+    #   if true, untracked content will be contained in the the diff patch text.
+    #
+    # :skip_binary_check ::
+    #   If true, diff deltas will be generated without spending time on binary
+    #   detection. This is useful to improve performance in cases where the actual
+    #   file content difference is not needed.
+    #
+    # :include_typechange ::
+    #   If true, type changes for files will not be interpreted as deletion of
+    #   the "old file" and addition of the "new file", but will generate
+    #   typechange records.
+    #
+    # :include_typechange_trees ::
+    #   Even if +:include_typechange+ is true, blob -> tree changes will still
+    #   usually be handled as a deletion of the blob. If this flag is set to true,
+    #   blob -> tree changes will be marked as typechanges.
+    #
+    # :ignore_filemode ::
+    #   If true, file mode changes will be ignored.
+    #
+    # :recurse_ignored_dirs ::
+    #   Even if +:include_ignored+ is true, ignored directories will only be
+    #   marked with a single entry in the diff. If this flag is set to true,
+    #   all files under ignored directories will be included in the diff, too.
+    #
+    # Examples:
+    #
+    #   # Emulating `git diff <treeish>`
+    #   tree = Rugged::Tree.lookup(repo, "d70d245ed97ed2aa596dd1af6536e4bfdb047b69")
+    #   diff = tree.diff(repo.index)
+    #   diff.merge!(tree.diff)
+    #
+    #   # Tree-to-Tree Diff
+    #   tree = Rugged::Tree.lookup(repo, "d70d245ed97ed2aa596dd1af6536e4bfdb047b69")
+    #   other_tree = Rugged::Tree.lookup(repo, "7a9e0b02e63179929fed24f0a3e0f19168114d10")
+    #   diff = tree.diff(other_tree)
+    #
+
+    def self.diff(repo, tree, other_tree = nil, options = {})
+      if tree && !tree.is_a?(Rugged::Tree)
+        raise TypeError, "At least a Rugged::Tree object is required for diffing"
+      end
+
+      if other_tree.nil?
+        if tree.nil?
+          raise TypeError, "Need 'old' or 'new' for diffing"
+        else
+          diff_tree_to_tree repo, tree, nil, options
+        end
+      else
+        if other_tree.is_a?(::String)
+          other_tree = Rugged::Object.rev_parse repo, other_tree
+        end
+
+        case other_tree
+        when Rugged::Commit
+          diff_tree_to_tree repo, tree, other_tree.tree, options
+        when Rugged::Tree
+          diff_tree_to_tree repo, tree, other_tree, options
+        when Rugged::Index
+          diff_tree_to_index repo, tree, other_tree, options
+        else
+          raise TypeError, "A Rugged::Commit, Rugged::Tree or Rugged::Index instance is required"
+        end
+      end
+    end
+
     include Enumerable
 
+    attr_reader :owner
+    alias repo owner
+
+    def diff(other = nil, options = nil)
+      Tree.diff(repo, self, other, options)
+    end
+
     def inspect
       data = "#<Rugged::Tree:#{object_id} {oid: #{oid}}>\n"
       self.each { |e| data << "  <\"#{e[:name]}\" #{e[:oid]}>\n" }
@@ -23,7 +185,7 @@ module Rugged
       self.each { |e| yield e if e[:type] == :blob }
     end
 
-    # Iterat over the subtrees in this tree
+    # Iterate over the subtrees in this tree
     def each_tree
       self.each { |e| yield e if e[:type] == :tree }
     end

data/lib/rugged/version.rb

@@ -1,3 +1,8 @@
+# Copyright (C) the Rugged contributors.  All rights reserved.
+#
+# This file is part of Rugged, distributed under the MIT license.
+# For full terms see the included LICENSE file.
+
 module Rugged
-  Version = VERSION = '0.19.0'
+  Version = VERSION = '0.28.0'
 end

data/lib/rugged/walker.rb

@@ -1,3 +1,8 @@
+# Copyright (C) the Rugged contributors.  All rights reserved.
+#
+# This file is part of Rugged, distributed under the MIT license.
+# For full terms see the included LICENSE file.
+
 module Rugged
   class Walker
     include Enumerable

data/lib/rugged.rb

@@ -1,4 +1,14 @@
-require 'rugged/rugged'
+# Copyright (C) the Rugged contributors.  All rights reserved.
+#
+# This file is part of Rugged, distributed under the MIT license.
+# For full terms see the included LICENSE file.
+
+begin
+  RUBY_VERSION =~ /(\d+.\d+)/
+  require "rugged/#{$1}/rugged"
+rescue LoadError
+  require "rugged/rugged"
+end
 require 'rugged/index'
 require 'rugged/object'
 require 'rugged/commit'
@@ -10,4 +20,9 @@ require 'rugged/tree'
 require 'rugged/tag'
 require 'rugged/branch'
 require 'rugged/diff'
+require 'rugged/patch'
 require 'rugged/remote'
+require 'rugged/credentials'
+require 'rugged/attributes'
+require 'rugged/blob'
+require 'rugged/submodule_collection'

data/vendor/libgit2/AUTHORS

@@ -0,0 +1,77 @@
+The following people contribute or have contributed
+to the libgit2 project (sorted alphabetically):
+
+Alex Budovski
+Alexei Sholik
+Andreas Ericsson
+Anton "antong" Gyllenberg
+Ankur Sethi
+Arthur Schreiber
+Ben Noordhuis
+Ben Straub
+Benjamin C Meyer
+Brian Downing
+Brian Lopez
+Carlos Martín Nieto
+Colin Timmermans
+Daniel Huckstep
+Dave Borowitz
+David Boyce
+David Glesser
+Dmitry Kakurin
+Dmitry Kovega
+Emeric Fermas
+Emmanuel Rodriguez
+Eric Myhre
+Florian Forster
+Holger Weiss
+Ingmar Vanhassel
+J. David Ibáñez
+Jacques Germishuys
+Jakob Pfender
+Jason Penny
+Jason R. McNeil
+Jerome Lambourg
+Johan 't Hart
+John Wiegley
+Jonathan "Duke" Leto
+Julien Miotte
+Julio Espinoza-Sokal
+Justin Love
+Kelly "kelly.leahy" Leahy
+Kirill A. Shutemov
+Lambert CLARA
+Luc Bertrand
+Marc Pegon
+Marcel Groothuis
+Marco Villegas
+Michael "schu" Schubert
+Microsoft Corporation
+Olivier Ramonat
+Peter Drahoš
+Pierre Habouzit
+Pierre-Olivier Latour
+Przemyslaw Pawelczyk
+Ramsay Jones
+Robert G. Jakabosky
+Romain Geissler
+Romain Muller
+Russell Belfer
+Sakari Jokinen
+Samuel Charles "Sam" Day
+Sarath Lakshman
+Sascha Cunz
+Sascha Peilicke
+Scott Chacon
+Sebastian Schuberth
+Sergey Nikishin
+Shawn O. Pearce
+Shuhei Tanuma
+Steve Frécinaux
+Sven Strickroth
+Tim Branyen
+Tim Clem
+Tim Harder
+Torsten Bögershausen
+Trent Mick
+Vicent Marti