Class: Git::Base

opens a bare Git Repository - no working directory options

# File lib/git/base.rb, line 12
    def self.bare(git_dir)
      self.new :repository => git_dir
    end

clone(repository, name, opts = {})

clones a git repository locally

 repository - http://repo.or.cz/w/sinatra.git
 name - sinatra

options:

  :repository

   :bare
  or
   :working_directory
   :index_file

[Source]

# File lib/git/base.rb, line 60
    def self.clone(repository, name, opts = {})
      # run git-clone 
      self.new(Git::Lib.new.clone(repository, name, opts))
    end

init(working_dir, opts = {})

initializes a git repository

options:

 :repository
 :index_file

[Source]

# File lib/git/base.rb, line 31
    def self.init(working_dir, opts = {})
      default = {:working_directory => working_dir,
                 :repository => File.join(working_dir, '.git')}
      git_options = default.merge(opts)
      
      if git_options[:working_directory]
        # if !working_dir, make it
        FileUtils.mkdir_p(git_options[:working_directory]) if !File.directory?(git_options[:working_directory])
      end
      
      # run git_init there
      Git::Lib.new(git_options).init
       
      self.new(git_options)
    end

new(options = {})

[Source]

# File lib/git/base.rb, line 65
    def initialize(options = {})
      if working_dir = options[:working_directory]
        options[:repository] = File.join(working_dir, '.git') if !options[:repository]
        options[:index] = File.join(working_dir, '.git', 'index') if !options[:index]
      end
      
      @working_directory = Git::WorkingDirectory.new(options[:working_directory]) if options[:working_directory]
      @repository = Git::Repository.new(options[:repository]) if options[:repository]
      @index = Git::Index.new(options[:index], false) if options[:index]
    end

open(working_dir, opts={})

opens a new Git Project from a working directory you can specify non-standard git_dir and index file in the options

[Source]

# File lib/git/base.rb, line 18
    def self.open(working_dir, opts={})    
      default = {:working_directory => working_dir}
      git_options = default.merge(opts)
      
      self.new(git_options)
    end

add(path = '.')

adds files from the working directory to the git repository

[Source]

# File lib/git/base.rb, line 234
    def add(path = '.')
      self.lib.add(path)
    end

add_remote(name, url, opts = {})

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')

[Source]

# File lib/git/base.rb, line 312
    def add_remote(name, url, opts = {})
      if url.is_a?(Git::Base)
        url = url.repo.path
      end
      self.lib.remote_add(name, url, opts)
      Git::Remote.new(self, name)
    end

add_tag(tag_name)

creates a new git tag (Git::Tag)

[Source]

# File lib/git/base.rb, line 331
    def add_tag(tag_name)
      self.lib.tag(tag_name)
      tag(tag_name)
    end

archive(treeish, file = nil, opts = {})

creates an archive file of the given tree-ish

[Source]

# File lib/git/base.rb, line 337
    def archive(treeish, file = nil, opts = {})
      self.object(treeish).archive(file, opts)
    end

branch(branch_name = 'master')

returns a Git::Branch object for branch_name

[Source]

# File lib/git/base.rb, line 189
    def branch(branch_name = 'master')
      Git::Branch.new(self, branch_name)
    end

branches()

returns a Git::Branches object of all the Git::Branch objects for this repo

[Source]

# File lib/git/base.rb, line 184
    def branches
      Git::Branches.new(self)
    end

chdir() {|dir.path| ...}

changes current working directory for a block to the git working directory

example

 @git.chdir do
   # write files
   @git.add
   @git.commit('message')
 end

[Source]

# File lib/git/base.rb, line 115
    def chdir
      Dir.chdir(dir.path) do
        yield dir.path
      end
    end

checkout(branch = 'master', opts = {})

checks out a branch as the new git working directory

[Source]

# File lib/git/base.rb, line 268
    def checkout(branch = 'master', opts = {})
      self.lib.checkout(branch, opts)
    end

checkout_index(opts = {})

[Source]

# File lib/git/base.rb, line 364
    def checkout_index(opts = {})
      self.lib.checkout_index(opts)
    end

