# File lib/git/lib.rb, line 65
def initialize(base = nil, logger = nil)
  @logger = logger || Logger.new(nil)

  case base
  when Git::Base
    initialize_from_base(base)
  when Hash
    initialize_from_hash(base)
  end
end

# File lib/git/lib.rb, line 1555
def self.warn_if_old_command(lib) # rubocop:disable Naming/PredicateMethod
  Git::Deprecation.warn('Git::Lib#warn_if_old_command is deprecated. Use meets_required_version?.')

  return true if @version_checked

  @version_checked = true
  unless lib.meets_required_version?
    warn "[WARNING] The git gem requires git #{lib.required_command_version.join('.')} or later, " \
         "but only found #{lib.current_command_version.join('.')}. You should probably upgrade."
  end
  true
end

# File lib/git/lib.rb, line 1048
def add(paths = '.', options = {})
  args = build_args(options, ADD_OPTION_MAP)

  args << '--'
  args.concat(Array(paths))

  command('add', *args)
end

# File lib/git/lib.rb, line 1170
def apply(patch_file)
  arr_opts = []
  arr_opts << '--' << patch_file if patch_file
  command('apply', *arr_opts)
end

# File lib/git/lib.rb, line 1176
def apply_mail(patch_file)
  arr_opts = []
  arr_opts << '--' << patch_file if patch_file
  command('am', *arr_opts)
end

# File lib/git/lib.rb, line 1507
def archive(sha, file = nil, opts = {})
  ArgsBuilder.validate!(opts, ARCHIVE_OPTION_MAP)
  file ||= temp_file_name
  format, gzip = parse_archive_format_options(opts)

  args = build_args(opts, ARCHIVE_OPTION_MAP)
  args.unshift("--format=#{format}")
  args << sha
  args.push('--', opts[:path]) if opts[:path]

  File.open(file, 'wb') { |f| command('archive', *args, out: f) }
  apply_gzip(file) if gzip

  file
end

# File lib/git/lib.rb, line 820
def assert_args_are_not_options(arg_name, *args)
  invalid_args = args.select { |arg| arg&.start_with?('-') }
  return unless invalid_args.any?

  raise ArgumentError, "Invalid #{arg_name}: '#{invalid_args.join("', '")}'"
end

# File lib/git/lib.rb, line 781
def branch_contains(commit, branch_name = '')
  command('branch',  branch_name, '--contains', commit)
end

# File lib/git/lib.rb, line 776
def branch_current
  branch_name = command('branch', '--show-current')
  branch_name.empty? ? 'HEAD' : branch_name
end

# File lib/git/lib.rb, line 1213
def branch_delete(branch)
  command('branch', '-D', branch)
end

# File lib/git/lib.rb, line 1209
def branch_new(branch)
  command('branch', branch)
end

# File lib/git/lib.rb, line 694
def branches_all
  lines = command_lines('branch', '-a')
  lines.each_with_index.filter_map do |line, index|
    parse_branch_line(line, index, lines)
  end
end

# File lib/git/lib.rb, line 482
def cat_file_commit(object)
  assert_args_are_not_options('object', object)

  cdata = command_lines('cat-file', 'commit', object)
  process_commit_data(cdata, object)
end

# File lib/git/lib.rb, line 408
def cat_file_contents(object)
  assert_args_are_not_options('object', object)

  if block_given?
    Tempfile.create do |file|
      # If a block is given, write the output from the process to a temporary
      # file and then yield the file to the block
      #
      command('cat-file', '-p', object, out: file, err: file)
      file.rewind
      yield file
    end
  else
    # If a block is not given, return the file contents as a string
    command('cat-file', '-p', object)
  end
end

# File lib/git/lib.rb, line 456
def cat_file_size(object)
  assert_args_are_not_options('object', object)

  command('cat-file', '-s', object).to_i
end

# File lib/git/lib.rb, line 551
def cat_file_tag(object)
  assert_args_are_not_options('object', object)

  tdata = command_lines('cat-file', 'tag', object)
  process_tag_data(tdata, object)
end

# File lib/git/lib.rb, line 438
def cat_file_type(object)
  assert_args_are_not_options('object', object)

  command('cat-file', '-t', object)
end

# File lib/git/lib.rb, line 666
def change_head_branch(branch_name)
  command('symbolic-ref', 'HEAD', "refs/heads/#{branch_name}")
end

# File lib/git/lib.rb, line 1232
def checkout(branch = nil, opts = {})
  if branch.is_a?(Hash) && opts.empty?
    opts = branch
    branch = nil
  end
  ArgsBuilder.validate!(opts, CHECKOUT_OPTION_MAP)

  flags = build_args(opts, CHECKOUT_OPTION_MAP)
  positional_args = build_checkout_positional_args(branch, opts)

  command('checkout', *flags, *positional_args)
