ruby-git-yz 1.3.3

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 1bc4cd37c73a1a0de02f66af9e26a5f461da4a92
+  data.tar.gz: 9d18f38cfaa1b43c78d72159a4ffbb52cd1d09a4
+SHA512:
+  metadata.gz: 953a988118f8f471ade0d628ec2612b4de804a0627590859499b20ba6a1a211d64ebed3c2b2696c3aa814a779d0d1f58cd2c43bb5dc21e2d0c91fb37f390ed2a
+  data.tar.gz: 635260465a710f273317698071dd3ef53b68f2f703db8d8b4ff125b7354d1a1a7b9311a441746383ae244c1a214b32fca2743352379afd3dbbecbb1a186625d8

data/CHANGELOG

@@ -0,0 +1,84 @@
+== 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/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,297 @@
+# 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'
+```
+
+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')
+
+    Git.ls_remote('https://github.com/schacon/ruby-git.git') # returns a hash containing the available references of the repo.
+    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.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/VERSION

@@ -0,0 +1,2 @@
+1.3.0
+

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.rb

@@ -0,0 +1,540 @@
+require 'git/base/factory'
+
+module Git
+  
+  class Base
+
+    include Git::Base::Factory
+
+    # opens a bare Git Repository - no working directory options
+    def self.bare(git_dir, opts = {})
+      self.new({:repository => git_dir}.merge(opts))
+    end
+    
+    # clones a git repository locally
+    #
+    #  repository - http://repo.or.cz/w/sinatra.git
+    #  name - sinatra
+    #
+    # options:
+    #   :repository
+    #
+    #    :bare
+    #   or 
+    #    :working_directory
+    #    :index_file
+    #
+    def self.clone(repository, name, opts = {})
+      # run git-clone 
+      self.new(Git::Lib.new.clone(repository, name, opts))
+    end
+    
+    # Returns (and initialize if needed) a Git::Config instance
+    #
+    # @return [Git::Config] the current config instance.
+    def self.config
+      return @@config ||= Config.new
+    end
+
+    # initializes a git repository
+    #
+    # options:
+    #  :bare
+    #  :index
+    #  :repository
+    #
+    def self.init(working_dir, opts = {})
+      opts[:working_directory] ||= working_dir 
+      opts[:repository] ||= File.join(opts[:working_directory], '.git')
+      
+      FileUtils.mkdir_p(opts[:working_directory]) if opts[:working_directory] && !File.directory?(opts[:working_directory])
+      
+      init_opts = {
+        :bare => opts[:bare]
+      }
+
+      opts.delete(:working_directory) if opts[:bare]
+      
+      # Submodules have a .git *file* not a .git folder.
+      # This file's contents point to the location of
+      # where the git refs are held (In the parent repo)
+      if File.file?('.git')
+        git_file = File.open('.git').read[8..-1].strip
+        opts[:repository] = git_file
+        opts[:index] = git_file + '/index'
+      end
+
+      Git::Lib.new(opts).init(init_opts)
+       
+      self.new(opts)
+    end
+    
+    # opens a new Git Project from a working directory
+    # you can specify non-standard git_dir and index file in the options
+    def self.open(working_dir, opts={})
+      self.new({:working_directory => working_dir}.merge(opts))
+    end
+    
+    def initialize(options = {})
+      if working_dir = options[:working_directory]
+        options[:repository] ||= File.join(working_dir, '.git')
+        options[:index] ||= File.join(working_dir, '.git', 'index')
+      end
+      if options[:log]
+        @logger = options[:log]
+        @logger.info("Starting Git")
+      else
+        @logger = nil
+      end
+     
+      @working_directory = options[:working_directory] ? Git::WorkingDirectory.new(options[:working_directory]) : nil
+      @repository = options[:repository] ? Git::Repository.new(options[:repository]) : nil 
+      @index = options[:index] ? Git::Index.new(options[:index], false) : nil
+    end
+    
+    # changes current working directory for a block
+    # to the git working directory
+    #
+    # example
+    #  @git.chdir do 
+    #    # write files
+    #    @git.add
+    #    @git.commit('message')
+    #  end
+    def chdir # :yields: the Git::Path
+      Dir.chdir(dir.path) do
+        yield dir.path
+      end
+    end
+    
+    #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)
+      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
+  
+    # returns a reference to the working directory
+    #  @git.dir.path
+    #  @git.dir.writeable?
+    def dir
+      @working_directory
+    end
+    
+    # returns reference to the git index file
+    def index
+      @index
+    end
+
+    # returns reference to the git repository directory
+    #  @git.dir.path
+    def repo
+      @repository
+    end
+    
+    # returns the repository size in bytes
+    def repo_size
+      Dir.chdir(repo.path) do
+        return `du -s`.chomp.split.first.to_i
+      end
+    end
+    
+    def set_index(index_file, check = true)
+      @lib = nil
+      @index = Git::Index.new(index_file.to_s, check)
+    end
+    
+    def set_working(work_dir, check = true)
+      @lib = nil
+      @working_directory = Git::WorkingDirectory.new(work_dir.to_s, check)
+    end
+    
+    # returns +true+ if the branch exists locally
+    def is_local_branch?(branch)
+      branch_names = self.branches.local.map {|b| b.name}
+      branch_names.include?(branch)
+    end
+
+    # returns +true+ if the branch exists remotely
+    def is_remote_branch?(branch)
+      branch_names = self.branches.remote.map {|b| b.name}
+      branch_names.include?(branch)
+    end
+
+    # returns +true+ if the branch exists
+    def is_branch?(branch)
+      branch_names = self.branches.map {|b| b.name}
+      branch_names.include?(branch)
+    end
+
+    # this is a convenience method for accessing the class that wraps all the 
+    # actual 'git' forked system calls.  At some point I hope to replace the Git::Lib
+    # class with one that uses native methods or libgit C bindings
+    def lib
+      @lib ||= Git::Lib.new(self, @logger)
+    end
+    
+    # will run a grep for 'string' on the HEAD of the git repository
+    # 
+    # to be more surgical in your grep, you can call grep() off a specific
+    # git object.  for example:
+    #
+    #  @git.object("v2.3").grep('TODO')
+    #
+    # in any case, it returns a hash of arrays of the type:
+    #  hsh[tree-ish] = [[line_no, match], [line_no, match2]]
+    #  hsh[tree-ish] = [[line_no, match], [line_no, match2]]
+    #
+    # so you might use it like this:
+    #
+    #   @git.grep("TODO").each do |sha, arr|
+    #     puts "in blob #{sha}:"
+    #     arr.each do |match|
+    #       puts "\t line #{match[0]}: '#{match[1]}'"
+    #     end
+    #   end
+    def grep(string, path_limiter = nil, opts = {})
+      self.object('HEAD').grep(string, path_limiter, opts)
+    end
+    
+    # updates the repository index using the working directory content
+    #
+    #    @git.add('path/to/file')
+    #    @git.add(['path/to/file1','path/to/file2'])
+    #    @git.add(:all => true)
+    #
+    # options:
+    #   :all => true
+    #
+    # @param [String,Array] paths files paths to be added (optional, default='.')
+    # @param [Hash] options
+    def add(*args)
+      if args[0].instance_of?(String) || args[0].instance_of?(Array)
+        self.lib.add(args[0],args[1]||{})
+      else
+        self.lib.add('.', args[0]||{})
+      end
+    end
+
+    # removes file(s) from the git repository
+    def remove(path = '.', opts = {})
+      self.lib.remove(path, opts)
+    end
+
+    # resets the working directory to the provided commitish
+    def reset(commitish = nil, opts = {})
+      self.lib.reset(commitish, opts)
+    end
+
+    # resets the working directory to the commitish with '--hard'
+    def reset_hard(commitish = nil, opts = {})
+      opts = {:hard => true}.merge(opts)
+      self.lib.reset(commitish, opts)
+    end
+
+    # cleans the working directory
+    #
+    # options:
+    #  :force
+    #  :d
+    #
+    def clean(opts = {})
+      self.lib.clean(opts)
+    end
+
+    #  returns the most recent tag that is reachable from a commit
+    #
+    # options:
+    #  :all
+    #  :tags
+    #  :contains
+    #  :debug
+    #  :exact_match
+    #  :dirty
+    #  :abbrev
+    #  :candidates
+    #  :long
+    #  :always
+    #  :match
+    #
+    def describe(committish=nil, opts={})
+      self.lib.describe(committish, opts)
+    end
+
+    # reverts the working directory to the provided commitish.
+    # Accepts a range, such as comittish..HEAD
+    #
+    # options:
+    #   :no_edit
+    #
+    def revert(commitish = nil, opts = {})
+      self.lib.revert(commitish, opts)
+    end
+
+    # commits all pending changes in the index file to the git repository
+    # 
+    # options:
+    #   :all
+    #   :allow_empty
+    #   :amend
+    #   :author
+    #
+    def commit(message, opts = {})
+      self.lib.commit(message, opts)
+    end
+        
+    # commits all pending changes in the index file to the git repository,
+    # but automatically adds all modified files without having to explicitly
+    # calling @git.add() on them.  
+    def commit_all(message, opts = {})
+      opts = {:add_all => true}.merge(opts)
+      self.lib.commit(message, opts)
+    end
+
+    # checks out a branch as the new git working directory
+    def checkout(branch = 'master', opts = {})
+      self.lib.checkout(branch, opts)
+    end
+    
+    # checks out an old version of a file
+    def checkout_file(version, file)
+      self.lib.checkout_file(version,file)
+    end
+
+    # fetches changes from a remote branch - this does not modify the working directory,
+    # it just gets the changes from the remote if there are any
+    def fetch(remote = 'origin', opts={})
+      self.lib.fetch(remote, opts)
+    end
+
+    # pushes changes to a remote repository - easiest if this is a cloned repository,
+    # otherwise you may have to run something like this first to setup the push parameters:
+    #
+    #  @git.config('remote.remote-name.push', 'refs/heads/master:refs/heads/master')
+    #
+    def push(remote = 'origin', branch = 'master', opts = {})
+      # Small hack to keep backwards compatibility with the 'push(remote, branch, tags)' method signature.
+      opts = {:tags => opts} if [true, false].include?(opts)
+
+      self.lib.push(remote, branch, opts)
+    end
+    
+    # merges one or more branches into the current working branch
+    #
+    # you can specify more than one branch to merge by passing an array of branches
+    def merge(branch, message = 'merge')
+      self.lib.merge(branch, message)
+    end
+
+    # iterates over the files which are unmerged
+    def each_conflict(&block) # :yields: file, your_version, their_version
+      self.lib.conflicts(&block)
+    end
+
+    # pulls the given branch from the given remote into the current branch
+    #
+    #  @git.pull                          # pulls from origin/master
+    #  @git.pull('upstream')              # pulls from upstream/master
+    #  @git.pull('upstream', 'develope')  # pulls from upstream/develop
+    #
+    def pull(remote='origin', branch='master')
+			self.lib.pull(remote, branch)
+    end
+    
+    # returns an array of Git:Remote objects
+    def remotes
+      self.lib.remotes.map { |r| Git::Remote.new(self, r) }
+    end
+
+    # adds a new remote to this repository
+    # url can be a git url or a Git::Base object if it's a local reference
+    # 
+    #  @git.add_remote('scotts_git', 'git://repo.or.cz/rubygit.git')
+    #  @git.fetch('scotts_git')
+    #  @git.merge('scotts_git/master')
+    #
+    # Options:
+    #   :fetch => true
+    #   :track => <branch_name>
+    def add_remote(name, url, opts = {})
+      url = url.repo.path if url.is_a?(Git::Base)
+      self.lib.remote_add(name, url, opts)
+      Git::Remote.new(self, name)
+    end
+
+    # removes a remote from this repository
+    #
+    # @git.remove_remote('scott_git')
+    def remove_remote(name)
+      self.lib.remote_remove(name)
+    end
+
+    # returns an array of all Git::Tag objects for this repository
+    def tags
+      self.lib.tags.map { |r| tag(r) }
+    end
+
+    # Creates a new git tag (Git::Tag)
+    # Usage:
+    #     repo.add_tag('tag_name', object_reference)
+    #     repo.add_tag('tag_name', object_reference, {:options => 'here'})
+    #     repo.add_tag('tag_name', {:options => 'here'})
+    #
+    # Options:
+    #   :a | :annotate -> true
+    #   :d             -> true
+    #   :f             -> true
+    #   :m | :message  -> String
+    #   :s             -> true
+    #   
+    def add_tag(name, *opts)
+      self.lib.tag(name, *opts)
+      self.tag(name)
+    end
+ 
+    # deletes a tag 
+    def delete_tag(name) 
+      self.lib.tag(name, {:d => true})
+    end
+    
+    # creates an archive file of the given tree-ish
+    def archive(treeish, file = nil, opts = {})
+      self.object(treeish).archive(file, opts)
+    end
+    
+    # repacks the repository
+    def repack
+      self.lib.repack
+    end
+    
+    def gc
+      self.lib.gc
+    end
+    
+    def apply(file)
+      if File.exist?(file)
+        self.lib.apply(file)
+      end
+    end
+    
+    def apply_mail(file)
+      self.lib.apply_mail(file) if File.exist?(file)
+    end
+
+    # Shows objects
+    #
+    # @param [String|NilClass] objectish the target object reference (nil == HEAD)
+    # @param [String|NilClass] path the path of the file to be shown
+    # @return [String] the object information
+    def show(objectish=nil, path=nil)
+      self.lib.show(objectish, path)
+    end
+    
+    ## LOWER LEVEL INDEX OPERATIONS ##
+    
+    def with_index(new_index) # :yields: new_index
+      old_index = @index
+      set_index(new_index, false)
+      return_value = yield @index
+      set_index(old_index)
+      return_value
+    end
+    
+    def with_temp_index &blk
+      # Workaround for JRUBY, since they handle the TempFile path different.
+      # MUST be improved to be safer and OS independent. 
+      if RUBY_PLATFORM == 'java'
+        temp_path = "/tmp/temp-index-#{(0...15).map{ ('a'..'z').to_a[rand(26)] }.join}"
+      else
+        tempfile = Tempfile.new('temp-index')
+        temp_path = tempfile.path
+        tempfile.close
+        tempfile.unlink
+      end
+
+      with_index(temp_path, &blk)
+    end
+    
+    def checkout_index(opts = {})
+      self.lib.checkout_index(opts)
+    end
+    
+    def read_tree(treeish, opts = {})
+      self.lib.read_tree(treeish, opts)
+    end
+    
+    def write_tree
+      self.lib.write_tree
+    end
+    
+    def write_and_commit_tree(opts = {})
+      tree = write_tree
+      commit_tree(tree, opts)
+    end
+      
+    def update_ref(branch, commit)
+      branch(branch).update_ref(commit)
+    end
+    
+    
+    def ls_files(location=nil)
+      self.lib.ls_files(location)
+    end
+
+    def with_working(work_dir) # :yields: the Git::WorkingDirectory
+      return_value = false
+      old_working = @working_directory
+      set_working(work_dir) 
+      Dir.chdir work_dir do
+        return_value = yield @working_directory
+      end
+      set_working(old_working)
+      return_value
+    end
+    
+    def with_temp_working &blk
+      tempfile = Tempfile.new("temp-workdir")
+      temp_dir = tempfile.path
+      tempfile.close
+      tempfile.unlink
+      Dir.mkdir(temp_dir, 0700)
+      with_working(temp_dir, &blk)
+    end
+    
+    
+    # runs git rev-parse to convert the objectish to a full sha
+    #
+    #   @git.revparse("HEAD^^")
+    #   @git.revparse('v2.4^{tree}')
+    #   @git.revparse('v2.4:/doc/index.html')
+    #
+    def revparse(objectish)
+      self.lib.revparse(objectish)
+    end
+    
+    def ls_tree(objectish)
+      self.lib.ls_tree(objectish)
+    end
+    
+    def cat_file(objectish)
+      self.lib.object_contents(objectish)
+    end
+
+    # returns the name of the branch the working directory is currently on
+    def current_branch
+      self.lib.branch_current
+    end
+    
+  end
+  
+end