git-ce 1.5.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: d274c0da6b1ae1db1b1b0157c41d081ced0012ebf3623a059d6a740018e362bc
+  data.tar.gz: f5ef516ae6892b64aecf6f7db37e5b7c29d22d6bc745bee9bf52f12357dc3508
+SHA512:
+  metadata.gz: 7a19e2ca8afea46f96a24c160c44cd265865eb1855325a6707a1413fd6e8b3bf00a59d31bcfd5a5344ef1ffbf263158ef516d0cbc8de8857b7158c82be9e0c62
+  data.tar.gz: b0806117c6c7a9102f31ad4835854aba31656208cd0a30f9156abf67f1ae57d8d92b2f4670e120f0bf8382d364a4ccffc53aaee83de0a82d9b304feff09d816f

data/CHANGELOG.md

@@ -0,0 +1,94 @@
+# Change Log
+
+## 1.5.0
+
+See https://github.com/ruby-git/ruby-git/releases/tag/v1.5.0
+
+## 1.4.0
+
+See https://github.com/ruby-git/ruby-git/releases/tag/v1.4.0
+
+## 1.3.0
+
+ * Dropping Ruby 1.8.x support
+
+## 1.2.10
+
+ * Adding Git::Diff.name_status
+ * Checking and fixing encoding on commands output to prevent encoding errors afterwards
+
+## 1.2.9
+
+* Adding Git.configure (to configure the git env)
+* Adding Git.ls_remote [Git.ls_remote(repo_path_or_url='.')]
+* Adding Git.describe [repo.describe(objectish, opts)]
+* Adding Git.show [repo.show(objectish=nil, path=nil)]
+* Fixing Git::Diff to support default references (implicit references)
+* Fixing Git::Diff to support diff over git .patch files
+* Fixing Git.checkout when using :new_branch opt
+* Fixing Git::Object::Commit to preserve its sha after fetching metadata
+* Fixing Git.is_remote_branch? to actually check against remote branches
+* Improvements over how ENV variables are modified
+* Improving thrade safety (using --git-dir and --work-tree git opts)
+* Improving Git::Object::Tag. Adding annotated?, tagger and message
+* Supporting a submodule path as a valid repo
+* Git.checkout - supporting -f and -b
+* Git.clone - supporting --branch
+* Git.fetch - supporting --prune
+* Git.tag - supporting
+
+## 1.2.8
+
+* Keeping the old escape format for windows users
+* revparse: Supporting ref names containing SHA like substrings (40-hex strings)
+* Fix warnings on Ruby 2.1.2
+
+## 1.2.7
+
+* Fixing mesages encoding
+* Fixing -f flag in git push
+* Fixing log parser for multiline messages
+* Supporting object references on Git.add_tag
+* Including dotfiles on Git.status
+* Git.fetch - supporting --tags
+* Git.clean - supporting -x
+* Git.add_tag options - supporting -a, -m and -s
+* Added Git.delete_tag
+
+## 1.2.6
+
+* Ruby 1.9.X/2.0 fully supported
+* JRuby 1.8/1.9 support
+* Rubinius support
+* Git.clone - supporting --recursive and --config
+* Git.log - supporting last and [] over the results
+* Git.add_remote - supporting -f and -t
+* Git.add - supporting --fore
+* Git.init - supporting --bare
+* Git.commit - supporting --all and --amend
+* Added Git.remote_remote, Git.revert and Git.clean
+* Added Bundler to the formula
+* Travis configuration
+* Licence included with the gem
+
+## 1.0.4
+
+* added camping/gitweb.rb frontend
+* added a number of speed-ups
+
+## 1.0.3
+
+* Sped up most of the operations
+* Added some predicate functions (commit?, tree?, etc)
+* Added a number of lower level operations (read-tree, write-tree, checkout-index, etc)
+* Fixed a bug with using bare repositories
+* Updated a good amount of the documentation
+
+## 1.0.2
+
+* Added methods to the git objects that might be helpful
+
+## 1.0.1
+
+* Initial version
+

data/CONTRIBUTING.md