end

# File lib/git/lib.rb, line 1245
def checkout_file(version, file)
  arr_opts = []
  arr_opts << version
  arr_opts << file
  command('checkout', *arr_opts)
end

# File lib/git/lib.rb, line 1487
def checkout_index(opts = {})
  ArgsBuilder.validate!(opts, CHECKOUT_INDEX_OPTION_MAP)
  args = build_args(opts, CHECKOUT_INDEX_OPTION_MAP)

  if (path = opts[:path_limiter]) && path.is_a?(String)
    args.push('--', path)
  end

  command('checkout-index', *args)
end

# File lib/git/lib.rb, line 1151
def clean(opts = {})
  args = build_args(opts, CLEAN_OPTION_MAP)
  command('clean', *args)
end

# File lib/git/lib.rb, line 149
def clone(repository_url, directory, opts = {})
  @path = opts[:path] || '.'
  clone_dir = opts[:path] ? File.join(@path, directory) : directory

  args = build_args(opts, CLONE_OPTION_MAP)
  args.push('--', repository_url, clone_dir)

  command('clone', *args, timeout: opts[:timeout])

  return_base_opts_from_clone(clone_dir, opts)
end

# File lib/git/lib.rb, line 1123
def commit(message, opts = {})
  opts[:message] = message if message # Handle message arg for backward compatibility

  # Perform cross-option validation before building args
  raise ArgumentError, 'cannot specify :gpg_sign and :no_gpg_sign' if opts[:gpg_sign] && opts[:no_gpg_sign]

  ArgsBuilder.validate!(opts, COMMIT_OPTION_MAP)

  args = build_args(opts, COMMIT_OPTION_MAP)
  command('commit', *args)
end

# File lib/git/lib.rb, line 1468
def commit_tree(tree, opts = {})
  opts[:message] ||= "commit tree #{tree}"
  ArgsBuilder.validate!(opts, COMMIT_TREE_OPTION_MAP)

  flags = build_args(opts, COMMIT_TREE_OPTION_MAP)
  command('commit-tree', tree, *flags)
end

# File lib/git/lib.rb, line 1543
def compare_version_to(*other_version)
  current_command_version <=> other_version
end

# File lib/git/lib.rb, line 972
def config_get(name)
  command('config', '--get', name, chdir: @git_dir)
end

# File lib/git/lib.rb, line 980
def config_list
  parse_config_list command_lines('config', '--list', chdir: @git_dir)
end

# File lib/git/lib.rb, line 964
def config_remote(name)
  hsh = {}
  config_list.each do |key, value|
    hsh[key.gsub("remote.#{name}.", '')] = value if /remote.#{name}/.match(key)
  end
  hsh
end

# File lib/git/lib.rb, line 1020
def config_set(name, value, options = {})
  ArgsBuilder.validate!(options, CONFIG_SET_OPTION_MAP)
  flags = build_args(options, CONFIG_SET_OPTION_MAP)
  command('config', *flags, name, value)
end

# File lib/git/lib.rb, line 1294
def conflicts # :yields: file, your, their
  unmerged.each do |file_path|
    Tempfile.create(['YOUR-', File.basename(file_path)]) do |your_file|
      write_staged_content(file_path, 2, your_file).flush

      Tempfile.create(['THEIR-', File.basename(file_path)]) do |their_file|
        write_staged_content(file_path, 3, their_file).flush
        yield(file_path, your_file.path, their_file.path)
      end
    end
  end
end

# File lib/git/lib.rb, line 768
def current_branch_state
  branch_name = command('branch', '--show-current')
  return HeadState.new(:detached, 'HEAD') if branch_name.empty?

  state = get_branch_state(branch_name)
  HeadState.new(state, branch_name)
end

# File lib/git/lib.rb, line 1524
def current_command_version
  output = command('version')
  version = output[/\d+(\.\d+)+/]
  version_parts = version.split('.').collect(&:to_i)
  version_parts.fill(0, version_parts.length...3)
end

# File lib/git/lib.rb, line 228
def describe(commit_ish = nil, opts = {})
  assert_args_are_not_options('commit-ish object', commit_ish)

  args = build_args(opts, DESCRIBE_OPTION_MAP)
  args << commit_ish if commit_ish

  command('describe', *args)
end

# File lib/git/lib.rb, line 883
def diff_files
  diff_as_hash('diff-files')
end

