Class: Git::Base

Inherits:
Object
  • Object
show all
Includes:
Factory
Defined in:
lib/git/base.rb,
lib/git/base/factory.rb

Overview

Git::Base is the main public interface for interacting with Git commands.

Instead of creating a Git::Base directly, obtain a Git::Base instance by calling one of the follow Git class methods: open, init, clone, or bare.

Defined Under Namespace

Modules: Factory

Class Method Summary collapse

Instance Method Summary collapse

Methods included from Factory

#branch, #branches, #commit_tree, #diff, #gblob, #gcommit, #gtree, #log, #merge_base, #object, #remote, #status, #tag, #worktree, #worktrees

Constructor Details

#initialize(options = {}) ⇒ Git::Base

Create an object that executes Git commands in the context of a working copy or a bare repository.

Parameters:

  • options (Hash) (defaults to: {}) —

    The options for this command (see list of valid options below)

Options Hash (options):

  • :working_dir (Pathname) —

    the path to the root of the working directory. Should be ‘nil` if executing commands on a bare repository.

  • :repository (Pathname) —

    used to specify a non-standard path to the repository directory. The default is ‘“#working_dir/.git”`.

  • :index (Pathname) —

    used to specify a non-standard path to an index file. The default is ‘“#working_dir/.git/index”`

  • :log (Logger) —

    A logger to use for Git operations. Git commands are logged at the ‘:info` level. Additional logging is done at the `:debug` level.



88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
 
# File 'lib/git/base.rb', line 88

def initialize(options = {})
  if working_dir = options[:working_directory]
    options[:repository] ||= File.join(working_dir, '.git')
    options[:index] ||= File.join(options[:repository], '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

Class Method Details

.bare(git_dir, options = {}) ⇒ Git::Base

Open a bare repository

Opens a bare repository located in the ‘git_dir` directory. Since there is no working copy, you can not checkout or commit but you can do most read operations.

Examples:

Open a bare repository and retrieve the first commit SHA

repository = Git.bare('ruby-git.git')
puts repository.log[0].sha #=> "64c6fa011d3287bab9158049c85f3e85718854a0"

Parameters:

  • git_dir (Pathname) —

    The path to the bare repository directory containing an initialized Git repository. If a relative path is given, it is converted to an absolute path using [File.expand_path](www.rubydoc.info/stdlib/core/File.expand_path).

  • options (Hash) (defaults to: {}) —

    The options for this command (see list of valid options below)

Options Hash (options):

  • :log (Logger) —

    A logger to use for Git operations. Git commands are logged at the ‘:info` level. Additional logging is done at the `:debug` level.

Returns:

  • (Git::Base) —

    an object that can execute git commands in the context of the bare repository.

See Also:



14
15
16
17
 
# File 'lib/git/base.rb', line 14

def self.bare(git_dir, options = {})
  normalize_paths(options, default_repository: git_dir, bare: true)
  self.new(options)
end

.clone(repository_url, directory, options = {}) ⇒ Git::Base

Clone a repository into an empty or newly created directory

Examples:

Clone into the default directory ‘ruby-git`

git = Git.clone('https://github.com/ruby-git/ruby-git.git')

Clone and then checkout the ‘development` branch

git = Git.clone('https://github.com/ruby-git/ruby-git.git', branch: 'development')

Clone into a different directory ‘my-ruby-git`

git = Git.clone('https://github.com/ruby-git/ruby-git.git', 'my-ruby-git')
# or:
git = Git.clone('https://github.com/ruby-git/ruby-git.git', path: 'my-ruby-git')

Create a bare repository in the directory ‘ruby-git.git`

git = Git.clone('https://github.com/ruby-git/ruby-git.git', bare: true)

Parameters:

  • repository_url (URI, Pathname) —

    The (possibly remote) repository url to clone from. See [GIT URLS](git-scm.com/docs/git-clone#_git_urls_a_id_urls_a) for more information.

  • directory (Pathname, nil) —

    The directory to clone into

    If ‘directory` is a relative directory it is relative to the `path` option if given. If `path` is not given, `directory` is relative to the current working directory.

    If ‘nil`, `directory` will be set to the basename of the last component of the path from the `repository_url`. For example, for the URL: `github.com/org/repo.git`, `directory` will be set to `repo`.

    If the last component of the path is ‘.git`, the next-to-last component of the path is used. For example, for the URL `/Users/me/foo/.git`, `directory` will be set to `foo`.

  • options (Hash) (defaults to: {}) —

    The options for this command (see list of valid options below)

Options Hash (options):

  • :bare (Boolean) —

    Make a bare Git repository. See [what is a bare repository?](git-scm.com/docs/gitglossary#Documentation/gitglossary.txt-aiddefbarerepositoryabarerepository).

  • :branch (String) —

    The name of a branch or tag to checkout instead of the default branch.

  • :depth (Integer) —

    Create a shallow clone with a history truncated to the specified number of commits.

  • :log (Logger) —

    A logger to use for Git operations. Git commands are logged at the ‘:info` level. Additional logging is done at the `:debug` level.

  • :mirror (Boolean) —

    Set up a mirror of the source repository.

  • :origin (String) —

    Use the value instead ‘origin` to track the upstream repository.

  • :path (Pathname) —

    The directory to clone into. May be used as an alternative to the ‘directory` parameter. If specified, the `path` option is used instead of the `directory` parameter.

  • :recursive (Boolean) —

    After the clone is created, initialize all submodules within, using their default settings.

Returns:

  • (Git::Base) —

    an object that can execute git commands in the context of the cloned local working copy or cloned repository.

See Also:



20
21
22
23
24
 
# File 'lib/git/base.rb', line 20

def self.clone(repository_url, directory, options = {})
  new_options = Git::Lib.new(nil, options[:log]).clone(repository_url, directory, options)
  normalize_paths(new_options, bare: options[:bare] || options[:mirror])
  new(new_options)
end

.config ⇒ Git::Config

Returns (and initialize if needed) a Git::Config instance

Returns:



29
30
31
 
# File 'lib/git/base.rb', line 29

def self.config
  @@config ||= Config.new
end

.init(directory = '.', options = {}) ⇒ Git::Base

Create an empty Git repository or reinitialize an existing Git repository

Examples:

Initialize a repository in the current directory

git = Git.init

Initialize a repository in some other directory

git = Git.init '~/code/ruby-git'

Initialize a bare repository

git = Git.init '~/code/ruby-git.git', bare: true

Initialize a repository in a non-default location (outside of the working copy)

git = Git.init '~/code/ruby-git', repository: '~/code/ruby-git.git'

Parameters:

  • directory (Pathname) (defaults to: '.') —

    If the ‘:bare` option is NOT given or is not `true`, the repository will be created in `“#directory/.git”`. Otherwise, the repository is created in `“#directory”`.

    All directories along the path to ‘directory` are created if they do not exist.

    A relative path is referenced from the current working directory of the process and converted to an absolute path using [File.expand_path](www.rubydoc.info/stdlib/core/File.expand_path).

  • options (Hash) (defaults to: {}) —

    The options for this command (see list of valid options below)

Options Hash (options):

  • :bare (Boolean) —

    Instead of creating a repository at ‘“#directory/.git”`, create a bare repository at `“#directory”`. See [what is a bare repository?](git-scm.com/docs/gitglossary#Documentation/gitglossary.txt-aiddefbarerepositoryabarerepository).

  • :initial_branch (String) —

    Use the specified name for the initial branch in the newly created repository.

  • :repository (Pathname) —

    the path to put the newly initialized Git repository. The default for non-bare repository is ‘“#directory/.git”`.

    A relative path is referenced from the current working directory of the process and converted to an absolute path using [File.expand_path](www.rubydoc.info/stdlib/core/File.expand_path).

  • :log (Logger) —

    A logger to use for Git operations. Git commands are logged at the ‘:info` level. Additional logging is done at the `:debug` level.

Returns:

  • (Git::Base) —

    an object that can execute git commands in the context of the newly initialized repository

See Also:



34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
 
# File 'lib/git/base.rb', line 34

def self.init(directory = '.', options = {})
  normalize_paths(options, default_working_directory: directory, default_repository: directory, bare: options[:bare])

  init_options = {
    :bare => options[:bare],
    :initial_branch => options[:initial_branch]
  }

  directory = options[:bare] ? options[:repository] : options[:working_directory]
  FileUtils.mkdir_p(directory) unless File.exist?(directory)

  # TODO: this dance seems awkward: this creates a Git::Lib so we can call
  #   init so we can create a new Git::Base which in turn (ultimately)
  #   creates another/different Git::Lib.
  #
  # TODO: maybe refactor so this Git::Bare.init does this:
  #   self.new(opts).init(init_opts) and move all/some of this code into
  #   Git::Bare#init. This way the init method can be called on any
  #   repository you have a Git::Base instance for.  This would not
  #   change the existing interface (other than adding to it).
  #
  Git::Lib.new(options).init(init_options)

  self.new(options)
end

.open(working_dir, options = {}) ⇒ Git::Base

Open a an existing Git working directory

Git.open will most likely be the most common way to create a git reference, referring to an existing working directory.

If not provided in the options, the library will assume the repository and index are in the default places (‘.git/`, `.git/index`).

Examples:

Open the Git working directory in the current directory

git = Git.open

Open a Git working directory in some other directory

git = Git.open('~/Projects/ruby-git')

Use a logger to see what is going on

logger = Logger.new(STDOUT)
git = Git.open('~/Projects/ruby-git', log: logger)

Open a working copy whose repository is in a non-standard directory

git = Git.open('~/Projects/ruby-git', repository: '~/Project/ruby-git.git')

Parameters:

  • working_dir (Pathname) —

    the path to the working directory to use for git commands.

    A relative path is referenced from the current working directory of the process and converted to an absolute path using [File.expand_path](www.rubydoc.info/stdlib/core/File.expand_path).

  • options (Hash) (defaults to: {}) —

    The options for this command (see list of valid options below)

Options Hash (options):

  • :repository (Pathname) —

    used to specify a non-standard path to the repository directory. The default is ‘“#working_dir/.git”`.

  • :index (Pathname) —

    used to specify a non-standard path to an index file. The default is ‘“#working_dir/.git/index”`

  • :log (Logger) —

    A logger to use for Git operations. Git commands are logged at the ‘:info` level. Additional logging is done at the `:debug` level.

Returns:

  • (Git::Base) —

    an object that can execute git commands in the context of the opened working copy



61
62
63
64
 
# File 'lib/git/base.rb', line 61

def self.open(working_dir, options = {})
  normalize_paths(options, default_working_directory: working_dir)
  self.new(options)
end

Instance Method Details

#add(paths = '.', **options) ⇒ Object

updates the repository index using the working directory content

options:

:all => true

Examples:

git.add
git.add('path/to/file')
git.add(['path/to/file1','path/to/file2'])
git.add(:all => true)

Parameters:

  • paths (String, Array) (defaults to: '.') —

    files paths to be added (optional, default=‘.’)

  • options (Hash)

Options Hash (**options):



247
248
249
 
# File 'lib/git/base.rb', line 247

def add(paths = '.', **options)
  self.lib.add(paths, options)
end

#add_remote(name, url, opts = {}) ⇒ Object

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>



396
397
398
399
400
 
# File 'lib/git/base.rb', line 396

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

#add_tag(name, *options) ⇒ Object

Creates a new git tag (Git::Tag)

Examples:

repo.add_tag('tag_name', object_reference)
repo.add_tag('tag_name', object_reference, {:options => 'here'})
repo.add_tag('tag_name', {:options => 'here'})

Parameters:

  • name (String) —

    The name of the tag to add

  • options (Hash) —

    Opstions to pass to ‘git tag`. See [git-tag](git-scm.com/docs/git-tag) for more details.

Options Hash (*options):

  • :annotate (boolean) —

    Make an unsigned, annotated tag object

  • :a (boolean) —

    An alias for the ‘:annotate` option

  • :d (boolean) —

    Delete existing tag with the given names.

  • :f (boolean) —

    Replace an existing tag with the given name (instead of failing)

  • :message (String) —

    Use the given tag message

  • :m (String) —

    An alias for the ‘:message` option

  • :s (boolean) —

    Make a GPG-signed tag.



443
444
445
446
 
# File 'lib/git/base.rb', line 443

def add_tag(name, *options)
  self.lib.tag(name, *options)
  self.tag(name)
end

#apply(file) ⇒ Object 



467
468
469
470
471
 
# File 'lib/git/base.rb', line 467

def apply(file)
  if File.exist?(file)
    self.lib.apply(file)
  end
end

#apply_mail(file) ⇒ Object 



473
474
475
 
# File 'lib/git/base.rb', line 473

def apply_mail(file)
  self.lib.apply_mail(file) if File.exist?(file)
end

#archive(treeish, file = nil, opts = {}) ⇒ Object

creates an archive file of the given tree-ish



454
455
456
 
# File 'lib/git/base.rb', line 454

def archive(treeish, file = nil, opts = {})
  self.object(treeish).archive(file, opts)
end

#cat_file(objectish) ⇒ Object 



572
573
574
 
# File 'lib/git/base.rb', line 572

def cat_file(objectish)
  self.lib.object_contents(objectish)
end

#chdir ⇒ Object

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

example

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



114
115
116
117
118
 
# File 'lib/git/base.rb', line 114

def chdir # :yields: the Git::Path
  Dir.chdir(dir.path) do
    yield dir.path
  end
end

#checkout(branch = 'master', opts = {}) ⇒ Object

checks out a branch as the new git working directory



328
329
330
 
# File 'lib/git/base.rb', line 328

def checkout(branch = 'master', opts = {})
  self.lib.checkout(branch, opts)
end

#checkout_file(version, file) ⇒ Object

checks out an old version of a file



333
334
335
 
# File 'lib/git/base.rb', line 333

def checkout_file(version, file)
  self.lib.checkout_file(version,file)
end

#checkout_index(opts = {}) ⇒ Object 



511
512
513
 
# File 'lib/git/base.rb', line 511

def checkout_index(opts = {})
  self.lib.checkout_index(opts)
end

#clean(opts = {}) ⇒ Object

cleans the working directory

options:

:force
:d
:ff



274
275
276
 
# File 'lib/git/base.rb', line 274

def clean(opts = {})
  self.lib.clean(opts)
end

#commit(message, opts = {}) ⇒ Object

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

options:

:all
:allow_empty
:amend
:author



315
316
317
 
# File 'lib/git/base.rb', line 315

def commit(message, opts = {})
  self.lib.commit(message, opts)
end

#commit_all(message, opts = {}) ⇒ Object

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.



322
323
324
325
 
# File 'lib/git/base.rb', line 322

def commit_all(message, opts = {})
  opts = {:add_all => true}.merge(opts)
  self.lib.commit(message, opts)
end

#config(name = nil, value = nil, options = {}) ⇒ Object

g.config(‘user.name’, ‘Scott Chacon’) # sets value g.config(‘user.email’, ‘[email protected]’) # sets value g.config(‘user.email’, ‘[email protected]’, file: ‘path/to/custom/config) # sets value in file g.config(’user.name’) # returns ‘Scott Chacon’ g.config # returns whole config hash



125
126
127
128
129
130
131
132
133
134
135
136
 
# File 'lib/git/base.rb', line 125

def config(name = nil, value = nil, options = {})
  if name && value
    # set value
    lib.config_set(name, value, options)
  elsif name
    # return value
    lib.config_get(name)
  else
    # return hash
    lib.config_list
  end
end

#current_branch ⇒ Object

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



577
578
579
 
# File 'lib/git/base.rb', line 577

def current_branch
  self.lib.branch_current
end

#delete_tag(name) ⇒ Object

deletes a tag



449
450
451
 
# File 'lib/git/base.rb', line 449

def delete_tag(name)
  self.lib.tag(name, {:d => true})
end

#describe(committish = nil, opts = {}) ⇒ Object

returns the most recent tag that is reachable from a commit

options:

:all
:tags
:contains
:debug
:exact_match
:dirty
:abbrev
:candidates
:long
:always
:match



293
294
295
 
# File 'lib/git/base.rb', line 293

def describe(committish=nil, opts={})
  self.lib.describe(committish, opts)
end

#dir ⇒ Object

returns a reference to the working directory

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



141
142
143
 
# File 'lib/git/base.rb', line 141

def dir
  @working_directory
end

#each_conflict(&block) ⇒ Object

iterates over the files which are unmerged



367
368
369
 
# File 'lib/git/base.rb', line 367

def each_conflict(&block) # :yields: file, your_version, their_version
  self.lib.conflicts(&block)
end

#fetch(remote = 'origin', opts = {}) ⇒ Object

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



339
340
341
342
343
344
345
 
# File 'lib/git/base.rb', line 339

def fetch(remote = 'origin', opts = {})
  if remote.is_a?(Hash)
    opts = remote
    remote = nil
  end
  self.lib.fetch(remote, opts)
end

#gc ⇒ Object 



463
464
465
 
# File 'lib/git/base.rb', line 463

def gc
  self.lib.gc
end

#grep(string, path_limiter = nil, opts = {}) ⇒ Hash<String, Array>

Run a grep for ‘string’ on the HEAD of the git repository

Examples:

Limit grep’s scope by calling grep() from a specific object:

git.object("v2.3").grep('TODO')

Using grep results:

git.grep("TODO").each do |sha, arr|
  puts "in blob #{sha}:"
  arr.each do |line_no, match_string|
    puts "\t line #{line_no}: '#{match_string}'"
  end
end

Returns:

  • (Hash<String, Array>) —

    a hash of arrays “‘Ruby 

    'tree-ish1' => [[line_no1, match_string1], ...],
'tree-ish2' => [[line_no1, match_string1], ...],
...

    “‘



224
225
226
 
# File 'lib/git/base.rb', line 224

def grep(string, path_limiter = nil, opts = {})
  self.object('HEAD').grep(string, path_limiter, opts)
end

#index ⇒ Object

returns reference to the git index file



146
147
148
 
# File 'lib/git/base.rb', line 146

def index
  @index
end

#is_branch?(branch) ⇒ Boolean

returns true if the branch exists

Returns:

  • (Boolean) 


190
191
192
193
 
# File 'lib/git/base.rb', line 190

def is_branch?(branch)
  branch_names = self.branches.map {|b| b.name}
  branch_names.include?(branch)
end

#is_local_branch?(branch) ⇒ Boolean

returns true if the branch exists locally

Returns:

  • (Boolean) 


178
179
180
181
 
# File 'lib/git/base.rb', line 178

def is_local_branch?(branch)
  branch_names = self.branches.local.map {|b| b.name}
  branch_names.include?(branch)
end

#is_remote_branch?(branch) ⇒ Boolean

returns true if the branch exists remotely

Returns:

  • (Boolean) 


184
185
186
187
 
# File 'lib/git/base.rb', line 184

def is_remote_branch?(branch)
  branch_names = self.branches.remote.map {|b| b.name}
  branch_names.include?(branch)
end

#lib ⇒ Object

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



198
199
200
 
# File 'lib/git/base.rb', line 198

def lib
  @lib ||= Git::Lib.new(self, @logger)
end

#ls_files(location = nil) ⇒ Object 



533
534
535
 
# File 'lib/git/base.rb', line 533

def ls_files(location=nil)
  self.lib.ls_files(location)
end

#ls_tree(objectish) ⇒ Object 



568
569
570
 
# File 'lib/git/base.rb', line 568

def ls_tree(objectish)
  self.lib.ls_tree(objectish)
end

#merge(branch, message = 'merge', opts = {}) ⇒ Object

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



362
363
364
 
# File 'lib/git/base.rb', line 362

def merge(branch, message = 'merge', opts = {})
  self.lib.merge(branch, message, opts)
end

#pull(remote = 'origin', branch = 'master') ⇒ Object

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



377
378
379
 
# File 'lib/git/base.rb', line 377

def pull(remote='origin', branch='master')
  self.lib.pull(remote, branch)
end

#push(remote = 'origin', branch = 'master', opts = {}) ⇒ Object

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



352
353
354
355
356
357
 
# File 'lib/git/base.rb', line 352

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

#read_tree(treeish, opts = {}) ⇒ Object 



515
516
517
 
# File 'lib/git/base.rb', line 515

def read_tree(treeish, opts = {})
  self.lib.read_tree(treeish, opts)
end

#remotes ⇒ Object

returns an array of Git:Remote objects



382
383
384
 
# File 'lib/git/base.rb', line 382

def remotes
  self.lib.remotes.map { |r| Git::Remote.new(self, r) }
end

#remove(path = '.', opts = {}) ⇒ Object

removes file(s) from the git repository



252
253
254
 
# File 'lib/git/base.rb', line 252

def remove(path = '.', opts = {})
  self.lib.remove(path, opts)
end

#remove_remote(name) ⇒ Object

removes a remote from this repository

@git.remove_remote(‘scott_git’)



416
417
418
 
# File 'lib/git/base.rb', line 416

def remove_remote(name)
  self.lib.remote_remove(name)
end

#repack ⇒ Object

repacks the repository



459
460
461
 
# File 'lib/git/base.rb', line 459

def repack
  self.lib.repack
end

#repo ⇒ Object

returns reference to the git repository directory

@git.dir.path



152
153
154
 
# File 'lib/git/base.rb', line 152

def repo
  @repository
end

#repo_size ⇒ Object

returns the repository size in bytes



157
158
159
160
161
162
163
164
165
 
# File 'lib/git/base.rb', line 157

def repo_size
  Dir.glob(File.join(repo.path, '**', '*'), File::FNM_DOTMATCH).reject do |f|
    f.include?('..')
  end.map do |f|
    File.expand_path(f)
  end.uniq.map do |f|
    File.stat(f).size.to_i
  end.reduce(:+)
end

#reset(commitish = nil, opts = {}) ⇒ Object

resets the working directory to the provided commitish



257
258
259
 
# File 'lib/git/base.rb', line 257

def reset(commitish = nil, opts = {})
  self.lib.reset(commitish, opts)
end

#reset_hard(commitish = nil, opts = {}) ⇒ Object

resets the working directory to the commitish with ‘–hard’



262
263
264
265
 
# File 'lib/git/base.rb', line 262

def reset_hard(commitish = nil, opts = {})
  opts = {:hard => true}.merge(opts)
  self.lib.reset(commitish, opts)
end

#revert(commitish = nil, opts = {}) ⇒ Object

reverts the working directory to the provided commitish. Accepts a range, such as comittish..HEAD

options:

:no_edit



303
304
305
 
# File 'lib/git/base.rb', line 303

def revert(commitish = nil, opts = {})
  self.lib.revert(commitish, opts)
end

#revparse(objectish) ⇒ Object

runs git rev-parse to convert the objectish to a full sha

Examples:

git.revparse("HEAD^^")
git.revparse('v2.4^{tree}')
git.revparse('v2.4:/doc/index.html')


564
565
566
 
# File 'lib/git/base.rb', line 564

def revparse(objectish)
  self.lib.revparse(objectish)
end

#set_index(index_file, check = true) ⇒ Object 



167
168
169
170
 
# File 'lib/git/base.rb', line 167

def set_index(index_file, check = true)
  @lib = nil
  @index = Git::Index.new(index_file.to_s, check)
end

#set_remote_url(name, url) ⇒ Object

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



407
408
409
410
411
 
# File 'lib/git/base.rb', line 407

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

#set_working(work_dir, check = true) ⇒ Object 



172
173
174
175
 
# File 'lib/git/base.rb', line 172

def set_working(work_dir, check = true)
  @lib = nil
  @working_directory = Git::WorkingDirectory.new(work_dir.to_s, check)
end

#show(objectish = nil, path = nil) ⇒ String

Shows objects

Parameters:

  • objectish (String|NilClass) (defaults to: nil) —

    the target object reference (nil == HEAD)

  • path (String|NilClass) (defaults to: nil) —

    the path of the file to be shown

Returns:

  • (String) —

    the object information



482
483
484
 
# File 'lib/git/base.rb', line 482

def show(objectish=nil, path=nil)
  self.lib.show(objectish, path)
end

#tags ⇒ Object

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



421
422
423
 
# File 'lib/git/base.rb', line 421

def tags
  self.lib.tags.map { |r| tag(r) }
end

#update_ref(branch, commit) ⇒ Object 



528
529
530
 
# File 'lib/git/base.rb', line 528

def update_ref(branch, commit)
  branch(branch).update_ref(commit)
end

#with_index(new_index) ⇒ Object

LOWER LEVEL INDEX OPERATIONS ##



488
489
490
491
492
493
494
 
# File 'lib/git/base.rb', line 488

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

#with_temp_index(&blk) ⇒ Object 



496
497
498
499
500
501
502
503
504
505
506
507
508
509
 
# File 'lib/git/base.rb', line 496

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

#with_temp_working(&blk) ⇒ Object 



548
549
550
551
552
553
554
555
 
# File 'lib/git/base.rb', line 548

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

#with_working(work_dir) ⇒ Object

:yields: the Git::WorkingDirectory



537
538
539
540
541
542
543
544
545
546
 
# File 'lib/git/base.rb', line 537

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

#write_and_commit_tree(opts = {}) ⇒ Object 



523
524
525
526
 
# File 'lib/git/base.rb', line 523

def write_and_commit_tree(opts = {})
  tree = write_tree
  commit_tree(tree, opts)
end

#write_tree ⇒ Object 



519
520
521
 
# File 'lib/git/base.rb', line 519

def write_tree
  self.lib.write_tree
end