git 4.0.0 → 4.0.1

data/lib/git/branch.rb

@@ -3,7 +3,8 @@
 require 'git/path'
 
 module Git
-  class Branch < Path
+  # Represents a Git branch
+  class Branch
     attr_accessor :full, :remote, :name
 
     def initialize(base, name)
@@ -56,12 +57,12 @@ module Git
       @base.lib.branch_delete(@name)
     end
 
-    def current
-      determine_current
+    def current # rubocop:disable Naming/PredicateMethod
+      @base.lib.branch_current == @name
     end
 
     def contains?(commit)
-      !@base.lib.branch_contains(commit, self.name).empty?
+      !@base.lib.branch_contains(commit, name).empty?
     end
 
     def merge(branch = nil, message = nil)
@@ -93,16 +94,6 @@ module Git
       @full
     end
 
-    private
-
-    def check_if_create
-      @base.lib.branch_new(@name) rescue nil
-    end
-
-    def determine_current
-      @base.lib.branch_current == @name
-    end
-
     BRANCH_NAME_REGEXP = %r{
       ^
         # Optional 'refs/remotes/' at the beggining to specify a remote tracking branch
@@ -114,6 +105,8 @@ module Git
       $
     }x
 
+    private
+
     # Given a full branch name return an Array containing the remote and branch names.
     #
     # Removes 'remotes' from the beggining of the name (if present).
@@ -139,7 +132,13 @@ module Git
       match = name.match(BRANCH_NAME_REGEXP)
       remote = match[:remote_name] ? Git::Remote.new(@base, match[:remote_name]) : nil
       branch_name = match[:branch_name]
-      [ remote, branch_name ]
+      [remote, branch_name]
+    end
+
+    def check_if_create
+      @base.lib.branch_new(@name)
+    rescue StandardError
+      nil
     end
   end
 end

data/lib/git/branches.rb

@@ -1,10 +1,8 @@
 # frozen_string_literal: true
 
 module Git
-
   # object that holds all the available branches
   class Branches
-
     include Enumerable
 
     def initialize(base)
@@ -18,11 +16,11 @@ module Git
     end
 
     def local
-      self.select { |b| !b.remote }
+      reject(&:remote)
     end
 
     def remote
-      self.select { |b| b.remote }
+      self.select(&:remote)
     end
 
     # array like methods
@@ -31,8 +29,8 @@ module Git
       @branches.size
     end
 
-    def each(&block)
-      @branches.values.each(&block)
+    def each(&)
+      @branches.values.each(&)
     end
 
     # Returns the target branch
@@ -49,24 +47,22 @@ module Git
     # @param [#to_s] branch_name the target branch name.
     # @return [Git::Branch] the target branch.
     def [](branch_name)
-      @branches.values.inject(@branches) do |branches, branch|
+      @branches.values.each_with_object(@branches) do |branch, branches|
         branches[branch.full] ||= branch
 
         # This is how Git (version 1.7.9.5) works.
-        # Lets you ignore the 'remotes' if its at the beginning of the branch full name (even if is not a real remote branch).
-        branches[branch.full.sub('remotes/', '')] ||= branch if branch.full =~ /^remotes\/.+/
-
-        branches
+        # Lets you ignore the 'remotes' if its at the beginning of the branch full
+        # name (even if is not a real remote branch).
+        branches[branch.full.sub('remotes/', '')] ||= branch if branch.full =~ %r{^remotes/.+}
       end[branch_name.to_s]
     end
 
     def to_s
       out = ''
-      @branches.each do |k, b|
+      @branches.each_value do |b|
         out << (b.current ? '* ' : '  ') << b.to_s << "\n"
       end
       out
     end
   end
-
 end

data/lib/git/command_line.rb

@@ -97,6 +97,10 @@ module Git
 
     # Execute a git command, wait for it to finish, and return the result
     #
