chore: run git commands using RubyGit::CommandLine.run

Author: jcouball

lib/ruby_git.rb

@@ -1,11 +1,10 @@
 # frozen_string_literal: true
 
-require 'ruby_git/command_line'
-require 'ruby_git/encoding_normalizer'
-require 'ruby_git/errors'
-require 'ruby_git/git_binary'
-require 'ruby_git/version'
-require 'ruby_git/working_tree'
+require_relative 'ruby_git/command_line'
+require_relative 'ruby_git/encoding_normalizer'
+require_relative 'ruby_git/errors'
+require_relative 'ruby_git/version'
+require_relative 'ruby_git/working_tree'
 
 require 'logger'
 
@@ -28,22 +27,6 @@
 # @api public
 #
 module RubyGit
-  @git = RubyGit::GitBinary.new
-
-  class << self
-    # Information about the git binary used by the RubyGit gem
-    #
-    # Use this object to set the path to the git binary to use or to see the
-    # path being used.
-    #
-    # @example Setting the git binary path
-    #   RubyGit.git.path = '/usr/local/bin/git'
-    #
-    # @return [RubyGit::GitBinary] the git binary object
-    #
-    attr_reader :git
-  end
-
   @logger = Logger.new(nil)
 
   class << self
@@ -66,6 +49,27 @@ class << self
     attr_accessor :logger
   end
 
+  @binary_path = 'git'
+
+  class << self
+    # The path to the git binary used by the RubyGit gem
+    #
+    # * If the path is a command name, the command is search for in the PATH.
+    #
+    # * If the path is a relative path, it relative to the current directory (not
+    #   recommended as this will change as the current directory is changed).
+    #
+    # * If the path is an absolute path, it is used as is.
+    #
+    # @example
+    #   RubyGit.binary_path
+    #    => "git"
+    #
+    # @return [String]
+    #
+    attr_accessor :binary_path
+  end
+
   # Create an empty Git repository under the root working tree `path`
   #
   # If the repository already exists, it will not be overwritten.
@@ -141,4 +145,21 @@ def self.open(working_tree_path)
   def self.clone(repository_url, to_path: '')
     RubyGit::WorkingTree.clone(repository_url, to_path:)
   end
+
+  # The version of git referred to by the path
+  #
+  # @example for version 2.28.0
+  #   RubyGit.binary_version #=> [2, 28, 0]
+  #
+  # @return [Array<Integer>] an array of integers representing the version.
+  #
+  # @raise [RuntimeError] if path was not set via `path=` and either PATH is not set
+  #   or git was not found on the path.
+  #
+  def self.binary_version
+    command = %w[version]
+    options = { out: StringIO.new, err: StringIO.new }
+    version_string = RubyGit::CommandLine.run(*command, **options).stdout[/\d+\.\d+(\.\d+)+/]
+    version_string.split('.').collect(&:to_i)
+  end
 end

lib/ruby_git/command_line.rb

@@ -3,3 +3,93 @@
 require_relative 'command_line/options'
 require_relative 'command_line/result'
 require_relative 'command_line/runner'
+
+module RubyGit
+  # Run git commands via the command line
+  #
+  # @api public
+  #
+  module CommandLine
+    # Run a git command
+    #
+    # @example A simple example
+    #   RubyGit::CommandLine.run('version') #=> outputs "git version 2.30.2\n" to stdout
+    #
+    # @example Capture stdout
+    #   command = %w[version]
+    #   options = { out: StringIO.new }
+    #   result = RubyGit::CommandLine.run(*command, **options) #=> #<Process::Status: pid 21742 exit 0>
+    #   result.stdout #=> "git version 2.30.2\n"
+    #
+    # @example A more complex example
+    #   command = %w[rev-parse --show-toplevel]
+    #   options = { chdir: working_tree_path, chomp: true, out: StringIO.new, err: StringIO.new }
+    #   RubyGit::CommandLine.run(*command, **options).stdout #=> "/path/to/working/tree"
+    #
+    # @param args [Array<String>] the git command and it arguments
+    # @param repository_path [String] the path to the git repository
+    # @param working_tree_path [String] the path to the working tree
+    # @param options [Hash<Symbol, Object>] options to pass to the command line runner
+    #
+    # @return [RubyGit::CommandLine::Result] the result of running the command
+    #
+    # @raise [RubyGit::Error] if the command fails for any of the following reasons
+    # @raise [RubyGit::FailedError] if the command returns with non-zero exitstatus
+    # @raise [RubyGit::TimeoutError] if the command times out
+    # @raise [RubyGit::SignaledError] if the command terminates due to an uncaught signal
+    # @raise [RubyGit::ProcessIOError] if an exception is raised while collecting subprocess output
+    #
+    def self.run(*args, repository_path: nil, working_tree_path: nil, **options)
+      runner = RubyGit::CommandLine::Runner.new(
+        env,
+        binary_path,
+        global_options(repository_path:, working_tree_path:),
+        logger
+      )
+      runner.call(*args, **options)
+    end
+
+    # The environment variables that will be set for all git commands
+    # @return [Hash<String, String>]
+    # @api private
+    def self.env
+      {
+        'GIT_DIR' => nil,
+        'GIT_WORK_TREE' => nil,
+        'GIT_INDEX_FILE' => nil,
+        # 'GIT_SSH' => Git::Base.config.git_ssh,
+        'LC_ALL' => 'en_US.UTF-8'
+      }
+    end
+
+    # The path to the git binary
+    # @return [String]
+    # @api private
+    def self.binary_path = RubyGit.binary_path
+
+    # The global options that will be set for all git commands
+    # @return [Array<String>]
+    # @api private
+    def self.global_options(repository_path:, working_tree_path:) # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
+      [].tap do |global_opts|
+        global_opts << "--git-dir=#{repository_path}" unless repository_path.nil?
+        global_opts << "--work-tree=#{working_tree_path}" unless working_tree_path.nil?
+        global_opts << '-c' << 'core.quotePath=true'
+        global_opts << '-c' << 'color.ui=false'
+        global_opts << '-c' << 'color.advice=false'
+        global_opts << '-c' << 'color.diff=false'
+        global_opts << '-c' << 'color.grep=false'
+        global_opts << '-c' << 'color.push=false'
+        global_opts << '-c' << 'color.remote=false'
+        global_opts << '-c' << 'color.showBranch=false'
+        global_opts << '-c' << 'color.status=false'
+        global_opts << '-c' << 'color.transport=false'
+      end
+    end
+
+    # The logger to use for logging git commands
+    # @return [Logger]
+    # @api private
+    def self.logger = RubyGit.logger
+  end
+end

