In Files

Parent

Included Modules

Files

Grit::Git

Attributes

git_binary[W]
git_max_size[RW]
git_timeout[RW]
bytes_read[RW]
git_dir[RW]
work_tree[RW]

Public Class Methods

git_binary() click to toggle source
# File lib/grit/git.rb, line 58
def git_binary
  @git_binary ||=
    ENV['PATH'].split(':').
      map  { |p| File.join(p, 'git') }.
      find { |p| File.exist?(p) }
end
new(git_dir) click to toggle source
# File lib/grit/git.rb, line 79
def initialize(git_dir)
  self.git_dir    = git_dir
  self.work_tree  = git_dir.gsub(/\/\.git$/,'')
  self.bytes_read = 0
end
with_timeout(timeout = 10.seconds) click to toggle source
# File lib/grit/git.rb, line 70
def self.with_timeout(timeout = 10.seconds)
  old_timeout = Grit::Git.git_timeout
  Grit::Git.git_timeout = timeout
  yield
  Grit::Git.git_timeout = old_timeout
end

Public Instance Methods

apply_patch(head_sha, patch) click to toggle source

Applies the given patch against the given SHA of the current repo.

head_sha - String SHA or ref to apply the patch to. patch - The String patch to apply. Get this from get_patch.

Returns the String Tree SHA on a successful patch application, or false.

# File lib/grit/git.rb, line 222
def apply_patch(head_sha, patch)
  git_index = create_tempfile('index', true)

  options = {:env => {'GIT_INDEX_FILE' => git_index}, :raise => true}
  begin
    native(:read_tree, options.dup, head_sha)
    native(:apply, options.merge(:cached => true, :input => patch))
  rescue CommandFailed
    return false
  end
  native(:write_tree, :env => options[:env]).to_s.chomp!
end
check_applies(head_sha, applies_sha) click to toggle source

Checks if the patch of a commit can be applied to the given head.

head_sha - String SHA or ref to check the patch against. applies_sha - String SHA of the patch. The patch itself is retrieved

with #get_patch.

Returns 0 if the patch applies cleanly (according to `git apply`), or an Integer that is the sum of the failed exit statuses.

# File lib/grit/git.rb, line 189
def check_applies(head_sha, applies_sha)
  git_index = create_tempfile('index', true)
  options   = {:env => {'GIT_INDEX_FILE' => git_index}, :raise => true}
  status    = 0
  begin
    native(:read_tree, options.dup, head_sha)
    stdin = native(:diff, options.dup, "#{applies_sha}^", applies_sha)
    native(:apply, options.merge(:check => true, :cached => true, :input => stdin))
  rescue CommandFailed => fail
    status += fail.exitstatus
  end
  status
end
commit_from_sha(id) click to toggle source
# File lib/grit/git.rb, line 168
def commit_from_sha(id)
  git_ruby_repo = GitRuby::Repository.new(self.git_dir)
  object = git_ruby_repo.get_object_by_sha1(id)

  if object.type == :commit
    id
  elsif object.type == :tag
    object.object
  else
    ''
  end
end
create_tempfile(seed, unlink = false) click to toggle source
# File lib/grit/git.rb, line 162
def create_tempfile(seed, unlink = false)
  path = Tempfile.new(seed).path
  File.unlink(path) if unlink
  return path
end
e(str) click to toggle source
Alias for: shell_escape
exist?() click to toggle source
# File lib/grit/git.rb, line 38
def exist?
  File.exist?(self.git_dir)
end
fs_chmod(mode, file = '/') click to toggle source

Chmod the the file or dir and everything beneath

+file+ is the relative path from the Git dir

Returns nothing

# File lib/grit/git.rb, line 148
def fs_chmod(mode, file = '/')
  FileUtils.chmod_R(mode, File.join(self.git_dir, file))
end
fs_delete(file) click to toggle source

Delete a normal file from the filesystem

+file+ is the relative path from the Git dir

Returns nothing

# File lib/grit/git.rb, line 123
def fs_delete(file)
  FileUtils.rm_rf(File.join(self.git_dir, file))
end
fs_exist?(file) click to toggle source

Check if a normal file exists on the filesystem

+file+ is the relative path from the Git dir

Returns Boolean

# File lib/grit/git.rb, line 94
def fs_exist?(file)
  File.exist?(File.join(self.git_dir, file))
end
fs_mkdir(dir) click to toggle source

Make a directory

+dir+ is the relative path to the directory to create

Returns nothing

# File lib/grit/git.rb, line 140
def fs_mkdir(dir)
  FileUtils.mkdir_p(File.join(self.git_dir, dir))
end
fs_move(from, to) click to toggle source

Move a normal file

+from+ is the relative path to the current file
+to+ is the relative path to the destination file

Returns nothing

# File lib/grit/git.rb, line 132
def fs_move(from, to)
  FileUtils.mv(File.join(self.git_dir, from), File.join(self.git_dir, to))
end
fs_read(file) click to toggle source

Read a normal file from the filesystem.

+file+ is the relative path from the Git dir

Returns the String contents of the file

# File lib/grit/git.rb, line 102
def fs_read(file)
  File.read(File.join(self.git_dir, file))
