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

data/lib/git/diff.rb

@@ -25,7 +25,7 @@ module Git
     # @example
     #   diff = Git::Diff.new(base, 'HEAD~1', 'HEAD')
     #
-    # @param base [Git::Base, Git::Repository] the git repository
+    # @param base [Git::Repository] the git repository
     #
     # @param from [String, nil] the starting commit ref, or `nil` to compare
     #   from the index
@@ -102,11 +102,7 @@ module Git
     # @return [String] the raw output of `git diff`
     #
     def patch
-      if @base.respond_to?(:diff_full)
-        @base.diff_full(@from, @to, path_limiter: @path)
-      else
-        @base.lib.diff_full(@from, @to, { path_limiter: @path })
-      end
+      @base.diff_full(@from, @to, path_limiter: @path)
     end
     alias to_s patch
 
@@ -287,7 +283,7 @@ module Git
       #     mode: '100644', src: 'abc123', dst: 'def456',
       #     type: 'modified', binary: false)
       #
-      # @param base [Git::Base, Git::Repository] the git repository
+      # @param base [Git::Repository] the git repository
       #
       # @param hash [Hash] the parsed diff attributes
       #
@@ -402,7 +398,7 @@ module Git
     class FullDiffParser
       # Creates a new FullDiffParser
       #
-      # @param base [Git::Base, Git::Repository] the git repository
+      # @param base [Git::Repository] the git repository
       #
       # @param patch_text [String] the raw `git diff` output to parse
       #

data/lib/git/diff_path_status.rb

@@ -61,26 +61,15 @@ module Git
 
     # Lazily fetches and caches the path status from the git lib
     #
-    # When constructed with a pre-fetched hash, returns it directly.
-    # When `@base` responds to `#diff_name_status` (e.g. {Git::Repository} or
-    # {Git::Base}, which defines it as an alias for `#diff_path_status`),
-    # delegates directly to that method. Otherwise falls back to the legacy
-    # `@base.lib.diff_path_status` call for duck-typed base objects that only
-    # expose path-status via their lib.
-    #
     # @return [Hash{String => String}] a mapping of file paths to status codes
     #
     def fetch_path_status
-      @fetch_path_status ||= if @base.respond_to?(:diff_name_status)
-                               @base.diff_name_status(@from, @to, path_limiter: @path_limiter).to_h
-                             else
-                               @base.lib.diff_path_status(@from, @to, { path_limiter: @path_limiter })
-                             end
+      @fetch_path_status ||= @base.diff_name_status(@from, @to, path_limiter: @path_limiter).to_h
     end
 
     # Sets up legacy (base, from, to, path_limiter) instance state
     #
-    # @param base [Git::Base, Git::Repository] the git base instance
+    # @param base [Git::Repository] the git object
     #
     # @param from [String] the first commit or object to compare
     #

data/lib/git/diff_stats.rb

@@ -88,17 +88,9 @@ module Git
 
     # Lazily fetches and caches the stats from the git lib
     #
-    # When `@base` implements `#diff_numstat`, delegates directly to that
-    # method. Otherwise falls back to the legacy `@base.lib.diff_stats` call
-    # so that existing `Git::Base`-backed callers continue to work unchanged.
-    #
     # @return [Hash] the fetched stats hash
     def fetch_stats
-      @fetch_stats ||= if @base.respond_to?(:diff_numstat)
-                         @base.diff_numstat(@from, @to, path_limiter: @path_limiter)
-                       else
-                         @base.lib.diff_stats(@from, @to, { path_limiter: @path_limiter })
-                       end
+      @fetch_stats ||= @base.diff_numstat(@from, @to, path_limiter: @path_limiter)
     end
   end
 end

data/lib/git/execution_context/global.rb

@@ -20,37 +20,12 @@ module Git
     # @example Create a context targeting a specific binary
     #   context = Git::ExecutionContext::Global.new(binary_path: '/usr/local/bin/git2')
     #
+    # @see Git::ExecutionContext#initialize for constructor parameters and
+    #   their semantics
+    #
     # @api private
     #
     class Global < ExecutionContext