+    # Non-option the command line arguements to pass to git. If you collect
+    # the command line arguments in an array, make sure you splat the array
+    # into the parameter list.
+    #
     # NORMALIZATION
     #
     # The command output is returned as a Unicde string containing the binary output
@@ -142,11 +146,9 @@ module Git
     #     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 options_hash [Hash] the options to pass to the command
     #
-    # @param out [#write, nil] the object to write stdout to or nil to ignore stdout
+    # @option options_hash [#write, nil] :out the object to write stdout to or nil to ignore stdout
     #
     #   If this is a 'StringIO' object, then `stdout_writer.string` will be returned.
     #
@@ -154,20 +156,20 @@ module Git
     #   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
+    # @option options_hash [#write, nil] :err 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
+    # @option options_hash [Boolean] :normalize whether to normalize the output of stdout and stderr
     #
-    # @param chomp [Boolean] whether to chomp the output
+    # @option options_hash [Boolean] :chomp whether to chomp both stdout and stderr output
     #
-    # @param merge [Boolean] whether to merge stdout and stderr in the string returned
+    # @option options_hash [Boolean] :merge whether to merge stdout and stderr in the string returned
     #
-    # @param chdir [String] the directory to run the command in
+    # @option options_hash [String, nil] :chdir the directory to run the command in
     #
-    # @param timeout [Numeric, nil] the maximum seconds to wait for the command to complete
+    # @option options_hash [Numeric, nil] :timeout the maximum seconds to wait for the command to complete
     #
     #   If timeout is zero, the timeout will not be enforced.
     #
@@ -189,21 +191,50 @@ module Git
     #
     # @raise [Git::TimeoutError] if the command times out
     #
-    def run(*args, out: nil, err: nil, normalize:, chomp:, merge:, chdir: nil, timeout: nil)
+    def run(*, **options_hash)
+      options_hash = RUN_ARGS.merge(options_hash)
+      extra_options = options_hash.keys - RUN_ARGS.keys
+      raise ArgumentError, "Unknown options: #{extra_options.join(', ')}" if extra_options.any?
+
+      result = run_with_capture(*, **options_hash)
+      process_result(result, options_hash[:normalize], options_hash[:chomp], options_hash[:timeout])
+    end
+
+    # @return [Git::CommandLineResult] the result of running the command
+    #
+    # @api private
+    #
+    def run_with_capture(*args, **options_hash)
       git_cmd = build_git_cmd(args)
-      begin
-        options = { chdir: (chdir || :not_set), timeout_after: timeout, raise_errors: false }
+      options = run_with_capture_options(**options_hash)
+      ProcessExecuter.run_with_capture(env, *git_cmd, **options)
+    rescue ProcessExecuter::ProcessIOError => e
+      raise Git::ProcessIOError.new(e.message), cause: e.exception.cause
+    end
+
+    def run_with_capture_options(**options_hash)
+      chdir = options_hash[:chdir] || :not_set
+      timeout_after = options_hash[:timeout]
+      out = options_hash[:out]
+      err = options_hash[:err]
+      merge_output = options_hash[:merge] || false
+
+      { chdir:, timeout_after:, merge_output:, raise_errors: false }.tap do |options|
         options[:out] = out unless out.nil?
         options[:err] = err unless err.nil?
-        options[:merge_output] = merge unless merge.nil?
-
-        result = ProcessExecuter.run_with_capture(env, *git_cmd, **options)
-      rescue ProcessExecuter::ProcessIOError => e
-        raise Git::ProcessIOError.new(e.message), cause: e.exception.cause
       end
-      process_result(result, normalize, chomp, timeout)
     end
 
+    RUN_ARGS = {
+      normalize: false,
+      chomp: false,
+      merge: false,
+      out: nil,
+      err: nil,
+      chdir: nil,
+      timeout: nil
+    }.freeze
+
     private
 
     # Build the git command line from the available sources to send to `Process.spawn`
@@ -211,9 +242,9 @@ module Git
     # @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) }
