git 5.0.0.beta.1 → 5.0.0.beta.2

data/lib/git.rb

@@ -3,11 +3,10 @@
 require 'active_support'
 require 'active_support/deprecation'
 
+require 'git/deprecation'
 require 'git/version'
 
 module Git
-  Deprecation = ActiveSupport::Deprecation.new('5.0.0', 'Git')
-
   # Minimum git version required by this gem
   #
   # Commands and features may require newer versions, but this is the absolute
@@ -26,8 +25,11 @@ require 'git/branch_info'
 require 'git/branches'
 require 'git/command_line_result'
 require 'git/command_line'
-require 'git/commands/init'
+require 'process_executer'
 require 'git/config'
+require 'git/config_entry_info'
+require 'git/parsers/config_entry'
+require 'git/configuring'
 require 'git/diff'
 require 'git/diff_file_numstat_info'
 require 'git/diff_file_patch_info'
@@ -40,16 +42,17 @@ require 'git/encoding_utils'
 require 'git/errors'
 require 'git/escaped_path'
 require 'git/execution_context'
+require 'git/execution_context/global'
 require 'git/file_ref'
 require 'git/fsck_object'
 require 'git/fsck_result'
+require 'git/parsers/ls_remote'
 require 'git/version_constraint'
-require 'git/lib'
+require 'git/commands'
 require 'git/log'
 require 'git/object'
 require 'git/remote'
 require 'git/repository'
-require 'git/base'
 require 'git/status'
 require 'git/stash'
 require 'git/stash_info'
@@ -69,34 +72,55 @@ require 'git/worktrees'
 # @author Scott Chacon (mailto:schacon@gmail.com)
 #
 module Git
-  # g.config('user.name', 'Scott Chacon') # sets value
-  # g.config('user.email', 'email@email.com')  # sets value
-  # g.config('user.name')  # returns 'Scott Chacon'
-  # g.config # returns whole config hash
+  extend Git::Configuring
+
+  # @deprecated Mixing in the `Git` module is deprecated and will be removed in v6.0.0.
+  #   Use `Git.open(Dir.pwd).config(...)` instead.
   def config(name = nil, value = nil)
-    lib = Git::Lib.new
-    if name && value
-      # set value
-      lib.config_set(name, value)
-    elsif name
-      # return value
-      lib.config_get(name)
-    else
-      # return hash
-      lib.config_list
-    end
+    Git::Deprecation.warn(
+      'Git#config is deprecated and will be removed in v6.0.0. ' \
+      'Use Git.open(Dir.pwd).config(...) instead.'
+    )
+    Git.__send__(:run_config_utility, name, value, global: false)
   end
 
+  # Configures the gem by yielding {Git::Config.instance} to the block
+  #
+  # @example Set the global git binary path
+  #   Git.configure { |c| c.binary_path = '/usr/local/bin/git' }
+  #
+  # @yield [config] yields the singleton config object
+  #
+  # @yieldparam config [Git::Config] the singleton config object
+  #
+  # @yieldreturn [void]
+  #
+  # @return [void]
+  #
   def self.configure
-    yield Base.config
+    yield Git::Config.instance
+    nil
   end
 
+  # Returns the process-wide {Git::Config} singleton
+  #
+  # @example Read the configured binary path
+  #   Git.config.binary_path  #=> "git"
+  #
+  # @return [Git::Config] the singleton config object
+  #
   def self.config
-    Base.config
+    Git::Config.instance
   end
 
+  # @deprecated Mixing in the `Git` module is deprecated and will be removed in v6.0.0.
+  #   Use `Git.global_config(...)` instead.
   def global_config(name = nil, value = nil)
-    self.class.global_config(name, value)
+    Git::Deprecation.warn(
+      'Git#global_config is deprecated and will be removed in v6.0.0. ' \
+      'Use Git.global_config(...) instead.'
+    )
+    Git.global_config(name, value)
   end
 
   # Open a bare repository
@@ -130,11 +154,11 @@ module Git
   #   are logged at the `:info` level.  Additional logging is done at the `:debug`
   #   level.
   #
-  # @return [Git::Base] an object that can execute git commands in the context
+  # @return [Git::Repository] an object that can execute git commands in the context
   #   of the bare repository.
   #
   def self.bare(git_dir, options = {})
-    Base.bare(git_dir, options)
+    Git::Repository.bare(git_dir, options)
   end
 
   # Clone a repository into an empty or newly created directory
@@ -248,11 +272,11 @@ module Git
   #     git_ssh: 'ssh -i /path/to/private_key'
   #   )
   #
-  # @return [Git::Base] an object that can execute git commands in the context
+  # @return [Git::Repository] an object that can execute git commands in the context
   #   of the cloned local working copy or cloned repository.
   #
   def self.clone(repository_url, directory = nil, options = {})
-    Base.clone(repository_url, directory, options)
+    Git::Repository.clone(repository_url, directory, options)
   end
 
   # Returns the name of the default branch of the given repository