commit(message, opts = {})

commits all pending changes in the index file to the git repository

[Source]

# File lib/git/base.rb, line 255
    def commit(message, opts = {})
      self.lib.commit(message, opts)
    end

commit_all(message, opts = {})

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.

[Source]

# File lib/git/base.rb, line 262
    def commit_all(message, opts = {})
      opts = {:add_all => true}.merge(opts)
      self.lib.commit(message, opts)
    end

commit_tree(tree = nil, opts = {})

[Source]

# File lib/git/base.rb, line 376
    def commit_tree(tree = nil, opts = {})
      Git::Object::Commit.new(self, self.lib.commit_tree(tree, opts))
    end

config(name = nil, value = nil)

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

[Source]

# File lib/git/base.rb, line 134
    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

current_branch()

returns the name of the branch the working directory is currently on

[Source]

# File lib/git/base.rb, line 425
    def current_branch
      self.lib.branch_current
    end

diff(objectish = 'HEAD', obj2 = nil)

returns a Git::Diff object

[Source]

# File lib/git/base.rb, line 229
    def diff(objectish = 'HEAD', obj2 = nil)
      Git::Diff.new(self, objectish, obj2)
    end

dir()

returns a reference to the working directory

 @git.dir.path
 @git.dir.writeable?

[Source]

# File lib/git/base.rb, line 80
    def dir
      @working_directory
    end

fetch(remote = 'origin')

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

[Source]

# File lib/git/base.rb, line 274
    def fetch(remote = 'origin')
      self.lib.fetch(remote)
    end

gblob(objectish)

[Source]

# File lib/git/base.rb, line 169
    def gblob(objectish)
      Git::Object.new(self, objectish, 'blob')
    end

gcommit(objectish)

[Source]

# File lib/git/base.rb, line 165
    def gcommit(objectish)
      Git::Object.new(self, objectish, 'commit')
    end

grep(string)

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

[Source]

# File lib/git/base.rb, line 224
    def grep(string)
      self.object('HEAD').grep(string)
    end

gtree(objectish)

[Source]

# File lib/git/base.rb, line 161
    def gtree(objectish)
      Git::Object.new(self, objectish, 'tree')
    end

index()

returns reference to the git index file

[Source]

# File lib/git/base.rb, line 91
    def index
      @index
    end

lib()

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

[Source]

# File lib/git/base.rb, line 201
    def lib
      @lib ||= Git::Lib.new(self)
    end

log(count = 30)

returns a Git::Log object with count commits

[Source]

# File lib/git/base.rb, line 174
    def log(count = 30)
      Git::Log.new(self, count)
    end

ls_files()

[Source]

# File lib/git/base.rb, line 390
    def ls_files
      self.lib.ls_files
    end

merge(branch, message = 'merge')

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

[Source]

# File lib/git/base.rb, line 290
    def merge(branch, message = 'merge')
      self.lib.merge(branch, message)
    end

object(objectish)

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

[Source]

# File lib/git/base.rb, line 157
    def object(objectish)
      Git::Object.new(self, objectish)
    end

pull(remote = 'origin', branch = 'master', message = 'origin pull')

fetches a branch from a remote and merges it into the current working branch

[Source]

# File lib/git/base.rb, line 295
    def pull(remote = 'origin', branch = 'master', message = 'origin pull')
      fetch(remote)
      merge(branch, message)
    end

push(remote = 'origin', branch = 'master')

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')

[Source]

# File lib/git/base.rb, line 283
    def push(remote = 'origin', branch = 'master')
      self.lib.push(remote, branch)
    end

read_tree(treeish, opts = {})

[Source]

# File lib/git/base.rb, line 368
    def read_tree(treeish, opts = {})
      self.lib.read_tree(treeish, opts)
    end

remote(remote_name = 'origin')

returns a Git::Remote object

[Source]

# File lib/git/base.rb, line 194
    def remote(remote_name = 'origin')
      Git::Remote.new(self, remote_name)
    end

remotes()

returns an array of Git:Remote objects

[Source]