# File lib/git/lib.rb, line 832
def diff_full(obj1 = 'HEAD', obj2 = nil, opts = {})
  assert_args_are_not_options('commit or commit range', obj1, obj2)
  ArgsBuilder.validate!(opts, DIFF_FULL_OPTION_MAP)

  args = build_args(opts, DIFF_FULL_OPTION_MAP)
  args.push(obj1, obj2).compact!

  if (path = opts[:path_limiter]) && path.is_a?(String)
    args.push('--', path)
  end

  command('diff', *args)
end

# File lib/git/lib.rb, line 888
def diff_index(treeish)
  diff_as_hash('diff-index', treeish)
end

# File lib/git/lib.rb, line 871
def diff_path_status(reference1 = nil, reference2 = nil, opts = {})
  assert_args_are_not_options('commit or commit range', reference1, reference2)
  ArgsBuilder.validate!(opts, DIFF_PATH_STATUS_OPTION_MAP)

  args = build_args(opts, DIFF_PATH_STATUS_OPTION_MAP)
  args.push(reference1, reference2).compact!
  args.push('--', opts[:path]) if opts[:path]

  parse_diff_path_status(args)
end

# File lib/git/lib.rb, line 851
def diff_stats(obj1 = 'HEAD', obj2 = nil, opts = {})
  assert_args_are_not_options('commit or commit range', obj1, obj2)
  ArgsBuilder.validate!(opts, DIFF_STATS_OPTION_MAP)

  args = build_args(opts, DIFF_STATS_OPTION_MAP)
  args.push(obj1, obj2).compact!

  if (path = opts[:path_limiter]) && path.is_a?(String)
    args.push('--', path)
  end

  output_lines = command_lines('diff', *args)
  parse_diff_stats_output(output_lines)
end

# File lib/git/lib.rb, line 502
def each_cat_file_header(data)
  while (match = CAT_FILE_HEADER_LINE.match(data.shift))
    key = match[:key]
    value_lines = [match[:value]]

    value_lines << data.shift.lstrip while data.first.start_with?(' ')

    yield key, value_lines.join("\n")
  end
end

# File lib/git/lib.rb, line 1076
def empty?
  command('rev-parse', '--verify', 'HEAD')
  false
rescue Git::FailedError => e
  raise unless e.result.status.exitstatus == 128 &&
               e.result.stderr == 'fatal: Needed a single revision'

  true
end

# File lib/git/lib.rb, line 1375
def fetch(remote, opts)
  ArgsBuilder.validate!(opts, FETCH_OPTION_MAP)
  args = build_args(opts, FETCH_OPTION_MAP)

  if remote || opts[:ref]
    args << '--'
    args << remote if remote
    args << opts[:ref] if opts[:ref]
  end

  command('fetch', *args, merge: true)
end

# File lib/git/lib.rb, line 337
def full_log_commits(opts = {})
  assert_args_are_not_options('between', opts[:between]&.first)
  assert_args_are_not_options('object', opts[:object])

  args = log_common_options(opts)
  args += build_args(opts, FULL_LOG_EXTRA_OPTIONS_MAP)
  args += log_path_options(opts)

  full_log = command_lines('log', *args)
  process_commit_log_data(full_log)
end

# File lib/git/lib.rb, line 658
def full_tree(sha)
  command_lines('ls-tree', '-r', sha)
end

# File lib/git/lib.rb, line 1445
def gc
  command('gc', '--prune', '--aggressive', '--auto')
end

# File lib/git/lib.rb, line 976
def global_config_get(name)
  command('config', '--global', '--get', name)
end

# File lib/git/lib.rb, line 984
def global_config_list
  parse_config_list command_lines('config', '--global', '--list')
end

# File lib/git/lib.rb, line 1026
def global_config_set(name, value)
  command('config', '--global', name, value)
end

# File lib/git/lib.rb, line 797
def grep(string, opts = {})
  opts[:object] ||= 'HEAD'
  ArgsBuilder.validate!(opts, GREP_OPTION_MAP)

  boolean_flags = build_args(opts, GREP_OPTION_MAP)
  args = ['-n', *boolean_flags, '-e', string, opts[:object]]

  if (limiter = opts[:path_limiter])
    args.push('--', *Array(limiter))
  end

  lines = execute_grep_command(args)
  parse_grep_output(lines)
end

# File lib/git/lib.rb, line 954
def ignored_files
  command_lines('ls-files', '--others', '-i', '--exclude-standard').map { |f| unescape_quoted_path(f) }
end

# File lib/git/lib.rb, line 88
def init(opts = {})
  args = build_args(opts, INIT_OPTION_MAP)
  command('init', *args)
end