@@ -293,7 +317,9 @@ module Git
   # @return [String] the name of the default branch
   #
   def self.default_branch(repository, options = {})
-    Base.repository_default_branch(repository, options)
+    context = Git::ExecutionContext::Global.new(logger: options[:log])
+    output = Git::Commands::LsRemote.new(context).call(repository, 'HEAD', symref: true).stdout
+    Git::Parsers::LsRemote.parse_default_branch(output)
   end
 
   # Export the current HEAD (or a branch, if <tt>options[:branch]</tt>
@@ -317,17 +343,7 @@ module Git
   # g.config('user.name')  # returns 'Scott Chacon'
   # g.config # returns whole config hash
   def self.global_config(name = nil, value = nil)
-    lib = Git::Lib.new(nil, nil)
-    if name && value
-      # set value
-      lib.global_config_set(name, value)
-    elsif name
-      # return value
-      lib.global_config_get(name)
-    else
-      # return hash
-      lib.global_config_list
-    end
+    run_config_utility(name, value, global: true)
   end
 
   # Create an empty Git repository or reinitialize an existing Git repository
@@ -367,11 +383,15 @@ module Git
   #   - If nil, disables SSH for this instance.
   #   - If a non-empty string, uses that value for this instance.
   #
+  # @option options [String, :use_global_config] :binary_path path to the git
+  #   binary; defaults to `Git::Config.instance.binary_path` when not specified.
+  #   Raises `ArgumentError` if set to `nil`.
+  #
   # @option options [Logger] :log A logger to use for Git operations.  Git
   #   commands are logged at the `:info` level.  Additional logging is done
   #   at the `:debug` level.
   #
-  # @return [Git::Base] an object that can execute git commands in the context
+  # @return [Git::Repository] an object that can execute git commands in the context
   #   of the newly initialized repository
   #
   # @example Initialize a repository in the current directory
@@ -389,31 +409,23 @@ module Git
   # @see https://git-scm.com/docs/git-init git init
   #
   def self.init(directory = '.', options = {})
-    require_relative 'git/commands/init'
-
-    options = options.dup
-    options[:repository] ||= options.delete(:separate_git_dir)
-    init_opts = options.slice(:bare, :initial_branch)
-    init_opts[:separate_git_dir] = options[:repository] if options.key?(:repository)
-    Git::Commands::Init.new(Git::Lib.new(nil, options[:log])).call(directory, **init_opts)
-
-    open_initialized_repository(directory, options)
+    Git::Repository.init(directory, options)
   end
 
-  # Open the repository after initialization
+  # Option keys accepted by {.ls_remote}
+  #
+  # Parser-incompatible options such as `:get_url` and `:symref` are intentionally
+  # excluded because {Git::Parsers::LsRemote.parse_output} cannot handle the
+  # non-standard output formats those flags produce.
+  #
+  # @return [Array<Symbol>]
   #
-  # @param directory [String] the directory containing the repository
-  # @param options [Hash] the options hash
-  # @return [Git::Base] the opened repository
   # @api private
   #
-  private_class_method def self.open_initialized_repository(directory, options)
-    if options[:bare]
-      Git.bare(options[:repository] || directory, options.slice(:log, :git_ssh).compact)
-    else
-      Git.open(directory, options.slice(:log, :git_ssh, :index, :repository).compact)
-    end
-  end
+  LS_REMOTE_ALLOWED_OPTS = %i[
+    branches b heads h tags t refs upload_pack quiet q exit_code sort server_option o timeout
+  ].freeze
+  private_constant :LS_REMOTE_ALLOWED_OPTS
 
   # returns a Hash containing information about the references
   # of the target repository
@@ -424,7 +436,15 @@ module Git
   # @param [String|NilClass] location the target repository location or nil for '.'
   # @return [{String=>Hash}] the available references of the target repo.
   def self.ls_remote(location = nil, options = {})
-    Git::Lib.new.ls_remote(location, options)
+    options = options.dup
+    log = options.delete(:log)
+    unknown = options.keys - LS_REMOTE_ALLOWED_OPTS
+    raise ArgumentError, "Unknown options: #{unknown.join(', ')}" unless unknown.empty?
+
+    context = Git::ExecutionContext::Global.new(logger: log)
+    repository = location || '.'
+    output_lines = Git::Commands::LsRemote.new(context).call(repository, **options).stdout.split("\n")
+    Git::Parsers::LsRemote.parse_output(output_lines)
   end
 
   # Open a an existing Git working directory
@@ -474,17 +494,41 @@ module Git
   #   commands are logged at the `:info` level.  Additional logging is done
   #   at the `:debug` level.
   #
-  # @return [Git::Base] an object that can execute git commands in the context
+  # @return [Git::Repository] an object that can execute git commands in the context
   #   of the opened working copy
   #
   def self.open(working_dir, options = {})
