# 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
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
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
# 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
# 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
# File lib/grit/git.rb, line 38 def exist? File.exist?(self.git_dir) end
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
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
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
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
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
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
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
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
# 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
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
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
# File lib/grit/git.rb, line 46 def object_exists?(object_id) ruby_git.object_exists?(object_id) end
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
# File lib/grit/git.rb, line 42 def put_raw_object(content, type) ruby_git.put_raw_object(content, type) end
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
# 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
# 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
# File lib/grit/git.rb, line 85 def shell_escape(str) str.to_s.gsub("'", "\\\\'").gsub(";", '\;') end
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 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
Generated with the Darkfish Rdoc Generator 2.