-      # Creates a new global execution context
-      #
-      # @example Create with default settings
-      #   Git::ExecutionContext::Global.new
-      #
-      # @example Create with an explicit binary path
-      #   Git::ExecutionContext::Global.new(binary_path: '/usr/local/bin/git2')
-      #
-      # @param binary_path [String, :use_global_config] path to the git binary
-      #
-      #   Give `:use_global_config` (the default) to use `Git::Base.config.binary_path`.
-      #
-      #   Passing `nil` raises `ArgumentError` — there is no "unset the
-      #   binary" semantic.
-      #
-      # @param git_ssh [String, nil, :use_global_config] the SSH wrapper path
-      #
-      #   Give `nil` to unset `GIT_SSH`, or `:use_global_config` (default) to use `Git::Base.config.git_ssh`.
-      #
-      # @param logger [Logger, nil] the logger to use in the CommandLine layer
-      #
-      #   Give `nil` to use a null logger (`Logger.new(nil)`).
-      #
-      # @raise [ArgumentError] if `binary_path` is `nil`
-      #
-      def initialize(binary_path: :use_global_config, git_ssh: :use_global_config, logger: nil)
-        super
-      end
     end
   end
 end

data/lib/git/execution_context/repository.rb

@@ -13,15 +13,10 @@ module Git
     #
     # ### Construction
     #
-    # Prefer the factory class methods over `new` when building from a
-    # {Git::Base} object or a hash:
+    # Use {.from_hash} to build from a configuration hash:
     #
-    #   context = Git::ExecutionContext::Repository.from_base(base)
     #   context = Git::ExecutionContext::Repository.from_hash(repository: '/repo/.git', ...)
     #
-    # @example Build from a Git::Base object
-    #   context = Git::ExecutionContext::Repository.from_base(git)
-    #
     # @example Build from a configuration hash
     #   context = Git::ExecutionContext::Repository.from_hash(
     #     repository: '/path/to/.git',
@@ -31,31 +26,6 @@ module Git
     # @api private
     #
     class Repository < ExecutionContext
-      # Creates a Repository context from a {Git::Base} instance
-      #
-      # @example Build from a base object
-      #   git = Git.open('/path/to/repo')
-      #   context = Git::ExecutionContext::Repository.from_base(git)
-      #
-      # @param base_object [Git::Base] the base Git object to derive context from
-      #
-      # @param logger [Logger, nil] logger forwarded to the CommandLine layer;
-      #   `nil` uses a null logger (see {Git::ExecutionContext#initialize})
-      #
-      # @return [Git::ExecutionContext::Repository] the new repository context
-      #
-      def self.from_base(base_object, logger: nil)
-        new(
-          git_dir: base_object.repo.to_s,
-          git_index_file: base_object.index&.to_s,
-          git_work_dir: base_object.dir&.to_s,
-          base_object: base_object,
-          git_ssh: base_object.git_ssh,
-          binary_path: base_object.binary_path,
-          logger: logger
-        )
-      end
-
       # Creates a Repository context from a Hash
       #
       # Expected keys: `:repository`, `:working_directory`, `:index`, `:git_ssh`,
@@ -79,8 +49,8 @@ module Git
           git_dir: base_hash[:repository],
           git_index_file: base_hash[:index],
           git_work_dir: base_hash[:working_directory],
-          git_ssh: base_hash.key?(:git_ssh) ? base_hash[:git_ssh] : :use_global_config,
-          binary_path: base_hash.key?(:binary_path) ? base_hash[:binary_path] : :use_global_config,
+          git_ssh: base_hash.fetch(:git_ssh, :use_global_config),
+          binary_path: base_hash.fetch(:binary_path, :use_global_config),
           logger: logger
         )
       end
@@ -96,18 +66,18 @@ module Git
       #
       # @param git_index_file [String, nil] path to the index file
       #
-      # @param base_object [Git::Base, nil] originating base object
-      #
       # @param binary_path [String, :use_global_config] path to the git binary
       #
-      #   Give `:use_global_config` (the default) to use `Git::Base.config.binary_path`.
+      #   Give `:use_global_config` (the default) to use
+      #   `Git::Config.instance.binary_path`.
       #
       #   Passing `nil` raises `ArgumentError` — there is no "unset the
       #   binary" semantic.
       #
       # @param git_ssh [String, nil, :use_global_config] the SSH wrapper path
       #