+      raise ArgumentError, '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 }
+      [binary_path, *global_opts, *args].map(&:to_s)
     end
 
     # Process the result of the command and return a Git::CommandLineResult
@@ -221,68 +252,79 @@ module Git
     # Post process output, log the command and result, and raise an error if the
     # command failed.
     #
-    # @param result [ProcessExecuter::Command::Result] the result it is a Process::Status and include command, stdout, and stderr
+    # @param result [ProcessExecuter::Command::Result] the result it is a
+    #   Process::Status and include command, stdout, and stderr
+    #
     # @param normalize [Boolean] whether to normalize the output of each writer
+    #
     # @param chomp [Boolean] whether to chomp the output of each writer
-    # @param timeout [Numeric, nil] the maximum seconds to wait for the command to complete
     #
-    # @return [Git::CommandLineResult] the result of the command to return to the caller
+    # @param timeout [Numeric, nil] the maximum seconds to wait for the command to
+    #   complete
+    #
+    # @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
+    #
     # @raise [Git::TimeoutError] if the command times out
-    # @raise [Git::ProcessIOError] if an exception was raised while collecting subprocess output
+    #
+    # @raise [Git::ProcessIOError] if an exception was raised while collecting
+    #   subprocess output
     #
     # @api private
     #
     def process_result(result, normalize, chomp, timeout)
       command = result.command
-      processed_out, processed_err = post_process_all([result.stdout, result.stderr], normalize, chomp)
+      processed_out, processed_err = post_process_output(result, normalize, chomp)
+      log_result(result, command, processed_out, processed_err)
+      command_line_result(command, result, processed_out, processed_err, timeout)
+    end
+
+    def log_result(result, command, processed_out, processed_err)
       logger.info { "#{command} exited with status #{result}" }
       logger.debug { "stdout:\n#{processed_out.inspect}\nstderr:\n#{processed_err.inspect}" }
+    end
+
+    def command_line_result(command, result, processed_out, processed_err, timeout)
       Git::CommandLineResult.new(command, result, processed_out, processed_err).tap do |processed_result|
         raise Git::TimeoutError.new(processed_result, timeout) if result.timeout?
-        raise Git::SignaledError.new(processed_result) if result.signaled?
-        raise Git::FailedError.new(processed_result) unless result.success?
+
+        raise Git::SignaledError, processed_result if result.signaled?
+
+        raise Git::FailedError, processed_result unless result.success?
       end
     end
 
-    # Post-process command output and return an array of the results
-    #
-    # @param raw_outputs [Array] the output 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
+    # Post-process and return an array of raw output strings
     #
-    # @return [Array<String, nil>] the processed output of each command output object that supports `#string`
+    # For each raw output string:
     #
-    # @api private
+    # * If normalize: is true, normalize the encoding by transcoding each line from
+    #   the detected encoding to UTF-8.
+    # * If chomp: is true chomp the output after normalization.
     #
-    def post_process_all(raw_outputs, normalize, chomp)
-      Array.new.tap do |result|
-        raw_outputs.each { |raw_output| result << post_process(raw_output, normalize, chomp) }
-      end
-    end
-
-    # Determine the output to return in the `CommandLineResult`
+    # Even if no post-processing is done based on the options, the strings returned
+    # are a copy of the raw output strings. The raw output strings are not modified.
     #
-    # 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.
+    # @param result [ProcessExecuter::ResultWithCapture] the command's output to post-process
     #
-    # 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 normalize [Boolean] whether to normalize the output of each writer
+    # @param chomp [Boolean] whether to chomp the output of each writer
     #
-    # @param raw_output [#string] the output to post-process
-    # @return [String, nil]
+    # @return [Array<String>]
     #
     # @api private
     #
