git 1.19.1 → 5.5.0

data/lib/git/parsers/fsck.rb

@@ -0,0 +1,144 @@
+# frozen_string_literal: true
+
+require 'git/fsck_object'
+require 'git/fsck_result'
+
+module Git
+  module Parsers
+    # Parser for git fsck command output
+    #
+    # Handles parsing of `git fsck` output into structured data objects
+    # for dangling, missing, unreachable objects, warnings, roots, and tagged objects.
+    #
+    # ## Design Note: Namespace Organization
+    #
+    # This parser creates and returns {Git::FsckObject} and {Git::FsckResult}
+    # objects, which live at the top-level `Git::` namespace rather than within
+    # `Git::Parsers::`. This is intentional:
+    #
+    # - **Parsers are infrastructure** - marked `@api private`, users shouldn't
+    #   interact with them directly
+    # - **Result classes are public API** - returned by commands and used
+    #   throughout the codebase
+    # - **FsckObject and FsckResult represent operation outcomes** - they describe
+    #   repository integrity status, not parsing details
+    #
+    # Keeping these classes at `Git::` improves discoverability and correctly
+    # reflects their role as public types rather than parser internals.
+    #
+    # @api private
+    #
+    module Fsck
+      # Pattern matcher for dangling/missing/unreachable object lines
+      # Matches lines like:
+      #   dangling commit abc123...
+      #   missing blob def456...
+      #   unreachable tree 789abc... (name)
+      OBJECT_PATTERN = /\A(dangling|missing|unreachable) (\w+) ([0-9a-f]{40})(?: \((.+)\))?\z/
+
+      # Pattern matcher for warning lines
+      # Matches lines like:
+      #   warning in commit abc123...: message here
+      WARNING_PATTERN = /\Awarning in (\w+) ([0-9a-f]{40}): (.+)\z/
+
+      # Pattern matcher for root commit lines
+      # Matches lines like:
+      #   root abc123...
+      ROOT_PATTERN = /\Aroot ([0-9a-f]{40})\z/
+
+      # Pattern matcher for tagged object lines
+      # Matches lines like:
+      #   tagged commit abc123... (tagname) in def456...
+      TAGGED_PATTERN = /\Atagged (\w+) ([0-9a-f]{40}) \((.+)\) in ([0-9a-f]{40})\z/
+
+      module_function
+
+      # Parse git fsck output into a FsckResult object
+      #
+      # @example
+      #   FsckParser.parse("dangling commit abc123...\nmissing blob def456...\n")
+      #   # => #<Git::FsckResult dangling: [...], missing: [...]>
+      #
+      # @param stdout [String] output from git fsck command
+      #
+      # @return [Git::FsckResult] the parsed result
+      #
+      def parse(stdout)
+        result = { dangling: [], missing: [], unreachable: [], warnings: [], root: [], tagged: [] }
+        stdout.each_line { |line| parse_line(line.strip, result) }
+        Git::FsckResult.new(**result)
+      end
+
+      # Parse a single line of fsck output
+      #
+      # @param line [String] a line of output
+      #
+      # @param result [Hash] the result hash to populate
+      #
+      # @return [Boolean] true if the line was parsed
+      #
+      def parse_line(line, result)
+        parse_object_line(line, result) ||
+          parse_warning_line(line, result) ||
+          parse_root_line(line, result) ||
+          parse_tagged_line(line, result)
+      end
+
+      # Parse a dangling/missing/unreachable object line
+      #
+      # @param line [String] a line of output
+      #
+      # @param result [Hash] the result hash to populate
+      #
+      # @return [Boolean] true if the line was parsed
+      #
+      def parse_object_line(line, result)
+        return unless (match = OBJECT_PATTERN.match(line))
+
+        result[match[1].to_sym] << Git::FsckObject.new(type: match[2].to_sym, oid: match[3], name: match[4])
+      end
+
+      # Parse a warning line
+      #
+      # @param line [String] a line of output
+      #
+      # @param result [Hash] the result hash to populate
+      #
+      # @return [Boolean] true if the line was parsed
+      #
+      def parse_warning_line(line, result)
+        return unless (match = WARNING_PATTERN.match(line))
+
+        result[:warnings] << Git::FsckObject.new(type: match[1].to_sym, oid: match[2], message: match[3])
+      end
+
+      # Parse a root line
+      #
+      # @param line [String] a line of output
+      #
+      # @param result [Hash] the result hash to populate
+      #
+      # @return [Boolean] true if the line was parsed
+      #
+      def parse_root_line(line, result)
+        return unless (match = ROOT_PATTERN.match(line))
+
+        result[:root] << Git::FsckObject.new(type: :commit, oid: match[1])
+      end
+
+      # Parse a tagged line
+      #
+      # @param line [String] a line of output
+      #
+      # @param result [Hash] the result hash to populate
+      #
+      # @return [Boolean] true if the line was parsed
+      #
+      def parse_tagged_line(line, result)
+        return unless (match = TAGGED_PATTERN.match(line))
+
+        result[:tagged] << Git::FsckObject.new(type: match[1].to_sym, oid: match[2], name: match[3])
+      end
+    end
+  end
+end