-      #   Give `nil` to unset `GIT_SSH`, or `:use_global_config` (default) to use `Git::Base.config.git_ssh`.
+      #   Give `nil` to unset `GIT_SSH`, or `:use_global_config` (default)
+      #   to use `Git::Config.instance.git_ssh`.
       #
       # @param logger [Logger, nil] the logger to use in the CommandLine layer
       #
@@ -119,7 +89,6 @@ module Git
         git_dir:,
         git_work_dir: nil,
         git_index_file: nil,
-        base_object: nil,
         binary_path: :use_global_config,
         git_ssh: :use_global_config,
         logger: nil
@@ -128,7 +97,6 @@ module Git
         @git_dir = git_dir
         @git_work_dir = git_work_dir
         @git_index_file = git_index_file
-        @base_object = base_object
       end
 
       # @return [String, nil] path to the `.git` directory
@@ -140,8 +108,29 @@ module Git
       # @return [String, nil] path to the index file
       attr_reader :git_index_file
 
-      # @return [Git::Base, nil] originating base object
-      attr_reader :base_object
+      # Returns a new instance with the same configuration, applying `overrides`
+      #
+      # Uses raw stored values for `binary_path`, `git_ssh`, and `logger` so
+      # that `:use_global_config` sentinels are preserved across rebuilds and
+      # future changes to `Git.configure` continue to take effect.
+      #
+      # @param overrides [Hash] keyword arguments to override in the new instance
+      #
+      # @return [Git::ExecutionContext::Repository] the new context
+      #
+      # @api private
+      #
+      def dup_with(**overrides)
+        self.class.new(
+          git_dir: @git_dir,
+          git_work_dir: @git_work_dir,
+          git_index_file: @git_index_file,
+          binary_path: @binary_path,
+          git_ssh: @git_ssh,
+          logger: @logger,
+          **overrides
+        )
+      end
     end
   end
 end

data/lib/git/execution_context.rb

@@ -88,20 +88,22 @@ module Git
     #
     # @param binary_path [String, :use_global_config] path to the git binary
     #
-    #   Give `:use_global_config` (the default) to use `Git::Base.config.binary_path`.
+    #   Give `:use_global_config` (the default) to use `Git::Config.instance.binary_path`.
     #
     #   Passing `nil` raises `ArgumentError` — there is no "unset the
     #   binary" semantic.
     #
     # @param git_ssh [String, nil, :use_global_config] the SSH wrapper path
     #
-    #   Give `nil` to unset `GIT_SSH`, or `:use_global_config` (default) to use `Git::Base.config.git_ssh`.
+    #   Give `nil` to unset `GIT_SSH`, or `:use_global_config` (default)
+    #   to use `Git::Config.instance.git_ssh`.
     #
     # @param logger [Logger, nil] the logger to use in the CommandLine layer
     #
     #   Give `nil` to use a null logger (`Logger.new(nil)`).
     #
-    # @raise [NotImplementedError] if called directly on {Git::ExecutionContext} rather than a subclass
+    # @raise [NotImplementedError] if called directly on {Git::ExecutionContext}
+    #   rather than a subclass
     #
     # @raise [ArgumentError] if `binary_path` is `nil`
     #
@@ -156,11 +158,12 @@ module Git
 
     # Returns the resolved git binary path for this context
     #
-    # `:use_global_config` is resolved to `Git::Base.config.binary_path` each time a
-    # command method is called, so runtime changes to `Git::Base.config.binary_path`
+    # `:use_global_config` is resolved to `Git::Config.instance.binary_path` each time a
+    # command method is called, so runtime changes to
+    # `Git.configure { |c| c.binary_path = ... }`
     # are reflected per command invocation.
     #
-    # @example With the default sentinel (resolves from Git::Base.config at call-time)
+    # @example With the default sentinel (resolves from Git::Config.instance at call-time)
     #   context = Git::ExecutionContext::Global.new
     #   context.binary_path  #=> "git"
     #
@@ -171,19 +174,20 @@ module Git
     # @return [String] the resolved git binary path
     #
     def binary_path