-    def post_process(raw_output, normalize, chomp)
-      output = raw_output.dup
-      output = output.lines.map { |l| Git::EncodingUtils.normalize_encoding(l) }.join if normalize
-      output.chomp! if chomp
-      output
+    def post_process_output(result, normalize, chomp)
+      [result.stdout, result.stderr].map do |raw_output|
+        output = raw_output.dup
+        output = output.lines.map { |l| Git::EncodingUtils.normalize_encoding(l) }.join if normalize
+        output.chomp! if chomp
+        output
+      end
     end
   end
 end

data/lib/git/config.rb

@@ -1,9 +1,8 @@
 # frozen_string_literal: true
 
 module Git
-
+  # The global configuration for this gem
   class Config
-
     attr_writer :binary_path, :git_ssh, :timeout
 
     def initialize
@@ -13,16 +12,15 @@ module Git
     end
 
     def binary_path
-      @binary_path || ENV['GIT_PATH'] && File.join(ENV['GIT_PATH'], 'git') || 'git'
+      @binary_path || (ENV.fetch('GIT_PATH', nil) && File.join(ENV.fetch('GIT_PATH', nil), 'git')) || 'git'
     end
 
     def git_ssh
-      @git_ssh || ENV['GIT_SSH']
+      @git_ssh || ENV.fetch('GIT_SSH', nil)
     end
 
     def timeout
-      @timeout || (ENV['GIT_TIMEOUT'] && ENV['GIT_TIMEOUT'].to_i)
+      @timeout || (ENV.fetch('GIT_TIMEOUT', nil) && ENV['GIT_TIMEOUT'].to_i)
     end
   end
-
 end

data/lib/git/diff.rb

@@ -10,8 +10,8 @@ module Git
 
     def initialize(base, from = nil, to = nil)
       @base = base
-      @from = from && from.to_s
-      @to = to && to.to_s
+      @from = from&.to_s
+      @to = to&.to_s
 
       @path = nil
       @full_diff_files = nil
@@ -26,16 +26,16 @@ module Git
     def patch
       @base.lib.diff_full(@from, @to, { path_limiter: @path })
     end
-    alias_method :to_s, :patch
+    alias to_s patch
 
     def [](key)
       process_full
       @full_diff_files.assoc(key)[1]
     end
 
-    def each(&block)
+    def each(&)
       process_full
-      @full_diff_files.map { |file| file[1] }.each(&block)
+      @full_diff_files.map { |file| file[1] }.each(&)
     end
 
     #
@@ -43,34 +43,32 @@ module Git
     #
 
     def name_status
-      Git::Deprecation.warn("Git::Diff#name_status is deprecated. Use Git::Base#diff_path_status instead.")
+      Git::Deprecation.warn('Git::Diff#name_status is deprecated. Use Git::Base#diff_path_status instead.')
       path_status_provider.to_h
     end
 
     def size
-      Git::Deprecation.warn("Git::Diff#size is deprecated. Use Git::Base#diff_stats(...).total[:files] instead.")
+      Git::Deprecation.warn('Git::Diff#size is deprecated. Use Git::Base#diff_stats(...).total[:files] instead.')
       stats_provider.total[:files]
     end
 
-
-
     def lines
-      Git::Deprecation.warn("Git::Diff#lines is deprecated. Use Git::Base#diff_stats(...).lines instead.")
+      Git::Deprecation.warn('Git::Diff#lines is deprecated. Use Git::Base#diff_stats(...).lines instead.')
       stats_provider.lines
     end
 
     def deletions
-      Git::Deprecation.warn("Git::Diff#deletions is deprecated. Use Git::Base#diff_stats(...).deletions instead.")
+      Git::Deprecation.warn('Git::Diff#deletions is deprecated. Use Git::Base#diff_stats(...).deletions instead.')
       stats_provider.deletions
     end
 
     def insertions
-      Git::Deprecation.warn("Git::Diff#insertions is deprecated. Use Git::Base#diff_stats(...).insertions instead.")
+      Git::Deprecation.warn('Git::Diff#insertions is deprecated. Use Git::Base#diff_stats(...).insertions instead.')
       stats_provider.insertions
     end
 
     def stats