# File lib/git/lib.rb, line 735
def list_files(ref_dir)
  dir = File.join(@git_dir, 'refs', ref_dir)
  Dir.glob('**/*', base: dir).select { |f| File.file?(File.join(dir, f)) }
end

# File lib/git/lib.rb, line 264
def log_commits(opts = {})
  assert_args_are_not_options('between', opts[:between]&.first)
  assert_args_are_not_options('object', opts[:object])

  arr_opts = log_common_options(opts)

  arr_opts << '--pretty=oneline'

  arr_opts += log_path_options(opts)

  command_lines('log', *arr_opts).map { |l| l.split.first }
end

# File lib/git/lib.rb, line 904
def ls_files(location = nil)
  location ||= '.'
  {}.tap do |files|
    command_lines('ls-files', '--stage', location).each do |line|
      (info, file) = split_status_line(line)
      (mode, sha, stage) = info.split
      files[file] = {
        path: file, mode_index: mode, sha_index: sha, stage: stage
      }
    end
  end
end

# File lib/git/lib.rb, line 944
def ls_remote(location = nil, opts = {})
  ArgsBuilder.validate!(opts, LS_REMOTE_OPTION_MAP)

  flags = build_args(opts, LS_REMOTE_OPTION_MAP)
  positional_arg = location || '.'

  output_lines = command_lines('ls-remote', *flags, positional_arg)
  parse_ls_remote_output(output_lines)
end

# File lib/git/lib.rb, line 638
def ls_tree(sha, opts = {})
  data = { 'blob' => {}, 'tree' => {}, 'commit' => {} }
  args = build_args(opts, LS_TREE_OPTION_MAP)

  args.unshift(sha)
  args << opts[:path] if opts[:path]

  command_lines('ls-tree', *args).each do |line|
    (info, filenm) = split_status_line(line)
    (mode, type, sha) = info.split
    data[type][filenm] = { mode: mode, sha: sha }
  end

  data
end

# File lib/git/lib.rb, line 1551
def meets_required_version?
  (current_command_version <=> required_command_version) >= 0
end

# File lib/git/lib.rb, line 1258
def merge(branch, message = nil, opts = {})
  # For backward compatibility, treat the message arg as the :m option.
  opts[:m] = message if message
  ArgsBuilder.validate!(opts, MERGE_OPTION_MAP)

  args = build_args(opts, MERGE_OPTION_MAP)
  args.concat(Array(branch))

  command('merge', *args)
end

# File lib/git/lib.rb, line 1276
def merge_base(*args)
  opts = args.last.is_a?(Hash) ? args.pop : {}
  ArgsBuilder.validate!(opts, MERGE_BASE_OPTION_MAP)

  flags = build_args(opts, MERGE_BASE_OPTION_MAP)
  command_args = flags + args

  command('merge-base', *command_args).lines.map(&:strip)
end

# File lib/git/lib.rb, line 654
def mv(file1, file2)
  command_lines('mv', '--', file1, file2)
end

# File lib/git/lib.rb, line 384
def name_rev(commit_ish)
  assert_args_are_not_options('commit_ish', commit_ish)

  command('name-rev', commit_ish).split[1]
end

# File lib/git/lib.rb, line 997
def parse_config(file)
  parse_config_list command_lines('config', '--list', '--file', file)
end

# File lib/git/lib.rb, line 988
def parse_config_list(lines)
  hsh = {}
  lines.each do |line|
    (key, *values) = line.split('=')
    hsh[key] = values.join('=')
  end
  hsh
end

# File lib/git/lib.rb, line 491
def process_commit_data(data, sha)
  # process_commit_headers consumes the header lines from the `data` array,
  # leaving only the message lines behind.
  headers = process_commit_headers(data)
  message = "#{data.join("\n")}\n"

  { 'sha' => sha, 'message' => message }.merge(headers)
end

# File lib/git/lib.rb, line 572
def process_commit_log_data(data)
  RawLogParser.new(data).parse
end

# File lib/git/lib.rb, line 560
def process_tag_data(data, name)
  hsh = { 'name' => name }

  each_cat_file_header(data) do |key, value|
    hsh[key] = value
  end

  hsh['message'] = "#{data.join("\n")}\n"

  hsh
end

# File lib/git/lib.rb, line 1417
def pull(remote = nil, branch = nil, opts = {})
  raise ArgumentError, 'You must specify a remote if a branch is specified' if remote.nil? && !branch.nil?

  ArgsBuilder.validate!(opts, PULL_OPTION_MAP)

  flags = build_args(opts, PULL_OPTION_MAP)
  positional_args = [remote, branch].compact

  command('pull', *flags, *positional_args)
end