end
fs_write(file, contents) click to toggle source

Write a normal file to the filesystem.

+file+ is the relative path from the Git dir
+contents+ is the String content to be written

Returns nothing

# File lib/grit/git.rb, line 111
def fs_write(file, contents)
  path = File.join(self.git_dir, file)
  FileUtils.mkdir_p(File.dirname(path))
  File.open(path, 'w') do |f|
    f.write(contents)
  end
end
get_patch(applies_sha) click to toggle source

Gets a patch for a given SHA using `git diff`.

applies_sha - String SHA to get the patch from, using this command:

`git diff #{applies_sha}^ #{applies_sha}`

Returns the String patch from `git diff`.

# File lib/grit/git.rb, line 209
def get_patch(applies_sha)
  git_index = create_tempfile('index', true)
  native(:diff, {
    :env => {'GIT_INDEX_FILE' => git_index}},
    "#{applies_sha}^", applies_sha)
end
list_remotes() click to toggle source
# File lib/grit/git.rb, line 152
def list_remotes
  remotes = []
  Dir.chdir(File.join(self.git_dir, 'refs/remotes')) do
    remotes = Dir.glob('*')
  end
  remotes
rescue
  []
end
method_missing(cmd, options={}, *args, &block) click to toggle source

Methods not defined by a library implementation execute the git command using native, passing the method name as the git command name.

Examples:

git.rev_list({:max_count => 10, :header => true}, "master")
# File lib/grit/git.rb, line 324
def method_missing(cmd, options={}, *args, &block)
  native(cmd, options, *args, &block)
end
native(cmd, options = {}, *args, &block) click to toggle source

Execute a git command, bypassing any library implementation.

cmd - The name of the git command as a Symbol. Underscores are

converted to dashes as in :rev_parse => 'rev-parse'.

options - Command line option arguments passed to the git command.

Single char keys are converted to short options (:a => -a).
Multi-char keys are converted to long options (:arg => '--arg').
Underscores in keys are converted to dashes. These special options
are used to control command execution and are not passed in command
invocation:
  :timeout - Maximum amount of time the command can run for before
    being aborted. When true, use Grit::Git.git_timeout; when numeric,
    use that number of seconds; when false or 0, disable timeout.
  :base - Set false to avoid passing the --git-dir argument when
    invoking the git command.
  :env - Hash of environment variable key/values that are set on the
    child process.
  :raise - When set true, commands that exit with a non-zero status
    raise a CommandFailed exception. This option is available only on
    platforms that support fork(2).

args - Non-option arguments passed on the command line.

Optionally yields to the block an IO object attached to the child process’s STDIN.

Examples

git.native(:rev_list, {:max_count => 10, :header => true}, "master")

Returns a String with all output written to the child process’s stdout. Raises Grit::Git::GitTimeout when the timeout is exceeded or when more

than Grit::Git.git_max_size bytes are output.

Raises Grit::Git::CommandFailed when the :raise option is set true and the

git command exits with a non-zero exit status. The CommandFailed's #command,
#exitstatus, and #err attributes can be used to retrieve additional
detail about the error.
# File lib/grit/git.rb, line 270
def native(cmd, options = {}, *args, &block)
  args     = args.first if args.size == 1 && args[0].is_a?(Array)
  args.map!    { |a| a.to_s.strip }
  args.reject! { |a| a.empty? }

  # special option arguments
  env = options.delete(:env) || {}
  raise_errors = options.delete(:raise)

  # fall back to using a shell when the last argument looks like it wants to
  # start a pipeline for compatibility with previous versions of grit.
  return run(prefix, cmd, '', options, args) if args[-1].to_s[0] == ||

  # more options
  input    = options.delete(:input)
  timeout  = options.delete(:timeout); timeout = true if timeout.nil?
  base     = options.delete(:base);    base    = true if base.nil?
  chdir    = options.delete(:chdir)

  # build up the git process argv
  argv = []
  argv << Git.git_binary
  argv << "--git-dir=#{git_dir}" if base
  argv << cmd.to_s.tr('_', '-')
  argv.concat(options_to_argv(options))
  argv.concat(args)

  # run it and deal with fallout
  Grit.log(argv.join(' ')) if Grit.debug

  process =
    Grit::Process.new(argv, env,
      :input   => input,
      :chdir   => chdir,
      :timeout => (Grit::Git.git_timeout if timeout == true),
      :max     => (Grit::Git.git_max_size if timeout == true)
    )
  status = process.status
  Grit.log(process.out) if Grit.debug
  Grit.log(process.err) if Grit.debug
  if raise_errors && !status.success?
    raise CommandFailed.new(argv.join(' '), status.exitstatus, process.err)
  else
    process.out
  end
rescue Grit::Process::TimeoutExceeded, Grit::Process::MaximumOutputExceeded
  raise GitTimeout, argv.join(' ')
end
object_exists?(object_id) click to toggle source
# File lib/grit/git.rb, line 46
def object_exists?(object_id)
  ruby_git.object_exists?(object_id)
end
options_to_argv(options) click to toggle source

