sigterm_extensions 0.0.4

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 846e4f9bb49bb713aaeb4e4cd3663a700e9a6200fc4ae370cd055c6e2a876688
+  data.tar.gz: 73ae7724f37986713f8cde129c2586f5b16d47926af16e0776fa932576421f37
+SHA512:
+  metadata.gz: 7d9115e03a2dd303772f032d705964d933f75e7d500404574429f2c82dc2877157896291a1332ebb0da6681a599fef1315b925ac878cd951622407ef6fe33094
+  data.tar.gz: 01c87397cb8295b8a514eda835b634de142932dbb77b41847d7955de75bd2e38f4473ab7c4bd270ef0778065d9c93cfa20f7a057de66b9209ccc65fa7f3f2b46

data/CHANGELOG.md

@@ -0,0 +1,17 @@
+# Changelog
+
+## Version 0.0.4
+  * Forked much from activesupport, thanks to the authors :)
+  * Just too much for me to recall :)
+
+## Version 0.0.3
+  * Bundler patch
+  * ctxirb can now live in other ruby/bundler projects
+
+## Version 0.0.2
+  * Git extension
+
+## Version 0.0.1
+  * Initial commit
+  * Inflector extension
+  * Core extensions (initial version)

data/Gemfile

@@ -0,0 +1,6 @@
+source "https://rubygems.org"
+gemspec
+
+ruby '2.6.5'
+
+gem 'irbtools-more', require: 'irbtools/binding'

data/bin/ctxirb

