git 1.19.1 → 4.4.5

data/lib/git/diff_path_status.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module Git
+  # The files and their status (e.g., added, modified, deleted) between two commits
+  class DiffPathStatus
+    include Enumerable
+
+    # @private
+    def initialize(base, from, to, path_limiter = nil)
+      # Eagerly check for invalid arguments
+      [from, to].compact.each do |arg|
+        raise ArgumentError, "Invalid argument: '#{arg}'" if arg.start_with?('-')
+      end
+
+      @base = base
+      @from = from
+      @to = to
+      @path_limiter = path_limiter
+      @path_status = nil
+    end
+
+    # Iterates over each file's status.
+    #
+    # @yield [path, status]
+    def each(&)
+      fetch_path_status.each(&)
+    end
+
+    # Returns the name-status report as a Hash.
+    #
+    # @return [Hash<String, String>] A hash where keys are file paths
+    #   and values are their status codes.
+    def to_h
+      fetch_path_status
+    end
+
+    private
+
+    # Lazily fetches and caches the path status from the git lib.
+    def fetch_path_status
+      @fetch_path_status ||= @base.lib.diff_path_status(
+        @from, @to, { path_limiter: @path_limiter }
+      )
+    end
+  end
+end

data/lib/git/diff_stats.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+module Git
+  # Provides access to the statistics of a diff between two commits,
+  # including insertions, deletions, and file-level details.
+  class DiffStats
+    # @private
+    def initialize(base, from, to, path_limiter = nil)
+      # Eagerly check for invalid arguments
+      [from, to].compact.each do |arg|
+        raise ArgumentError, "Invalid argument: '#{arg}'" if arg.start_with?('-')
+      end
+
+      @base = base
+      @from = from
+      @to = to
+      @path_limiter = path_limiter
+      @stats = nil
+    end
+
+    # Returns the total number of lines deleted.
+    def deletions
+      fetch_stats[:total][:deletions]
+    end
+
+    # Returns the total number of lines inserted.
+    def insertions
+      fetch_stats[:total][:insertions]
+    end
+
+    # Returns the total number of lines changed (insertions + deletions).
+    def lines
+      fetch_stats[:total][:lines]
+    end
+
+    # Returns a hash of statistics for each file in the diff.
+    #
+    # @return [Hash<String, {insertions: Integer, deletions: Integer}>]
+    def files
+      fetch_stats[:files]
+    end
+
+    # Returns a hash of the total statistics for the diff.
+    #
+    # @return [{insertions: Integer, deletions: Integer, lines: Integer, files: Integer}]
+    def total
+      fetch_stats[:total]
+    end
+
+    private
+
+    # Lazily fetches and caches the stats from the git lib.
+    def fetch_stats
+      @fetch_stats ||= @base.lib.diff_stats(
+        @from, @to, { path_limiter: @path_limiter }
+      )
+    end
+  end
+end

data/lib/git/errors.rb

