ruby_git 0.2.0 → 0.3.0

data/lib/ruby_git/status/branch.rb

@@ -0,0 +1,92 @@
+# frozen_string_literal: true
+
+module RubyGit
+  module Status
+    # Represents git branch information
+    #
+    # @api public
+    class Branch
+      # @attribute [rw] name
+      #
+      # The name of the current branch
+      #
+      # @example
+      #   branch.name #=> 'main'
+      #
+      # @return [String, nil] branch name or nil if detached HEAD
+      #
+      # @api public
+      attr_accessor :name
+
+      # @attribute [rw] oid
+      #
+      # The object ID (hash) of the current commit
+      #
+      # @example
+      #   branch.oid #=> 'abcdef1234567890'
+      #
+      # @return [String] commit hash
+      #
+      # @api public
+      attr_accessor :oid
+
+      # @attribute [rw] upstream
+      #
+      # The name of the upstream branch
+      #
+      # @example
+      #   branch.upstream #=> 'origin/main'
+      #
+      # @return [String, nil] upstream branch name or nil if no upstream
+      #
+      # @api public
+      attr_accessor :upstream
+
+      # @attribute [rw] ahead
+      #
+      # Number of commits ahead of upstream
+      #
+      # @example
+      #   branch.ahead #=> 2
+      #
+      # @return [Integer] number of commits ahead
+      #
+      # @api public
+      attr_accessor :ahead
+
+      # @attribute [rw] behind
+      #
+      # Number of commits behind upstream
+      #
+      # @example
+      #   branch.behind #=> 3
+      #
+      # @return [Integer] number of commits behind
+      #
+      # @api public
+      attr_accessor :behind
+
+      # Check if the branch has an upstream configured
+      #
+      # @example
+      #   branch.upstream? #=> true
+      #
+      # @return [Boolean] true if upstream is configured
+      #
+      def upstream?
+        !@upstream.nil?
+      end
+
+      # Check if HEAD is detached
+      #
+      # @example
+      #   branch.detached? #=> true
+      #
+      # @return [Boolean] true if HEAD is detached
+      #
+      def detached?
+        @name.nil?
+      end
+    end
+  end
+end

data/lib/ruby_git/status/entry.rb

@@ -0,0 +1,162 @@
+# frozen_string_literal: true
+
+module RubyGit
+  module Status
+    # Base class for git status entries
+    #
+    # @api public
+    class Entry
+      # Status code mapping to symbols
+      STATUS_CODES = {
+        '.': :unmodified,
+        M: :modified,
+        T: :type_changed,
+        A: :added,
+        D: :deleted,
+        R: :renamed,
+        C: :copied,
+        U: :updated_but_unmerged,
+        '?': :untracked,
+        '!': :ignored
+      }.freeze
+
+      # Rename operation mapping to symbols
+      RENAME_OPERATIONS = {
+        'R' => :rename
+        # git status doesn't actually try to detect copies
+        # 'C' => :copy
+      }.freeze
+
+      # @attribute [r] path
+      #
+      # The path of the file
+      #
+      # @example
+      #   entry.path #=> 'lib/example.rb'
+      #
+      # @return [String] file path
+      #
+      attr_reader :path
+
+      # Initialize a new entry
+      #
+      # @example
+      #   Entry.new('lib/example.rb')
+      #
+      # @param path [String] file path
+      #
+      def initialize(path)
+        @path = path
+      end
+
+      # Convert a status code to a symbol
+      #
+      # @example
+      #   Entry.status_to_symbol('M') #=> :modified
+      #
+      # @param code [String] status code
+      # @return [Symbol] status as symbol
+      #
+      def self.status_to_symbol(code)
+        STATUS_CODES[code.to_sym] || :unknown
+      end
+
+      # Convert a rename operation to a symbol
+      #
+      # @example
+      #   Entry.rename_operation_to_symbol('R') #=> :rename
+      #
+      # @param code [String] the operation code
+      # @return [Symbol] operation as symbol
+      #
+      def self.rename_operation_to_symbol(code)
+        RENAME_OPERATIONS[code] || :unknown
+      end
+
+      # Get the staging status
+      #
+      # @example
+      #   entry.staging_status #=> :modified
+      #
+      # @return [Symbol, nil] staging status symbol or nil if not applicable
+      #
+      def index_status = nil
+
+      # Get the worktree status
+      #
+      # @example
+      #   entry.worktree_status #=> :unmodified
+      #
+      # @return [Symbol, nil] worktree status symbol or nil if not applicable
+      #
+      def worktree_status = nil
+
+      # Is the entry an ignored file?
+      #
+      # * Ignored entries are not considered untracked
+      #
+      # @example
+      #   entry.ignored? #=> false
+      #
+      # @return [Boolean]
+      #
+      def ignored? = false
+
+      # Is the entry an untracked file?
+      #
+      # * Ignored entries are not considered untracked
+      #
+      # @example
+      #   entry.ignored? #=> false
+      #
+      # @return [Boolean]
+      #
+      def untracked? = false
+
+      # Does the entry have unstaged changes in the worktree?
+      #
+      # * An entry can have both staged and unstaged changes
+      # * All untracked entries are considered unstaged
+      #
+      # @example
+      #   entry.ignored? #=> false
+      #
+      # @return [Boolean]
+      #
+      def unstaged? = false
+
+      # Does the entry have staged changes in the index?
+      #
+      # * An entry can have both staged and unstaged changes
+      #
+      # @example
+      #   entry.ignored? #=> false
+      #
+      # @return [Boolean]
+      #
+      def staged? = false
+
+      # Does the entry have staged changes in the index with no unstaged changes?
+      #
+      # * An entry can have both staged and unstaged changes
+      #
+      # @example
+      #   entry.fully_staged? #=> false
+      #
+      # @return [Boolean]
+      #
+      def fully_staged? = staged? && !unstaged?
+
+      # Does the entry represent a merge conflict?
+      #
+      # * Merge conflicts are not considered untracked, staged or unstaged
+      #
+      # @example
+      #   entry.conflict? #=> false
+      #
+      # @return [Boolean]
+      #
+      def unmerged? = false
+    end
+  end
+end

data/lib/ruby_git/status/ignored_entry.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+require_relative 'entry'
+
+module RubyGit
+  module Status
+    # Represents an ignored file in git status
+    #
+    # @api public
+    class IgnoredEntry < Entry
+      # Parse a git status line to create an ignored entry
+      #
+      # @example
+      #   IgnoredEntry.parse('!! lib/example.rb') #=> #<RubyGit::Status::IgnoredEntry:0x00000001046bd488 ...>
+      #
+      # @param line [String] line from git status
+      # @return [RubyGit::Status::IgnoredEntry] parsed entry
+      #
+      def self.parse(line)
+        tokens = line.split(' ', 2)
+        new(path: tokens[1])
+      end
+
+      # Initialize with the path
+      #
+      # @example
+      #   IgnoredEntry.new(path: 'lib/example.rb')
+      #
+      # @param path [String] file path
+      #
+      def initialize(path:)
+        super(path)
+      end
+
+      # Is the entry an ignored file?
+      # @example
+      #   entry.ignored? #=> false
+      # @return [Boolean]
+      def ignored?
+        true
+      end
+    end
+  end
+end

data/lib/ruby_git/status/ordinary_entry.rb

@@ -0,0 +1,207 @@
+# frozen_string_literal: true
+
+require_relative 'entry'
+require_relative 'submodule_status'
+
+module RubyGit
+  module Status
+    # Represents an ordinary changed file in git status
+    #
+    # @api public
+    class OrdinaryEntry < Entry
+      # @attribute [r] index_status
+      #
+      # The status in the staging area
+      #
+      # @example
+      #   entry.index_status #=> :modified
+      #
+      # @return [Symbol] staging status
+      #
+      # @api public
+      attr_reader :index_status
+
+      # @attribute [r] worktree_status
+      #
+      # The status in the worktree
+      #
+      # @example
+      #   entry.worktree_status #=> :modified
+      #
+      # @return [Symbol] worktree status
+      #
+      # @api public
+      attr_reader :worktree_status
+
+      # @attribute [r] submodule_status
+      #
+      # The submodule status if the entry is a submodule
+      #
+      # @example
+      #   entry.submodule #=> 'N...'
+      #
+      # @return [SubmoduleStatus, nil] submodule status or nil if not a submodule
+      #
+      # @api public
+      attr_reader :submodule_status
+
+      # @attribute [r] head_sha
+      #
+      # The SHA of this object in HEAD
+      #
+      # @example
+      #   entry.head_sha #=> 'd670460b4b4aece5915caf5c68d12f560a9fe3e4'
+      #
+      # @return [String] SHA of this object in HEAD
+      #
+      # @api public
+      attr_reader :head_sha
+
+      # @attribute [r] index_sha
+      #
+      # The SHA of this object in the index
+      #
+      # @example
+      #  entry.index_sha #=> 'd670460b4b4aece5915caf5c68d12f560a9fe3e4'
+      #
+      # @return [String] SHA of this object in the index
+      #
+      # @api public
+      attr_reader :index_sha
+
+      # @attribute [r] head_mode
+      #
+      # The file mode in HEAD
+      #
+      # @example
+      #   entry.head_mode #=> 0o100644
+      #
+      # @return [Integer] file mode in HEAD
+      #
+      # @api private
+      attr_reader :head_mode
+
+      # @attribute [r] index_mode
+      #
+      # The file mode in the index
+      #
+      # @example
+      #   entry.index_mode #=> 0o100644
+      #
+      # @return [Integer] file mode in the index
+      #
+      # @api private
+      attr_reader :index_mode
+
+      # @attribute [r] worktree_mode
+      #
+      # The file mode in the worktree
+      #
+      # @example
+      #   entry.worktree_mode #=> 0o100644
+      #
+      # @return [Integer] file mode in the worktree
+      #
+      # @api private
+      attr_reader :worktree_mode
+
+      # Parse an ordinary change line of git status output
+      #
+      # The line is expected to be in porcelain v2 format with NUL terminators.
+      #
+      # The format is as follows:
+      # 1 <XY> <sub> <mH> <mI> <mW> <hH> <hI> <path>
+      #
+      # @example
+      #   line = '1 M N... 100644 100644 100644 d670460b4b4aece5915caf5c68d12f560a9fe3e4 ' \
+      #     \d670460b4b4aece5915caf5c68d12f560a9fe3e4 lib/example.rb'
+      #   OrdinaryEntry.parse(line) #=> #<RubyGit::Status::OrdinaryEntry:0x00000001046bd488 ...>
+      #
+      # @param line [String] line from git status
+      #
+      # @return [RubyGit::Status::OrdinaryEntry] parsed entry
+      #
+      def self.parse(line) # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
+        tokens = line.split
+
+        new(
+          index_status: Entry.status_to_symbol(tokens[1][0]),
+          worktree_status: Entry.status_to_symbol(tokens[1][1]),
+          submodule_status: SubmoduleStatus.parse(tokens[2]),
+          head_mode: Integer(tokens[3], 8),
+          index_mode: Integer(tokens[4], 8),
+          worktree_mode: Integer(tokens[5], 8),
+          head_sha: tokens[6],
+          index_sha: tokens[7],
+          path: tokens[8]
+        )
+      end
+
+      # Initialize a new ordinary entry
+      #
+      # @example
+      #   path = 'lib/example.rb'
+      #   index_status = :modified
+      #   worktree_status = :modified
+      #   submodule_status = nil
+      #   worktree_mode = 0o100644
+      #   index_mode = 0o100644
+      #   head_mode = 0o100644
+      #   head_sha = 'd670460b4b4aece5915caf5c68d12f560a9fe3e4'
+      #   index_sha = 'd670460b4b4aece5915caf5c68d12f560a9fe3e4'
+      #   OrdinaryEntry.new(
+      #     path:, index_status:, worktree_status:, submodule_status:,
+      #     worktree_mode:, index_mode:, head_mode:, head_sha:, index_sha:
+      #   )
+      #
+      # @param path [String] file path
+      # @param index_status [Symbol] status in staging area
+      # @param worktree_status [Symbol] status in worktree
+      # @param submodule_status [SubmoduleStatus, nil] submodule status if applicable
+      # @param worktree_mode [Integer] file mode in worktree
+      # @param index_mode [Integer] file mode in staging area
+      # @param head_mode [Integer] file mode in HEAD
+      #
+      def initialize( # rubocop:disable Metrics/ParameterLists
+        path:,
+        index_status:, worktree_status:,
+        submodule_status:,
+        head_mode:, index_mode:, worktree_mode:,
+        head_sha:, index_sha:
+      )
+        super(path)
+        @index_status = index_status
+        @worktree_status = worktree_status
+        @submodule_status = submodule_status
+        @worktree_mode = worktree_mode
+        @index_mode = index_mode
+        @head_mode = head_mode
+        @head_sha = head_sha
+        @index_sha = index_sha
+      end
+
+      # Does the entry have unstaged changes in the worktree?
+      #
+      # * An entry can have both staged and unstaged changes
+      # * All untracked entries are considered unstaged
+      #
+      # @example
+      #   entry.ignored? #=> false
+      # @return [Boolean]
+      def unstaged?
+        worktree_status != :unmodified
+      end
+
+      # Does the entry have staged changes in the index?
+      #
+      # * An entry can have both staged and unstaged changes
+      #
+      # @example
+      #   entry.ignored? #=> false
+      # @return [Boolean]
+      def staged?
+        index_status != :unmodified
+      end
+    end
+  end
+end

data/lib/ruby_git/status/parser.rb

@@ -0,0 +1,203 @@
+# frozen_string_literal: true
+
+require_relative 'report'
+require_relative 'branch'
+require_relative 'stash'
+require_relative 'entry'
+require_relative 'ordinary_entry'
+require_relative 'renamed_entry'
+require_relative 'unmerged_entry'
+require_relative 'ignored_entry'
+require_relative 'untracked_entry'
+
+module RubyGit
+  module Status
+    # Parses the git status porcelain v2 format output
+    #
+    # git status --porcelain=v2 -z \
+    #   --untracked-files --ignored-files --renames \
+    #   --ahead-behind --branch --show-stash
+    #
+    # @api public
+    class Parser
+      # Parse the git status output and return a report object
+      #
+      # @example
+      #   status_output = `git status -u --porcelain=v2 --renames --branch --show-stash -z`
+      #   report = RubyGit::Status::Parser.parse(status_output) #=> #<RubyGit::Status::Report>
+      #
+      # @param status_output [String] raw git status output
+      #
+      # @return [RubyGit::Status::Report] parsed status report
+      #
+      def self.parse(status_output)
+        new(status_output).parse
+      end
+
+      # Create a new status output parser
+      #
+      # @example
+      #    status_output = `git status -u --porcelain=v2 --renames --branch --show-stash -z`
+      #    parser = RubyGit::Status::Parser.new(status_output)
+      #
+      # @param status_output [String] raw git status output
+      #
+      def initialize(status_output)
+        @status_output = status_output
+        @entries = []
+        @branch = nil
+        @stash = Stash.new(0)
+      end
+
+      # Parse the git status output
+      #
+      # @example
+      #   status_output = `git status -u --porcelain=v2 --renames --branch --show-stash -z`
+      #   parser = RubyGit::Status::Parser.new(status_output)
+      #   parser.parse #=> #<RubyGit::Status::Report>
+      #
+      # @return [RubyGit::Status::Report] parsed status report
+      #
+      def parse
+        process_lines(status_output_lines)
+
+        Report.new(@branch, @stash, @entries)
+      end
+
+      # Define the parser for each line type
+      LINE_PARSER_FACTORY = {
+        '1' => ->(line) { OrdinaryEntry.parse(line) },
+        '2' => ->(line) { RenamedEntry.parse(line) },
+        'u' => ->(line) { UnmergedEntry.parse(line) },
+        '!' => ->(line) { IgnoredEntry.parse(line) },
+        '?' => ->(line) { UntrackedEntry.parse(line) }
+      }.freeze
+
+      private
+
+      # Process the split lines of git status output
+      #
+      # @param lines [Array<String>] lines from git status output
+      # @return [void]
+      #
+      # @api private
+      def process_lines(lines)
+        # Use the LINE_PARSER_FACTORY to parse each line
+        # based on the first character like the code below
+        lines.each do |line|
+          next if line.empty?
+
+          if line.start_with?('#')
+            parse_header_line(line)
+          else
+            @entries << LINE_PARSER_FACTORY[line[0]].call(line)
+          end
+        end
+      end
+
+      # Parse a header line (starts with #)
+      #
+      # @param line [String] header line from git status
+      #
+      # @return [void]
+      #
+      # @api private
+      def parse_header_line(line)
+        tokens = line.split
+        header_type = tokens[1]
+
+        process_header(header_type, tokens)
+      end
+
+      # Split the status output into lines
+      #
+      # This is more complicated than a simple split because
+      # the lines are NUL terminated but some entries have
+      # also use NUL as a field separator (e.g. renamed entries).
+      #
+      # @return [Array<String>] split lines
+      #
+      # @api private
+      #
+      def status_output_lines
+        parts = @status_output.split("\u0000")
+        [].tap do |lines|
+          until parts.empty?
+            next_entry_type = parts.first[0]
+            lines << parts.shift
+            lines[-1] = "#{lines[-1]}\u0000#{parts.shift}" if next_entry_type == '2'
+          end
+        end
+      end
+
+      # Info from the status_output about the branch
+      # @return [Branch]
+      # @api private
+      def branch = @branch ||= Branch.new
+
+      # Info about the stashes about stashes
+      # @return [Stash]
+      # @api private
+      attr_reader :stash
+
+      # Branch name setter that handles detached HEAD
+      # @param name [String] branch name
+      # @return [void]
+      # @api private
+      def branch_name=(name)
+        branch.name = name unless name == '(detached)'
+      end
+
+      # Branch oid setter that handles initial commit
+      # @param oid [String] branch oid
+      # @return [void]
+      # @api private
+      def branch_oid=(oid)
+        branch.oid = oid unless oid == '(initial)'
+      end
+
+      # Branch upstream setter
+      # @param upstream [String] branch upstream
+      # @return [void]
+      # @api private
+      def branch_upstream=(upstream)
+        branch.upstream = upstream
+      end
+
+      # Branch ahead setter that converts from string to integer
+      # @param ahead [String] branch ahead
+      # @return [void]
+      # @api private
+      def branch_ahead=(ahead)
+        branch.ahead = ahead.sub('+', '').to_i
+      end
+
+      # Branch behind setter that converts from string to integer
+      # @param behind [String] branch behind
+      # @return [void]
+      # @api private
+      def branch_behind=(behind)
+        branch.behind = behind.sub('-', '').to_i
+      end
+
+      # Process a specific header type with its tokens
+      #
+      # @param header_type [String] type of header
+      # @param tokens [Array<String>] tokens from header line
+      # @return [void]
+      #
+      # @api private
+      def process_header(header_type, tokens)
+        case header_type
+        when 'branch.head' then self.branch_name = tokens[2]
+        when 'branch.oid' then self.branch_oid = tokens[2]
+        when 'branch.upstream' then self.branch_upstream = tokens[2]
+        when 'branch.ab'
+          self.branch_ahead = tokens[2]
+          self.branch_behind = tokens[3]
+        when 'stash' then stash.count = tokens[2].to_i
+        end
+      end
+    end
+  end
+end