Transform a ruby-style options hash to command-line arguments sutiable for use with Kernel::exec. No shell escaping is performed.

Returns an Array of String option arguments.

# File lib/grit/git.rb, line 332
def options_to_argv(options)
  argv = []
  options.each do |key, val|
    if key.to_s.size == 1
      if val == true
        argv << "-#{key}"
      elsif val == false
        # ignore
      else
        argv << "-#{key}"
        argv << val.to_s
      end
    else
      if val == true
        argv << "--#{key.to_s.tr('_', '-')}"
      elsif val == false
        # ignore
      else
        argv << "--#{key.to_s.tr('_', '-')}=#{val}"
      end
    end
  end
  argv
end
put_raw_object(content, type) click to toggle source
# File lib/grit/git.rb, line 42
def put_raw_object(content, type)
  ruby_git.put_raw_object(content, type)
end
run(prefix, cmd, postfix, options, args, &block) click to toggle source

DEPRECATED OPEN3-BASED COMMAND EXECUTION

# File lib/grit/git.rb, line 375
def run(prefix, cmd, postfix, options, args, &block)
  timeout  = options.delete(:timeout) rescue nil
  timeout  = true if timeout.nil?

  base     = options.delete(:base) rescue nil
  base     = true if base.nil?

  if input = options.delete(:input)
    block = lambda { |stdin| stdin.write(input) }
  end

  opt_args = transform_options(options)

  if RUBY_PLATFORM.downcase =~ /mswin(?!ce)|mingw|bccwin/
    ext_args = args.reject { |a| a.empty? }.map { |a| (a == '--' || a[0].chr == '|' || Grit.no_quote) ? a : "\"#{e(a)}\"" }
    gitdir = base ? "--git-dir=\"#{self.git_dir}\"" : ""
    call = "#{prefix}#{Git.git_binary} #{gitdir} #{cmd.to_s.gsub(/_/, '-')} #{(opt_args + ext_args).join(' ')}#{e(postfix)}"
  else
    ext_args = args.reject { |a| a.empty? }.map { |a| (a == '--' || a[0].chr == '|' || Grit.no_quote) ? a : "'#{e(a)}'" }
    gitdir = base ? "--git-dir='#{self.git_dir}'" : ""
    call = "#{prefix}#{Git.git_binary} #{gitdir} #{cmd.to_s.gsub(/_/, '-')} #{(opt_args + ext_args).join(' ')}#{e(postfix)}"
  end

  Grit.log(call) if Grit.debug
  response, err = timeout ? sh(call, &block) : wild_sh(call, &block)
  Grit.log(response) if Grit.debug
  Grit.log(err) if Grit.debug
  response
end
select_existing_objects(object_ids) click to toggle source
# File lib/grit/git.rb, line 50
def select_existing_objects(object_ids)
  object_ids.select do |object_id|
    object_exists?(object_id)
  end
end
sh(command, &block) click to toggle source
# File lib/grit/git.rb, line 405
def sh(command, &block)
  process =
    Grit::Process.new(
      command, {},
      :timeout => Git.git_timeout,
      :max     => Git.git_max_size
    )
  [process.out, process.err]
rescue Grit::Process::TimeoutExceeded, Grit::Process::MaximumOutputExceeded
  raise GitTimeout, command
end
shell_escape(str) click to toggle source
# File lib/grit/git.rb, line 85
def shell_escape(str)
  str.to_s.gsub("'", "\\\\'").gsub(";", '\;')
end
Also aliased as: e
timeout_after(seconds) click to toggle source

Simple wrapper around Timeout::timeout.

seconds - Float number of seconds before a Timeout::Error is raised. When

true, the Grit::Git.git_timeout value is used. When the timeout is less
than or equal to 0, no timeout is established.

Raises Timeout::Error when the timeout has elapsed.

# File lib/grit/git.rb, line 364
def timeout_after(seconds)
  seconds = self.class.git_timeout if seconds == true
  if seconds && seconds > 0
    Timeout.timeout(seconds) { yield }
  else
    yield
  end
end
transform_options(options) click to toggle source

Transform Ruby style options into git command line options

+options+ is a hash of Ruby style options

Returns String[]

e.g. ["--max-count=10", "--header"]
# File lib/grit/git.rb, line 427
def transform_options(options)
  args = []
  options.keys.each do |opt|
    if opt.to_s.size == 1
      if options[opt] == true
        args << "-#{opt}"
      elsif options[opt] == false
        # ignore
      else
        val = options.delete(opt)
        args << "-#{opt.to_s} '#{e(val)}'"
      end
    else
      if options[opt] == true
        args << "--#{opt.to_s.gsub(/_/, '-')}"
      elsif options[opt] == false
        # ignore
      else
        val = options.delete(opt)
        args << "--#{opt.to_s.gsub(/_/, '-')}='#{e(val)}'"
      end
    end
  end
  args
end
wild_sh(command, &block) click to toggle source
# File lib/grit/git.rb, line 417
def wild_sh(command, &block)
  process = Grit::Process.new(command)
  [process.out, process.err]
end

[Validate]

Generated with the Darkfish Rdoc Generator 2.