-    Base.open(working_dir, options)
+    Git::Repository.open(working_dir, options)
+  end
+
+  # Thread-safe cache for git versions, keyed by binary path.
+  @git_version_cache_mutex = Mutex.new
+  @git_version_cache = {}
+
+  # @api private
+  def self.cached_git_version(binary_path, &block)
+    @git_version_cache_mutex.synchronize do
+      @git_version_cache[binary_path] ||= block.call
+    end
+  end
+
+  # @api private
+  def self.clear_git_version_cache
+    @git_version_cache_mutex.synchronize do
+      @git_version_cache.clear
+    end
   end
 
   # Return the version of a git binary as a {Git::Version}
   #
+  # @example Default binary
+  #   Git.git_version #=> #<Git::Version 2.42.0>
+  #
+  # @example Explicit binary path
+  #   Git.git_version('/opt/homebrew/bin/git') #=> #<Git::Version 2.42.0>
+  #
   # @param binary_path [String, nil] path to the git binary; defaults to
-  #   `Git::Base.config.binary_path`
+  #   `Git::Config.instance.binary_path`
   #
   # @return [Git::Version] the parsed git version
   #
@@ -494,15 +538,9 @@ module Git
   #
   # @raise [Git::Error] if the binary is not found or fails to launch
   #
-  # @example Default binary
-  #   Git.git_version #=> #<Git::Version 2.42.0>
-  #
-  # @example Explicit binary path
-  #   Git.git_version('/opt/homebrew/bin/git') #=> #<Git::Version 2.42.0>
-  #
   def self.git_version(binary_path = nil)
-    path = binary_path || Git::Base.config.binary_path
-    Git::Lib.cached_git_version(path) { run_git_version(path) }
+    path = binary_path || Git::Config.instance.binary_path
+    cached_git_version(path) { run_git_version(path) }
   end
 
   # @api private
@@ -512,18 +550,83 @@ module Git
   end
   private_class_method :run_git_version
 
+  # @api private
+  def self.run_config_utility(name, value, global:)
+    context = Git::ExecutionContext::Global.new
+    options = global ? { global: true } : {}
+
+    return Git::Commands::ConfigOptionSyntax::Set.new(context).call(name, value, **options) if !name.nil? && !value.nil?
+    return run_config_get(context, name, options) if name
+
+    output = Git::Commands::ConfigOptionSyntax::List.new(context).call(**options).stdout
+    parse_config_list(output.split("\n"))
+  end
+  private_class_method :run_config_utility
+
+  def self.run_config_get(context, name, options)
+    result = Git::Commands::ConfigOptionSyntax::Get.new(context).call(name, **options)
+    raise Git::FailedError, result if result.status.exitstatus != 0
+
+    result.stdout
+  end
+  private_class_method :run_config_get
+
+  # @api private
+  def self.parse_config_list(lines)
+    lines.each_with_object({}) do |line, hsh|
+      key, value = line.split('=', 2)
+      hsh[key] = value || ''
+    end
+  end
+  private_class_method :parse_config_list
+
+  # @api private
+  def self.execution_context
+    Git::ExecutionContext::Global.new
+  end
+  private_class_method :execution_context
+
+  # Scopes that require an active repository and cannot be used at the Git module level
+  #
+  # @api private
+  #
+  REPOSITORY_SPECIFIC_SCOPES = %i[local worktree blob].freeze
+  private_constant :REPOSITORY_SPECIFIC_SCOPES
+
+  # Raises +ArgumentError+ when a repository-specific scope is requested.
+  #
+  # The +:local+, +:worktree+, and +:blob+ scopes require an active git
+  # repository and are therefore not valid at the Git module level.
+  #
+  # @api private
+  #
+  def self.assert_valid_scope!(**opts)
+    invalid = REPOSITORY_SPECIFIC_SCOPES.select { |s| opts[s] }
+    return if invalid.empty?
+
+    raise ArgumentError, "#{invalid.join(', ')} scope requires a repository"
+  end
+  private_class_method :assert_valid_scope!
+
   # Return the version of the git binary
   #
-  # @example
-  #  Git.binary_version # => [2, 46, 0]
+  # @example Basic usage
+  #   Git.binary_version  # => [2, 46, 0]
+  #
+  # @param binary_path [String, nil] path to the git binary; defaults to
+  #   `Git::Config.instance.binary_path`
   #
   # @return [Array<Integer>] the version of the git binary
   #
-  # @deprecated Use {Git.git_version} instead, which returns a {Git::Version} (not an Array).
+  # @deprecated Use {Git.git_version} instead, which returns a
+  #   {Git::Version} (not an Array)
+  #
   #   For the legacy array shape, call: `Git.git_version.to_a`.
-  #   The optional binary_path argument is preserved: `Git.git_version(binary_path)`.
+  #   The optional binary_path argument is preserved:
+  #   `Git.git_version(binary_path)`.
   #
-  def self.binary_version(binary_path = Git::Base.config.binary_path)
+  def self.binary_version(binary_path = nil)
+    binary_path ||= Git::Config.instance.binary_path
     Git::Deprecation.warn(
       'Git.binary_version is deprecated and will be removed in 6.0. ' \
       'Use Git.git_version instead, which returns a Git::Version ' \