fix(branch): parse slash remote names

Author: jcouball

lib/git/branch_info.rb

@@ -19,11 +19,10 @@ module Git
   #   {Git::BranchInfo#refname} and normalized short-form refs (e.g., `main`,
   #   `remotes/origin/main`) used elsewhere.
   #
-  # @note This regex assumes remote names do not contain '/'. If a remote name
-  #   contains '/', parsing will be incorrect. For example, 'remotes/team/upstream/main'
-  #   would parse as remote_name='team' instead of 'team/upstream'. This is an inherent
-  #   ambiguity in git refnames that can only be resolved with knowledge of configured
-  #   remotes. See: https://github.com/ruby-git/ruby-git/issues/919
+  # @note This regex is a fallback for branch refnames parsed without configured
+  #   remote context. Remote names containing '/' can only be resolved reliably
+  #   when the parser is given the configured remote names. See:
+  #   https://github.com/ruby-git/ruby-git/issues/919
   #
   # @api private
   BRANCH_REFNAME_REGEXP = %r{
@@ -34,6 +33,10 @@ module Git
     \z                                            # end of string
   }x
 
+  # Sentinel for distinguishing omitted BranchInfo remote_name from explicit nil
+  REMOTE_NAME_NOT_GIVEN = Object.new.freeze
+  private_constant :REMOTE_NAME_NOT_GIVEN
+
   # Value object representing branch metadata from git branch output
   #
   # This is a lightweight, immutable data structure returned by branch listing
@@ -84,6 +87,11 @@ module Git
   #   @return [String] the branch refname (e.g., 'refs/heads/main',
   #     'refs/remotes/origin/main')
   #
+  # @!attribute [r] remote_name
+  #
+  #   @return [String, nil] the resolved or fallback-derived remote name, or nil
+  #     for local branches
+  #
   # @!attribute [r] target_oid
   #
   #   The commit object ID (SHA) that this branch points to (aka HEAD)
@@ -138,7 +146,64 @@ module Git
   #   @note This is the raw refname snapshot from when the branch list was read.
   #     It does not reflect live git state after the snapshot was taken.
   #
