git 3.1.1 → 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,16 +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
-        result = ProcessExecuter.run(env, *git_cmd, out: out, err: err, merge:, chdir: (chdir || :not_set), timeout: timeout, raise_errors: false)
-      rescue ProcessExecuter::Command::ProcessIOError => e
-        raise Git::ProcessIOError.new(e.message), cause: e.exception.cause
+      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?
       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`
@@ -206,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
@@ -216,71 +252,78 @@ 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
+    # Post-process and return an array of raw output strings
     #
-    # @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
+    # For each raw output string:
     #
-    # @return [Array<String, nil>] the processed output of each command output object that supports `#string`
+    # * 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.
     #
-    # @api private
-    #
-    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)
-      if raw_output.respond_to?(:string)
-        output = raw_output.string.dup
+    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
-      else
-        nil
       end
     end
   end

data/lib/git/command_line_result.rb

@@ -19,15 +19,21 @@ module Git
     #   result = Git::CommandLineResult.new(git_cmd, status, stdout, stderr)
     #
     # @param git_cmd [Array<String>] the git command that was executed
-    # @param status [Process::Status] the status of the process
-    # @param stdout [String] the output of the process
-    # @param stderr [String] the error output of the process
+    # @param status [ProcessExecuter::ResultWithCapture] the status of the process
+    # @param stdout [String] the processed stdout of the process
+    # @param stderr [String] the processed stderr of the process
     #
     def initialize(git_cmd, status, stdout, stderr)
       @git_cmd = git_cmd
       @status = status
       @stdout = stdout
       @stderr = stderr
+
+      # ProcessExecuter::ResultWithCapture changed the timeout? method to timed_out?
+      # in version 4.x. This is a compatibility layer to maintain the old method name
+      # for backward compatibility.
+      #
+      status.define_singleton_method(:timeout?) { timed_out? }
     end
 
     # @attribute [r] git_cmd

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

@@ -1,80 +1,87 @@
 # frozen_string_literal: true
 
-module Git
+require_relative 'diff_path_status'
+require_relative 'diff_stats'
 
-  # object that holds the last X commits on given branch
+module Git
+  # object that holds the diff between two commits
   class Diff
     include Enumerable
 
     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 = nil
       @full_diff_files = nil
-      @stats = nil
     end
     attr_reader :from, :to
 
-    def name_status
-      cache_name_status
-    end
-
     def path(path)
       @path = path
-      return self
+      self
     end
 
-    def size
-      cache_stats
-      @stats[:total][:files]
+    def patch
+      @base.lib.diff_full(@from, @to, { path_limiter: @path })
     end
+    alias to_s patch
 
-    def lines
-      cache_stats
-      @stats[:total][:lines]
+    def [](key)
+      process_full
+      @full_diff_files.assoc(key)[1]
     end
 
-    def deletions
-      cache_stats
-      @stats[:total][:deletions]
+    def each(&)
+      process_full
+      @full_diff_files.map { |file| file[1] }.each(&)
     end
 
-    def insertions
-      cache_stats
-      @stats[:total][:insertions]
+    #
+    # DEPRECATED METHODS
+    #
+
+    def name_status
+      Git::Deprecation.warn('Git::Diff#name_status is deprecated. Use Git::Base#diff_path_status instead.')
+      path_status_provider.to_h
     end
 
-    def stats
-      cache_stats
-      @stats
+    def size
+      Git::Deprecation.warn('Git::Diff#size is deprecated. Use Git::Base#diff_stats(...).total[:files] instead.')
+      stats_provider.total[:files]
     end
 
-    # if file is provided and is writable, it will write the patch into the file
-    def patch(file = nil)
-      cache_full
-      @full_diff
+    def lines
+      Git::Deprecation.warn('Git::Diff#lines is deprecated. Use Git::Base#diff_stats(...).lines instead.')
+      stats_provider.lines
     end
-    alias_method :to_s, :patch
 
-    # enumerable methods
+    def deletions
+      Git::Deprecation.warn('Git::Diff#deletions is deprecated. Use Git::Base#diff_stats(...).deletions instead.')
+      stats_provider.deletions
+    end
 
-    def [](key)
-      process_full
-      @full_diff_files.assoc(key)[1]
+    def insertions
+      Git::Deprecation.warn('Git::Diff#insertions is deprecated. Use Git::Base#diff_stats(...).insertions instead.')
+      stats_provider.insertions
     end
 
-    def each(&block) # :yields: each Git::DiffFile in turn
-      process_full
-      @full_diff_files.map { |file| file[1] }.each(&block)
+    def stats
+      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,
+        total: stats_provider.total
+      }
     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
@@ -102,56 +109,84 @@ module Git
 
     private
 
-      def cache_full
-        @full_diff ||= @base.lib.diff_full(@from, @to, {:path_limiter => @path})
+    def process_full
+      return if @full_diff_files
+
+      @full_diff_files = process_full_diff
+    end
+
+    def path_status_provider
+      @path_status_provider ||= Git::DiffPathStatus.new(@base, @from, @to, @path)
+    end
+
+    def stats_provider
+      @stats_provider ||= Git::DiffStats.new(@base, @from, @to, @path)
+    end
+
+    def process_full_diff
+      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 process_full
-        return if @full_diff_files
-        cache_full
-        @full_diff_files = process_full_diff
+      def parse
+        @patch_text.split("\n").each { |line| process_line(line) }
+        @final_files.map { |filename, data| [filename, DiffFile.new(@base, data)] }
       end
 
-      def cache_stats
-        @stats ||=  @base.lib.diff_stats(@from, @to, {:path_limiter => @path})
+      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
+          append_to_current_file(line)
+        end
       end
 
-      def cache_name_status
-        @name_status ||= @base.lib.diff_name_status(@from, @to, {:path => @path})
+      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
 
-      # break up @diff_full
-      def process_full_diff
-        defaults = {
-          :mode => '',
-          :src => '',
-          :dst => '',
-          :type => 'modified'
-        }
-        final = {}
-        current_file = nil
-        @full_diff.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})
-          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
-          end
-        end
-        final.map { |e| [e[0], DiffFile.new(@base, e[1])] }
+      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