clc-git 1.2.8

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: edc5ddca224078904bd029b3e80eb3c5db325d1d
+  data.tar.gz: 0004502da99f70453a78ee742fb9477ec65828ad
+SHA512:
+  metadata.gz: 23f169c450c651ee9f2b18a72f1b507a7c925505775a401c05875ee528f179e02e0995cefb5d1008297bbfacbc31830bd43ebd5829ebdd503b24beaf31a27ba6
+  data.tar.gz: 4f4b73b65c8bef13bf4af7a0565beb18a761b3212a2bd3519ddfba220694ea7d4c44c05b6e1fb39ad2cc6d4d66b47588cc314cd9bc41b07da8f30f6a9a268753

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/README.md

@@ -0,0 +1,268 @@
+# Git Library for Ruby
+
+Library for using Git in Ruby.
+
+## Homepage
+
+Git public hosting of the project source code is at:
+
+http://github.com/schacon/ruby-git
+
+## Install
+
+You can install Ruby/Git like this:
+
+    $ sudo gem install git
+    
+## Code Status
+
+* [![Build Status](https://api.travis-ci.org/schacon/ruby-git.png)](https://travis-ci.org/schacon/ruby-git)
+* [![Code Climate](https://codeclimate.com/github/schacon/ruby-git.png)](https://codeclimate.com/github/schacon/ruby-git)
+* [![Gem Version](https://badge.fury.io/rb/git.png)](http://badge.fury.io/rb/git)
+* [![Dependencies](https://gemnasium.com/schacon/ruby-git.png?travis)](https://gemnasium.com/schacon/ruby-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'
+```
+
+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.diff(commit1, commit2).size
+    g.diff(commit1, commit2).stats
+    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
+```
+
+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('file.txt')
+     g.remove(['file.txt', 'file2.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.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.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.rb

@@ -0,0 +1,148 @@
+# Add the directory containing this file to the start of the load path if it
+# isn't there already.
+$:.unshift(File.dirname(__FILE__)) unless
+  $:.include?(File.dirname(__FILE__)) || $:.include?(File.expand_path(File.dirname(__FILE__)))
+
+require 'git/author'
+require 'git/base'
+require 'git/branch'
+require 'git/branches'
+require 'git/diff'
+require 'git/index'
+require 'git/lib'
+require 'git/log'
+require 'git/object'
+require 'git/path'
+require 'git/remote'
+require 'git/repository'
+require 'git/status'
+require 'git/stash'
+require 'git/stashes'
+require 'git/working_directory'
+
+lib = Git::Lib.new(nil, nil)
+unless lib.meets_required_version?
+  $stderr.puts "[WARNING] The git gem requires git #{lib.required_command_version.join('.')} or later, but only found #{lib.current_command_version.join('.')}. You should probably upgrade."
+end
+
+# Git/Ruby Library
+#
+# This provides bindings for working with git in complex
+# interactions, including branching and merging, object
+# inspection and manipulation, history, patch generation
+# and more.  You should be able to do most fundamental git
+# operations with this library.
+#
+# This module provides the basic functions to open a git 
+# reference to work with. You can open a working directory,
+# open a bare repository, initialize a new repo or clone an
+# existing remote repository.
+#
+# Author::    Scott Chacon (mailto:schacon@gmail.com)
+# License::   MIT License
+module Git
+  
+  #g.config('user.name', 'Scott Chacon') # sets value
+  #g.config('user.email', 'email@email.com')  # sets value
+  #g.config('user.name')  # returns 'Scott Chacon'
+  #g.config # returns whole config hash
+  def config(name = nil, value = nil)
+    lib = Git::Lib.new
+    if(name && value)
+      # set value
+      lib.config_set(name, value)
+    elsif (name)
+      # return value
+      lib.config_get(name)
+    else
+      # return hash
+      lib.config_list
+    end
+  end
+
+  def global_config(name = nil, value = nil)
+    self.class.global_config(name, value)
+  end
+
+  # open a bare repository
+  #
+  # this takes the path to a bare git repo
+  # it expects not to be able to use a working directory
+  # so you can't checkout stuff, commit things, etc.
+  # but you can do most read operations
+  def self.bare(git_dir, options = {})
+    Base.bare(git_dir, options)
+  end
+    
+  # clones a remote repository
+  #
+  # options
+  #   :bare => true (does a bare clone)
+  #   :repository => '/path/to/alt_git_dir'
+  #   :index => '/path/to/alt_index_file'
+  #
+  # example
+  #  Git.clone('git://repo.or.cz/rubygit.git', 'clone.git', :bare => true)
+  #
+  def self.clone(repository, name, options = {})
+    Base.clone(repository, name, options)
+  end
+
+  # Export the current HEAD (or a branch, if <tt>options[:branch]</tt>
+  # is specified) into the +name+ directory, then remove all traces of git from the
+  # directory.
+  #
+  # See +clone+ for options.  Does not obey the <tt>:remote</tt> option,
+  # since the .git info will be deleted anyway; always uses the default
+  # remote, 'origin.'
+  def self.export(repository, name, options = {})
+    options.delete(:remote)
+    repo = clone(repository, name, {:depth => 1}.merge(options))
+    repo.checkout("origin/#{options[:branch]}") if options[:branch]
+    Dir.chdir(repo.dir.to_s) { FileUtils.rm_r '.git' }
+  end
+  
+  # Same as g.config, but forces it to be at the global level
+  #
+  #g.config('user.name', 'Scott Chacon') # sets value
+  #g.config('user.email', 'email@email.com')  # sets value
+  #g.config('user.name')  # returns 'Scott Chacon'
+  #g.config # returns whole config hash
+  def self.global_config(name = nil, value = nil)
+    lib = Git::Lib.new(nil, nil)
+    if(name && value)
+      # set value
+      lib.global_config_set(name, value)
+    elsif (name)
+      # return value
+      lib.global_config_get(name)
+    else
+      # return hash
+      lib.global_config_list
+    end
+  end
+
+  # initialize a new git repository, defaults to the current working directory
+  #
+  # options
+  #   :repository => '/path/to/alt_git_dir'
+  #   :index => '/path/to/alt_index_file'
+  def self.init(working_dir = '.', options = {})
+    Base.init(working_dir, options)
+  end
+
+  # open an existing git working directory
+  # 
+  # this will most likely be the most common way to create
+  # a git reference, referring to a working directory.
+  # if not provided in the options, the library will assume
+  # your git_dir and index are in the default place (.git/, .git/index)
+  #
+  # options
+  #   :repository => '/path/to/alt_git_dir'
+  #   :index => '/path/to/alt_index_file'
+  def self.open(working_dir, options = {})
+    Base.open(working_dir, options)
+  end
+    
+end

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