data/lib/git/parsers/grep.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module Git
+  module Parsers
+    # Parser for `git grep` output
+    #
+    # Provides a class method that transforms raw `git grep --null` output into a
+    # structured Hash consumed by the `Git::Repository::ObjectOperations` facade.
+    #
+    # This parser is a pure text transformer with no exit-status logic. The
+    # calling facade is responsible for interpreting the command's exit status
+    # before delegating output parsing to this class.
+    #
+    # @api private
+    #
+    module Grep
+      module_function
+
+      # Parse `git grep --line-number --null --no-color` output into a match hash
+      #
+      # With `--null`, git separates the path and line number fields with NUL
+      # bytes: `treeish:filename\0linenum\0text\n`. This keeps filenames that
+      # contain `:<digits>:` from being confused with the line-number delimiter.
+      #
+      # @param output [String] raw output from `git grep --null --line-number`
+      #
+      # @return [Hash<String, Array<Array(Integer, String)>>] hash mapping
+      #   `"treeish:filename"` keys to arrays of `[line_number, text]` pairs
+      #
+      # @api private
+      #
+      def parse(output)
+        output.each_line.with_object(Hash.new { |h, k| h[k] = [] }) do |line, hsh|
+          filename, line_num, text = line.chomp.split("\0", 3)
+          next unless text && line_num.match?(/\A\d+\z/)
+
+          hsh[filename] << [line_num.to_i, text]
+        end
+      end
+    end
+  end
+end

data/lib/git/parsers/ls_remote.rb

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+module Git
+  module Parsers
+    # Parser for `git ls-remote` command output
+    #
+    # @api private
+    #
+    module LsRemote
+      module_function
+
+      # Parse `git ls-remote` stdout lines into a structured Hash
+      #
+      # @param lines [Array<String>] the individual stdout lines
+      #
+      # @return [Hash{String => Hash}] a map of ref type to ref data
+      #
+      #   The structure differs by key:
+      #
+      #   - `"head"` maps directly to `{ ref: String, sha: String }`
+      #   - Other keys (e.g. `"branches"`, `"tags"`) map to
+      #     `{ name => { ref: String, sha: String } }`
+      #
+      def parse_output(lines)
+        lines.each_with_object(Hash.new { |h, k| h[k] = {} }) do |line, hsh|
+          type, name, value = parse_line(line)
+          if name
+            hsh[type][name] = value
+          else
+            hsh[type].update(value)
+          end
+        end
+      end
+
+      # Parse a single `git ls-remote` output line
+      #
+      # @param line [String] a single line from ls-remote stdout
+      #
+      # @return [Array(String, (String, nil), Hash)] `[type, name, value]` where
+      #   `value` is `{ ref: String, sha: String }`
+      #
+      # @raise [Git::UnexpectedResultError] if the line is not in `<sha>\t<ref>` format
+      #
+      def parse_line(line)
+        unless line.include?("\t") && line.match?(/\A[0-9a-f]{4,}\t/)
+          raise Git::UnexpectedResultError, "Unexpected ls-remote output line: #{line.inspect}"
+        end
+
+        sha, info = line.split("\t", 2)
+        _, type, name = info.split('/', 3)
+
+        type ||= 'head'
+        type = 'branches' if type == 'heads'
+
+        value = { ref: info, sha: sha }
+
+        [type, name, value]
+      end
+
+      # Parse `git ls-remote --symref <repo> HEAD` output into a branch name
+      #
+      # @param output [String] command stdout
+      #
+      # @return [String] the default branch name
+      #
+      # @raise [Git::UnexpectedResultError] when the branch cannot be determined
+      #
+      def parse_default_branch(output)
+        match_data = output.match(%r{^ref: refs/remotes/[^/]+/(?<default_branch>[^\t]+)\t})
+        return match_data[:default_branch] if match_data
+
+        match_data = output.match(%r{^ref: refs/heads/(?<default_branch>[^\t]+)\tHEAD$})
+        return match_data[:default_branch] if match_data
+
+        raise Git::UnexpectedResultError, 'Unable to determine the default branch'
+      end
+    end
+  end
+end