# File lib/git/base.rb, line 301
    def remotes
      self.lib.remotes.map { |r| Git::Remote.new(self, r) }
    end

remove(path = '.', opts = {})

removes file(s) from the git repository

[Source]

# File lib/git/base.rb, line 239
    def remove(path = '.', opts = {})
      self.lib.remove(path, opts)
    end

repack()

repacks the repository

[Source]

# File lib/git/base.rb, line 342
    def repack
      self.lib.repack
    end

repo()

returns reference to the git repository directory

 @git.dir.path

[Source]

# File lib/git/base.rb, line 86
    def repo
      @repository
    end

repo_size()

returns the repository size in bytes

[Source]

# File lib/git/base.rb, line 122
    def repo_size
      size = 0
      Dir.chdir(repo.path) do
        (size, dot) = `du -d0`.chomp.split
      end
      size.to_i
    end

reset(commitish = nil, opts = {})

resets the working directory to the provided commitish

[Source]

# File lib/git/base.rb, line 244
    def reset(commitish = nil, opts = {})
      self.lib.reset(commitish, opts)
    end

reset_hard(commitish = nil, opts = {})

resets the working directory to the commitish with ’—hard’

[Source]

# File lib/git/base.rb, line 249
    def reset_hard(commitish = nil, opts = {})
      opts = {:hard => true}.merge(opts)
      self.lib.reset(commitish, opts)
    end

revparse(objectish)

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')

[Source]

# File lib/git/base.rb, line 420
    def revparse(objectish)
      self.lib.revparse(objectish)
    end

set_index(index_file, check = true)

[Source]

# File lib/git/base.rb, line 101
    def set_index(index_file, check = true)
      @lib = nil
      @index = Git::Index.new(index_file.to_s, check)
    end

set_working(work_dir, check = true)

[Source]

# File lib/git/base.rb, line 96
    def set_working(work_dir, check = true)
      @lib = nil
      @working_directory = Git::WorkingDirectory.new(work_dir.to_s, check)
    end

status()

returns a Git::Status object

[Source]

# File lib/git/base.rb, line 179
    def status
      Git::Status.new(self)
    end

tag(tag_name)

returns a Git::Tag object

[Source]

# File lib/git/base.rb, line 326
    def tag(tag_name)
      Git::Object.new(self, tag_name, 'tag', true)
    end

tags()

returns an array of all Git::Tag objects for this repository

[Source]

# File lib/git/base.rb, line 321
    def tags
      self.lib.tags.map { |r| tag(r) }
    end

update_ref(branch, commit)

[Source]

# File lib/git/base.rb, line 385
    def update_ref(branch, commit)
      branch(branch).update_ref(commit)
    end

with_index(new_index) {|@index| ...}

LOWER LEVEL INDEX OPERATIONS ##

[Source]

# File lib/git/base.rb, line 349
    def with_index(new_index)
      old_index = @index
      set_index(new_index, false)
      return_value = yield @index
      set_index(old_index)
      return_value
    end

with_temp_index(&blk)

[Source]

# File lib/git/base.rb, line 357
    def with_temp_index &blk
      tempfile = Tempfile.new('temp-index')
      temp_path = tempfile.path
      tempfile.unlink
      with_index(temp_path, &blk)
    end

with_temp_working(&blk)

[Source]

# File lib/git/base.rb, line 405
    def with_temp_working &blk
      tempfile = Tempfile.new("temp-workdir")
      temp_dir = tempfile.path
      tempfile.unlink
      Dir.mkdir(temp_dir, 0700)
      with_working(temp_dir, &blk)
    end

with_working(work_dir) {|@working_directory| ...}

[Source]

# File lib/git/base.rb, line 394
    def with_working(work_dir)
      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

write_and_commit_tree(opts = {})

[Source]

# File lib/git/base.rb, line 380
    def write_and_commit_tree(opts = {})
      tree = write_tree
      commit_tree(tree, opts)
    end

write_tree()

[Source]

# File lib/git/base.rb, line 372
    def write_tree
      self.lib.write_tree
    end

Methods

Public Class methods

Public Instance methods