# File lib/git/lib.rb, line 1397
def push(remote = nil, branch = nil, opts = nil)
  remote, branch, opts = normalize_push_args(remote, branch, opts)
  ArgsBuilder.validate!(opts, PUSH_OPTION_MAP)

  raise ArgumentError, 'remote is required if branch is specified' if !remote && branch

  args = build_push_args(remote, branch, opts)

  if opts[:mirror]
    command('push', *args)
  else
    command('push', *args)
    command('push', '--tags', *(args - [branch].compact)) if opts[:tags]
  end
end

# File lib/git/lib.rb, line 1453
def read_tree(treeish, opts = {})
  ArgsBuilder.validate!(opts, READ_TREE_OPTION_MAP)
  flags = build_args(opts, READ_TREE_OPTION_MAP)
  command('read-tree', *flags, treeish)
end

# File lib/git/lib.rb, line 1312
def remote_add(name, url, opts = {})
  ArgsBuilder.validate!(opts, REMOTE_ADD_OPTION_MAP)

  flags = build_args(opts, REMOTE_ADD_OPTION_MAP)
  positional_args = ['--', name, url]
  command_args = ['add'] + flags + positional_args

  command('remote', *command_args)
end

# File lib/git/lib.rb, line 1330
def remote_remove(name)
  command('remote', 'rm', name)
end

# File lib/git/lib.rb, line 1322
def remote_set_url(name, url)
  arr_opts = ['set-url']
  arr_opts << name
  arr_opts << url

  command('remote', *arr_opts)
end

# File lib/git/lib.rb, line 1334
def remotes
  command_lines('remote')
end

# File lib/git/lib.rb, line 1441
def repack
  command('repack', '-a', '-d')
end

# File lib/git/lib.rb, line 167
def repository_default_branch(repository)
  output = command('ls-remote', '--symref', '--', repository, 'HEAD')

  match_data = output.match(%r{^ref: refs/remotes/origin/(?<default_branch>[^\t]+)\trefs/remotes/origin/HEAD$})
  return match_data[:default_branch] if match_data

  match_data = output.match(%r{^ref: refs/heads/(?<default_branch>[^\t]+)\tHEAD$})
  return match_data[:default_branch] if match_data

  raise Git::UnexpectedResultError, 'Unable to determine the default branch'
end

# File lib/git/lib.rb, line 1547
def required_command_version
  [2, 28]
end

# File lib/git/lib.rb, line 1138
def reset(commit, opts = {})
  args = build_args(opts, RESET_OPTION_MAP)
  args << commit if commit
  command('reset', *args)
end

# File lib/git/lib.rb, line 367
def rev_parse(revision)
  assert_args_are_not_options('rev', revision)

  command('rev-parse', '--revs-only', '--end-of-options', revision, '--')
end

# File lib/git/lib.rb, line 1160
def revert(commitish, opts = {})
  # Forcing --no-edit as default since it's not an interactive session.
  opts = { no_edit: true }.merge(opts)

  args = build_args(opts, REVERT_OPTION_MAP)
  args << commitish

  command('revert', *args)
end

# File lib/git/lib.rb, line 1063
def rm(path = '.', opts = {})
  args = build_args(opts, RM_OPTION_MAP)

  args << '--'
  args.concat(Array(path))

  command('rm', *args)
end

# File lib/git/lib.rb, line 1006
def show(objectish = nil, path = nil)
  arr_opts = []

  arr_opts << (path ? "#{objectish}:#{path}" : objectish)

  command('show', *arr_opts.compact, chomp: false)
end

# File lib/git/lib.rb, line 1193
def stash_apply(id = nil)
  if id
    command('stash', 'apply', id)
  else
    command('stash', 'apply')
  end
end

# File lib/git/lib.rb, line 1201
def stash_clear
  command('stash', 'clear')
end

# File lib/git/lib.rb, line 1205
def stash_list
  command('stash', 'list')
end

# File lib/git/lib.rb, line 1188
def stash_save(message)
  output = command('stash', 'save', message)
  output =~ /HEAD is now at/
end

# File lib/git/lib.rb, line 1182
def stashes_all
  stash_log_lines.each_with_index.map do |line, index|
    parse_stash_log_line(line, index)
  end
end

# File lib/git/lib.rb, line 1350
def tag(name, *args)
  opts = args.last.is_a?(Hash) ? args.pop : {}
  target = args.first

  validate_tag_options!(opts)
  ArgsBuilder.validate!(opts, TAG_OPTION_MAP)

  flags = build_args(opts, TAG_OPTION_MAP)
  positional_args = [name, target].compact

  command('tag', *flags, *positional_args)
end