-  BranchInfo = Data.define(:refname, :target_oid, :current, :worktree_path, :symref, :upstream) do
+  BranchInfo = Data.define(:refname, :remote_name, :target_oid, :current, :worktree_path, :symref, :upstream) do
+    # @param refname [String] the full branch refname
+    #
+    # @param remote_name [String, nil] resolved remote name, nil for local branches,
+    #   or omitted to derive from `refname`
+    #
+    # @param target_oid [String, nil] the commit object ID, or nil for unborn branches
+    #
+    # @param current [Boolean] whether this branch is currently checked out
+    #
+    # @param worktree_path [String, nil] path to another linked worktree, or nil
+    #
+    # @param symref [String, nil] symbolic reference target, or nil
+    #
+    # @param upstream [String, nil] upstream refname, or nil
+    #
+    def initialize(refname:, target_oid:, current:, worktree_path:, symref:, upstream:, # rubocop:disable Metrics/ParameterLists
+                   remote_name: REMOTE_NAME_NOT_GIVEN)
+      remote_name = self.class.fallback_remote_name(refname) if remote_name.equal?(REMOTE_NAME_NOT_GIVEN)
+      self.class.validate_remote_name!(refname, remote_name)
+
+      super
+    end
+
+    # @param refname [String] the branch refname to validate
+    #
+    # @param remote_name [String, nil] the remote name to validate
+    #
+    # @return [void]
+    #
+    # @raise [ArgumentError] if the remote name contradicts the refname type
+    def self.validate_remote_name!(refname, remote_name)
+      if remote_tracking_refname?(refname)
+        unless remote_name.is_a?(String) && !remote_name.empty?
+          raise ArgumentError, 'remote_name must be a non-empty String for remote-tracking refname'
+        end
+
+        remote_ref_prefix = %r{\A(?:refs/)?remotes/#{Regexp.escape(remote_name)}/}
+        raise ArgumentError, 'remote_name must match remote-tracking refname' unless refname.match?(remote_ref_prefix)
+      elsif !remote_name.nil?
+        raise ArgumentError, 'remote_name must be nil for local branch refname'
+      end
+    end
+
+    # @param refname [String] the branch refname to parse
+    #
+    # @return [String, nil] the regex-derived remote name, or nil for local branches
+    def self.fallback_remote_name(refname)
+      refname.match(Git::BRANCH_REFNAME_REGEXP)[:remote_name]
+    end
+
+    # @param refname [String] the branch refname to inspect
+    #
+    # @return [Boolean] true if the refname is a remote-tracking refname
+    def self.remote_tracking_refname?(refname)
+      refname.match?(%r{\A(?:refs/)?remotes/[^/]+/.+})
+    end
+
     # @return [Boolean] always false for BranchInfo (see DetachedHeadInfo for detached state)
     def detached? = false
 
@@ -147,7 +212,12 @@ def unborn? = target_oid.nil?
 
     # @return [String] the short branch name without any remote or heads prefix
     #   (e.g., 'main' or 'feature/foo')
-    def short_name = refname.match(Git::BRANCH_REFNAME_REGEXP)[:branch_name]
+    def short_name
+      return refname.delete_prefix('refs/heads/') if remote_name.nil?
+
+      remote_ref_prefix = %r{\A(?:refs/)?remotes/#{Regexp.escape(remote_name)}/}
+      refname.sub(remote_ref_prefix, '')
+    end
 
     # @return [Boolean] true if this is the currently checked out branch
     def current? = current
@@ -161,9 +231,6 @@ def symref? = !symref.nil?
     # @return [Boolean] true if this is a remote-tracking branch
     def remote? = !remote_name.nil?
 
-    # @return [String, nil] the name of the remote (e.g., 'origin'), or nil for local branches
-    def remote_name = refname.match(Git::BRANCH_REFNAME_REGEXP)[:remote_name]
-
     # @return [String] string representation (the full refname)
     def to_s = refname
   end

lib/git/parsers/branch.rb

@@ -78,45 +78,74 @@ module Branch
       #
       # @param stdout [String] output from git branch --list --format=...
       #
+      # @param remote_names [Array<String>] configured remote names used to resolve
+      #   remote-tracking refs with slash-containing remote names
+      #
       # @return [Array<Git::BranchInfo>] parsed branch information
       #
-      def parse_list(stdout)
-        stdout.split("\n").filter_map { |line| parse_branch_line(line) }
+      def parse_list(stdout, remote_names: [])
+        stdout.split("\n").filter_map { |line| parse_branch_line(line, remote_names: remote_names) }
       end
 
       # Parse a single formatted branch line
       #
       # @param line [String] the line to parse (NUL-delimited fields)
       #
+      # @param remote_names [Array<String>] configured remote names used to resolve
+      #   remote-tracking refs with slash-containing remote names
+      #
       # @return [Git::BranchInfo, nil] branch info object, or nil if line should be skipped
       #
-      def parse_branch_line(line)
+      def parse_branch_line(line, remote_names: [])
         fields = line.split(FIELD_DELIMITER, 6)
 
         return nil if non_branch_entry?(fields[0])
 
-        build_branch_info(fields)
+        build_branch_info(fields, remote_names: remote_names)
       end
 
       # Build a BranchInfo from parsed fields
       #
       # @param fields [Array<String>] the parsed fields:
       #   [refname, objectname, head, worktreepath, symref, upstream]
       #
+      # @param remote_names [Array<String>] configured remote names used to resolve
+      #   remote-tracking refs with slash-containing remote names
+      #
       # @return [Git::BranchInfo] the branch info object
       #
-      def build_branch_info(fields)
+      def build_branch_info(fields, remote_names: [])
         raw_refname, objectname, head, worktreepath, symref, upstream = fields
         Git::BranchInfo.new(
           refname: raw_refname,
           target_oid: presence(objectname),
           current: head == '*',
           worktree_path: head == '*' ? nil : presence(worktreepath),
           symref: presence(symref),
-          upstream: build_upstream_info(upstream)
+          upstream: build_upstream_info(upstream),
+          remote_name: resolve_remote_name(raw_refname, remote_names)
         )
       end
 
+      # Resolve a remote-tracking refname to a configured remote name
+      #
+      # @param refname [String] the branch refname to inspect
+      #
+      # @param remote_names [Array<String>] configured remote names
+      #
+      # @return [String, nil] the resolved remote name, or nil for local branches
+      #
+      def resolve_remote_name(refname, remote_names)
+        remote_path = refname[%r{\A(?:refs/)?remotes/(.+)\z}, 1]
+        return nil if remote_path.nil?
+
+        configured_remote_name = remote_names
+                                 .select { |remote_name| remote_path.start_with?("#{remote_name}/") }
+                                 .max_by(&:length)
+
+        configured_remote_name || Git::BranchInfo.fallback_remote_name(refname)
+      end
+
       # Check if the refname represents a detached HEAD state or non-branch entry
       #
       # Git outputs special entries for detached HEAD and non-branch states:

spec/integration/git/parsers/branch_spec.rb

@@ -110,6 +110,34 @@ def git_branch_output(*args)
       end
     end
 
+    context 'with a slash-containing remote name' do
+      let(:bare_dir) { Dir.mktmpdir('bare_repo') }
+
+      after do
+        FileUtils.rm_rf(bare_dir)
+      end
+
+      before do
+        write_file('file.txt')
+        repo.add('file.txt')
+        repo.commit('Initial commit')
+
+        Git.init(bare_dir, bare: true)
+        repo.remote_add('team/upstream', bare_dir)
+        repo.push('team/upstream', 'main')
+        repo.fetch('team/upstream')
+      end
+
+      it 'resolves the remote name using configured remote names' do
+        output = git_branch_output('--remotes')
+        result = described_class.parse_list(output, remote_names: ['team/upstream'])
+        remote_branch = result.find { |branch| branch.refname == 'refs/remotes/team/upstream/main' }
+
+        expect(remote_branch.remote_name).to eq('team/upstream')
+        expect(remote_branch.short_name).to eq('main')
+      end
+    end
+
     context 'with detached HEAD' do
       before do
         write_file('file.txt')