-      return Git::Base.config.binary_path if @binary_path == :use_global_config
+      return Git::Config.instance.binary_path if @binary_path == :use_global_config
 
       @binary_path
     end
 
     # Returns the resolved `GIT_SSH` wrapper path for this context
     #
-    # `:use_global_config` is resolved to `Git::Base.config.git_ssh` each time a
-    # command method is called, so runtime changes to `Git::Base.config.git_ssh`
+    # `:use_global_config` is resolved to `Git::Config.instance.git_ssh` each time a
+    # command method is called, so runtime changes to
+    # `Git.configure { |c| c.git_ssh = ... }`
     # are reflected per command invocation. `nil` means the variable will be
     # explicitly unset.
     #
-    # @example With the default sentinel (resolves from Git::Base.config at call-time)
+    # @example With the default sentinel (resolves from Git::Config.instance at call-time)
     #   context = Git::ExecutionContext::Global.new
     #   context.git_ssh  #=> nil
     #
@@ -194,11 +198,23 @@ module Git
     # @return [String, nil] the resolved `GIT_SSH` wrapper path, or `nil` to unset
     #
     def git_ssh
-      return Git::Base.config.git_ssh if @git_ssh == :use_global_config
+      return Git::Config.instance.git_ssh if @git_ssh == :use_global_config
 
       @git_ssh
     end
 
+    # Returns the logger used by this context
+    #
+    # @example
+    #   context = Git::ExecutionContext::Repository.new(git_dir: '/repo/.git', logger: my_logger)
+    #   context.logger  #=> my_logger
+    #
+    # @return [Logger] the logger instance; never `nil`
+    #
+    # @api private
+    #
+    attr_reader :logger
+
     # Runs a git command and returns the result
     #
     # By default, raises {Git::FailedError} if the command exits with a non-zero
@@ -393,25 +409,24 @@ module Git
 
     # Returns the installed git version
     #
-    # The result is memoized per instance.
+    # The result is memoized per instance. Accepts an optional timeout used
+    # only when the version has not yet been fetched for this context.
     #
-    # @example Get the installed git version
-    #   context = Git::ExecutionContext::Global.new
-    #   context.git_version  #=> #<Git::Version 2.42.0>
+    # @param timeout [Numeric, nil] seconds to wait for `git version`; `nil`
+    #   falls back to the global {Git::Config} timeout; `0` disables the timeout
+    #   entirely (the command runs until it completes or the process is killed)
     #
     # @return [Git::Version] the installed git version
     #
     # @raise [Git::UnexpectedResultError] if the version string cannot be parsed
     #
-    def git_version
+    def git_version(timeout: nil)
       @git_version ||= begin
-        output = Git::Commands::Version.new(self).call.stdout
-        Git::Version.parse(output)
+        call_opts = timeout.nil? ? {} : { timeout: timeout }
+        Git::Version.parse(Git::Commands::Version.new(self).call(**call_opts).stdout)
       end
     end
 
-    private
-
     # Returns a Hash of environment variable overrides for this context
     #
     # Builds the standard git environment from the public accessor methods
@@ -424,6 +439,8 @@ module Git
     #
     # @return [Hash<String, String|nil>] the merged environment variable overrides
     #
+    # @api private
+    #
     def env_overrides(**additional_overrides)
       {
         'GIT_DIR' => git_dir,
@@ -435,6 +452,8 @@ module Git
       }.merge(additional_overrides)
     end
 
+    private
+
     # Returns the Array of git global option strings for this context
     #
     # Prepends `--git-dir` and `--work-tree` when the corresponding attributes
@@ -453,9 +472,9 @@ module Git
     # Creates a {Git::CommandLine::Capturing} instance for the current invocation.
     #
     # A new instance is created per call so that {#binary_path} — resolved from
-    # `Git::Base.config` when set to `:use_global_config` — and {#env_overrides}
+    # `Git::Config.instance` when set to `:use_global_config` — and {#env_overrides}
     # — including {#git_ssh} resolution for `:use_global_config` — reflect the
-    # state of `Git::Base.config` at the time of each command invocation.
+    # state of {Git::Config.instance} at the time of each command invocation.
     #
     # @return [Git::CommandLine::Capturing] the capturing command line instance
     #