@@ -0,0 +1,135 @@
+# ruby-git-ce
+
+The ruby-git Community Edition is a fork of the awesome but incomplete and
+unmaintained ruby-git gem.
+
+The aim of this fork is to accept people's pull requests, then allow to accept
+other pull requests, and so on.
+
+With this principle, when I'll not be available next time, this repository will
+not be abandoned, and people can still rely on it.
+I want to be sure this little piece of love, that is this library, will never
+stop growing, even when I'll be on something else.
+
+BTW there will be NO stupid bots closing your PRs ! (Who the hell is the stupid
+guy who invented this absurd concept ... 🤦‍)
+
+If this kind of ways is working fine, that would be great to creation an
+organisation to group those Community Editions all together.
+
+Anyway, it's a new concept I'd like to try ! 😉
+
+# Contributing to ruby-git-ce
+
+Thank you for your interest in contributing to this project.
+
+These are mostly guidelines, not rules.
+Use your best judgment, and feel free to propose changes to this document in a
+pull request.
+
+#### Table Of Contents
+
+[How Can I Contribute?](#how-can-i-contribute)
+  * [Submitting Issues](#submitting-issues)
+  * [Contribution Process](#contribution-process)
+  * [Pull Request Requirements](#pull-request-requirements)
+  * [Code Review Process](#code-review-process)
+  * [Developer Certification of Origin (DCO)](#developer-certification-of-origin-dco)
+
+
+## How Can I Contribute?
+
+### Submitting Issues
+
+We utilize **GitHub Issues** for issue tracking and contributions.
+You can contribute in two ways:
+
+1. Reporting an issue or making a feature request [here](https://github.com/zedtux/ruby-git-ce/issues/new).
+2. Adding features or fixing bugs yourself and contributing your code to
+ruby-git-ce.
+
+### Contribution Process
+
+We have a 3 step process for contributions:
+
+1. Commit changes to a git branch in your fork.  Making sure to sign-off those
+changes for the [Developer Certificate of Origin](#developer-certification-of-origin-dco).
+2. Create a GitHub Pull Request for your change, following the instructions in
+the pull request template.
+3. Perform a [Code Review](#code-review-process) with the project maintainers
+on the pull request.
+
+### Pull Request Requirements
+In order to ensure high quality, we require that all pull requests to this
+project meet these specifications:
+
+1. Unit Testing: We require all the new code to include unit tests, and any
+fixes to pass previous units.
+2. Green CI Tests: We are using [Travis CI](https://travis-ci.org/zedtux/ruby-git-ce)
+to run unit tests on various ruby versions, we expect them to all pass before a
+pull request will be merged.
+3. Up-to-date Documentation: New methods as well as updated methods should have
+[YARD](https://yardoc.org/) documentation added to them
+
+### Code Review Process
+
+Code review takes place in GitHub pull requests. See [this article](https://help.github.com/articles/about-pull-requests/)
+if you're not familiar with GitHub Pull Requests.
+
+Once you open a pull request, project maintainers will review your code and
+respond to your pull request with any feedback they might have.
+
+The process at this point is as follows:
+
+1. One thumbs-up (:+1:) is required from project maintainers. See the master
+maintainers document for the ruby-git-ce project at <https://github.com/zedtux/ruby-git-ce/blob/master/MAINTAINERS.md>.
+2. When ready, your pull request will be merged into `master`, we may require
+you to rebase your PR to the latest `master`.
+
+### Developer Certification of Origin (DCO)
+
+Licensing is very important to open source projects. It helps ensure the
+software continues to be available under the terms that the author desired.
+
+ruby-git-ce uses [the MIT license](https://github.com/zedtux/ruby-git-ce/blob/master/LICENSE)
+
+Detail about the LICENSE can be found [here](https://choosealicense.com/licenses/mit/)
+
+To make a good faith effort to ensure these criteria are met, ruby-git-ce
+requires the Developer Certificate of Origin (DCO) process to be followed.
+
+The DCO is an attestation attached to every contribution made by every
+developer.
+
+In the commit message of the contribution, the developer simply adds a
+Signed-off-by statement and thereby agrees to the DCO, which you can find below
+or at <http://developercertificate.org/>.
+
+```
+Developer's Certificate of Origin 1.1
+
+By making a contribution to this project, I certify that:
+
+(a) The contribution was created in whole or in part by me and I
+    have the right to submit it under the open source license
+    indicated in the file; or
+
+(b) The contribution is based upon previous work that, to the
+    best of my knowledge, is covered under an appropriate open
+    source license and I have the right under that license to   
+    submit that work with modifications, whether created in whole
+    or in part by me, under the same open source license (unless
+    I am permitted to submit under a different license), as
+    Indicated in the file; or
+
+(c) The contribution was provided directly to me by some other
+    person who certified (a), (b) or (c) and I have not modified
+    it.
+
+(d) I understand and agree that this project and the contribution
+    are public and that a record of the contribution (including
+    all personal information I submit with it, including my
+    sign-off) is maintained indefinitely and may be redistributed
+    consistent with this project or the open source license(s)
+    involved.
+```

data/LICENSE

@@ -0,0 +1,21 @@
+The MIT License
+
+Copyright (c) 2008 Scott Chacon
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/MAINTAINERS.md

@@ -0,0 +1,8 @@
+# Maintainers
+
+When making changes to the system, this file tells you who needs to review your patch - you need at least two maintainers to provide a :+1: on your pull request.
+
+### Maintainers
+
+* [Per Lundberg](https://github.com/perlun)
+* [Vern Burton](https://github.com/tarcinil)

data/README.md

@@ -0,0 +1,313 @@
+# Git Library for Ruby
+
+Library for using Git in Ruby.
+
+## Homepage
+
+Git public hosting of the project source code is at:
+
+http://github.com/zedtux/ruby-git-ce
+
+## Install
+
+You can install Ruby/Git like this:
+
+    $ sudo gem install git
+
+## Code Status
+
+* [![Build Status](https://travis-ci.org/zedtux/ruby-git-ce.svg?branch=master)](https://travis-ci.org/zedtux/ruby-git-ce)
+* [![Code Climate](https://codeclimate.com/github/zedtux/ruby-git-ce.png)](https://codeclimate.com/github/zedtux/ruby-git-ce)
+* [![Gem Version](https://badge.fury.io/rb/git.png)](http://badge.fury.io/rb/git)
+
+## Major Objects
+
+**Git::Base** - The object returned from a `Git.open` or `Git.clone`.
+Most major actions are called from this object.
+
+**Git::Object** - The base object for your tree, blob and commit objects,
+returned from `@git.gtree` or `@git.object` calls.  the `Git::AbstractObject`
+will have most of the calls in common for all those objects.
+
+**Git::Diff** - returns from a `@git.diff` command.  It is an Enumerable that
+returns `Git::Diff:DiffFile` objects from which you can get per file patches and
+insertion/deletion statistics.  You can also get total statistics from the
+Git::Diff object directly.
+
+**Git::Status** - returns from a `@git.status` command.  It is an Enumerable
+that returns `Git:Status::StatusFile` objects for each object in git, which
+includes files in the working directory, in the index and in the repository.
+Similar to running 'git status' on the command line to determine untracked and
+changed files.
+
+**Git::Branches** - Enumerable object that holds `Git::Branch objects`.
+You can call .local or .remote on it to filter to just your local or remote
+branches.
+
+**Git::Remote**- A reference to a remote repository that is tracked by this
+repository.
+
+**Git::Log** - An Enumerable object that references all the
+`Git::Object::Commit` objects that encompass your log query, which can be
+constructed through methods on the `Git::Log object`,
+like:
+
+ `@git.log(20).object("some_file").since("2 weeks ago").between('v2.6', 'v2.7').each { |commit| [block] }`
+
+## Examples
+
+Here are a bunch of examples of how to use the Ruby/Git package.
+
+Ruby < 1.9 will require rubygems to be loaded.
+
+```ruby
+    require 'rubygems'
+```
+
+Require the 'git' gem.
+```ruby
+    require 'git'
+```
+
+Git env config
+
+```ruby
+  Git.configure do |config|
+    # If you want to use a custom git binary
+    config.binary_path = '/git/bin/path'
+
+    # If you need to use a custom SSH script
+    config.git_ssh = '/path/to/ssh/script'
+  end
+
+```
+
+
+Here are the operations that need read permission only.
+
+```ruby
+    g = Git.open(working_dir, :log => Logger.new(STDOUT))
+
+    g.index
+    g.index.readable?
+    g.index.writable?
+    g.repo
+    g.dir
+
+    g.log   # returns array of Git::Commit objects
+    g.log.since('2 weeks ago')
+    g.log.between('v2.5', 'v2.6')
+    g.log.each {|l| puts l.sha }
+    g.gblob('v2.5:Makefile').log.since('2 weeks ago')
+
+    g.object('HEAD^').to_s  # git show / git rev-parse
+    g.object('HEAD^').contents
+    g.object('v2.5:Makefile').size
+    g.object('v2.5:Makefile').sha
+
+    g.gtree(treeish)
+    g.gblob(treeish)
+    g.gcommit(treeish)
+
+
+    commit = g.gcommit('1cc8667014381')
+
+    commit.gtree
+    commit.parent.sha
+    commit.parents.size
+    commit.author.name
+    commit.author.email
+    commit.author.date.strftime("%m-%d-%y")
+    commit.committer.name
+    commit.date.strftime("%m-%d-%y")
+    commit.message
+
+    tree = g.gtree("HEAD^{tree}")
+
+    tree.blobs
+    tree.subtrees
+    tree.children # blobs and subtrees
+
+    g.revparse('v2.5:Makefile')
+
+    g.branches # returns Git::Branch objects
+    g.branches.local
+    g.branches.remote
+    g.branches[:master].gcommit
+    g.branches['origin/master'].gcommit
+
+    g.grep('hello')  # implies HEAD
+    g.blob('v2.5:Makefile').grep('hello')
+    g.tag('v2.5').grep('hello', 'docs/')
+    g.describe()
+    g.describe('0djf2aa')
+    g.describe('HEAD', {:all => true, :tags => true})
+
+    g.diff(commit1, commit2).size
+    g.diff(commit1, commit2).stats
+    g.diff(commit1, commit2).name_status
+    g.gtree('v2.5').diff('v2.6').insertions
+    g.diff('gitsearch1', 'v2.5').path('lib/')
+    g.diff('gitsearch1', @git.gtree('v2.5'))
+    g.diff('gitsearch1', 'v2.5').path('docs/').patch
+    g.gtree('v2.5').diff('v2.6').patch
+
+    g.gtree('v2.5').diff('v2.6').each do |file_diff|
+       puts file_diff.path
+       puts file_diff.patch
+       puts file_diff.blob(:src).contents
+    end
+
+    g.config('user.name')  # returns 'Scott Chacon'
+    g.config # returns whole config hash
+
+    g.tags # returns array of Git::Tag objects
+
+    g.show()
+    g.show('HEAD')
+    g.show('v2.8', 'README.md')
+
+    # returns a hash containing the available references of the repo.
+    Git.ls_remote('https://github.com/zedtux/ruby-git-ce.git')
+    Git.ls_remote('/path/to/local/repo')
+    Git.ls_remote() # same as Git.ls_remote('.')
+
+```
+
+And here are the operations that will need to write to your git repository.
+
+```ruby
+      g = Git.init
+       Git.init('project')
+       Git.init('/home/schacon/proj',
+        { :repository => '/opt/git/proj.git',
+           :index => '/tmp/index'} )
+
+     g = Git.clone(URI, NAME, :path => '/tmp/checkout')
+     g.config('user.name', 'Scott Chacon')
+     g.config('user.email', 'email@email.com')
+
+     g.add                                   # git add -- "."
+     g.add(:all=>true)                       # git add --all -- "."
+     g.add('file_path')                      # git add -- "file_path"
+     g.add(['file_path_1', 'file_path_2'])   # git add -- "file_path_1" "file_path_2"
+
+     g.remove()									# git rm -f -- "."
+     g.remove('file.txt')						# git rm -f -- "file.txt"
+     g.remove(['file.txt', 'file2.txt'])		# git rm -f -- "file.txt" "file2.txt"
+     g.remove('file.txt', :recursive => true) 	# git rm -f -r -- "file.txt"
+     g.remove('file.txt', :cached => true)		# git rm -f --cached -- "file.txt"
+
+     g.commit('message')
+     g.commit_all('message')
+
+     g = Git.clone(repo, 'myrepo')
+     g.chdir do
+      new_file('test-file', 'blahblahblah')
+      g.status.changed.each do |file|
+       puts file.blob(:index).contents
+      end
+     end
+
+     g.reset # defaults to HEAD
+     g.reset_hard(Git::Commit)
+
+     g.branch('new_branch') # creates new or fetches existing
+     g.branch('new_branch').checkout
+     g.branch('new_branch').delete
+     g.branch('existing_branch').checkout
+     g.branch('master').contains?('existing_branch')
+
+     g.checkout('new_branch')
+     g.checkout(g.branch('new_branch'))
+
+     g.branch(name).merge(branch2)
+     g.branch(branch2).merge  # merges HEAD with branch2
+
+     g.branch(name).in_branch(message) { # add files }  # auto-commits
+     g.merge('new_branch')
+     g.merge('origin/remote_branch')
+     g.merge(g.branch('master'))
+     g.merge([branch1, branch2])
+
+     r = g.add_remote(name, uri)  # Git::Remote
+     r = g.add_remote(name, Git::Base)  # Git::Remote
+
+     g.remotes  # array of Git::Remotes
+     g.remote(name).fetch
+     g.remote(name).remove
+     g.remote(name).merge
+     g.remote(name).merge(branch)
+
+     g.fetch
+     g.fetch(g.remotes.first)
+     g.fetch('origin', {:ref => 'some/ref/head'} )
+
+     g.pull
+     g.pull(Git::Repo, Git::Branch) # fetch and a merge
+
+     g.add_tag('tag_name') # returns Git::Tag
+     g.add_tag('tag_name', 'object_reference')
+     g.add_tag('tag_name', 'object_reference', {:options => 'here'})
+     g.add_tag('tag_name', {:options => 'here'})
+
+     Options:
+       :a | :annotate
+       :d
+       :f
+       :m | :message
+       :s
+
+     g.delete_tag('tag_name')
+
+     g.repack
+
+     g.push
+     g.push(g.remote('name'))
+```
+
+Some examples of more low-level index and tree operations
+
+```ruby
+     g.with_temp_index do
+
+       g.read_tree(tree3) # calls self.index.read_tree
+       g.read_tree(tree1, :prefix => 'hi/')
+
+       c = g.commit_tree('message')
+       # or #
+       t = g.write_tree
+       c = g.commit_tree(t, :message => 'message', :parents => [sha1, sha2])
+
+       g.branch('branch_name').update_ref(c)
+       g.update_ref(branch, c)
+
+       g.with_temp_working do # new blank working directory
+         g.checkout
+         g.checkout(another_index)
+         g.commit # commits to temp_index
+       end
+     end
+
+     g.set_index('/path/to/index')
+
+
+     g.with_index(path) do
+       # calls set_index, then switches back after
+     end
+
+     g.with_working(dir) do
+     # calls set_working, then switches back after
+     end
+
+     g.with_temp_working(dir) do
+       g.checkout_index(:prefix => dir, :path_limiter => path)
+       # do file work
+       g.commit # commits to index
+     end
+```
+
+## License
+
+licensed under MIT License Copyright (c) 2008  Scott Chacon. See LICENSE for
+further details.

data/lib/git/author.rb

@@ -0,0 +1,14 @@
+module Git
+  class Author
+    attr_accessor :name, :email, :date
+    
+    def initialize(author_string)
+      if m = /(.*?) <(.*?)> (\d+) (.*)/.match(author_string)
+        @name = m[1]
+        @email = m[2]
+        @date = Time.at(m[3].to_i)
+      end
+    end
+    
+  end
+end

data/lib/git/base/factory.rb

@@ -0,0 +1,75 @@
+module Git
+
+  class Base
+
+    module Factory
+      
+      # returns a Git::Branch object for branch_name
+      def branch(branch_name = 'master')
+        Git::Branch.new(self, branch_name)
+      end
+
+      # returns a Git::Branches object of all the Git::Branch 
+      # objects for this repo
+      def branches
+        Git::Branches.new(self)
+      end
+      
+      def commit_tree(tree = nil, opts = {})
+        Git::Object::Commit.new(self, self.lib.commit_tree(tree, opts))
+      end
+
+      # returns a Git::Diff object
+      def diff(objectish = 'HEAD', obj2 = nil)
+        Git::Diff.new(self, objectish, obj2)
+      end
+      
+      def gblob(objectish)
+        Git::Object.new(self, objectish, 'blob')
+      end
+      
+      def gcommit(objectish)
+        Git::Object.new(self, objectish, 'commit')
+      end
+
+      def gtree(objectish)
+        Git::Object.new(self, objectish, 'tree')
+      end
+      
+      # returns a Git::Log object with count commits
+      def log(count = 30)
+        Git::Log.new(self, count)
+      end
+      
+      # returns a Git::Object of the appropriate type
+      # you can also call @git.gtree('tree'), but that's 
+      # just for readability.  If you call @git.gtree('HEAD') it will
+      # still return a Git::Object::Commit object.  
+      #
+      # @git.object calls a factory method that will run a rev-parse 
+      # on the objectish and determine the type of the object and return 
+      # an appropriate object for that type 
+      def object(objectish)
+        Git::Object.new(self, objectish)
+      end
+  
+      # returns a Git::Remote object
+      def remote(remote_name = 'origin')
+        Git::Remote.new(self, remote_name)
+      end
+
+      # returns a Git::Status object
+      def status
+        Git::Status.new(self)
+      end
+    
+      # returns a Git::Tag object
+      def tag(tag_name)
+        Git::Object.new(self, tag_name, 'tag', true)
+      end
+
+    end
+
+  end
+
+end