# File lib/git/lib.rb, line 1428
def tag_sha(tag_name)
  head = File.join(@git_dir, 'refs', 'tags', tag_name)
  return File.read(head).chomp if File.exist?(head)

  begin
    command('show-ref', '--tags', '-s', tag_name)
  rescue Git::FailedError => e
    raise unless e.result.status.exitstatus == 1 && e.result.stderr == ''

    ''
  end
end

# File lib/git/lib.rb, line 1338
def tags
  command_lines('tag')
end

# File lib/git/lib.rb, line 662
def tree_depth(sha)
  full_tree(sha).size
end

# File lib/git/lib.rb, line 932
def unescape_quoted_path(path)
  if path.start_with?('"') && path.end_with?('"')
    Git::EscapedPath.new(path[1..-2]).unescape
  else
    path
  end
end

# File lib/git/lib.rb, line 1286
def unmerged
  unmerged = []
  command_lines('diff', '--cached').each do |line|
    unmerged << ::Regexp.last_match(1) if line =~ /^\* Unmerged path (.*)/
  end
  unmerged
end

# File lib/git/lib.rb, line 958
def untracked_files
  command_lines('ls-files', '--others', '--exclude-standard', chdir: @git_work_dir).map do |f|
    unescape_quoted_path(f)
  end
end

# File lib/git/lib.rb, line 1476
def update_ref(ref, commit)
  command('update-ref', ref, commit)
end

# File lib/git/lib.rb, line 721
def worktree_add(dir, commitish = nil)
  return command('worktree', 'add', dir, commitish) unless commitish.nil?

  command('worktree', 'add', dir)
end

# File lib/git/lib.rb, line 731
def worktree_prune
  command('worktree', 'prune')
end

# File lib/git/lib.rb, line 727
def worktree_remove(dir)
  command('worktree', 'remove', dir)
end

# File lib/git/lib.rb, line 701
def worktrees_all
  arr = []
  directory = ''
  # Output example for `worktree list --porcelain`:
  # worktree /code/public/ruby-git
  # HEAD 4bef5abbba073c77b4d0ccc1ffcd0ed7d48be5d4
  # branch refs/heads/master
  #
  # worktree /tmp/worktree-1
  # HEAD b8c63206f8d10f57892060375a86ae911fad356e
  # detached
  #
  command_lines('worktree', 'list', '--porcelain').each do |w|
    s = w.split
    directory = s[1] if s[0] == 'worktree'
    arr << [directory, s[1]] if s[0] == 'HEAD'
  end
  arr
end

# File lib/git/lib.rb, line 1459
def write_tree
  command('write-tree')
end

# File lib/git/lib.rb, line 1871
def apply_gzip(file)
  file_content = File.read(file)
  Zlib::GzipWriter.open(file) { |gz| gz.write(file_content) }
end

# File lib/git/lib.rb, line 1623
def build_args(opts, option_map)
  Git::ArgsBuilder.new(opts, option_map).build
end

# File lib/git/lib.rb, line 1612
def build_checkout_positional_args(branch, opts)
  args = []
  if opts[:new_branch] || opts[:b]
    args.push('-b', branch)
    args << opts[:start_point] if opts[:start_point]
  elsif branch
    args << branch
  end
  args
end

# File lib/git/lib.rb, line 1765
def build_files_hash(file_stats)
  file_stats.to_h { |s| [s[:filename], s.slice(:insertions, :deletions)] }
end

# File lib/git/lib.rb, line 1747
def build_final_stats_hash(file_stats)
  {
    total: build_total_stats(file_stats),
    files: build_files_hash(file_stats)
  }
end

# File lib/git/lib.rb, line 1846
def build_push_args(remote, branch, opts)
  # Build the simple flags using the ArgsBuilder
  args = build_args(opts, PUSH_OPTION_MAP)

  # Manually handle the flag with external dependencies and positional args
  args << '--all' if opts[:all] && remote
  args << remote if remote
  args << branch if branch
  args
end

# File lib/git/lib.rb, line 1754
def build_total_stats(file_stats)
  insertions = file_stats.sum { |s| s[:insertions] }
  deletions = file_stats.sum { |s| s[:deletions] }
  {
    insertions: insertions,
    deletions: deletions,
    lines: insertions + deletions,
    files: file_stats.size
  }
end

# File lib/git/lib.rb, line 1956
def command(*, **options_hash)
  options_hash = COMMAND_ARG_DEFAULTS.merge(options_hash)
  options_hash[:timeout] ||= Git.config.timeout

  extra_options = options_hash.keys - COMMAND_ARG_DEFAULTS.keys
  raise ArgumentError, "Unknown options: #{extra_options.join(', ')}" if extra_options.any?

  result = command_line.run(*, **options_hash)
  result.stdout