@@ -466,9 +485,9 @@ module Git
     # Creates a {Git::CommandLine::Streaming} instance for the current invocation.
     #
     # A new instance is created per call so that {#binary_path} — resolved from
-    # `Git::Base.config` when set to `:use_global_config` — and {#env_overrides}
+    # `Git::Config.instance` when set to `:use_global_config` — and {#env_overrides}
     # — including {#git_ssh} resolution for `:use_global_config` — reflect the
-    # state of `Git::Base.config` at the time of each command invocation.
+    # state of {Git::Config.instance} at the time of each command invocation.
     #
     # @return [Git::CommandLine::Streaming] the streaming command line instance
     #

data/lib/git/log.rb

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require 'git/base'
-
 module Git
   # Builds and executes a `git log` query
   #
@@ -44,7 +42,8 @@ module Git
     #   git = Git.open('.')
     #   Git::Log.new(git)
     #
-    # @param base [Git::Repository, Git::Base] the git repository object
+    # @param base [Git::Repository] the git repository object
+    #
     # @param max_count [Integer, Symbol, nil] the number of commits to return, or
     #   `:all` or `nil` to return all
     #
@@ -159,15 +158,10 @@ module Git
       self
     end
 
-    # Returns the facade interface for log operations.
-    #
-    # Accepts either a {Git::Repository} (new form) or a {Git::Base} (legacy).
-    # The `is_a?` guard will be removed when {Git::Base} is deleted in Phase 4.
-    #
     # @return [Git::Repository]
     #
     def log_repository
-      @base.is_a?(Git::Base) ? @base.facade_repository : @base
+      @base
     end
 
     def run_log_if_dirty

data/lib/git/object.rb

@@ -4,7 +4,6 @@ require 'git/author'
 require 'git/diff'
 require 'git/errors'
 require 'git/log'
-require 'git/base'
 
 module Git
   # represents a git object
@@ -103,7 +102,7 @@ module Git
       #
       # @param file [String, nil] destination file path; a temp file is created if `nil`
       #
-      # @param opts [Hash] archive options (see {Git::Lib#archive})
+      # @param opts [Hash] archive options (see {Git::Repository#archive})
       #
       # @return [String] the path to the written archive file
       #
@@ -126,15 +125,10 @@ module Git
 
       private
 
-      # Returns the facade interface for git object queries.
-      #
-      # Accepts either a {Git::Repository} (new form) or a {Git::Base} (legacy).
-      # The `is_a?` guard will be removed when {Git::Base} is deleted in Phase 4.
-      #
       # @return [Git::Repository]
       #
       def object_repository
-        @base.is_a?(Git::Base) ? @base.facade_repository : @base
+        @base
       end
     end
 
@@ -315,19 +309,23 @@ module Git
       attr_accessor :name
 
       # @overload initialize(base, name)
-      #   @param base [Git::Base] The Git base object
-      #   @param name [String] The name of the tag
+      #
+      #   @param base [Git::Repository] the git repository
+      #
+      #   @param name [String] the name of the tag
       #
       # @overload initialize(base, sha, name)
-      #   @param base [Git::Base] The Git base object
-      #   @param sha [String] The SHA of the tag object
-      #   @param name [String] The name of the tag
+      #
+      #   @param base [Git::Repository] the git repository
+      #
+      #   @param sha [String] the SHA of the tag object
+      #
+      #   @param name [String] the name of the tag
       #
       def initialize(base, sha, name = nil)
         if name.nil?
           name = sha
-          repo = base.is_a?(Git::Base) ? base.facade_repository : base
-          sha = repo.tag_sha(name)
+          sha = base.tag_sha(name)
           raise Git::UnexpectedResultError, "Tag '#{name}' does not exist." if sha == ''
         end
 
@@ -394,15 +392,10 @@ module Git
       Git::Object::Tag.new(base, objectish)
     end
 
-    # Returns the facade interface for git object queries.
-    #
-    # Accepts either a {Git::Repository} (new form) or a {Git::Base} (legacy).
-    # The `is_a?` guard will be removed when {Git::Base} is deleted in Phase 4.
-    #
     # @return [Git::Repository]
     #
     private_class_method def self.object_repository_for(base)