lib/ruby_git/command_line/runner.rb

@@ -23,6 +23,7 @@ class Runner
       #   cli.run('version') #=> #<RubyGit::CommandLineResult:0x00007f9b0c0b0e00
       #
       # @param env [Hash<String, String>] environment variables to set
+      # @param binary_path [String] the path to the git binary
       # @param global_options [Array<String>] global options to pass to git
       # @param logger [Logger] the logger to use
       #

lib/ruby_git/git_binary.rb

@@ -39,11 +39,11 @@ class WorkingTree
     def self.init(working_tree_path)
       raise RubyGit::Error, "Path '#{working_tree_path}' not valid." unless File.directory?(working_tree_path)
 
-      command = [RubyGit.git.path.to_s, 'init']
-      _out, err, status = Open3.capture3(*command, chdir: working_tree_path)
-      raise RubyGit::Error, err unless status.success?
+      command = ['init']
+      options = { chdir: working_tree_path, out: StringIO.new, err: StringIO.new }
+      RubyGit::CommandLine.run(*command, **options)
 
-      WorkingTree.new(working_tree_path)
+      new(working_tree_path)
     end
 
     # Open an existing Git working tree that contains working_tree_path
@@ -94,16 +94,15 @@ def self.open(working_tree_path)
     # `to_path` will be created if it does not exist.  An error is raised if `to_path` exists and
     # not an empty directory.
     #
-    # @raise [RubyGit::Error] if (1) `repository_url` is not valid or does not point to a valid repository OR
+    # @raise [RubyGit::FailedError] if (1) `repository_url` is not valid or does not point to a valid repository OR
     #   (2) `to_path` is not an empty directory.
     #
     # @return [RubyGit::WorkingTree] the Git working tree checked out from the cloned repository
     #
     def self.clone(repository_url, to_path: '')
-      command = [RubyGit.git.path.to_s, 'clone', '--', repository_url, to_path]
-      _out, err, status = Open3.capture3(*command)
-      raise RubyGit::Error, err unless status.success?
-
+      command = ['clone', '--', repository_url, to_path]
+      options = { out: StringIO.new, err: StringIO.new }
+      RubyGit::CommandLine.run(*command, **options)
       new(to_path)
     end
 
@@ -121,18 +120,20 @@ def initialize(working_tree_path)
 
     # Find the root path of a Git working tree containing `path`
     #
-    # @raise [RubyGit::Error] if the path is not in a Git working tree
+    # @raise [RubyGit::FailedError] if the path is not in a Git working tree
     #
     # @return [String] the root path of the Git working tree containing `path`
     #
     # @api private
     #
     def root_path(working_tree_path)
-      command = [RubyGit.git.path.to_s, 'rev-parse', '--show-toplevel']
-      out, err, status = Open3.capture3(*command, chdir: working_tree_path)
-      raise RubyGit::Error, err unless status.success?
-
-      out.chomp
+      command = %w[rev-parse --show-toplevel]
+      options = { chdir: working_tree_path, chomp: true, out: StringIO.new, err: StringIO.new }
+      RubyGit::CommandLine.run(*command, **options).stdout
     end
+
+    # def run(*command, **options)
+    #   RubyGit::CommandLine.run(*command, working_tree_path: path, **options)
+    # end
   end
 end