@@ -0,0 +1,212 @@
+# 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
+  # `Git::Error`. It does not explicitly raise any other types of errors.
+  #
+  # It is recommended to rescue `Git::Error` to catch any runtime error raised by
+  # this gem unless you need more specific error handling.
+  #
+  # Git's custom errors are arranged in the following class heirarchy:
+  #
+  # ```text
+  # StandardError
+  # └─> Git::Error
+  #     ├─> Git::CommandLineError
+  #     │   ├─> Git::FailedError
+  #     │   └─> Git::SignaledError
+  #     │       └─> Git::TimeoutError
+  #     ├─> Git::ProcessIOError
+  #     └─> Git::UnexpectedResultError
+  # ```
+  #
+  # | Error Class | Description |
+  # | --- | --- |
+  # | `Error` | This catch-all error serves as the base class for other custom errors raised by the git gem. |
+  # | `CommandLineError` | A subclass of this error is raised when there is a problem executing the git command line. |
+  # | `FailedError` | This error is raised when the git command line exits with a non-zero status code that is not expected by the git gem. |
+  # | `SignaledError` | This error is raised when the git command line is terminated as a result of receiving a signal. This could happen if the process is forcibly terminated or if there is a serious system error. |
+  # | `TimeoutError` | This is a specific type of `SignaledError` that is raised when the git command line operation times out and is killed via the SIGKILL signal. This happens if the operation takes longer than the timeout duration configured in `Git.config.timeout` or via the `:timeout` parameter given in git methods that support timeouts. |
+  # | `ProcessIOError` | An error was encountered reading or writing to a subprocess. |
+  # | `UnexpectedResultError` | The command line ran without error but did not return the expected results. |
+  #
+  # @example Rescuing a generic error
+  #   begin
+  #     # some git operation
+  #   rescue Git::Error => e
+  #     puts "An error occurred: #{e.message}"
+  #   end
+  #
+  # @example Rescuing a timeout error
+  #   begin
+  #     timeout_duration = 0.001 # seconds
+  #     repo = Git.clone('https://github.com/ruby-git/ruby-git', 'ruby-git-temp', timeout: timeout_duration)
+  #   rescue Git::TimeoutError => e # Catch the more specific error first!
+  #     puts "Git clone took too long and timed out #{e}"
+  #   rescue Git::Error => e
+  #     puts "Received the following error: #{e}"
+  #   end
+  #
+  # @see Git::CommandLineError
+  # @see Git::FailedError
+  # @see Git::SignaledError
+  # @see Git::TimeoutError
+  # @see Git::ProcessIOError
+  # @see Git::UnexpectedResultError
+  #
+  # @api public
+  #
+  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
+  # compatibility. It is recommended to use Git::Error directly.
+  #
+  # @deprecated Use Git::Error instead
+  #
+  GitExecuteError = ActiveSupport::Deprecation::DeprecatedConstantProxy.new('Git::GitExecuteError', 'Git::Error', Git::Deprecation)
+
+  # Raised when a git command fails or exits because of an uncaught signal
+  #
+  # The git command executed, status, stdout, and stderr are available from this
+  # object.
+  #
+  # The Gem will raise a more specific error for each type of failure:
+  #
+  # * {Git::FailedError}: when the git command exits with a non-zero status
+  # * {Git::SignaledError}: when the git command exits because of an uncaught signal
+  # * {Git::TimeoutError}: when the git command times out
+  #
+  # @api public
+  #
+  class CommandLineError < Git::Error
+    # Create a CommandLineError object
+    #
+    # @example
+    #   `exit 1` # set $? appropriately for this example
+    #   result = Git::CommandLineResult.new(%w[git status], $?, 'stdout', 'stderr')
+    #   error = Git::CommandLineError.new(result)
+    #   error.to_s #=> '["git", "status"], status: pid 89784 exit 1, stderr: "stderr"'
+    #
+    # @param result [Git::CommandLineResult] the result of the git command including
+    #   the git command, status, stdout, and stderr
+    #
+    def initialize(result)
+      @result = result
+      super(error_message)
+    end
+
+    # The human readable representation of this error
+    #
+    # @example
+    #   error.error_message #=> '["git", "status"], status: pid 89784 exit 1, stderr: "stderr"'
+    #
+    # @return [String]
+    #
+    def error_message = <<~MESSAGE.chomp
+      #{result.git_cmd}, status: #{result.status}, stderr: #{result.stderr.inspect}
+    MESSAGE
+
+    # @attribute [r] result
+    #
+    # The result of the git command including the git command and its status and output
+    #
+    # @example
+    #   error.result #=> #<Git::CommandLineResult:0x00000001046bd488 ...>
+    #
+    # @return [Git::CommandLineResult]
+    #
+    attr_reader :result
+  end
+
+  # This error is raised when a git command returns a non-zero exitstatus
+  #
+  # The git command executed, status, stdout, and stderr are available from this
+  # object.
+  #
+  # @api public
+  #
+  class FailedError < Git::CommandLineError; end
+
+  # This error is raised when a git command exits because of an uncaught signal
+  #
+  # @api public
+  #
+  class SignaledError < Git::CommandLineError; end
+
+  # This error is raised when a git command takes longer than the configured timeout
+  #
+  # The git command executed, status, stdout, and stderr, and the timeout duration
+  # are available from this object.
+  #
+  # result.status.timeout? will be `true`
+  #
+  # @api public
+  #
+  class TimeoutError < Git::SignaledError
+    # Create a TimeoutError object
+    #
+    # @example
+    #   command = %w[sleep 10]
+    #   timeout_duration = 1
+    #   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'
+    #
+    # @param result [Git::CommandLineResult] the result of the git command including
+    #   the git command, status, stdout, and stderr
+    #
+    # @param timeout_duration [Numeric] the amount of time the subprocess was allowed
+    #   to run before being killed
+    #
+    def initialize(result, timeout_duration)
+      @timeout_duration = timeout_duration
+      super(result)
+    end
+
+    # 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'
+    #
+    # @return [String]
+    #
+    def error_message = <<~MESSAGE.chomp
+      #{super}, timed out after #{timeout_duration}s
+    MESSAGE
+
+    # The amount of time the subprocess was allowed to run before being killed
+    #
+    # @example
+    #   `kill -9 $$` # set $? appropriately for this example
+    #   result = Git::CommandLineResult.new(%w[git status], $?, '', "killed")
+    #   error = Git::TimeoutError.new(result, 10)
+    #   error.timeout_duration #=> 10
+    #
+    # @return [Numeric]
+    #
+    attr_reader :timeout_duration
+  end
+
+  # Raised when the output of a git command can not be read
+  #
+  # @api public
+  #
+  class ProcessIOError < Git::Error; end
+
+  # Raised when the git command result was not as expected
+  #
+  # @api public
+  #
+  class UnexpectedResultError < Git::Error; end
+end