@@ -0,0 +1,156 @@
+#!/usr/bin/env ruby
+
+
+require 'irb'
+require 'irb/completion'
+require 'irb/ext/save-history'
+require 'highline/import'
+require 'pry'
+lib = File.expand_path("../lib", __dir__)
+$:.unshift(lib) unless $LOAD_PATH.include?(lib)
+
+pwd_lib = File.expand_path('lib', Dir.pwd)
+$:.unshift(pwd_lib) if File.exists?(pwd_lib)
+#puts $:
+
+require 'sigterm_extensions'
+
+
+def colorize_objects!
+  # Method to pretty-print object methods
+  # Coded by sebastian delmont
+  # http://snippets.dzone.com/posts/show/2916
+  Object.class_eval do
+    const_set :ANSI_BOLD     , "\033[1m"
+    const_set :ANSI_RESET    , "\033[0m"
+    const_set :ANSI_LGRAY    , "\033[0;37m"
+    const_set :ANSI_GRAY     , "\033[1;30m"
+    # Print object's methods
+    def pm(*options)
+      methods = self.methods
+      methods -= Object.methods unless options.include? :more
+      filter = options.select {|opt| opt.kind_of? Regexp}.first
+      methods = methods.select {|name| name =~ filter} if filter
+
+      data = methods.sort.collect do |name|
+        method = self.method(name)
+        if method.arity == 0
+          args = "()"
+        elsif method.arity > 0
+          n = method.arity
+          args = "(#{(1..n).collect {|i| "arg#{i}"}.join(", ")})"
+        elsif method.arity < 0
+          n = -method.arity
+          args = "(#{(1..n).collect {|i| "arg#{i}"}.join(", ")}, ...)"
+        end
+        klass = $1 if method.inspect =~ /Method: (.*?)#/
+          [name, args, klass]
+      end
+      max_name = data.collect {|item| item[0].size}.max
+      max_args = data.collect {|item| item[1].size}.max
+      data.each do |item|
+        print " #{ANSI_BOLD}#{item[0].to_s.rjust(max_name)}#{ANSI_RESET}"
+        print "#{ANSI_GRAY}#{item[1].ljust(max_args)}#{ANSI_RESET}"
+        print "   #{ANSI_LGRAY}#{item[2]}#{ANSI_RESET}\n"
+      end
+      data.size
+    end
+  end
+end
+
+module IRB # :nodoc:
+  def self.start_session(binding)
+    unless @__initialized
+      args = ARGV
+      ARGV.replace(ARGV.dup)
+      IRB.setup(nil)
+      ARGV.replace(args)
+      @__initialized = true
+    end
+
+    workspace = WorkSpace.new(binding)
+
+    irb = Irb.new(workspace)
+
+    @CONF[:IRB_RC].call(irb.context) if @CONF[:IRB_RC]
+    @CONF[:MAIN_CONTEXT] = irb.context
+    @CONF[:SAVE_HISTORY] = 10000
+    @CONF[:HISTORY_FILE] = File.join(ENV['PWD'], '.irb-history')
+    @CONF[:BACK_TRACE_LIMIT] = 16
+    @CONF[:USE_READLINE] = true
+    @CONF[:AUTO_INDENT] = true
+    histfile = @CONF[:HISTORY_FILE]
+
+    #puts @CONF
+    maxsize = @CONF[:SAVE_HISTORY]
+
+    if File::exists?(histfile)
+      lines = IO::readlines(histfile).collect { |line| line.chomp }
+      puts "Read #{lines.nitems} saved history commands from '#{histfile}'." if $VERBOSE
+      Readline::HISTORY.push(*lines)
+    end
+
+    Kernel::at_exit do
+      lines = Readline::HISTORY.to_a.reverse.uniq.reverse
+      lines = lines[-maxsize, maxsize] if lines.length > maxsize
+      puts "Saving #{lines.length} history lines to '#{histfile}'."
+      File::open(histfile, File::WRONLY|File::CREAT|File::TRUNC) { |io| io.puts lines.join("\n") }
+    end
+
+    colorize_objects!
+
+    catch(:IRB_EXIT) do
+      irb.eval_input
+    end
+  end
+end
+
+Signal.trap("INT") {
+  confirm = ask("\033[31mExit? [Y/n] \033[0m") { |yn| yn.limit = 1, yn.validate = /[yn]/i }
+  exit unless confirm.downcase == 'n'
+}
+
+#ENV['BUNDLE_GEMFILE'] = File.expand_path('Gemfile', Dir.pwd)
+#bundler_runtime = Bundler.setup
+#bundler_runtime.setup(:default,'development')
+
+#eval File.read('Gemfile') if File.exists? 'Gemfile'
+#Gem.refresh
+#load_everything!
+#pry
+#puts $:
+
+ENV['BUNDLE_GEMFILE'] ||= File.expand_path('Gemfile', Dir.pwd)
+require 'bundler/setup'
+
+ctx_files = Dir["#{Dir.pwd}/lib/*.rb"]
+ctx_files.each do |f|
+  require f
+end
+
+def reload!(print = true)
+  puts 'Reloading ...' if print
+  # Silence warnings
+  warn_level = $VERBOSE
+  $VERBOSE = nil
+  # Main project directory.
+  root_dir = Dir.pwd #File.expand_path('..', __dir__)
+  sigterm_dir = File.expand_path('..', __dir__)
+  # Directories within the project that should be reloaded.
+  reload_dirs = %w{lib}
+  # Loop through and reload every file in all relevant project directories.
+  reload_dirs.each do |dir|
+    Dir.glob("#{root_dir}/#{dir}/**/*.rb").each { |f| load(f) }
+  end
+  # Reload sigterm extensions directory as well
+  reload_dirs.each do |dir|
+    Dir.glob("#{sigterm_dir}/#{dir}/**/*.rb").each { |f| load(f) }
+  end
+  # Re-enable warnings
+  $VERBOSE = warn_level
+  # Return true when complete.
+  true
+end
+
+IRB.start_session(binding)
+

data/lib/git.rb

@@ -0,0 +1,166 @@
+# 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/config'
+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 self.configure
+    yield Base.config
+  end
+
+  def self.config
+    return Base.config
+  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
+    
+  # returns a Hash containing information about the references 
+  # of the target repository
+  #
+  # @param [String|NilClass] location the target repository location or nil for '.'
+  # @return [{String=>Hash}] the available references of the target repo.
+  def self.ls_remote(location=nil)
+    Git::Lib.new.ls_remote(location)
+  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/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/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,551 @@
+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
+
+    # sets the url for a remote
+    # url can be a git url or a Git::Base object if it's a local reference
+    #
+    #  @git.set_remote_url('scotts_git', 'git://repo.or.cz/rubygit.git')
+    #
+    def set_remote_url(name, url)
+      url = url.repo.path if url.is_a?(Git::Base)
+      self.lib.remote_set_url(name, url)
+      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