-      base.is_a?(Git::Base) ? base.facade_repository : base
+      base
     end
   end
 end

data/lib/git/parsers/config_entry.rb

@@ -0,0 +1,110 @@
+# frozen_string_literal: true
+
+require 'git/config_entry_info'
+
+module Git
+  module Parsers
+    # Parser for `git config` output
+    #
+    # Each public method corresponds to a different `git config` sub-command
+    # variant and handles the specific output format that variant produces.
+    # Most variants are called with `--show-scope --show-origin --null`;
+    # `parse_urlmatch` handles the `--get-urlmatch` format where `--show-origin`
+    # is unsupported and therefore absent.
+    #
+    # @api private
+    #
+    module ConfigEntry
+      module_function
+
+      # Parse `git config --get --show-scope --show-origin --null` output
+      #
+      # Output format (per entry): `scope\0origin\0value\0`
+      #
+      # The key name is absent from `--get` output and must be supplied by the
+      # caller.
+      #
+      # @param key [String] the config key name that was queried
+      #
+      # @param output [String] raw stdout from the command
+      #
+      # @return [Git::ConfigEntryInfo, nil] the parsed entry, or `nil` when not found
+      #
+      def parse_get(key, output)
+        return nil if output.empty?
+
+        scope, origin, value = output.split("\0", -1)
+        Git::ConfigEntryInfo.new(scope: scope, origin: origin, key: key, value: value)
+      end
+
+      # Parse `git config --get-all --show-scope --show-origin --null` output
+      #
+      # Output format (per entry): `scope\0origin\0value\0`
+      #
+      # The key name is absent from `--get-all` output and must be supplied by
+      # the caller. Multiple entries appear back-to-back in the same string.
+      #
+      # @param key [String] the config key name that was queried
+      #
+      # @param output [String] raw stdout from the command
+      #
+      # @return [Array<Git::ConfigEntryInfo>] the parsed entries
+      #
+      def parse_get_all(key, output)
+        return [] if output.empty?
+
+        tokens = output.split("\0", -1)
+        tokens.pop if tokens.last == ''
+        tokens.each_slice(3).map do |scope, origin, value|
+          Git::ConfigEntryInfo.new(scope: scope, origin: origin, key: key, value: value)
+        end
+      end
+
+      # Parse `git config --list --show-scope --show-origin --null` output
+      #
+      # Also handles `--get-regexp` output, which shares the same format.
+      #
+      # Output format (per entry): `scope\0origin\0key\nvalue\0`
+      #
+      # Multiple entries appear back-to-back in the same string.
+      #
+      # @param output [String] raw stdout from the command
+      #
+      # @return [Array<Git::ConfigEntryInfo>] the parsed entries
+      #
+      def parse_list(output)
+        return [] if output.empty?
+
+        tokens = output.split("\0", -1)
+        tokens.pop if tokens.last == ''
+        tokens.each_slice(3).map do |scope, origin, key_value|
+          key, value = key_value.split("\n", 2)
+          Git::ConfigEntryInfo.new(scope: scope, origin: origin, key: key, value: value || '')
+        end
+      end
+
+      # Parse `git config --get-urlmatch --show-scope --null` output
+      #
+      # Handles the two-field-per-entry format produced by `--get-urlmatch` when
+      # `--show-scope` is used but `--show-origin` is not (git does not support
+      # `--show-origin` with `--get-urlmatch`).
+      #
+      # Output format (per entry): `scope\0key\nvalue\0`
+      #
+      # @param output [String] raw stdout from the command
+      #
+      # @return [Array<Git::ConfigEntryInfo>] the parsed entries; `origin` is `nil` for each
+      #
+      def parse_urlmatch(output)
+        return [] if output.empty?
+
+        tokens = output.split("\0", -1)
+        tokens.pop if tokens.last == ''
+        tokens.each_slice(2).map do |scope, key_value|
+          key, value = key_value.split("\n", 2)
+          Git::ConfigEntryInfo.new(scope: scope, origin: nil, key: key, value: value || '')
+        end
+      end
+    end
+  end
+end