git 1.19.0 → 2.0.0.pre1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 41e2cebd7f83840b2e72176aa0d0a9f7b2441dbbe26f916b795877037bc82b6c
-  data.tar.gz: 03d373beb11219313117e419afdfce5be3ee225fd2f69dbee8d2e75b76ff7f10
+  metadata.gz: bf201a54a634864ee66f8e43866215d0c133fba4d2169ac1e0da3e5aa7bb1a2f
+  data.tar.gz: 38e2e3d0f2429fe458bca0218a49bd7d09707acd7d76da40cc8f9d7ce6fcfd74
 SHA512:
-  metadata.gz: f0eb02c8af807265598c6e1fce6910d46dc6de257b4874e5957a65fd5788457eb084a4bec94b9e20ab69f05e4dff1d8bd7704f5a5af80679e0ab0ed819f3ef06
-  data.tar.gz: 78e566642f10ce5d18ff7112e864a9b1e4b6347cb4445abe5d1e0dea2e6f4b316e7218b896fdef39e17efdb928a0b1a2a2d169b640675f6d282f2537f99dfc86
+  metadata.gz: 03cb58e9fc52d517d1a95584dae5c99d15532446442bac8aa6383a81770d7cc439643cd8bea04e5ae93dda8e481936ed3deebe86166fef2c4b9cd0ca3cdc8580
+  data.tar.gz: 2ca4de81d5a9359dc8f80d1a4ca218dafc472f5b9cb5a5b7f01c6633adbeaf8361c34e9f741147ae1948593779af9770508be35a3ef3590991e6830990a6355f

data/.github/workflows/continuous_integration.yml

@@ -2,35 +2,39 @@ name: CI
 
 on:
   push:
-    branches: [master]
+    branches: [master,v1]
   pull_request:
-    branches: [master]
+    branches: [master,v1]
   workflow_dispatch:
 
 jobs:
-  continuous_integration_build:
-    continue-on-error: true
+  build:
+    name: Ruby ${{ matrix.ruby }} on ${{ matrix.operating-system }}
+    runs-on: ${{ matrix.operating-system }}
+    continue-on-error: ${{ matrix.experimental == 'Yes' }}
+    env: { JAVA_OPTS: -Djdk.io.File.enableADS=true }
+
     strategy:
       fail-fast: false
       matrix:
-        ruby: [2.7, 3.0, 3.1, 3.2]
+        # Only the latest versions of JRuby and TruffleRuby are tested
+        ruby: ["3.0", "3.1", "3.2", "3.3", "truffleruby-23.1.1", "jruby-9.4.5.0"]
         operating-system: [ubuntu-latest]
+        experimental: [No]
         include:
-          - ruby: head
+          - # Building against head version of Ruby is considered experimental
+            ruby: head
             operating-system: ubuntu-latest
-          - ruby: truffleruby-head
-            operating-system: ubuntu-latest
-          - ruby: 2.7
-            operating-system: windows-latest
-          - ruby: jruby-head
-            operating-system: windows-latest
+            experimental: Yes
 
-    name: Ruby ${{ matrix.ruby }} on ${{ matrix.operating-system }}
-
-    runs-on: ${{ matrix.operating-system }}
+          - # Only test with minimal Ruby version on Windows
+            ruby: 3.0
+            operating-system: windows-latest
 
-    env:
-      JAVA_OPTS: -Djdk.io.File.enableADS=true
+          - # Since JRuby on Windows is known to not work, consider this experimental
+            ruby: jruby-9.4.5.0
+            operating-system: windows-latest
+            experimental: Yes
 
     steps:
       - name: Checkout Code

data/CHANGELOG.md

@@ -5,6 +5,24 @@
 
 # Change Log
 