-      Git::Deprecation.warn("Git::Diff#stats is deprecated. Use Git::Base#diff_stats instead.")
+      Git::Deprecation.warn('Git::Diff#stats is deprecated. Use Git::Base#diff_stats instead.')
       # CORRECTED: Re-create the original hash structure for backward compatibility
       {
         files: stats_provider.files,
@@ -78,10 +76,12 @@ module Git
       }
     end
 
+    # The changes for a single file within a diff
     class DiffFile
       attr_accessor :patch, :path, :mode, :src, :dst, :type
+
       @base = nil
-      NIL_BLOB_REGEXP = /\A0{4,40}\z/.freeze
+      NIL_BLOB_REGEXP = /\A0{4,40}\z/
 
       def initialize(base, hash)
         @base = base
@@ -111,46 +111,82 @@ module Git
 
     def process_full
       return if @full_diff_files
+
       @full_diff_files = process_full_diff
     end
 
-    # CORRECTED: Pass the @path variable to the new objects
     def path_status_provider
       @path_status_provider ||= Git::DiffPathStatus.new(@base, @from, @to, @path)
     end
 
-    # CORRECTED: Pass the @path variable to the new objects
     def stats_provider
       @stats_provider ||= Git::DiffStats.new(@base, @from, @to, @path)
     end
 
     def process_full_diff
-      defaults = {
-        mode: '', src: '', dst: '', type: 'modified'
-      }
-      final = {}
-      current_file = nil
-      patch.split("\n").each do |line|
-        if m = %r{\Adiff --git ("?)a/(.+?)\1 ("?)b/(.+?)\3\z}.match(line)
-          current_file = Git::EscapedPath.new(m[2]).unescape
-          final[current_file] = defaults.merge({ patch: line, path: current_file })
+      FullDiffParser.new(@base, patch).parse
+    end
+
+    # A private parser class to process the output of `git diff`
+    # @api private
+    class FullDiffParser
+      def initialize(base, patch_text)
+        @base = base
+        @patch_text = patch_text
+        @final_files = {}
+        @current_file_data = nil
+        @defaults = { mode: '', src: '', dst: '', type: 'modified', binary: false }
+      end
+
+      def parse
+        @patch_text.split("\n").each { |line| process_line(line) }
+        @final_files.map { |filename, data| [filename, DiffFile.new(@base, data)] }
+      end
+
+      private
+
+      def process_line(line)
+        if (new_file_match = line.match(%r{\Adiff --git ("?)a/(.+?)\1 ("?)b/(.+?)\3\z}))
+          start_new_file(new_file_match, line)
         else
-          if m = /^index ([0-9a-f]{4,40})\.\.([0-9a-f]{4,40})( ......)*/.match(line)
-            final[current_file][:src] = m[1]
-            final[current_file][:dst] = m[2]
-            final[current_file][:mode] = m[3].strip if m[3]
-          end
-          if m = /^([[:alpha:]]*?) file mode (......)/.match(line)
-            final[current_file][:type] = m[1]
-            final[current_file][:mode] = m[2]
-          end
-          if m = /^Binary files /.match(line)
-            final[current_file][:binary] = true
-          end
-          final[current_file][:patch] << "\n" + line
+          append_to_current_file(line)
         end
       end