data/lib/git/escaped_path.rb

@@ -3,7 +3,7 @@
 module Git
   # Represents an escaped Git path string
   #
-  # Git commands that output paths (e.g. ls-files, diff), will escape usual
+  # Git commands that output paths (e.g. ls-files, diff), will escape unusual
   # characters in the path with backslashes in the same way C escapes control
   # characters (e.g. \t for TAB, \n for LF, \\ for backslash) or bytes with values
   # larger than 0x80 (e.g. octal \302\265 for "micro" in UTF-8).
@@ -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)

data/lib/git/fsck_object.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+module Git
+  # Represents an object returned by `git fsck`
+  #
+  # This class provides information about dangling, missing, unreachable, or
+  # problematic Git objects found during repository integrity checks.
+  #
+  # @api public
+  #
+  class FsckObject
+    # The type of the Git object
+    # @return [Symbol] one of :commit, :tree, :blob, or :tag
+    attr_reader :type
+
+    # The SHA-1 hash of the object
+    # @return [String] the 40-character SHA-1 hash
+    attr_reader :sha
+
+    # A warning or error message associated with this object
+    # @return [String, nil] the message, or nil if no message
+    attr_reader :message
+
+    # A name describing how the object is reachable (from --name-objects)
+    # @return [String, nil] the name, or nil if not provided
+    attr_reader :name
+
+    # Create a new FsckObject
+    #
+    # @param type [Symbol] the object type (:commit, :tree, :blob, or :tag)
+    # @param sha [String] the 40-character SHA-1 hash
+    # @param message [String, nil] optional warning/error message
+    # @param name [String, nil] optional name from --name-objects (e.g., "HEAD~2^2:src/")
+    #
+    def initialize(type:, sha:, message: nil, name: nil)
+      @type = type
+      @sha = sha
+      @message = message
+      @name = name
+    end
+
+    # Returns the SHA as the string representation
+    # @return [String] the SHA-1 hash
+    def to_s
+      sha
+    end
+  end
+end