+## v2.0.0.pre1 (2024-01-15)
+
+[Full Changelog](https://github.com/ruby-git/ruby-git/compare/v1.19.1..v2.0.0.pre1)
+
+Changes since v1.19.1:
+
+* 7585c39 Change how the git CLI subprocess is executed (#684)
+* f93e042 Update instructions for releasing a new version of the git gem (#686)
+* f48930d Update minimum required version of Ruby and Git (#685)
+
+## v1.19.1 (2024-01-13)
+
+[Full Changelog](https://github.com/ruby-git/ruby-git/compare/v1.19.0..v1.19.1)
+
+Changes since v1.19.0:
+
+* f97c57c Announce the 2.0.0 pre-release (#682)
+
 ## v1.19.0 (2023-12-28)
 
 [Full Changelog](https://github.com/ruby-git/ruby-git/compare/v1.18.0..v1.19.0)

data/README.md

@@ -5,45 +5,63 @@
 
 # The Git Gem
 
-The Git Gem provides an API that can be used to create, read, and manipulate
-Git repositories by wrapping system calls to the `git` binary. The API can be
-used for working with Git in complex interactions including branching and
-merging, object inspection and manipulation, history, patch generation and
-more.
+[![Gem Version](https://badge.fury.io/rb/git.svg)](https://badge.fury.io/rb/git)
+[![Documentation](https://img.shields.io/badge/Documentation-Latest-green)](https://rubydoc.info/gems/git/)
+[![Change Log](https://img.shields.io/badge/CHANGELOG-Latest-green)](https://rubydoc.info/gems/git/file/CHANGELOG.md)
+[![Build Status](https://github.com/ruby-git/ruby-git/workflows/CI/badge.svg?branch=master)](https://github.com/ruby-git/ruby-git/actions?query=workflow%3ACI)
+[![Code Climate](https://codeclimate.com/github/ruby-git/ruby-git.png)](https://codeclimate.com/github/ruby-git/ruby-git)
+
+The [git gem](https://rubygems.org/gems/git) provides an API that can be used to
+create, read, and manipulate Git repositories by wrapping system calls to the `git`
+command line. The API can be used for working with Git in complex interactions
+including branching and merging, object inspection and manipulation, history, patch
+generation and more.
 
-## Homepage
+Get started by obtaining a repository object by:
 
-The project source code is at:
+* opening an existing working copy with [Git.open](https://rubydoc.info/gems/git/Git#open-class_method)
+* initializing a new repository with [Git.init](https://rubydoc.info/gems/git/Git#init-class_method)
+* cloning a repository with [Git.clone](https://rubydoc.info/gems/git/Git#clone-class_method)
 
-http://github.com/ruby-git/ruby-git
+Methods that can be called on a repository object are documented in [Git::Base](https://rubydoc.info/gems/git/Git/Base)
 
-## Documentation
+## v2.0.0 pre-release
 
-Detailed documentation can be found at:
+git 2.0.0 is available as a pre-release version for testing! Please give it a try.
 
-https://rubydoc.info/gems/git/Git.html
+**JRuby on Windows is not yet supported by the 2.x release line. Users running JRuby
+on Windows should continue to use the 1.x release line.**
 
-Get started by obtaining a repository object by:
+The changes coming in this major release include:
 
-* opening an existing working copy with [Git.open](https://rubydoc.info/gems/git/Git#open-class_method)
-* initializing a new repository with [Git.init](https://rubydoc.info/gems/git/Git#init-class_method)
-* cloning a repository with [Git.clone](https://rubydoc.info/gems/git/Git#clone-class_method)
+* Create a policy of supported Ruby versions to support only non-EOL Ruby versions
+* Create a policy of supported Git CLI versions (released 2020-12-25)
+* Update the required Ruby version to at least 3.0 (released 2020-07-27)
+* Update the required Git command line version to at least 2.28
+* Update how CLI commands are called to use the [process_executer](https://github.com/main-branch/process_executer)
+  gem which is built on top of [Kernel.spawn](https://ruby-doc.org/3.3.0/Kernel.html#method-i-spawn).
+  See [PR #684](https://github.com/ruby-git/ruby-git/pull/684) for more details
+  on the motivation for this implementation.
 
-Methods that can be called on a repository object are documented in [Git::Base](https://rubydoc.info/gems/git/Git/Base)
+The tentative plan is to release `2.0.0` near the end of March 2024 depending on
+the feedback received during the pre-release period.
+
+The `master` branch will be used for `2.x` development. If needed, fixes for `1.x`
+version will be done on the `v1` branch.
 
 ## Install
 
-You can install Ruby/Git like this:
+Install the gem and add to the application's Gemfile by executing:
 
-```
-sudo gem install git
+```shell
+bundle add git
 ```
 
-## Code Status
+If bundler is not being used to manage dependencies, install the gem by executing:
 
-* [![Build Status](https://github.com/ruby-git/ruby-git/workflows/CI/badge.svg?branch=master)](https://github.com/ruby-git/ruby-git/actions?query=workflow%3ACI)
-* [![Code Climate](https://codeclimate.com/github/ruby-git/ruby-git.png)](https://codeclimate.com/github/ruby-git/ruby-git)
-* [![Gem Version](https://badge.fury.io/rb/git.svg)](https://badge.fury.io/rb/git)
+```shell
+gem install git
+```
 
 ## Major Objects
 
@@ -76,12 +94,6 @@ Pass the `--all` option to `git log` as follows:
 
 Here are a bunch of examples of how to use the Ruby/Git package.
 
-Ruby < 1.9 will require rubygems to be loaded.
-
-```ruby
-require 'rubygems'
-```
-
 Require the 'git' gem.
 ```ruby
 require 'git'
@@ -395,6 +407,14 @@ g.with_temp_working(dir) do
 end
 ```
 
+## Ruby version support policy
+
+This gem will be expected to function correctly on:
+
+* All non-EOL versions of the MRI Ruby on Mac, Linux, and Windows
+* The latest version of JRuby on Linux and Windows
+* The latest version of Truffle Ruby on Linus
+
 ## License
 
 licensed under MIT License Copyright (c) 2008  Scott Chacon. See LICENSE for further details.

data/RELEASING.md

@@ -7,64 +7,79 @@
 
 Releasing a new version of the `git` gem requires these steps:
 
-- [How to release a new git.gem](#how-to-release-a-new-gitgem)
-  - [Install Prerequisites](#install-prerequisites)
-  - [Prepare the Release](#prepare-the-release)
-  - [Review and Merge the Release](#review-and-merge-the-release)
-  - [Build and Release the Gem](#build-and-release-the-gem)
-
-These instructions use an example where:
-
-- The default branch is `master`
-- The current release version is `1.5.0`
-- You want to create a new *minor* release, `1.6.0`
+* [Install Prerequisites](#install-prerequisites)
+* [Determine the SemVer release type](#determine-the-semver-release-type)
+* [Create the release](#create-the-release)
+* [Review the CHANGELOG and release PR](#review-the-changelog-and-release-pr)
+* [Manually merge the release PR](#manually-merge-the-release-pr)
+* [Publish the git gem to RubyGems.org](#publish-the-git-gem-to-rubygemsorg)
 
 ## Install Prerequisites
 
 The following tools need to be installed in order to create the release:
 
-- [git](https://git-scm.com) is used to interact with the local and remote repositories
-- [gh](https://cli.github.com) is used to create the release and PR in GitHub
-- [Docker](https://www.docker.com) is used to run the script to create the release notes
+* [create_githhub_release](https://github.com/main-branch/create_github_release) is used to create the release
+* [git](https://git-scm.com) is used by `create-github-release` to interact with the local and remote repositories
+* [gh](https://cli.github.com) is used by `create-github-release` to create the release and PR in GitHub
 
-On a Mac, these tools can be installed using [brew](https://brew.sh):
+On a Mac, these tools can be installed using [gem](https://guides.rubygems.org/rubygems-basics/) and [brew](https://brew.sh):
 
 ```shell
+$ gem install create_github_release
+...
 $ brew install git
 ...
 $ brew install gh
 ...
-$ brew install --cask docker
-...
 $
 ```
 
-## Prepare the Release
+## Determine the SemVer release type
 
-Bump the version, create release notes, tag the release and create a GitHub release and PR which can be used to review the release.
+Determine the SemVer version increment that should be applied for the new release:
 
-Steps:
+* `major`: when the release includes incompatible API or functional changes.
+* `minor`: when the release adds functionality in a backward-compatible manner
+* `patch`: when the release includes small user-facing changes that are
+  backward-compatible and do not introduce new functionality.
 
-- Check out the code with `git clone https://github.com/ruby-git/ruby-git ruby-git-v1.6.0 && cd ruby-git-v1.6.0`
-- Install development dependencies using bundle `bundle install`
-- Based upon the nature of the changes, decide on the type of release: `major`, `minor`, or `patch` (in this example we will use `minor`)
-- Run the release script `bundle exec create-github-release minor`
+## Create the release
 
-## Review and Merge the Release
+Create the release using the `create-github-release` command. If the release type
+is `major`, the command is:
 
-Have the release PR approved and merge the changes into the `master` branch.
+```shell
+create-github-release major
+```
 
-**IMPORTANT** DO NOT merge to the `master` branch using the GitHub UI. Instead use the instructions below.
+Follow the directions given by the `create-github-release` command to finish the
+release. Where the instructions given by the command differ than the instructions
+below, follow the instructions given by the command.
 
-Steps:
+## Review the CHANGELOG and release PR
 
-- Get the release PR reviewed and approved in GitHub
-- Merge the changes with the command `git checkout master && git merge --ff-only v1.6.0 && git push`
+The `create-github-release` command will output a link to the CHANGELOG and the PR
+it created for the release. Review the CHANGELOG and have someone review and approve
+the release PR.
 
-## Build and Release the Gem
+## Manually merge the release PR
 
-Build the gem and publish it to [rubygems.org](https://rubygems.org/gems/git)
+It is important to manually merge the PR so a separate merge commit can be avoided.
+Use the commands output by the `create-github-release` which will looks like this
+if you are creating a 2.0.0 release:
 
-Steps:
+```shell
+git checkout master
+git merge --ff-only release-v2.0.0
+git push
+```
+
+This will automatically close the release PR.
+
+## Publish the git gem to RubyGems.org
 
-- Build and release the gem using rake `bundle exec rake release`
+Finally, publish the git gem to RubyGems.org using the following command:
+
+```shell
+rake release:rubygem_push
+```

data/git.gemspec

@@ -9,35 +9,35 @@ Gem::Specification.new do |s|
   s.name = 'git'
   s.summary = 'An API to create, read, and manipulate Git repositories'
   s.description = <<~DESCRIPTION
-    The Git Gem provides an API that can be used to create, read, and manipulate
-    Git repositories by wrapping system calls to the `git` binary. The API can be
-    used for working with Git in complex interactions including branching and
-    merging, object inspection and manipulation, history, patch generation and
-    more.
+    The git gem provides an API that can be used to
+    create, read, and manipulate Git repositories by wrapping system calls to the git
+    command line. The API can be used for working with Git in complex interactions
+    including branching and merging, object inspection and manipulation, history, patch
+    generation and more.
   DESCRIPTION
   s.version = Git::VERSION
 
+
   s.metadata['homepage_uri'] = s.homepage
   s.metadata['source_code_uri'] = s.homepage
-  s.metadata['changelog_uri'] = 'http://rubydoc.info/gems/git/file.CHANGELOG.html'
+  s.metadata['changelog_uri'] = "https://rubydoc.info/gems/#{s.name}/#{s.version}/file/CHANGELOG.md"
+  s.metadata['documentation_uri'] = "https://rubydoc.info/gems/#{s.name}/#{s.version}"
 
   s.require_paths = ['lib']
-  s.required_ruby_version = '>= 2.3'
-  s.required_rubygems_version = Gem::Requirement.new('>= 0') if s.respond_to?(:required_rubygems_version=)
-  s.requirements = ['git 1.6.0.0, or greater']
+  s.required_ruby_version = '>= 3.0.0'
+  s.requirements = ['git 2.28.0 or greater']
 
   s.add_runtime_dependency 'addressable', '~> 2.8'
+  s.add_runtime_dependency 'process_executer', '~> 0.7'
   s.add_runtime_dependency 'rchardet', '~> 1.8'
 
-  s.add_development_dependency 'bump', '~> 0.10'
-  s.add_development_dependency 'create_github_release', '~> 0.2'
   s.add_development_dependency 'minitar', '~> 0.9'
   s.add_development_dependency 'mocha', '~> 2.1'
-  s.add_development_dependency 'rake', '~> 13.0'
-  s.add_development_dependency 'test-unit', '~> 3.3'
+  s.add_development_dependency 'rake', '~> 13.1'
+  s.add_development_dependency 'test-unit', '~> 3.6'
 
   unless RUBY_PLATFORM == 'java'
-    s.add_development_dependency 'redcarpet', '~> 3.5'
+    s.add_development_dependency 'redcarpet', '~> 3.6'
     s.add_development_dependency 'yard', '~> 0.9', '>= 0.9.28'
     s.add_development_dependency 'yardstick', '~> 0.9'
   end

data/lib/git/command_line.rb

@@ -0,0 +1,342 @@
+# frozen_string_literal: true
+
+require 'git/base'
+require 'git/command_line_result'
+require 'git/failed_error'
+require 'git/signaled_error'
+require 'stringio'
+
+module Git
+  # Runs a git command and returns the result
+  #
+  # @api public
+  #
+  class CommandLine
+    # Create a Git::CommandLine object
+    #
+    # @example
+    #   env = { 'GIT_DIR' => '/path/to/git/dir' }
+    #   binary_path = '/usr/bin/git'
+    #   global_opts = %w[--git-dir /path/to/git/dir]
+    #   logger = Logger.new(STDOUT)
+    #   cli = CommandLine.new(env, binary_path, global_opts, logger)
+    #   cli.run('version') #=> #<Git::CommandLineResult:0x00007f9b0c0b0e00
+    #
+    # @param env [Hash<String, String>] environment variables to set
+    # @param global_opts [Array<String>] global options to pass to git
+    # @param logger [Logger] the logger to use
+    #
+    def initialize(env, binary_path, global_opts, logger)
+      @env = env
+      @binary_path = binary_path
+      @global_opts = global_opts
+      @logger = logger
+    end
+
+    # @attribute [r] env
+    #
+    # Variables to set (or unset) in the git command's environment
+    #
+    # @example
+    #   env = { 'GIT_DIR' => '/path/to/git/dir' }
+    #   command_line = Git::CommandLine.new(env, '/usr/bin/git', [], Logger.new(STDOUT))
+    #   command_line.env #=> { 'GIT_DIR' => '/path/to/git/dir' }
+    #
+    # @return [Hash<String, String>]
+    #
+    # @see https://ruby-doc.org/3.2.1/Process.html#method-c-spawn Process.spawn
+    #   for details on how to set environment variables using the `env` parameter
+    #
+    attr_reader :env
+
+    # @attribute [r] binary_path
+    #
+    # The path to the command line binary to run
+    #
+    # @example
+    #   binary_path = '/usr/bin/git'
+    #   command_line = Git::CommandLine.new({}, binary_path, ['version'], Logger.new(STDOUT))
+    #   command_line.binary_path #=> '/usr/bin/git'
+    #
+    # @return [String]
+    #
+    attr_reader :binary_path
+
+    # @attribute [r] global_opts
+    #
+    # The global options to pass to git
+    #
+    # These are options that are passed to git before the command name and
+    # arguments. For example, in `git --git-dir /path/to/git/dir version`, the
+    # global options are %w[--git-dir /path/to/git/dir].
+    #
+    # @example
+    #   env = {}
+    #   global_opts = %w[--git-dir /path/to/git/dir]
+    #   logger = Logger.new(nil)
+    #   cli = CommandLine.new(env, '/usr/bin/git', global_opts, logger)
+    #   cli.global_opts #=> %w[--git-dir /path/to/git/dir]
+    #
+    # @return [Array<String>]
+    #
+    attr_reader :global_opts
+
+    # @attribute [r] logger
+    #
+    # The logger to use for logging git commands and results
+    #
+    # @example
+    #   env = {}
+    #   global_opts = %w[]
+    #   logger = Logger.new(STDOUT)
+    #   cli = CommandLine.new(env, '/usr/bin/git', global_opts, logger)
+    #   cli.logger == logger #=> true
+    #
+    # @return [Logger]
+    #
+    attr_reader :logger
+
+    # Execute a git command, wait for it to finish, and return the result
+    #
+    # NORMALIZATION
+    #
+    # The command output is returned as a Unicde string containing the binary output
+    # from the command. If the binary output is not valid UTF-8, the output will
+    # cause problems because the encoding will be invalid.
+    #
+    # Normalization is a process that trys to convert the binary output to a valid
+    # UTF-8 string. It uses the `rchardet` gem to detect the encoding of the binary
+    # output and then converts it to UTF-8.
+    #
+    # Normalization is not enabled by default. Pass `normalize: true` to Git::CommandLine#run
+    # to enable it. Normalization will only be performed on stdout and only if the `out:`` option
+    # is nil or is a StringIO object. If the out: option is set to a file or other IO object,
+    # the normalize option will be ignored.
+    #
+    # @example Run a command and return the output
+    #
+    #   cli.run('version') #=> "git version 2.39.1\n"
+    #
+    # @example The args array should be splatted into the parameter list
+    #   args = %w[log -n 1 --oneline]
+    #   cli.run(*args) #=> "f5baa11 beginning of Ruby/Git project\n"
+    #
+    # @example Run a command and return the chomped output
+    #   cli.run('version', chomp: true) #=> "git version 2.39.1"
+    #
+    # @example Run a command and without normalizing the output
+    #   cli.run('version', normalize: false) #=> "git version 2.39.1\n"
+    #
+    # @example Capture stdout in a temporary file
+    #   require 'tempfile'
+    #   tempfile = Tempfile.create('git') do |file|
+    #     cli.run('version', out: file)
+    #     file.rewind
+    #     file.read #=> "git version 2.39.1\n"
+    #   end
+    #
+    # @example Capture stderr in a StringIO object
+    #   require 'stringio'
+    #   stderr = StringIO.new
+    #   begin
+    #     cli.run('log', 'nonexistent-branch', err: stderr)
+    #   rescue Git::FailedError => e
+    #     stderr.string #=> "unknown revision or path not in the working tree.\n"
+    #   end
+    #
+    # @param args [Array<String>] the command line arguements to pass to git
+    #
+    #   This array should be splatted into the parameter list.
+    #
+    # @param out [#write, nil] the object to write stdout to or nil to ignore stdout
+    #
+    #   If this is a 'StringIO' object, then `stdout_writer.string` will be returned.
+    #
+    #   In general, only specify a `stdout_writer` object when you want to redirect
+    #   stdout to a file or some other object that responds to `#write`. The default
+    #   behavior will return the output of the command.
+    #
+    # @param err [#write] the object to write stderr to or nil to ignore stderr
+    #
+    #   If this is a 'StringIO' object and `merged_output` is `true`, then
+    #   `stderr_writer.string` will be merged into the output returned by this method.
+    #
+    # @param normalize [Boolean] whether to normalize the output to a valid encoding
+    # @param chomp [Boolean] whether to chomp the output
+    # @param merge [Boolean] whether to merge stdout and stderr in the string returned
+    # @param chdir [String] the directory to run the command in
+    #
+    # @return [Git::CommandLineResult] the output of the command
+    #
+    #   This result of running the command.
+    #
+    # @raise [ArgumentError] if `args` is not an array of strings
+    # @raise [Git::SignaledError] if the command was terminated because of an uncaught signal
+    # @raise [Git::FailedError] if the command returned a non-zero exitstatus
+    #
+    def run(*args, out:, err:, normalize:, chomp:, merge:, chdir: nil)
+      git_cmd = build_git_cmd(args)
+      out ||= StringIO.new
+      err ||= (merge ? out : StringIO.new)
+      status = execute(git_cmd, out, err, chdir: (chdir || :not_set))
+
+      process_result(git_cmd, status, out, err, normalize, chomp)
+    end
+
+    private
+
+    # Build the git command line from the available sources to send to `Process.spawn`
+    # @return [Array<String>]
+    # @api private
+    #
+    def build_git_cmd(args)
+      raise ArgumentError.new('The args array can not contain an array') if args.any? { |a| a.is_a?(Array) }
+
+      [binary_path, *global_opts, *args].map { |e| e.to_s }
+    end
+
+    # Determine the output to return in the `CommandLineResult`
+    #
+    # If the writer can return the output by calling `#string` (such as a StringIO),
+    # then return the result of normalizing the encoding and chomping the output
+    # as requested.
+    #
+    # If the writer does not support `#string`, then return nil. The output is
+    # assumed to be collected by the writer itself such as when the  writer
+    # is a file instead of a StringIO.
+    #
+    # @param writer [#string] the writer to post-process
+    #
+    # @return [String, nil]
+    #
+    # @api private
+    #
+    def post_process(writer, normalize, chomp)
+      if writer.respond_to?(:string)
+        output = writer.string.dup
+        output = output.lines.map { |l| Git::EncodingUtils.normalize_encoding(l) }.join if normalize
+        output.chomp! if chomp
+        output
+      else
+        nil
+      end
+    end
+
+    # Post-process all writers and return an array of the results
+    #
+    # @param writers [Array<#write>] the writers to post-process
+    # @param normalize [Boolean] whether to normalize the output of each writer
+    # @param chomp [Boolean] whether to chomp the output of each writer
+    #
+    # @return [Array<String, nil>] the output of each writer that supports `#string`
+    #
+    # @api private
+    #
+    def post_process_all(writers, normalize, chomp)
+      Array.new.tap do |result|
+        writers.each { |writer| result << post_process(writer, normalize, chomp) }
+      end
+    end
+
+    # Raise an error when there was exception while collecting the subprocess output
+    #
+    # @param git_cmd [Array<String>] the git command that was executed
+    # @param pipe_name [Symbol] the name of the pipe that raised the exception
+    # @param pipe [ProcessExecuter::MonitoredPipe] the pipe that raised the exception
+    #
+    # @raise [Git::GitExecuteError]
+    #
+    # @return [void] this method always raises an error
+    #
+    # @api private
+    #
+    def raise_pipe_error(git_cmd, pipe_name, pipe)
+      raise Git::GitExecuteError.new("Pipe Exception for #{git_cmd}: #{pipe_name}"), cause: pipe.exception
+    end
+
+    # Execute the git command and collect the output
+    #
+    # @param cmd [Array<String>] the git command to execute
+    # @param chdir [String] the directory to run the command in
+    #
+    # @raise [Git::GitExecuteError] if an exception was raised while collecting subprocess output
+    #
+    # @return [Process::Status] the status of the completed subprocess
+    #
+    # @api private
+    #
+    def spawn(cmd, out_writers, err_writers, chdir:)
+      out_pipe = ProcessExecuter::MonitoredPipe.new(*out_writers, chunk_size: 10_000)
+      err_pipe = ProcessExecuter::MonitoredPipe.new(*err_writers, chunk_size: 10_000)
+      ProcessExecuter.spawn(env, *cmd, out: out_pipe, err: err_pipe, chdir: chdir)
+    ensure
+      out_pipe.close
+      err_pipe.close
+      raise_pipe_error(cmd, :stdout, out_pipe) if out_pipe.exception
+      raise_pipe_error(cmd, :stderr, err_pipe) if err_pipe.exception
+    end
+
+    # The writers that will be used to collect stdout and stderr
+    #
+    # Additional writers could be added here if you wanted to tee output
+    # or send output to the terminal.
+    #
+    # @param out [#write] the object to write stdout to
+    # @param err [#write] the object to write stderr to
+    #
+    # @return [Array<Array<#write>, Array<#write>>] the writers for stdout and stderr
+    #
+    # @api private
+    #
+    def writers(out, err)
+      out_writers = [out]
+      err_writers = [err]
+      [out_writers, err_writers]
+    end
+
+    # Process the result of the command and return a Git::CommandLineResult
+    #
+    # Post process output, log the command and result, and raise an error if the
+    # command failed.
+    #
+    # @param git_cmd [Array<String>] the git command that was executed
+    # @param status [Process::Status] the status of the completed subprocess
+    # @param out [#write] the object that stdout was written to
+    # @param err [#write] the object that stderr was written to
+    # @param normalize [Boolean] whether to normalize the output of each writer
+    # @param chomp [Boolean] whether to chomp the output of each writer
+    #
+    # @return [Git::CommandLineResult] the result of the command to return to the caller
+    #
+    # @raise [Git::FailedError] if the command failed
+    # @raise [Git::SignaledError] if the command was signaled
+    #
+    # @api private
+    #
+    def process_result(git_cmd, status, out, err, normalize, chomp)
+      out_str, err_str = post_process_all([out, err], normalize, chomp)
+      logger.info { "#{git_cmd} exited with status #{status}" }
+      logger.debug { "stdout:\n#{out_str.inspect}\nstderr:\n#{err_str.inspect}" }
+      Git::CommandLineResult.new(git_cmd, status, out_str, err_str).tap do |result|
+        raise Git::SignaledError.new(result) if status.signaled?
+        raise Git::FailedError.new(result) unless status.success?
+      end
+    end
+
+    # Execute the git command and write the command output to out and err
+    #
+    # @param git_cmd [Array<String>] the git command to execute
+    # @param out [#write] the object to write stdout to
+    # @param err [#write] the object to write stderr to
+    # @param chdir [String] the directory to run the command in
+    #
+    # @return [Git::CommandLineResult] the result of the command to return to the caller
+    #
+    # @api private
+    #
+    def execute(git_cmd, out, err, chdir:)
+      out_writers, err_writers = writers(out, err)
+      spawn(git_cmd, out_writers, err_writers, chdir: chdir)
+    end
+  end
+end

data/lib/git/failed_error.rb

@@ -14,20 +14,18 @@ module Git
   class FailedError < Git::GitExecuteError
     # Create a FailedError object
     #
-    # Since this gem redirects stderr to stdout, the stdout of the process is used.
-    #
     # @example
     #   `exit 1` # set $? appropriately for this example
     #   result = Git::CommandLineResult.new(%w[git status], $?, 'stdout', 'stderr')
     #   error = Git::FailedError.new(result)
     #   error.message #=>
-    #     "[\"git\", \"status\"]\nstatus: pid 89784 exit 1\noutput: \"stdout\""
+    #     "[\"git\", \"status\"]\nstatus: pid 89784 exit 1\nstderr: \"stderr\""
     #
     # @param result [Git::CommandLineResult] the result of the git command including
     #   the git command, status, stdout, and stderr
     #
     def initialize(result)
-      super("#{result.git_cmd}\nstatus: #{result.status}\noutput: #{result.stdout.inspect}")
+      super("#{result.git_cmd}\nstatus: #{result.status}\nstderr: #{result.stderr.inspect}")
       @result = result
     end
 

data/lib/git/lib.rb

@@ -1,14 +1,15 @@
 require 'git/failed_error'
+require 'git/command_line'
 require 'logger'
+require 'pp'
+require 'process_executer'
+require 'stringio'
 require 'tempfile'
 require 'zlib'
 require 'open3'
 
 module Git
   class Lib
-
-    @@semaphore = Mutex.new
-
     # The path to the Git working copy.  The default is '"./.git"'.
     #
     # @return [Pathname] the path to the Git working copy.
@@ -337,7 +338,19 @@ module Git
     end
 
     def object_contents(sha, &block)
-      command('cat-file', '-p', sha, &block)
+      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", sha, out: file, err: file)
+          file.rewind
+          yield file
+        end
+      else
+        # If a block is not given, return stdout
+        command('cat-file', '-p', sha)
+      end
     end
 
     def ls_tree(sha)
@@ -474,11 +487,15 @@ module Git
       grep_opts.push('--', *opts[:path_limiter]) if opts[:path_limiter].is_a?(Array)
 
       hsh = {}
-      command_lines('grep', *grep_opts).each do |line|
-        if m = /(.*?)\:(\d+)\:(.*)/.match(line)
-          hsh[m[1]] ||= []
-          hsh[m[1]] << [m[2].to_i, m[3]]
+      begin
+        command_lines('grep', *grep_opts).each do |line|
+          if m = /(.*?)\:(\d+)\:(.*)/.match(line)
+            hsh[m[1]] ||= []
+            hsh[m[1]] << [m[2].to_i, m[3]]
+          end
         end
+      rescue Git::FailedError => e
+        raise unless e.result.status.exitstatus == 1 && e.result.stderr == ''
       end
       hsh
     end
@@ -865,16 +882,17 @@ module Git
 
     def conflicts # :yields: file, your, their
       self.unmerged.each do |f|
-        your_tempfile = Tempfile.new("YOUR-#{File.basename(f)}")
-        your = your_tempfile.path
-        your_tempfile.close # free up file for git command process
-        command('show', ":2:#{f}", redirect: "> #{escape your}")
-
-        their_tempfile = Tempfile.new("THEIR-#{File.basename(f)}")
-        their = their_tempfile.path
-        their_tempfile.close # free up file for git command process
-        command('show', ":3:#{f}", redirect: "> #{escape their}")
-        yield(f, your, their)
+        Tempfile.create("YOUR-#{File.basename(f)}") do |your|
+          command('show', ":2:#{f}", out: your)
+          your.close
+
+          Tempfile.create("THEIR-#{File.basename(f)}") do |their|
+            command('show', ":3:#{f}", out: their)
+            their.close
+
+            yield(f, your.path, their.path)
+          end
+        end
       end
     end
 
@@ -948,7 +966,7 @@ module Git
       arr_opts << remote if remote
       arr_opts << opts[:ref] if opts[:ref]
 
-      command('fetch', *arr_opts)
+      command('fetch', *arr_opts, merge: true)
     end
 
     def push(remote = nil, branch = nil, opts = nil)
@@ -1001,7 +1019,13 @@ module Git
       head = File.join(@git_dir, 'refs', 'tags', tag_name)
       return File.read(head).chomp if File.exist?(head)
 
-      command('show-ref',  '--tags', '-s', tag_name)
+      begin
+        command('show-ref',  '--tags', '-s', tag_name)
+      rescue Git::FailedError => e
+        raise unless e.result.status.exitstatus == 1 && e.result.stderr == ''
+
+        ''
+      end
     end
 
     def repack
@@ -1026,15 +1050,12 @@ module Git
 
     def commit_tree(tree, opts = {})
       opts[:message] ||= "commit tree #{tree}"
-      t = Tempfile.new('commit-message')
-      t.write(opts[:message])
-      t.close
-
       arr_opts = []
       arr_opts << tree
       arr_opts << '-p' << opts[:parent] if opts[:parent]
-      arr_opts += Array(opts[:parents]).map { |p| ['-p', p] }.flatten if opts[:parents]
-      command('commit-tree', *arr_opts, redirect: "< #{escape t.path}")
+      Array(opts[:parents]).each { |p| arr_opts << '-p' << p } if opts[:parents]
+      arr_opts << '-m' << opts[:message]
+      command('commit-tree', *arr_opts)
     end
 
     def update_ref(ref, commit)
@@ -1080,7 +1101,11 @@ module Git
       arr_opts << "--remote=#{opts[:remote]}" if opts[:remote]
       arr_opts << sha
       arr_opts << '--' << opts[:path] if opts[:path]
-      command('archive', *arr_opts, redirect: " > #{escape file}")
+
+      f = File.open(file, 'wb')
+      command('archive', *arr_opts, out: f)
+      f.close
+
       if opts[:add_gzip]
         file_content = File.read(file)
         Zlib::GzipWriter.open(file) do |gz|
@@ -1115,7 +1140,7 @@ module Git
     end
 
     def required_command_version
-      [1, 6]
+      [2, 28]
     end
 
     def meets_required_version?
@@ -1133,11 +1158,6 @@ module Git
 
     private
 
-    # Systen ENV variables involved in the git commands.
-    #
-    # @return [<String>] the names of the EVN variables involved in the git commands
-    ENV_VARIABLE_NAMES = ['GIT_DIR', 'GIT_WORK_TREE', 'GIT_INDEX_FILE', 'GIT_SSH']
-
     def command_lines(cmd, *opts, chdir: nil)
       cmd_op = command(cmd, *opts, chdir: chdir)
       if cmd_op.encoding.name != "UTF-8"
@@ -1148,84 +1168,32 @@ module Git
       op.split("\n")
     end
 
-    # Takes the current git's system ENV variables and store them.
-    def store_git_system_env_variables
-      @git_system_env_variables = {}
-      ENV_VARIABLE_NAMES.each do |env_variable_name|
-        @git_system_env_variables[env_variable_name] = ENV[env_variable_name]
-      end
+    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
+      }
     end
 
-    # Takes the previously stored git's ENV variables and set them again on ENV.
-    def restore_git_system_env_variables
-      ENV_VARIABLE_NAMES.each do |env_variable_name|
-        ENV[env_variable_name] = @git_system_env_variables[env_variable_name]
+    def global_opts
+      Array.new.tap do |global_opts|
+        global_opts << "--git-dir=#{@git_dir}" if !@git_dir.nil?
+        global_opts << "--work-tree=#{@git_work_dir}" if !@git_work_dir.nil?
+        global_opts << '-c' << 'core.quotePath=true'
+        global_opts << '-c' << 'color.ui=false'
       end
     end
 
-    # Sets git's ENV variables to the custom values for the current instance.
-    def set_custom_git_env_variables
-      ENV['GIT_DIR'] = @git_dir
-      ENV['GIT_WORK_TREE'] = @git_work_dir
-      ENV['GIT_INDEX_FILE'] = @git_index_file
-      ENV['GIT_SSH'] = Git::Base.config.git_ssh
+    def command_line
+      @command_line ||=
+        Git::CommandLine.new(env_overrides, Git::Base.config.binary_path, global_opts, @logger)
     end
 
-    # Runs a block inside an environment with customized ENV variables.
-    # It restores the ENV after execution.
-    #
-    # @param [Proc] block block to be executed within the customized environment
-    def with_custom_env_variables(&block)
-      @@semaphore.synchronize do
-        store_git_system_env_variables()
-        set_custom_git_env_variables()
-        return block.call()
-      end
-    ensure
-      restore_git_system_env_variables()
-    end
-
-    def command(*cmd, redirect: '', chomp: true, chdir: nil, &block)
-      Git::Lib.warn_if_old_command(self)
-
-      raise 'cmd can not include a nested array' if cmd.any? { |o| o.is_a? Array }
-
-      global_opts = []
-      global_opts << "--git-dir=#{@git_dir}" if !@git_dir.nil?
-      global_opts << "--work-tree=#{@git_work_dir}" if !@git_work_dir.nil?
-      global_opts << '-c' << 'core.quotePath=true'
-      global_opts << '-c' << 'color.ui=false'
-
-      escaped_cmd = cmd.map { |part| escape(part) }.join(' ')
-
-      global_opts = global_opts.map { |s| escape(s) }.join(' ')
-
-      git_cmd = "#{Git::Base.config.binary_path} #{global_opts} #{escaped_cmd} #{redirect} 2>&1"
-
-      output = nil
-
-      command_thread = nil;
-
-      status = nil
-
-      with_custom_env_variables do
-        command_thread = Thread.new do
-          output, status = run_command(git_cmd, chdir, &block)
-        end
-        command_thread.join
-      end
-
-      @logger.info(git_cmd)
-      @logger.debug(output)
-
-      if status.exitstatus > 1 || (status.exitstatus == 1 && output != '')
-        result = Git::CommandLineResult.new(git_cmd, status, output, '')
-        raise Git::FailedError.new(result)
-      end
-
-      output.chomp! if output && chomp && !block_given?
-
-      output
+    def command(*args, out: nil, err: nil, normalize: true, chomp: true, merge: false, chdir: nil)
+      result = command_line.run(*args, out: out, err: err, normalize: normalize, chomp: chomp, merge: merge, chdir: chdir)
+      result.stdout
     end
 
     # Takes the diff command line output (as Array) and parse it into a Hash
@@ -1291,38 +1259,5 @@ module Git
       end
       arr_opts
     end
-
-    def run_command(git_cmd, chdir=nil, &block)
-      block ||= Proc.new do |io|
-        io.readlines.map { |l| Git::EncodingUtils.normalize_encoding(l) }.join
-      end
-
-      opts = {}
-      opts[:chdir] = File.expand_path(chdir) if chdir
-
-      Open3.popen2(git_cmd, opts) do |stdin, stdout, wait_thr|
-        [block.call(stdout), wait_thr.value]
-      end
-    end
-
-    def escape(s)
-      windows_platform? ? escape_for_windows(s) : escape_for_sh(s)
-    end
-
-    def escape_for_sh(s)
-      "'#{s && s.to_s.gsub('\'','\'"\'"\'')}'"
-    end
-
-    def escape_for_windows(s)
-      # Escape existing double quotes in s and then wrap the result with double quotes
-      escaped_string = s.to_s.gsub('"','\\"')
-      %Q{"#{escaped_string}"}
-    end
-
-    def windows_platform?
-      # Check if on Windows via RUBY_PLATFORM (CRuby) and RUBY_DESCRIPTION (JRuby)
-      win_platform_regex = /mingw|mswin/
-      RUBY_PLATFORM =~ win_platform_regex || RUBY_DESCRIPTION =~ win_platform_regex
-    end
   end
 end

data/lib/git/version.rb

@@ -1,5 +1,5 @@
 module Git
   # The current gem version
   # @return [String] the current gem version.
-  VERSION='1.19.0'
+  VERSION='2.0.0.pre1'
 end

data/lib/git.rb

@@ -8,6 +8,7 @@ require 'git/base'
 require 'git/branch'
 require 'git/branches'
 require 'git/command_line_result'
+require 'git/command_line'
 require 'git/config'
 require 'git/diff'
 require 'git/encoding_utils'
@@ -23,6 +24,7 @@ require 'git/remote'
 require 'git/repository'
 require 'git/signaled_error'
 require 'git/status'
+require 'git/signaled_error'
 require 'git/stash'
 require 'git/stashes'
 require 'git/url'

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: git
 version: !ruby/object:Gem::Version
-  version: 1.19.0
+  version: 2.0.0.pre1
 platform: ruby
 authors:
 - Scott Chacon and others
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2023-12-29 00:00:00.000000000 Z
+date: 2024-01-15 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: addressable
@@ -25,47 +25,33 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '2.8'
 - !ruby/object:Gem::Dependency
-  name: rchardet
+  name: process_executer
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.8'
+        version: '0.7'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.8'
+        version: '0.7'
 - !ruby/object:Gem::Dependency
-  name: bump
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '0.10'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '0.10'
-- !ruby/object:Gem::Dependency
-  name: create_github_release
+  name: rchardet
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.2'
-  type: :development
+        version: '1.8'
+  type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.2'
+        version: '1.8'
 - !ruby/object:Gem::Dependency
   name: minitar
   requirement: !ruby/object:Gem::Requirement
@@ -100,42 +86,42 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '13.0'
+        version: '13.1'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '13.0'
+        version: '13.1'
 - !ruby/object:Gem::Dependency
   name: test-unit
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '3.3'
+        version: '3.6'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '3.3'
+        version: '3.6'
 - !ruby/object:Gem::Dependency
   name: redcarpet
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '3.5'
+        version: '3.6'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '3.5'
+        version: '3.6'
 - !ruby/object:Gem::Dependency
   name: yard
   requirement: !ruby/object:Gem::Requirement
@@ -171,11 +157,11 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0.9'
 description: |
-  The Git Gem provides an API that can be used to create, read, and manipulate
-  Git repositories by wrapping system calls to the `git` binary. The API can be
-  used for working with Git in complex interactions including branching and
-  merging, object inspection and manipulation, history, patch generation and
-  more.
+  The git gem provides an API that can be used to
+  create, read, and manipulate Git repositories by wrapping system calls to the git
+  command line. The API can be used for working with Git in complex interactions
+  including branching and merging, object inspection and manipulation, history, patch
+  generation and more.
 email: schacon@gmail.com
 executables: []
 extensions: []
@@ -203,6 +189,7 @@ files:
 - lib/git/base/factory.rb
 - lib/git/branch.rb
 - lib/git/branches.rb
+- lib/git/command_line.rb
 - lib/git/command_line_result.rb
 - lib/git/config.rb
 - lib/git/diff.rb
@@ -232,7 +219,8 @@ licenses:
 metadata:
   homepage_uri: http://github.com/ruby-git/ruby-git
   source_code_uri: http://github.com/ruby-git/ruby-git
-  changelog_uri: http://rubydoc.info/gems/git/file.CHANGELOG.html
+  changelog_uri: https://rubydoc.info/gems/git/2.0.0.pre1/file/CHANGELOG.md
+  documentation_uri: https://rubydoc.info/gems/git/2.0.0.pre1
 post_install_message:
 rdoc_options: []
 require_paths:
@@ -241,15 +229,15 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '2.3'
+      version: 3.0.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements:
-- git 1.6.0.0, or greater
-rubygems_version: 3.4.14
+- git 2.28.0 or greater
+rubygems_version: 3.5.3
 signing_key:
 specification_version: 4
 summary: An API to create, read, and manipulate Git repositories