Class: Git::Base

opens a bare Git Repository - no working directory options

# File lib/git/base.rb, line 10
    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 58
    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 29
    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 63
    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 16
    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 212
    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 290
    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 309
    def add_tag(tag_name)
      self.lib.tag(tag_name)
      tag(tag_name)
    end

branch(branch_name = 'master')

returns a Git::Branch object for branch_name

[Source]

# File lib/git/base.rb, line 167
    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 162
    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 102
    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 246
    def checkout(branch = 'master', opts = {})
      self.lib.checkout(branch, opts)
    end

commit(message, opts = {})

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

[Source]

# File lib/git/base.rb, line 233
    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 240
    def commit_all(message, opts = {})
      opts = {:add_all => true}.merge(opts)
      self.lib.commit(message, 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 121
    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 330
    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 207
    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 78
    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 252
    def fetch(remote = 'origin')
      self.lib.fetch(remote)
    end

gblob(objectish)

Alias for object

gcommit(objectish)

Alias for object

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 202
    def grep(string)
      self.object('HEAD').grep(string)
    end

gtree(objectish)

Alias for object

index()

returns reference to the git index file

[Source]

# File lib/git/base.rb, line 89
    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 179
    def lib
      Git::Lib.new(self)
    end

log(count = 30)

returns a Git::Log object with count commits

[Source]

# File lib/git/base.rb, line 152
    def log(count = 30)
      Git::Log.new(self, count)
    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 268
    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 144
    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 273
    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 261
    def push(remote = 'origin', branch = 'master')
      self.lib.push(remote, branch)
    end

remote(remote_name = 'origin')

returns a Git::Remote object

[Source]

# File lib/git/base.rb, line 172
    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 279
    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 217
    def remove(path = '.', opts = {})
      self.lib.remove(path, opts)
    end

repack()

repacks the repository

[Source]

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

repo()

returns reference to the git repository directory

 @git.dir.path

[Source]

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

repo_size()

returns the repository size in bytes

[Source]

# File lib/git/base.rb, line 109
    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 222
    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 227
    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 325
    def revparse(objectish)
      self.lib.revparse(objectish)
    end

status()

returns a Git::Status object

[Source]

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

tag(tag_name)

returns a Git::Tag object

[Source]

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

tags()

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

[Source]

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

Methods

Public Class methods

Public Instance methods