end

# File lib/git/lib.rb, line 1904
def command_line
  @command_line ||=
    Git::CommandLine.new(env_overrides, Git::Base.config.binary_path, global_opts, @logger)
end

# File lib/git/lib.rb, line 1876
def command_lines(cmd, *opts, chdir: nil)
  cmd_op = command(cmd, *opts, chdir: chdir)
  op = if cmd_op.encoding.name == 'UTF-8'
         cmd_op
       else
         cmd_op.encode('UTF-8', 'binary', invalid: :replace, undef: :replace)
       end
  op.split("\n")
end

# File lib/git/lib.rb, line 1972
def diff_as_hash(diff_command, opts = [])
  # update index before diffing to avoid spurious diffs
  command('status')
  command_lines(diff_command, *opts).each_with_object({}) do |line, memo|
    info, file = split_status_line(line)
    mode_src, mode_dest, sha_src, sha_dest, type = info.split

    memo[file] = {
      mode_index: mode_dest, mode_repo: mode_src.to_s[1, 7],
      path: file, sha_repo: sha_src, sha_index: sha_dest,
      type: type
    }
  end
end

# File lib/git/lib.rb, line 1886
def env_overrides
  {
    'GIT_DIR' => @git_dir,
    'GIT_WORK_TREE' => @git_work_dir,
    'GIT_INDEX_FILE' => @git_index_file,
    'GIT_SSH' => Git::Base.config.git_ssh,
    'LC_ALL' => 'en_US.UTF-8'
  }
end

# File lib/git/lib.rb, line 1706
def execute_grep_command(args)
  command_lines('grep', *args)
rescue Git::FailedError => e
  # `git grep` returns 1 when no lines are selected.
  raise unless e.result.status.exitstatus == 1 && e.result.stderr.empty?

  [] # Return an empty array for "no matches found"
end

# File lib/git/lib.rb, line 1674
def format_branch_data(match_data)
  [
    match_data[:refname],
    !match_data[:current].nil?,
    !match_data[:worktree].nil?,
    match_data[:symref]
  ]
end

# File lib/git/lib.rb, line 1695
def get_branch_state(branch_name)
  command('rev-parse', '--verify', '--quiet', branch_name)
  :active
rescue Git::FailedError => e
  # An exit status of 1 with empty stderr from `rev-parse --verify`
  # indicates a ref that exists but does not yet point to a commit.
  raise unless e.result.status.exitstatus == 1 && e.result.stderr.empty?

  :unborn
end

# File lib/git/lib.rb, line 1896
def global_opts
  [].tap do |global_opts|
    global_opts << "--git-dir=#{@git_dir}" unless @git_dir.nil?
    global_opts << "--work-tree=#{@git_work_dir}" unless @git_work_dir.nil?
    global_opts.concat(STATIC_GLOBAL_OPTS)
  end
end

# File lib/git/lib.rb, line 1627
def initialize_from_base(base_object)
  @git_dir = base_object.repo.path
  @git_index_file = base_object.index&.path
  @git_work_dir = base_object.dir&.path
end

# File lib/git/lib.rb, line 1633
def initialize_from_hash(base_hash)
  @git_dir = base_hash[:repository]
  @git_index_file = base_hash[:index]
  @git_work_dir = base_hash[:working_directory]
end

# File lib/git/lib.rb, line 1991
def log_common_options(opts)
  if opts[:count] && !opts[:count].is_a?(Integer)
    raise ArgumentError, "The log count option must be an Integer but was #{opts[:count].inspect}"
  end

  build_args(opts, LOG_OPTION_MAP)
end

# File lib/git/lib.rb, line 2003
def log_path_options(opts)
  arr_opts = []

  arr_opts << opts[:object] if opts[:object].is_a? String
  if opts[:path_limiter]
    arr_opts << '--'
    arr_opts += Array(opts[:path_limiter])
  end
  arr_opts
end

# File lib/git/lib.rb, line 1667
def match_branch_line(line, index, all_lines)
  match_data = line.match(BRANCH_LINE_REGEXP)
  raise Git::UnexpectedResultError, unexpected_branch_line_error(all_lines, line, index) unless match_data

  match_data
end

# File lib/git/lib.rb, line 1831
def normalize_push_args(remote, branch, opts)
  if branch.is_a?(Hash)
    opts = branch
    branch = nil
  elsif remote.is_a?(Hash)
    opts = remote
    remote = nil
  end

  opts ||= {}
  # Backwards compatibility for `push(remote, branch, true)`
  opts = { tags: opts } if [true, false].include?(opts)
  [remote, branch, opts]
end

