rdavila-rugged 0.24.0b13

data/lib/rugged/remote.rb

@@ -0,0 +1,4 @@
+module Rugged
+  class Remote
+  end
+end

data/lib/rugged/repository.rb

@@ -0,0 +1,227 @@
+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
+  # to you.
+  class Repository
+    # Pretty formatting of a Repository.
+    #
+    # Returns a very pretty String.
+    def inspect
+      "#<Rugged::Repository:#{object_id} {path: #{path.inspect}}>"
+    end
+
+    # Get the most recent commit from this repo.
+    #
+    # Returns a Rugged::Commit object.
+    def last_commit
+      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 = {})
+      left = rev_parse(left) if left.kind_of?(String)
+      right = rev_parse(right) if right.kind_of?(String)
+
+      if !left.is_a?(Rugged::Tree) && !left.is_a?(Rugged::Commit) && !left.nil?
+        raise TypeError, "Expected a Rugged::Tree or Rugged::Commit instance"
+      end
+
+      if !right.is_a?(Rugged::Tree) && !right.is_a?(Rugged::Commit) && !right.nil?
+        raise TypeError, "Expected a Rugged::Tree or Rugged::Commit instance"
+      end
+
+      if left
+        left.diff(right, opts)
+      elsif right
+        right.diff(left, opts.merge(:reverse => !opts[:reverse]))
+      end
+    end
+
+    def diff_workdir(left, opts = {})
+      left = rev_parse(left) if left.kind_of?(String)
+
+      if !left.is_a?(Rugged::Tree) && !left.is_a?(Rugged::Commit)
+        raise TypeError, "Expected a Rugged::Tree or Rugged::Commit instance"
+      end
+
+      left.diff_workdir(opts)
+    end
+
+    # Walks over a set of commits using Rugged::Walker.
+    #
+    # from    - The String SHA1 to push onto Walker to begin our walk.
+    # sorting - The sorting order of the commits, as defined in the README.
+    # block   - A block that we pass into walker#each.
+    #
+    # Returns nothing if called with a block, otherwise returns an instance of
+    # Enumerable::Enumerator containing Rugged::Commit objects.
+    def walk(from, sorting=Rugged::SORT_DATE, &block)
+      walker = Rugged::Walker.new(self)
+      walker.sorting(sorting)
+      walker.push(from)
+      walker.each(&block)
+    end
+
+    # Look up a SHA1.
+    #
+    # Returns one of the four classes that inherit from Rugged::Object.
+    def lookup(oid)
+      Rugged::Object.lookup(self, oid)
+    end
+
+    # Look up an object by a revision string.
+    #
+    # Returns one of the four classes that inherit from Rugged::Object.
+    def rev_parse(spec)
+      Rugged::Object.rev_parse(self, spec)
+    end
+
+    # Look up an object by a revision string.
+    #
+    # Returns the oid of the matched object as a String
+    def rev_parse_oid(spec)
+      Rugged::Object.rev_parse_oid(self, spec)
+    end
+
+    # Look up a single reference by name.
+    #
+    # Example:
+    #
+    #   repo.ref 'refs/heads/master'
+    #   # => #<Rugged::Reference:2199125780 {name: "refs/heads/master",
+    #          target: "25b5d3b40c4eadda8098172b26c68cf151109799"}>
+    #
+    # Returns a Rugged::Reference.
+    def ref(ref_name)
+      references[ref_name]
+    end
+
+    def refs(glob = nil)
+      references.each(glob)
+    end
+
+    def references
+      @references ||= ReferenceCollection.new(self)
+    end
+
+    def ref_names(glob = nil)
+      references.each_name(glob)
+    end
+
+    # All the tags in the repository.
+    #
+    # Returns an TagCollection containing all the tags.
+    def tags
+      @tags ||= TagCollection.new(self)
+    end
+
+    # All the remotes in the repository.
+    #
+    # Returns a Rugged::RemoteCollection containing all the Rugged::Remote objects
+    # in the repository.
+    def remotes
+      @remotes ||= RemoteCollection.new(self)
+    end
+
+    # All the branches in the repository
+    #
+    # Returns an BranchCollection containing Rugged::Branch objects
+    def branches
+      @branches ||= BranchCollection.new(self)
+    end
+
+    # All the submodules in the repository
+    #
+    # Returns an SubmoduleCollection containing Rugged::Submodule objects
+    def submodules
+      @submodules ||= SubmoduleCollection.new(self)
+    end
+
+    # Create a new branch in the repository
+    #
+    # name - The name of the branch (without a full reference path)
+    # sha_or_ref - The target of the branch; either a String representing
+    # an OID or a reference name, or a Rugged::Object instance.
+    #
+    # Returns a Rugged::Branch object
+    def create_branch(name, sha_or_ref = "HEAD")
+      case sha_or_ref
+      when Rugged::Object
+        target = sha_or_ref.oid
+      else
+        target = rev_parse_oid(sha_or_ref)
+      end
+
+      branches.create(name, target)
+    end
+
+    # Get the blob at a path for a specific revision.
+    #
+    # revision - The String SHA1.
+    # path     - The String file path.
+    #
+    # Returns a String.
+    def blob_at(revision, path)
+      tree = Rugged::Commit.lookup(self, revision).tree
+      begin
+        blob_data = tree.path(path)
+      rescue Rugged::TreeError
+        return nil
+      end
+      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,48 @@
+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