-      final.map { |e| [e[0], DiffFile.new(@base, e[1])] }
+
+      def start_new_file(match, line)
+        filename = Git::EscapedPath.new(match[2]).unescape
+        @current_file_data = @defaults.merge({ patch: line, path: filename })
+        @final_files[filename] = @current_file_data
+      end
+
+      def append_to_current_file(line)
+        return unless @current_file_data
+
+        parse_index_line(line)
+        parse_file_mode_line(line)
+        check_for_binary(line)
+
+        @current_file_data[:patch] << "\n#{line}"
+      end
+
+      def parse_index_line(line)
+        return unless (match = line.match(/^index ([0-9a-f]{4,40})\.\.([0-9a-f]{4,40})( ......)*/))
+
+        @current_file_data[:src] = match[1]
+        @current_file_data[:dst] = match[2]
+        @current_file_data[:mode] = match[3].strip if match[3]
+      end
+
+      def parse_file_mode_line(line)
+        return unless (match = line.match(/^([[:alpha:]]*?) file mode (......)/))
+
+        @current_file_data[:type] = match[1]
+        @current_file_data[:mode] = match[2]
+      end
+
+      def check_for_binary(line)
+        @current_file_data[:binary] = true if line.match?(/^Binary files /)
+      end
     end
   end
 end

data/lib/git/diff_path_status.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 module Git
+  # The files and their status (e.g., added, modified, deleted) between two commits
   class DiffPathStatus
     include Enumerable
 
@@ -21,8 +22,8 @@ module Git
     # Iterates over each file's status.
     #
     # @yield [path, status]
-    def each(&block)
-      fetch_path_status.each(&block)
+    def each(&)
+      fetch_path_status.each(&)
     end
 
     # Returns the name-status report as a Hash.
@@ -37,7 +38,7 @@ module Git
 
     # Lazily fetches and caches the path status from the git lib.
     def fetch_path_status
-      @path_status ||= @base.lib.diff_path_status(
+      @fetch_path_status ||= @base.lib.diff_path_status(
         @from, @to, { path: @path_limiter }
       )
     end

data/lib/git/diff_stats.rb

@@ -51,7 +51,7 @@ module Git
 
     # Lazily fetches and caches the stats from the git lib.
     def fetch_stats
-      @stats ||= @base.lib.diff_stats(
+      @fetch_stats ||= @base.lib.diff_stats(
         @from, @to, { path_limiter: @path_limiter }
       )
     end

data/lib/git/errors.rb

@@ -1,6 +1,8 @@
 # frozen_string_literal: true
 
 module Git
+  # rubocop:disable Layout/LineLength
+
   # Base class for all custom git module errors
   #
   # The git gem will only raise an `ArgumentError` or an error that is a subclass of
@@ -60,6 +62,8 @@ module Git
   #
   class Error < StandardError; end
 
+  # rubocop:enable Layout/LineLength
+
   # An alias for Git::Error
   #
   # Git::GitExecuteError error class is an alias for Git::Error for backwards
@@ -155,7 +159,8 @@ module Git
     #   status = ProcessExecuter.spawn(*command, timeout: timeout_duration)
     #   result = Git::CommandLineResult.new(command, status, 'stdout', 'err output')
     #   error = Git::TimeoutError.new(result, timeout_duration)
-    #   error.error_message #=> '["sleep", "10"], status: pid 70144 SIGKILL (signal 9), stderr: "err output", timed out after 1s'
+    #   error.error_message
+    #   #=> '["sleep", "10"], status: pid 70144 SIGKILL (signal 9), stderr: "err output", timed out after 1s'
     #
     # @param result [Git::CommandLineResult] the result of the git command including
     #   the git command, status, stdout, and stderr
@@ -171,7 +176,8 @@ module Git
     # The human readable representation of this error
     #
     # @example
-    #   error.error_message #=> '["sleep", "10"], status: pid 88811 SIGKILL (signal 9), stderr: "err output", timed out after 1s'
+    #   error.error_message
+    #   #=> '["sleep", "10"], status: pid 88811 SIGKILL (signal 9), stderr: "err output", timed out after 1s'
     #
     # @return [String]
     #

data/lib/git/escaped_path.rb

@@ -42,7 +42,7 @@ module Git
     private
 
     def extract_octal(path, index)
-      [path[index + 1..index + 3].to_i(8), 4]
+      [path[(index + 1)..(index + 3)].to_i(8), 4]
     end
 
     def extract_escape(path, index)