data/lib/git/parsers/ls_tree.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+require 'git/escaped_path'
+
+module Git
+  module Parsers
+    # Parser for `git ls-tree` output
+    #
+    # Provides a class method that transforms raw `git ls-tree` output into a
+    # structured Hash consumed by the `Git::Repository::ObjectOperations` facade.
+    #
+    # @api private
+    #
+    module LsTree
+      module_function
+
+      # Parse `git ls-tree` output into a type-keyed hash of entries
+      #
+      # Each line of output is expected in the format produced by
+      # `git ls-tree`: `<mode> <type> <sha>\t<file>`.
+      #
+      # @param output [String] raw stdout from `git ls-tree`
+      #
+      # @return [Hash<String, Hash<String, Hash>>] hash keyed by object type
+      #   (`'blob'`, `'tree'`, `'commit'`), then by filename, holding
+      #   `:mode` and `:sha` values
+      #
+      # @api private
+      #
+      def parse(output)
+        data = { 'blob' => {}, 'tree' => {}, 'commit' => {} }
+        output.split("\n").each do |line|
+          info, filenm = line.split("\t", 2)
+          filenm = unescape_path(filenm) if filenm
+          mode, type, entry_sha = info.split
+          data[type][filenm] = { mode: mode, sha: entry_sha }
+        end
+        data
+      end
+
+      # Converts a git-quoted path back to its original form
+      #
+      # @param path [String] the path, possibly git-quoted
+      #
+      # @return [String] the unquoted path
+      #
+      # @api private
+      #
+      def unescape_path(path)
+        if path.start_with?('"') && path.end_with?('"')
+          Git::EscapedPath.new(path[1..-2]).unescape
+        else
+          path
+        end
+      end
+    end
+  end
+end

data/lib/git/parsers/remote.rb

@@ -0,0 +1,162 @@
+# frozen_string_literal: true
+
+require 'git/config_entry_info'
+require 'git/remote_info'
+
+module Git
+  module Parsers
+    # Parser that builds {Git::RemoteInfo} objects from git config entries
+    #
+    # Accepts `Array<Git::ConfigEntryInfo>` as returned by
+    # {Git::Configuring#config_list} and groups entries by remote name,
+    # collecting multi-value fields and coercing boolean values.
+    #
+    # @api private
+    #
+    module Remote
+      module_function
+
+      # Parse an array of config entries into an array of RemoteInfo objects
+      #
+      # Groups entries whose key matches `remote.<name>.<variable>` by remote
+      # name and builds one {Git::RemoteInfo} per unique remote name.
+      #
+      # Non-remote config entries (keys that do not start with `remote.`) are
+      # silently ignored.
+      #
+      # @param config_entries [Array<Git::ConfigEntryInfo>] all config entries
+      #   to inspect; may contain non-remote entries
+      #
+      # @return [Array<Git::RemoteInfo>] one entry per unique remote name, in
+      #   the order the first entry for each name appeared in `config_entries`
+      #
+      # @raise [ArgumentError] if a boolean config field carries an unrecognized
+      #   value (mirrors git's own fatal-error behavior)
+      #
+      def parse_list(config_entries)
+        group_by_remote(config_entries).map { |name, pairs| build_remote_info(name, pairs) }
+      end
+
+      # Group config entries by remote name, collecting variable/value pairs
+      #
+      # @param config_entries [Array<Git::ConfigEntryInfo>]
+      #
+      # @return [Hash{String => Array}] remote name to variable/value pairs
+      #
+      # @api private
+      #
+      def group_by_remote(config_entries)
+        config_entries.each_with_object({}) do |entry, groups|
+          next unless entry.section == 'remote' && !entry.subsection.empty?
+
+          remote_name = entry.subsection
+          variable    = entry.variable.downcase
+          groups[remote_name] ||= []
+          groups[remote_name] << [variable, entry.value]
+        end
+      end
+
+      # Config variable names that hold arrays of strings
+      ARRAY_VARIABLES = %w[url pushurl fetch push].freeze
+      private_constant :ARRAY_VARIABLES
+
+      # Config variable names that hold boolean values
+      BOOLEAN_VARIABLES = %w[mirror skipdefaultupdate prune prunetags promisor].freeze
+      private_constant :BOOLEAN_VARIABLES
+
+      # Map from git config variable name to RemoteInfo field name (symbol)
+      #
+      # All keys are lowercase because `git config --list` unconditionally
+      # lowercases section names and variable names (subsection names are
+      # case-preserved, but are never used as lookup keys here).
+      VARIABLE_TO_FIELD = {
+        'url' => :url,
+        'pushurl' => :push_url,
+        'fetch' => :fetch,
+        'push' => :push,
+        'mirror' => :mirror,
+        'skipdefaultupdate' => :skip_default_update,
+        'tagopt' => :tag_opt,
+        'prune' => :prune,
+        'prunetags' => :prune_tags,
+        'receivepack' => :receivepack,
+        'uploadpack' => :uploadpack,
+        'promisor' => :promisor,
+        'partialclonefilter' => :partial_clone_filter,
+        'vcs' => :vcs
+      }.freeze
+      private_constant :VARIABLE_TO_FIELD
+
+      # True string values per git's boolean rules
+      BOOL_TRUE_VALUES = %w[true yes on 1].freeze
+      private_constant :BOOL_TRUE_VALUES
+
+      # False string values per git's boolean rules
+      BOOL_FALSE_VALUES = %w[false no off 0].freeze
+      private_constant :BOOL_FALSE_VALUES
+
+      # Build a RemoteInfo from grouped variable/value pairs
+      #
+      # @param remote_name [String]
+      #
+      # @param pairs [Array] variable/value pairs collected from config entries
+      #
+      # @return [Git::RemoteInfo]
+      #
+      # @api private
+      #
+      def build_remote_info(remote_name, pairs)
+        attrs = { name: remote_name }
+        pairs.each { |variable, value| apply_pair(attrs, variable, value) }
+        Git::RemoteInfo.new(**attrs)
+      end
+
+      # Apply a single variable/value pair to an attrs hash
+      #
+      # @param attrs [Hash] accumulator of RemoteInfo keyword arguments
+      #
+      # @param variable [String] git config variable name (e.g. 'url', 'tagopt')
+      #
+      # @param value [String] raw config value
+      #
+      # @return [void]
+      #
+      # @api private
+      #
+      def apply_pair(attrs, variable, value)
+        field = VARIABLE_TO_FIELD[variable]
+        return unless field # ignore unknown variables
+
+        if ARRAY_VARIABLES.include?(variable)
+          attrs[field] ||= []
+          attrs[field] << value
+        elsif BOOLEAN_VARIABLES.include?(variable)
+          attrs[field] = coerce_boolean(variable, value)
+        else
+          attrs[field] = value
+        end
+      end
+
+      # Coerce a git config boolean string to a Ruby boolean
+      #
+      # @param variable [String] the config variable name (for error messages)
+      #
+      # @param value [String] the raw string value from git config
+      #
+      # @return [Boolean] `true` or `false`
+      #
+      # @raise [ArgumentError] if the value is not a recognized boolean
+      #
+      # @api private
+      #
+      def coerce_boolean(variable, value)
+        normalized = value.downcase
+        return true  if BOOL_TRUE_VALUES.include?(normalized) || normalized == ''
+        return false if BOOL_FALSE_VALUES.include?(normalized)
+
+        raise ArgumentError,
+              "unrecognized boolean value #{value.inspect} for config variable #{variable.inspect}"
+      end
+    end
+  end
+end