@@ -0,0 +1,50 @@
+module Rugged
+  class Tag < Rugged::Reference
+    GPG_SIGNATURE_PREFIX = "-----BEGIN PGP SIGNATURE-----".freeze
+
+    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
+
+      if index = object.data.index(prefix)
+        [
+          object.data.byteslice(index..-1),
+          object.data.byteslice(0...index)
+        ]
+      else
+        [nil, object.data]
+      end
+    end
+
+    def name
+      canonical_name.sub(%r{^refs/tags/}, "")
+    end
+
+    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

@@ -0,0 +1,38 @@
+module Rugged
+  class Tree
+    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" }
+      data
+    end
+
+    # Walks the tree but only yields blobs
+    def walk_blobs(mode=:postorder)
+      self.walk(mode) { |root, e| yield root, e if e[:type] == :blob }
+    end
+
+    # Walks the tree but only yields subtrees
+    def walk_trees(mode=:postorder)
+      self.walk(mode) { |root, e| yield root, e if e[:type] == :tree }
+    end
+
+    # Iterate over the blobs in this tree
+    def each_blob
+      self.each { |e| yield e if e[:type] == :blob }
+    end
+
+    # Iterat over the subtrees in this tree
+    def each_tree
+      self.each { |e| yield e if e[:type] == :tree }
+    end
+  end
+end

data/lib/rugged/version.rb

@@ -0,0 +1,3 @@
+module Rugged
+  Version = VERSION = '0.24.0b13'
+end

data/lib/rugged/walker.rb

@@ -0,0 +1,5 @@
+module Rugged
+  class Walker
+    include Enumerable
+  end
+end

metadata

@@ -0,0 +1,146 @@
+--- !ruby/object:Gem::Specification
+name: rdavila-rugged
+version: !ruby/object:Gem::Version
+  version: 0.24.0b13
+platform: ruby
+authors:
+- Scott Chacon
+- Vicent Marti
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2016-02-12 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rake-compiler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.9.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.9.0
+- !ruby/object:Gem::Dependency
+  name: pry
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+description: |
+  Rugged is a Ruby bindings to the libgit2 linkable C Git library. This is
+  for testing and using the libgit2 library in a language that is awesome.
+email: schacon@gmail.com
+executables: []
+extensions:
+- ext/rugged/extconf.rb
+extra_rdoc_files: []
+files:
+- LICENSE
+- README.md
+- ext/rugged/extconf.rb
+- ext/rugged/rugged.c
+- ext/rugged/rugged.h
+- ext/rugged/rugged_backend.c
+- ext/rugged/rugged_blame.c
+- ext/rugged/rugged_blob.c
+- ext/rugged/rugged_branch.c
+- ext/rugged/rugged_branch_collection.c
+- ext/rugged/rugged_commit.c
+- ext/rugged/rugged_config.c
+- ext/rugged/rugged_cred.c
+- ext/rugged/rugged_diff.c
+- ext/rugged/rugged_diff_delta.c
+- ext/rugged/rugged_diff_hunk.c
+- ext/rugged/rugged_diff_line.c
+- ext/rugged/rugged_index.c
+- ext/rugged/rugged_note.c
+- ext/rugged/rugged_object.c
+- ext/rugged/rugged_patch.c
+- ext/rugged/rugged_reference.c
+- ext/rugged/rugged_reference_collection.c
+- ext/rugged/rugged_remote.c
+- ext/rugged/rugged_remote_collection.c
+- ext/rugged/rugged_repo.c
+- ext/rugged/rugged_revwalk.c
+- ext/rugged/rugged_settings.c
+- ext/rugged/rugged_signature.c
+- ext/rugged/rugged_submodule.c
+- ext/rugged/rugged_submodule_collection.c
+- ext/rugged/rugged_tag.c
+- ext/rugged/rugged_tag_collection.c
+- ext/rugged/rugged_tree.c
+- lib/rugged.rb
+- lib/rugged/attributes.rb
+- lib/rugged/blob.rb
+- lib/rugged/branch.rb
+- lib/rugged/commit.rb
+- lib/rugged/console.rb
+- lib/rugged/credentials.rb
+- lib/rugged/diff.rb
+- lib/rugged/diff/delta.rb
+- lib/rugged/diff/hunk.rb
+- lib/rugged/diff/line.rb
+- lib/rugged/index.rb
+- lib/rugged/object.rb
+- lib/rugged/patch.rb
+- lib/rugged/reference.rb
+- lib/rugged/remote.rb
+- lib/rugged/repository.rb
+- lib/rugged/submodule_collection.rb
+- lib/rugged/tag.rb
+- lib/rugged/tree.rb
+- lib/rugged/version.rb
+- lib/rugged/walker.rb
+homepage: https://github.com/libgit2/rugged
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 1.9.3
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">"
+    - !ruby/object:Gem::Version
+      version: 1.3.1
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.4.8
+signing_key: 
+specification_version: 4
+summary: Rugged is a Ruby binding to the libgit2 linkable library
+test_files: []
+has_rdoc: