Class: Git::Base

Inherits:
Object
  • Object
show all
Defined in:
lib/git/base.rb

Overview

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.

Instance Attribute Summary collapse

Class Method Summary collapse

Instance Method Summary collapse

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_directory (Pathname) —

    the path to the root of the working directory or 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_directory>/.git".

  • :index (Pathname) —

    used to specify a non-standard path to an index file

    The default is "<working_directory>/.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.

  • :git_ssh (String, nil) —

    Path to a custom SSH executable or script

    Controls how SSH is configured for this Git::Base instance:

    • If this option is not provided, the global Git::Base.config.git_ssh setting is used.
    • If this option is explicitly set to nil, SSH is disabled for this instance.
    • If this option is a non-empty String, that value is used as the SSH command for this instance, overriding the global Git::Base.config.git_ssh setting.
  • :binary_path (String, :use_global_config) —

    Path to the git binary

    Controls which git binary is used for commands routed through ExecutionContext (i.e., commands already migrated to +Git::Commands::*+ classes). Commands still delegating through +Git::Lib+ continue to use the global Git::Base.config.binary_path setting.

    This limitation will be resolved when the architectural migration to +Git::Repository+ is complete.

    • If this option is not provided, the global Git::Base.config.binary_path setting is used.
    • If this option is a String, that value is used as the git binary path for migrated commands, overriding the global Git::Base.config.binary_path setting.
    • Passing nil raises ArgumentError — there is no "unset the binary" semantic.

Raises:

  • (ArgumentError) —

    if binary_path is nil



144
145
146
147
148
149
150
151
152
153
154
155
 
# File 'lib/git/base.rb', line 144

def initialize(options = {})
  setup_logger(options[:log])
  @git_ssh = options.key?(:git_ssh) ? options[:git_ssh] : :use_global_config
  if options.key?(:binary_path)
    raise ArgumentError, 'binary_path must not be nil' if options[:binary_path].nil?

    @binary_path = options[:binary_path]
  else
    @binary_path = :use_global_config
  end
  initialize_components(options)
end

Instance Attribute Details

#binary_path ⇒ String, Symbol (readonly)

This method is part of a private API. You should avoid using this method if possible, as it may be removed or be changed in the future.

Returns the per-instance git binary path configuration value

This may be:

  • a [String] path when an explicit binary path has been configured
  • the Symbol :use_global_config when this instance is using the global config

Returns:

  • (String, Symbol) —

    the binary_path configuration value for this instance



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

def binary_path
  @binary_path
end

#git_ssh ⇒ String, ... (readonly)

This method is part of a private API. You should avoid using this method if possible, as it may be removed or be changed in the future.

Returns the per-instance git_ssh configuration value

This may be:

  • a [String] path when an explicit git_ssh command has been configured
  • the Symbol :use_global_config when this instance is using the global config
  • nil when SSH has been explicitly disabled for this instance

Returns:

  • (String, Symbol, nil) —

    the git_ssh configuration value for this instance



371
372
373
 
# File 'lib/git/base.rb', line 371

def git_ssh
  @git_ssh
end

#index ⇒ Pathname (readonly)

Returns a reference to the git index file

Returns:

  • (Pathname) —

    the index file path



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

def index
  @index
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.

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

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

Options Hash (options):

  • :git_ssh (String, nil) —

    An optional custom SSH command

    • If not specified, uses the global config (Git.configure { |c| c.git_ssh = ... }).
    • If nil, disables SSH for this instance.
    • If a non-empty string, uses that value for this instance.
  • :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:



18
19
20
21
 
# File 'lib/git/base.rb', line 18

def self.bare(git_dir, options = {})
  paths = Git::Repository::PathResolver.resolve_paths(repository: git_dir, bare: true)
  new(options.merge(paths))
end

.binary_version(binary_path)

Deprecated.

Use Git.git_version instead, which returns a Version (not an Array). For the legacy array shape, call: Git.git_version.to_a



52
53
54
55
56
57
58
59
 
# File 'lib/git/base.rb', line 52

def self.binary_version(binary_path)
  Git::Deprecation.warn(
    'Git::Base.binary_version is deprecated and will be removed in 6.0. ' \
    'Use Git.git_version instead, which returns a Git::Version ' \
    '(not an Array). For the legacy array shape, call: Git.git_version.to_a'
  )
  Git.git_version(binary_path).to_a
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')

Clone into a specific parent directory

git = Git.clone('https://github.com/ruby-git/ruby-git.git', chdir: '/path/to/projects')
# clones into /path/to/projects/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)

Clone a repository and set a single config option

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

Clone a repository and set multiple config options

git = Git.clone(
  'https://github.com/ruby-git/ruby-git.git',
  config: ['user.name=John Doe', 'user.email=john@doe.com']
)

Clone using a specific SSH key

git = Git.clone(
  'git@github.com:ruby-git/ruby-git.git',
  'local-dir',
  git_ssh: 'ssh -i /path/to/private_key'
)

Parameters:

  • repository_url (URI, Pathname) —

    The (possibly remote) repository url to clone from. See GIT URLS for more information.

  • directory (Pathname, nil) —

    The directory to clone into

    If directory is a relative path it is relative to the :chdir option if given. If :chdir 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: https://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?.

  • :branch (String) —

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

  • :config (Array, String) —

    A list of configuration options to set on the newly created repository.

  • :depth (Integer) —

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

  • :filter (String) —

    Request that the server send a partial clone according to the given filter

  • :single_branch (Boolean, nil) —

    Control whether the clone limits fetch refspecs to a single branch.

    • If nil (default), no flag is passed and the Git default is used.
    • If true, --single-branch is passed to limit the refspec to the checkout branch.
    • If false, --no-single-branch is passed to broaden the refspec (useful for shallow clones that should include all branches).
  • :git_ssh (String, nil) —

    An optional custom SSH command

    • If not specified, uses the global config (Git.configure { |c| c.git_ssh = ... }).
    • If nil, disables SSH for this instance.
    • If a non-empty string, uses that value for this instance.
  • :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.

  • :chdir (Pathname) —

    Run git clone from within this directory.

    The directory parameter (or the repository basename when directory is nil) is resolved relative to :chdir, just as if you had cd'd into it before running git clone. The returned path is the join of :chdir and the cloned directory path.

  • :path (Pathname) —

    Deprecated — use :chdir instead.

  • :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:



24
25
26
27
28
29
30
31
32
33
34
35
 
# File 'lib/git/base.rb', line 24

def self.clone(repository_url, directory, options = {})
  lib_options = {}
  lib_options[:git_ssh] = options[:git_ssh] if options.key?(:git_ssh)
  clone_result = Git::Lib.new(lib_options, options[:log]).clone(repository_url, directory, options)
  bare = options[:bare] || options[:mirror]
  paths = Git::Repository::PathResolver.resolve_paths(
    working_directory: clone_result[:working_directory],
    repository: clone_result[:repository],
    bare: bare
  )
  new(options.merge(paths))
end

.config ⇒ Git::Config

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

Returns:



45
46
47
 
# File 'lib/git/base.rb', line 45

def self.config
  @config ||= Config.new
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.

  • 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"

  • :git_ssh (String, nil) —

    An optional custom SSH command

    • If not specified, uses the global config (Git.configure { |c| c.git_ssh = ... }).
    • If nil, disables SSH for this instance.
    • If a non-empty string, uses that value for this instance.
  • :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

Raises:

  • (ArgumentError) 


78
79
80
81
82
83
84
85
86
87
88
89
90
 
# File 'lib/git/base.rb', line 78

def self.open(working_dir, options = {})
  raise ArgumentError, "'#{working_dir}' is not a directory" unless Dir.exist?(working_dir)

  working_dir = root_of_worktree(working_dir) unless options[:repository]

  paths = Git::Repository::PathResolver.resolve_paths(
    working_directory: working_dir,
    repository: options[:repository],
    index: options[:index]
  )

  new(options.merge(paths))
end

.repository_default_branch(repository, options = {}) ⇒ String

Returns the name of the default branch of the given repository

Examples:

with a URI string

Git.default_branch('https://github.com/ruby-git/ruby-git') # => 'master'
Git.default_branch('https://github.com/rspec/rspec-core') # => 'main'

with a URI object

repository_uri = URI('https://github.com/ruby-git/ruby-git')
Git.default_branch(repository_uri) # => 'master'

with a local repository

Git.default_branch('.') # => 'master'

with a local repository Pathname

repository_path = Pathname('.')
Git.default_branch(repository_path) # => 'master'

with the logging option

logger = Logger.new(STDOUT, level: Logger::INFO)
Git.default_branch('.', log: logger) # => 'master'
I, [2022-04-13T16:01:33.221596 #18415]  INFO -- : git '-c' 'core.quotePath=true'
  '-c' 'color.ui=false' ls-remote '--symref' '--' '.' 'HEAD'  2>&1

Parameters:

  • repository (URI, Pathname, String) —

    The (possibly remote) repository to get the default branch name for

    See GIT URLS for more information.

  • 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:

  • (String) —

    the name of the default branch



38
39
40
 
# File 'lib/git/base.rb', line 38

def self.repository_default_branch(repository, options = {})
  Git::Lib.new(nil, options[:log]).repository_default_branch(repository)
end

.root_of_worktree(working_dir) ⇒ String

Find the root of the working tree that contains working_dir

Delegates to Repository::PathResolver.root_of_worktree, using the global config for binary_path and git_ssh.

Parameters:

  • working_dir (String) —

    a path inside the working tree

Returns:

  • (String) —

    the absolute path to the root of the working tree

Raises:

  • (ArgumentError) —

    if working_dir does not exist or is not inside a git working tree



73
74
75
 
# File 'lib/git/base.rb', line 73

def self.root_of_worktree(working_dir)
  Git::Repository::PathResolver.root_of_worktree(working_dir)
end

Instance Method Details

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

Update the index from the current worktree to prepare for the next commit

Returns git's stdout from the add.

Examples:

Stage all changed files

git.add

Stage a specific file

git.add('path/to/file.rb')

Stage multiple files

git.add(['path/to/file1.rb', 'path/to/file2.rb'])

Stage all changes including deletions

git.add(all: true)

Parameters:

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

    a file or files to add (relative to the worktree root); defaults to '.' (all files)

  • options (Hash) —

    options for the add command

Options Hash (**options):

  • :all (Boolean, nil) — default: nil —

    add, modify, and remove index entries to match the worktree

  • :force (Boolean, nil) — default: nil —

    allow adding otherwise ignored files

Returns:

  • (String) —

    git's stdout from the add

Raises:

  • (ArgumentError) —

    if unsupported options are provided

  • (Git::FailedError) —

    if git exits with a non-zero exit status



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

def add(paths = '.', **)
  facade_repository.add(paths, **)
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')

Options: :fetch => true :track => 



204
205
206
 
# File 'lib/git/base.rb', line 204

def add_remote(name, url, opts = {})
  facade_repository.add_remote(name, url, opts)
end

#add_tag(name, *options)

Create a new 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) —

    Options to pass to git tag. See git-tag for more details.

Options Hash (*options):

  • :annotate (Boolean, nil) — default: nil —

    make an unsigned, annotated tag object

  • :a (Boolean, nil) — default: nil —

    an alias for the :annotate option

  • :d (Boolean, nil) — default: nil —

    delete existing tag with the given name — deprecated; use #delete_tag instead (alias: :delete)

  • :delete (Boolean, nil) — default: nil —

    delete existing tag with the given name — deprecated; use #delete_tag instead (alias: :d)

  • :f (Boolean, nil) — default: nil —

    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, nil) — default: nil —

    make a GPG-signed tag



670
671
672
 
# File 'lib/git/base.rb', line 670

def add_tag(name, *options)
  facade_repository.add_tag(name, *options)
end

#apply(file)

rubocop:enable Style/ArgumentsForwarding



766
767
768
769
770
 
# File 'lib/git/base.rb', line 766

def apply(file)
  return unless File.exist?(file)

  lib.apply(file)
end

#apply_mail(file) 



772
773
774
 
# File 'lib/git/base.rb', line 772

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

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

Creates an archive of the given tree-ish and writes it to a file

Examples:

Archive HEAD to a zip file

git.archive('HEAD', '/tmp/release.zip', format: 'zip')
#=> "/tmp/release.zip"

Parameters:

  • treeish (String) —

    the commit, tag, branch, or tree to archive

  • file (String, nil) (defaults to: nil) —

    destination file path; a temp file is created if nil

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

    archive options (see Repository::ObjectOperations#archive)

Returns:

  • (String) —

    the path to the written archive file

Raises:

  • (ArgumentError) —

    if unsupported options are provided

  • (ArgumentError) —

    if file is an existing directory

  • (Git::FailedError) —

    if git exits with a non-zero exit status



702
703
704
 
# File 'lib/git/base.rb', line 702

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

#branch(branch_name = current_branch) ⇒ Git::Branch

Returns an object for branch_name.

Returns:



929
930
931
 
# File 'lib/git/base.rb', line 929

def branch(branch_name = current_branch)
  facade_repository.branch(branch_name)
end

#branch?(branch) ⇒ Boolean

returns +true+ if the branch exists

Returns:

  • (Boolean) 


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

def branch?(branch)
  facade_repository.branch?(branch)
end

#branches ⇒ Git::Branches

Returns a collection of all the branches in the repository. Each branch is represented as a Git::Branch.

Returns:



935
936
937
 
# File 'lib/git/base.rb', line 935

def branches
  facade_repository.branches
end

#cat_file(objectish) 



912
913
914
 
# File 'lib/git/base.rb', line 912

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

#chdir

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

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



217
218
219
220
221
 
# File 'lib/git/base.rb', line 217

def chdir # :yields: the working directory Pathname
  Dir.chdir(dir.to_s) do
    yield dir
  end
end

#checkout

checks out a branch as the new git working directory



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

def checkout(*, **)
  facade_repository.checkout(*, **)
end

#checkout_file(version, file)

checks out an old version of a file



517
518
519
 
# File 'lib/git/base.rb', line 517

def checkout_file(version, file)
  facade_repository.checkout_file(version, file)
end

#checkout_index(opts = {}) 



810
811
812
 
# File 'lib/git/base.rb', line 810

def checkout_index(opts = {})
  facade_repository.checkout_index(opts)
end

#clean(opts = {})

cleans the working directory

options: :force :d :ff



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

def clean(opts = {})
  facade_repository.clean(opts)
end

#commit(message, opts = {})

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

options: :all :allow_empty :amend :author



500
501
502
 
# File 'lib/git/base.rb', line 500

def commit(message, opts = {})
  facade_repository.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.



507
508
509
 
# File 'lib/git/base.rb', line 507

def commit_all(message, opts = {})
  facade_repository.commit_all(message, **opts)
end

#commit_tree(tree = nil, opts = {}) ⇒ Git::Object::Commit

Returns a commit object.

Returns:



968
969
970
 
# File 'lib/git/base.rb', line 968

def commit_tree(tree = nil, opts = {})
  Git::Object::Commit.new(self, facade_repository.commit_tree(tree, **opts))
end

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

g.config('user.name', 'Scott Chacon') # sets value g.config('user.email', 'email@email.com') # sets value g.config('user.email', 'email@email.com', file: 'path/to/custom/config') # sets value in file g.config('user.name') # returns 'Scott Chacon' g.config # returns whole config hash



228
229
230
 
# File 'lib/git/base.rb', line 228

def config(name = nil, value = nil, options = {})
  facade_repository.config(name, value, options)
end

#current_branch ⇒ String

The name of the branch HEAD refers to or 'HEAD' if detached

Returns one of the following:

  • The branch name that HEAD refers to (even if it is an unborn branch)
  • 'HEAD' if in a detached HEAD state

Returns:

  • (String) —

    the name of the branch HEAD refers to or 'HEAD' if detached



924
925
926
 
# File 'lib/git/base.rb', line 924

def current_branch
  facade_repository.current_branch
end

#delete_tag(name)

deletes a tag



675
676
677
 
# File 'lib/git/base.rb', line 675

def delete_tag(name)
  facade_repository.delete_tag(name)
end

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

returns the most recent tag that is reachable from a commit

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



478
479
480
 
# File 'lib/git/base.rb', line 478

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

#diff(objectish = 'HEAD', obj2 = nil) ⇒ Git::Diff

Returns a Git::Diff object.

Returns:



973
974
975
 
# File 'lib/git/base.rb', line 973

def diff(objectish = 'HEAD', obj2 = nil)
  facade_repository.diff(objectish, obj2)
end

#diff_files ⇒ Hash{String => Hash}

Compares the index and the working directory

Examples:

List all files with unstaged changes

repo.diff_files #=> { "lib/foo.rb" => { mode_index: "100644", ... } }

Returns:

Raises:

See Also:



1174
1175
1176
 
# File 'lib/git/base.rb', line 1174

def diff_files
  facade_repository.diff_files
end

#diff_full(obj1 = 'HEAD', obj2 = nil, opts = {}) ⇒ String

Note:

Unknown option keys are silently ignored for backward compatibility; only :path_limiter is forwarded to the underlying command.

Returns the full unified diff patch text between two commits

Examples:

Get the patch for the most recent commit

repo.diff_full #=> "diff --git a/lib/foo.rb b/lib/foo.rb\n..."

Parameters:

  • obj1 (String) (defaults to: 'HEAD') —

    the first commit or object to compare; defaults to 'HEAD'

  • obj2 (String, nil) (defaults to: nil) —

    the second commit or object to compare

    When nil, the comparison is against the index or working tree.

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

    options to filter the diff

Options Hash (opts):

  • :path_limiter (String, Pathname, Array<String, Pathname>, nil) — default: nil —

    limit the diff to the given path(s)

Returns:

  • (String) —

    the unified diff patch output

Raises:

See Also:



1068
1069
1070
 
# File 'lib/git/base.rb', line 1068

def diff_full(obj1 = 'HEAD', obj2 = nil, opts = {})
  facade_repository.diff_full(obj1, obj2, opts.slice(:path_limiter))
end

#diff_path_status(objectish = 'HEAD', obj2 = nil, opts = {}) ⇒ Git::DiffPathStatus Also known as: diff_name_status

Returns the file path status between two commits

Examples:

Get all changed files between HEAD and the previous commit

repo.diff_path_status.to_h #=> { "README.md" => "M", "lib/foo.rb" => "A" }

Parameters:

  • objectish (String) (defaults to: 'HEAD') —

    the first commit or object to compare; defaults to 'HEAD'

  • obj2 (String, nil) (defaults to: nil) —

    the second commit or object to compare

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

    options to filter the diff

Options Hash (opts):

  • :path_limiter (String, Pathname, Array<String, Pathname>, nil) — default: nil —

    limit the status report to specified path(s)

  • :path (String, Pathname, Array<String, Pathname>, nil) — default: nil —

    deprecated; use :path_limiter instead

Returns:

Raises:

  • (ArgumentError) —

    if objectish or obj2 starts with "-"

  • (Git::FailedError) —

    if git exits outside the allowed range (exit code > 1)

See Also:



1158
1159
1160
 
# File 'lib/git/base.rb', line 1158

def diff_path_status(objectish = 'HEAD', obj2 = nil, opts = {})
  facade_repository.diff_path_status(objectish, obj2, opts.slice(:path_limiter, :path))
end

#diff_stats(objectish = 'HEAD', obj2 = nil, opts = {}) ⇒ Git::DiffStats

Note:

Unknown option keys are silently ignored for backward compatibility; only :path_limiter is forwarded to the underlying command.

Returns a lazy DiffStats object for accessing diff statistics

Compares (1) two commits, (2) a commit against the working tree, or (3) the index against the working tree and constructs a lazy DiffStats that computes per-file insertion and deletion counts on demand when its accessor methods are called.

Comparing two commits

When both objectish and obj2 are provided, the comparison is between those two refs (commits, tags, branches, etc.).

Comparing a commit against the working tree

When only objectish is provided (and isn't nil), the comparison is between objectish and the working tree; the stats reflect all changes since objectish.

Comparing the index against the working tree

When objectish is explicitly nil then obj2 must be omitted or nil. In this case, the comparison is between the index and the working tree; the stats reflect unstaged changes.

Examples:

Get working tree stats since HEAD

repo.diff_stats.insertions #=> 3

Compare two specific commits

repo.diff_stats('abc1234', 'def5678')

Get unstaged stats (index vs. working tree)

repo.diff_stats(nil).insertions

Limit stats to a sub-path

repo.diff_stats('HEAD~1', 'HEAD', path_limiter: 'lib/')

Parameters:

  • objectish (String, nil) (defaults to: 'HEAD') —

    the first commit or object to compare; defaults to 'HEAD'; pass nil to compare the index against the working tree

  • obj2 (String, nil) (defaults to: nil) —

    the second commit or object to compare

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

    options to filter the diff

Options Hash (opts):

  • :path_limiter (String, Pathname, Array<String, Pathname>, nil) — default: nil —

    limit the stats to the given path(s)

Returns:

Raises:

  • (ArgumentError) —

    if objectish or obj2 starts with "-"

  • (ArgumentError) —

    if objectish is nil but obj2 is not

See Also:



1128
1129
1130
 
# File 'lib/git/base.rb', line 1128

def diff_stats(objectish = 'HEAD', obj2 = nil, opts = {})
  facade_repository.diff_stats(objectish, obj2, opts.slice(:path_limiter))
end

#dir ⇒ Pathname

Returns a reference to the working directory

Examples:

@git.dir.to_s
@git.dir.writable?

Returns:

  • (Pathname) —

    the working directory path



240
241
242
 
# File 'lib/git/base.rb', line 240

def dir
  @working_directory
end

#each_conflict

iterates over the files which are unmerged



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

def each_conflict(&)
  facade_repository.each_conflict(&)
end

#facade_repository ⇒ Git::Repository

This method is part of a private API. You should avoid using this method if possible, as it may be removed or be changed in the future.

Returns the Repository facade for this repository

Returns:



356
357
358
359
360
 
# File 'lib/git/base.rb', line 356

def facade_repository
  @facade_repository ||= Git::Repository.new(
    execution_context: Git::ExecutionContext::Repository.from_base(self, logger: @logger)
  )
end

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

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



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

def fetch(remote = 'origin', opts = {})
  facade_repository.fetch(remote, opts)
end

#fsck(objects = [], options = {}) ⇒ Git::FsckResult

Verifies the connectivity and validity of objects in the database

Runs git fsck to check repository integrity and identify dangling, missing, or unreachable objects.

rubocop:disable Style/ArgumentsForwarding

Returns categorized objects flagged by fsck.

Examples:

Check repository integrity

result = git.fsck
result.dangling.each { |obj| puts "#{obj.type}: #{obj.oid}" }

Check with strict mode and suppress dangling output

result = git.fsck(strict: true, no_dangling: true)

Check if repository has any issues

result = git.fsck
puts "Repository is clean" if result.empty?

List root commits

result = git.fsck(root: true)
result.root.each { |obj| puts obj.oid }

Check specific objects

result = git.fsck('abc1234', 'def5678')

Parameters:

  • objects (Array<String>) (defaults to: []) —

    specific objects to treat as heads for unreachability trace. If no objects are given, git fsck defaults to using the index file, all SHA-1 references in the refs namespace, and all reflogs.

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

    options to pass to the underlying git fsck command

Options Hash (options):

  • :unreachable (Boolean, nil) — default: nil —

    print unreachable objects

  • :strict (Boolean, nil) — default: nil —

    enable strict checking

  • :connectivity_only (Boolean, nil) — default: nil —

    check only connectivity (faster)

  • :root (Boolean, nil) — default: nil —

    report root nodes

  • :tags (Boolean, nil) — default: nil —

    report tags

  • :cache (Boolean, nil) — default: nil —

    consider objects in the index

  • :no_reflogs (Boolean, nil) — default: nil —

    do not consider reflogs

  • :lost_found (Boolean, nil) — default: nil —

    write dangling objects to .git/lost-found (note: this modifies the repository by creating files)

  • :dangling (Boolean, nil) —

    print dangling objects (true/false/nil for default)

  • :full (Boolean, nil) —

    check objects in alternate pools (true/false/nil for default)

  • :name_objects (Boolean, nil) —

    name objects by refs (true/false/nil for default)

  • :references (Boolean, nil) —

    check refs database consistency (true/false/nil for default)

Returns:



761
762
763
 
# File 'lib/git/base.rb', line 761

def fsck(*objects, **opts)
  facade_repository.fsck(*objects, **opts)
end

#full_log_commits(opts = {}) ⇒ Array<Hash>

Return commits that are within the given revision range

Parameters:

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

    options for the log query

Returns:

  • (Array<Hash>) —

    the parsed raw log output for each commit



1001
1002
1003
 
# File 'lib/git/base.rb', line 1001

def full_log_commits(opts = {})
  facade_repository.full_log_commits(opts)
end

#gblob(objectish) ⇒ Git::Object

Returns a Git object.

Returns:



978
979
980
 
# File 'lib/git/base.rb', line 978

def gblob(objectish)
  facade_repository.gblob(objectish)
end

#gc 



711
712
713
 
# File 'lib/git/base.rb', line 711

def gc
  lib.gc
end

#gcommit(objectish) ⇒ Git::Object

Returns a Git object.

Returns:



983
984
985
 
# File 'lib/git/base.rb', line 983

def gcommit(objectish)
  facade_repository.gcommit(objectish)
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

Parameters:

  • string (String) —

    the string to search for

  • path_limiter (String, Pathname, Array<String, Pathname>) (defaults to: nil) —

    a path or array of paths to limit the search to or nil for no limit

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

    options to pass to the underlying git grep command

Options Hash (opts):

  • :ignore_case (Boolean, nil) — default: nil —

    ignore case when matching

  • :invert_match (Boolean, nil) — default: nil —

    select non-matching lines

  • :extended_regexp (Boolean, nil) — default: nil —

    use extended regular expressions

  • :object (String) — default: HEAD —

    the object to search from

Returns:

  • (Hash<String, Array>) —

    a hash of arrays

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



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

def grep(string, path_limiter = nil, opts = {})
  opts = opts.merge(object: facade_repository.rev_parse('HEAD')) unless opts.key?(:object)
  facade_repository.grep(string, path_limiter, opts)
end

#gtree(objectish) ⇒ Git::Object

Returns a Git object.

Returns:



988
989
990
 
# File 'lib/git/base.rb', line 988

def gtree(objectish)
  facade_repository.gtree(objectish)
end

#ignored_files ⇒ Array<String>

List the files in the worktree that are ignored by git

Returns:

  • (Array<String>) —

    the list of ignored files relative to the root of the worktree



423
424
425
 
# File 'lib/git/base.rb', line 423

def ignored_files
  facade_repository.ignored_files
end

#is_branch?(branch) ⇒ Boolean

rubocop:disable Naming/PredicatePrefix

Returns:

  • (Boolean) 


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

def is_branch?(branch) # rubocop:disable Naming/PredicatePrefix
  Git::Deprecation.warn(
    'Git::Base#is_branch? is deprecated and will be removed in a future version. ' \
    'Use Git::Base#branch? instead.'
  )
  branch?(branch)
end

#is_local_branch?(branch) ⇒ Boolean

rubocop:disable Naming/PredicatePrefix

Returns:

  • (Boolean) 


311
312
313
314
315
316
317
 
# File 'lib/git/base.rb', line 311

def is_local_branch?(branch) # rubocop:disable Naming/PredicatePrefix
  Git::Deprecation.warn(
    'Git::Base#is_local_branch? is deprecated and will be removed in a future version. ' \
    'Use Git::Base#local_branch? instead.'
  )
  local_branch?(branch)
end

#is_remote_branch?(branch) ⇒ Boolean

rubocop:disable Naming/PredicatePrefix

Returns:

  • (Boolean) 


324
325
326
327
328
329
330
 
# File 'lib/git/base.rb', line 324

def is_remote_branch?(branch) # rubocop:disable Naming/PredicatePrefix
  Git::Deprecation.warn(
    'Git::Base#is_remote_branch? is deprecated and will be removed in a future version. ' \
    'Use Git::Base#remote_branch? instead.'
  )
  remote_branch?(branch)
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



348
349
350
 
# File 'lib/git/base.rb', line 348

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

#local_branch?(branch) ⇒ Boolean

returns +true+ if the branch exists locally

Returns:

  • (Boolean) 


307
308
309
 
# File 'lib/git/base.rb', line 307

def local_branch?(branch)
  facade_repository.local_branch?(branch)
end

#log(count = 30) ⇒ Git::Log

Returns a log with the specified number of commits.

Returns:

  • (Git::Log) —

    a log with the specified number of commits



993
994
995
 
# File 'lib/git/base.rb', line 993

def log(count = 30)
  facade_repository.log(count)
end

#ls_files(location = nil) 



830
831
832
 
# File 'lib/git/base.rb', line 830

def ls_files(location = nil)
  facade_repository.ls_files(location)
end

#ls_tree(objectish, opts = {}) ⇒ Hash<String, Hash<String, Hash>>

Lists the objects in a git tree object

Examples:

List all top-level objects

git.ls_tree('HEAD')
# => { 'blob' => { 'README.md' => { mode: '100644', sha: '...' } }, ... }

Parameters:

  • objectish (String) —

    the tree-ish object to list

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

    additional options

Options Hash (opts):

  • :recursive (Boolean, nil) — default: nil —

    recurse into subtrees

  • :path (String, Array<String>) — default: nil —

    limit the listing to the given path or array of paths

Returns:

  • (Hash<String, Hash<String, Hash>>) —

    a three-level Hash keyed by object type ('blob', 'tree', 'commit'), then by filename, then holding :mode and :sha values

Raises:

  • (ArgumentError) —

    when unsupported options are provided

  • (Git::FailedError) —

    when git exits with a non-zero exit status



908
909
910
 
# File 'lib/git/base.rb', line 908

def ls_tree(objectish, opts = {})
  facade_repository.ls_tree(objectish, opts)
end

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

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



559
560
561
 
# File 'lib/git/base.rb', line 559

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

#merge_base ⇒ Array<Git::Object::Commit>

Find as good common ancestors as possible for a merge example: g.merge_base('master', 'some_branch', 'some_sha', octopus: true)

Returns:



1038
1039
1040
 
# File 'lib/git/base.rb', line 1038

def merge_base(*)
  facade_repository.merge_base(*).map { |sha| gcommit(sha) }
end

#object(objectish) ⇒ Git::Object

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.

object calls a 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

Returns:

  • (Git::Object) —

    an instance of the appropriate type of Git::Object



1015
1016
1017
 
# File 'lib/git/base.rb', line 1015

def object(objectish)
  facade_repository.object(objectish)
end

#pull(remote = nil, branch = nil, opts = {}) ⇒ String

Pulls the given branch from the given remote into the current branch

Examples:

pulls from origin/master

@git.pull

pulls from upstream/master

@git.pull('upstream')

pulls from upstream/develop

@git.pull('upstream', 'develop')

Parameters:

  • remote (String) (defaults to: nil) —

    the remote repository to pull from

  • branch (String) (defaults to: nil) —

    the branch to pull from

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

    options to pass to the pull command

Options Hash (opts):

  • :allow_unrelated_histories (Boolean, nil) — default: nil —

    merges histories of two projects that started their lives independently

Returns:

  • (String) —

    the stdout output from the pull command

Raises:

  • (Git::FailedError) —

    if the pull fails

  • (ArgumentError) —

    if a branch is given without a remote



587
588
589
 
# File 'lib/git/base.rb', line 587

def pull(remote = nil, branch = nil, opts = {})
  facade_repository.pull(remote, branch, opts)
end

#push(remote = nil, branch = nil, options = {}) ⇒ String

Push changes to a remote repository

Returns the stdout output from the push command.

Parameters:

  • remote (String) (defaults to: nil) —

    the remote repository to push to

  • branch (String) (defaults to: nil) —

    the branch to push

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

    options to pass to the push command

Options Hash (options):

  • :mirror (Boolean, nil) — default: nil —

    push all refs under refs/heads/, refs/tags/ and refs/remotes/

  • :delete (Boolean, nil) — default: nil —

    delete refs that don't exist on the remote

  • :force (Boolean, nil) — default: nil —

    force updates

  • :tags (Boolean, nil) — default: nil —

    push all refs under refs/tags/

  • :push_option (String, Array<String>) — default: nil —

    push options to transmit

Returns:

  • (String) —

    the stdout output from the push command

Raises:

  • (Git::FailedError) —

    if the push fails

  • (ArgumentError) —

    if a branch is given without a remote



552
553
554
 
# File 'lib/git/base.rb', line 552

def push(*, **)
  facade_repository.push(*, **)
end

#read_tree(treeish, opts = {}) 



814
815
816
 
# File 'lib/git/base.rb', line 814

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

#remote(remote_name = 'origin') ⇒ Git::Remote

Returns a remote of the specified name.

Returns:



1020
1021
1022
 
# File 'lib/git/base.rb', line 1020

def remote(remote_name = 'origin')
  facade_repository.remote(remote_name)
end

#remote_branch?(branch) ⇒ Boolean

returns +true+ if the branch exists remotely

Returns:

  • (Boolean) 


320
321
322
 
# File 'lib/git/base.rb', line 320

def remote_branch?(branch)
  facade_repository.remote_branch?(branch)
end

#remote_set_branches(name, *branches, add: false) ⇒ nil

Configures which branches are fetched for a remote

Uses git remote set-branches to set or append fetch refspecs. When the add: option is not given, the --add option is not passed to the git command

the underlying git command fails

Examples:

Replace fetched branches with a single glob pattern

git = Git.open('/path/to/repo')
# Only fetch branches matching "feature/*" from origin
git.remote_set_branches('origin', 'feature/*')

Append a glob pattern to existing fetched branches

git = Git.open('/path/to/repo')
# Keep existing fetch refspecs and add all release branches
git.remote_set_branches('origin', 'release/*', add: true)

Configure multiple explicit branches

git = Git.open('/path/to/repo')
git.remote_set_branches('origin', 'main', 'development', 'hotfix')

Parameters:

  • name (String) —

    the remote name (for example, "origin")

  • branches (Array<String>) —

    branch names or globs (for example, '*')

  • add (Boolean) (defaults to: false) —

    when true, append to existing refspecs instead of replacing them

Returns:

  • (nil)

Raises:

  • (ArgumentError) —

    if no branches are provided @raise [Git::FailedError] if



633
634
635
 
# File 'lib/git/base.rb', line 633

def remote_set_branches(name, *branches, add: false)
  facade_repository.remote_set_branches(name, *branches, add: add)
end

#remotes

returns an array of Git:Remote objects



592
593
594
 
# File 'lib/git/base.rb', line 592

def remotes
  facade_repository.remotes
end

#remove_remote(name)

removes a remote from this repository

@git.remove_remote('scott_git')



640
641
642
 
# File 'lib/git/base.rb', line 640

def remove_remote(name)
  facade_repository.remove_remote(name)
end

#repack

repacks the repository



707
708
709
 
# File 'lib/git/base.rb', line 707

def repack
  lib.repack
end

#repo ⇒ Pathname

Returns a reference to the git repository directory

Examples:

@git.repo.to_s

Returns:

  • (Pathname) —

    the repository directory path



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

def repo
  @repository
end

#repo_size

returns the repository size in bytes



262
263
264
265
266
267
268
269
 
# File 'lib/git/base.rb', line 262

def repo_size
  all_files = Dir.glob(File.join(repo.path, '**', '*'), File::FNM_DOTMATCH)

  all_files.reject { |file| file.include?('..') }
           .map { |file| File.expand_path(file) }
           .uniq
           .sum { |file| File.stat(file).size.to_i }
end

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

resets the working directory to the provided commitish



435
436
437
 
# File 'lib/git/base.rb', line 435

def reset(commitish = nil, opts = {})
  facade_repository.reset(commitish, **opts)
end

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

Deprecated.

Use #reset with hard: true instead.

resets the working directory to the commitish with '--hard'



443
444
445
446
447
448
449
450
 
# File 'lib/git/base.rb', line 443

def reset_hard(commitish = nil, opts = {})
  Git::Deprecation.warn(
    'Git::Base#reset_hard is deprecated and will be removed in a future version. ' \
    'Use Git::Base#reset(commitish, hard: true) instead.'
  )
  opts = { hard: true }.merge(opts)
  lib.reset(commitish, opts)
end

#rev_parse(objectish) Also known as: revparse

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

Examples:

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


861
862
863
 
# File 'lib/git/base.rb', line 861

def rev_parse(objectish)
  facade_repository.rev_parse(objectish)
end

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

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

options: :no_edit



488
489
490
 
# File 'lib/git/base.rb', line 488

def revert(commitish = nil, opts = {})
  facade_repository.revert(commitish, **opts)
end

#rm(path = '.', opts = {}) Also known as: remove

removes file(s) from the git repository



428
429
430
 
# File 'lib/git/base.rb', line 428

def rm(path = '.', opts = {})
  facade_repository.rm(path, opts)
end

#set_index(index_file, check = nil, must_exist: nil) 



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

def set_index(index_file, check = nil, must_exist: nil)
  must_exist = deprecate_check_argument(check, must_exist)
  @lib = nil
  @facade_repository = nil
  @index = validate_path(index_file, must_exist)
end

#set_remote_url(name, url)

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



601
602
603
 
# File 'lib/git/base.rb', line 601

def set_remote_url(name, url)
  facade_repository.set_remote_url(name, url)
end

#set_working(work_dir, check = nil, must_exist: nil) 



299
300
301
302
303
304
 
# File 'lib/git/base.rb', line 299

def set_working(work_dir, check = nil, must_exist: nil)
  must_exist = deprecate_check_argument(check, must_exist)
  @lib = nil
  @facade_repository = nil
  @working_directory = validate_path(work_dir, must_exist)
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



781
782
783
 
# File 'lib/git/base.rb', line 781

def show(objectish = nil, path = nil)
  facade_repository.show(objectish, path)
end

#status ⇒ Git::Status

Returns a status object.

Returns:



1025
1026
1027
 
# File 'lib/git/base.rb', line 1025

def status
  facade_repository.status
end

#tag(tag_name) ⇒ Git::Object::Tag

Returns a tag object.

Returns:



1030
1031
1032
 
# File 'lib/git/base.rb', line 1030

def tag(tag_name)
  facade_repository.tag(tag_name)
end

#tags

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



645
646
647
 
# File 'lib/git/base.rb', line 645

def tags
  facade_repository.tags
end

#tree_depth(objectish) ⇒ Integer

Returns the number of entries in a git tree object

Examples:

Count recursive entries in the HEAD tree

git.tree_depth('HEAD^{tree}') #=> 42

Parameters:

  • objectish (String) —

    the tree-ish object to recurse into

Returns:

  • (Integer) —

    the number of entries in the recursive tree listing

Raises:

See Also:



881
882
883
 
# File 'lib/git/base.rb', line 881

def tree_depth(objectish)
  facade_repository.tree_depth(objectish)
end

#update_ref(branch, commit) 



826
827
828
 
# File 'lib/git/base.rb', line 826

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

#with_index(new_index)

LOWER LEVEL INDEX OPERATIONS ##



787
788
789
790
791
792
793
 
# File 'lib/git/base.rb', line 787

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 



795
796
797
798
799
800
801
802
803
804
805
806
807
808
 
# File 'lib/git/base.rb', line 795

def with_temp_index(&)
  # 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, &)
end

#with_temp_working 



845
846
847
848
849
850
851
852
 
# File 'lib/git/base.rb', line 845

def with_temp_working(&)
  tempfile = Tempfile.new('temp-workdir')
  temp_dir = tempfile.path
  tempfile.close
  tempfile.unlink
  Dir.mkdir(temp_dir, 0o700)
  with_working(temp_dir, &)
end

#with_working(work_dir)

:yields: the working directory Pathname



834
835
836
837
838
839
840
841
842
843
 
# File 'lib/git/base.rb', line 834

def with_working(work_dir) # :yields: the working directory Pathname
  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

#worktree(dir, commitish = nil) ⇒ Git::Worktree

Returns a Worktree object for the given path and optional commitish

Examples:

Create a worktree object for an existing path

worktree = repo.worktree('/path/to/worktree')

Parameters:

  • dir (String) —

    filesystem path of the worktree

  • commitish (String, nil) (defaults to: nil) —

    branch, tag, or commit to check out

Returns:



950
951
952
 
# File 'lib/git/base.rb', line 950

def worktree(dir, commitish = nil)
  facade_repository.worktree(dir, commitish)
end

#worktrees ⇒ Git::Worktrees

Returns a Worktrees collection of all worktrees in the repository

Examples:

List paths for all worktrees

repo.worktrees.each { |wt| puts wt.dir }

Returns:

Raises:



963
964
965
 
# File 'lib/git/base.rb', line 963

def worktrees
  facade_repository.worktrees
end

#write_and_commit_tree(opts = {}) 



822
823
824
 
# File 'lib/git/base.rb', line 822

def write_and_commit_tree(opts = {})
  Git::Object::Commit.new(self, facade_repository.write_and_commit_tree(**opts))
end

#write_tree 



818
819
820
 
# File 'lib/git/base.rb', line 818

def write_tree
  facade_repository.write_tree
end