data/lib/git/fsck_result.rb

@@ -0,0 +1,121 @@
+# frozen_string_literal: true
+
+module Git
+  # Represents the result of running `git fsck`
+  #
+  # This class provides structured access to the objects found during a
+  # repository integrity check, categorized by their status.
+  #
+  # @api public
+  #
+  class FsckResult
+    # Objects not referenced by any other object
+    # @return [Array<Git::FsckObject>]
+    attr_reader :dangling
+
+    # Objects that are referenced but not present in the repository
+    # @return [Array<Git::FsckObject>]
+    attr_reader :missing
+
+    # Objects not reachable from any ref
+    # @return [Array<Git::FsckObject>]
+    attr_reader :unreachable
+
+    # Objects with warnings (each includes a message)
+    # @return [Array<Git::FsckObject>]
+    attr_reader :warnings
+
+    # Root nodes (commits with no parents) when --root is used
+    # @return [Array<Git::FsckObject>]
+    attr_reader :root
+
+    # Tagged objects when --tags is used
+    # @return [Array<Git::FsckObject>]
+    attr_reader :tagged
+
+    # rubocop:disable Metrics/ParameterLists
+
+    # Create a new FsckResult
+    #
+    # @param dangling [Array<Git::FsckObject>] dangling objects
+    # @param missing [Array<Git::FsckObject>] missing objects
+    # @param unreachable [Array<Git::FsckObject>] unreachable objects
+    # @param warnings [Array<Git::FsckObject>] objects with warnings
+    # @param root [Array<Git::FsckObject>] root nodes
+    # @param tagged [Array<Git::FsckObject>] tagged objects
+    #
+    def initialize(dangling: [], missing: [], unreachable: [], warnings: [], root: [], tagged: [])
+      @dangling = dangling
+      @missing = missing
+      @unreachable = unreachable
+      @warnings = warnings
+      @root = root
+      @tagged = tagged
+    end
+
+    # rubocop:enable Metrics/ParameterLists
+
+    # Returns true if any issues were found
+    #
+    # @return [Boolean]
+    #
+    # @example
+    #   result = git.fsck
+    #   puts "Repository has issues!" if result.any_issues?
+    #
+    def any_issues?
+      [dangling, missing, unreachable, warnings].any?(&:any?)
+    end
+
+    # Returns true if no issues were found
+    #
+    # @return [Boolean]
+    #
+    # @example
+    #   result = git.fsck
+    #   puts "Repository is clean" if result.empty?
+    #
+    def empty?
+      !any_issues?
+    end
+
+    # Returns all objects from all categories (excluding informational root/tagged)
+    #
+    # @return [Array<Git::FsckObject>]
+    #
+    # @example
+    #   result = git.fsck
+    #   result.all_objects.each { |obj| puts obj.sha }
+    #
+    def all_objects
+      dangling + missing + unreachable + warnings
+    end
+
+    # Returns the total number of issues found
+    #
+    # @return [Integer]
+    #
+    # @example
+    #   result = git.fsck
+    #   puts "Found #{result.count} issues"
+    #
+    def count
+      all_objects.size
+    end
+
+    # Returns a hash representation of the result
+    #
+    # @return [Hash{Symbol => Array<Git::FsckObject>}]
+    #
+    # @example
+    #   result = git.fsck
+    #   result.to_h # => { dangling: [...], missing: [...], ... }
+    #
+    def to_h
+      {
+        dangling: dangling, missing: missing, unreachable: unreachable,
+        warnings: warnings, root: root, tagged: tagged
+      }
+    end
+  end
+end

data/lib/git/index.rb

@@ -1,5 +1,6 @@
+# frozen_string_literal: true
+
 module Git
   class Index < Git::Path
-    
   end
 end