# File lib/git/lib.rb, line 1864
def parse_archive_format_options(opts)
  format = opts[:format] || 'zip'
  gzip = opts[:add_gzip] == true || format == 'tgz'
  format = 'tar' if format == 'tgz'
  [format, gzip]
end

# File lib/git/lib.rb, line 1659
def parse_branch_line(line, index, all_lines)
  match_data = match_branch_line(line, index, all_lines)

  return nil if match_data[:not_a_branch] || match_data[:detached_ref]

  format_branch_data(match_data)
end

# File lib/git/lib.rb, line 1605
def parse_diff_path_status(args)
  command_lines('diff', *args).each_with_object({}) do |line, memo|
    status, path = split_status_line(line)
    memo[path] = status
  end
end

# File lib/git/lib.rb, line 1725
def parse_diff_stats_output(lines)
  file_stats = parse_stat_lines(lines)
  build_final_stats_hash(file_stats)
end

# File lib/git/lib.rb, line 1715
def parse_grep_output(lines)
  lines.each_with_object(Hash.new { |h, k| h[k] = [] }) do |line, hsh|
    match = line.match(/\A(.*?):(\d+):(.*)/)
    next unless match

    _full, filename, line_num, text = match.to_a
    hsh[filename] << [line_num.to_i, text]
  end
end

# File lib/git/lib.rb, line 1780
def parse_ls_remote_line(line)
  sha, info = line.split("\t", 2)
  ref, type, name = info.split('/', 3)

  type ||= 'head'
  type = 'branches' if type == 'heads'

  value = { ref: ref, sha: sha }

  [type, name, value]
end

# File lib/git/lib.rb, line 1769
def parse_ls_remote_output(lines)
  lines.each_with_object(Hash.new { |h, k| h[k] = {} }) do |line, hsh|
    type, name, value = parse_ls_remote_line(line)
    if name
      hsh[type][name] = value
    else # Handles the HEAD entry, which has no name
      hsh[type].update(value)
    end
  end
end

# File lib/git/lib.rb, line 1799
def parse_stash_log_line(line, index)
  full_message = line.split("\t", 2).last
  match_data = full_message.match(/^[^:]+:(.*)$/)
  message = match_data ? match_data[1] : full_message

  [index, message.strip]
end

# File lib/git/lib.rb, line 1730
def parse_stat_lines(lines)
  lines.map do |line|
    insertions_s, deletions_s, filename = split_status_line(line)
    {
      filename: filename,
      insertions: insertions_s.to_i,
      deletions: deletions_s.to_i
    }
  end
end

# File lib/git/lib.rb, line 1647
def process_commit_headers(data)
  headers = { 'parent' => [] } # Pre-initialize for multiple parents
  each_cat_file_header(data) do |key, value|
    if key == 'parent'
      headers['parent'] << value
    else
      headers[key] = value
    end
  end
  headers
end

# File lib/git/lib.rb, line 1639
def return_base_opts_from_clone(clone_dir, opts)
  base_opts = {}
  base_opts[:repository] = clone_dir if opts[:bare] || opts[:mirror]
  base_opts[:working_directory] = clone_dir unless opts[:bare] || opts[:mirror]
  base_opts[:log] = opts[:log] if opts[:log]
  base_opts
end

# File lib/git/lib.rb, line 1741
def split_status_line(line)
  parts = line.split("\t")
  parts[-1] = unescape_quoted_path(parts[-1]) if parts.any?
  parts
end

# File lib/git/lib.rb, line 1792
def stash_log_lines
  path = File.join(@git_dir, 'logs/refs/stash')
  return [] unless File.exist?(path)

  File.readlines(path, chomp: true)
end

# File lib/git/lib.rb, line 1857
def temp_file_name
  tempfile = Tempfile.new('archive')
  file = tempfile.path
  tempfile.close! # Prevents Ruby from deleting the file on garbage collection
  file
end

# File lib/git/lib.rb, line 1683
    def unexpected_branch_line_error(lines, line, index)
      <<~ERROR
        Unexpected line in output from `git branch -a`, line #{index + 1}

        Full output:
          #{lines.join("\n  ")}

        Line #{index + 1}:
          "#{line}"
      ERROR
    end

# File lib/git/lib.rb, line 1822
def validate_tag_options!(opts)
  is_annotated = opts[:a] || opts[:annotate]
  has_message = opts[:m] || opts[:message]

  return unless is_annotated && !has_message

  raise ArgumentError, 'Cannot create an annotated tag without a message.'
end

# File lib/git/lib.rb, line 1817
def write_staged_content(path, stage, out_io)
  command('show', ":#{stage}:#{path}", out: out_io)
  out_io
end