ruby-lsp 0.23.15 → 0.26.9

data/lib/ruby_lsp/listeners/spec_style.rb

@@ -4,151 +4,227 @@
 module RubyLsp
   module Listeners
     class SpecStyle < TestDiscovery
-      extend T::Sig
+      class Group
+        #: String
+        attr_reader :id
 
-      #: (response_builder: ResponseBuilders::TestCollection, global_state: GlobalState, dispatcher: Prism::Dispatcher, uri: URI::Generic) -> void
+        #: (String) -> void
+        def initialize(id)
+          @id = id
+        end
+      end
+
+      class ClassGroup < Group; end
+      class DescribeGroup < Group; end
+
+      #: (ResponseBuilders::TestCollection, GlobalState, Prism::Dispatcher, URI::Generic) -> void
       def initialize(response_builder, global_state, dispatcher, uri)
-        super
+        super(response_builder, global_state, uri)
 
-        @describe_block_nesting = [] #: Array[String]
-        @spec_class_stack = [] #: Array[bool]
+        @spec_group_id_stack = [] #: Array[Group?]
 
-        dispatcher.register(
-          self,
-          # Common handlers registered in parent class
+        register_events(
+          dispatcher,
           :on_class_node_enter,
-          :on_call_node_enter, # e.g. `describe` or `it`
+          :on_call_node_enter,
           :on_call_node_leave,
         )
       end
 
-      #: (node: Prism::ClassNode) -> void
-      def on_class_node_enter(node)
-        with_test_ancestor_tracking(node) do |_, ancestors|
-          is_spec = ancestors.include?("Minitest::Spec")
-          @spec_class_stack.push(is_spec)
+      #: (Prism::ClassNode) -> void
+      def on_class_node_enter(node) # rubocop:disable RubyLsp/UseRegisterWithHandlerMethod
+        with_test_ancestor_tracking(node) do |name, ancestors|
+          @spec_group_id_stack << (ancestors.include?("Minitest::Spec") ? ClassGroup.new(name) : nil)
         end
       end
 
-      #: (node: Prism::ClassNode) -> void
+      #: (Prism::ClassNode) -> void
       def on_class_node_leave(node) # rubocop:disable RubyLsp/UseRegisterWithHandlerMethod
+        @spec_group_id_stack.pop
+        super
+      end
+
+      #: (Prism::ModuleNode) -> void
+      def on_module_node_enter(node) # rubocop:disable RubyLsp/UseRegisterWithHandlerMethod
+        @spec_group_id_stack << nil
         super
+      end
 
-        @spec_class_stack.pop
+      #: (Prism::ModuleNode) -> void
+      def on_module_node_leave(node) # rubocop:disable RubyLsp/UseRegisterWithHandlerMethod
+        @spec_group_id_stack.pop
+        super
       end
 
-      #: (node: Prism::CallNode) -> void
-      def on_call_node_enter(node)
+      #: (Prism::CallNode) -> void
+      def on_call_node_enter(node) # rubocop:disable RubyLsp/UseRegisterWithHandlerMethod
         case node.name
         when :describe
           handle_describe(node)
         when :it, :specify
-          handle_example(node)
+          handle_example(node) if in_spec_context?
         end
       end
 
-      #: (node: Prism::CallNode) -> void
-      def on_call_node_leave(node)
+      #: (Prism::CallNode) -> void
+      def on_call_node_leave(node) # rubocop:disable RubyLsp/UseRegisterWithHandlerMethod
         return unless node.name == :describe && !node.receiver
 
-        @describe_block_nesting.pop
+        current_group = @spec_group_id_stack.last
+        return unless current_group.is_a?(DescribeGroup)
+
+        description = extract_description(node)
+        return unless description && current_group.id.end_with?(description)
+
+        @spec_group_id_stack.pop
       end
 
       private
 
-      #: (node: Prism::CallNode) -> void
+      #: (Prism::CallNode) -> void
       def handle_describe(node)
+        # Describes will include the nesting of all classes and all outer describes as part of its ID, unlike classes
+        # that ignore describes
         return if node.block.nil?
 
         description = extract_description(node)
         return unless description
 
-        return unless in_spec_context?
-
-        if @nesting.empty? && @describe_block_nesting.empty?
-          test_item = Requests::Support::TestItem.new(
-            description,
-            description,
-            @uri,
-            range_from_node(node),
-            framework: :minitest,
-          )
-          @response_builder.add(test_item)
+        parent = latest_group
+        return unless parent
+
+        id = case parent
+        when Requests::Support::TestItem
+          "#{parent.id}::#{description}"
         else
-          add_to_parent_test_group(description, node)
+          description
         end
 
-        @describe_block_nesting << description
+        test_item = Requests::Support::TestItem.new(
+          id,
+          description,
+          @uri,
+          range_from_node(node),
+          framework: :minitest,
+        )
+
+        parent.add(test_item)
+        @response_builder.add_code_lens(test_item)
+        @spec_group_id_stack << DescribeGroup.new(id)
       end
 
-      #: (node: Prism::CallNode) -> void
+      #: (Prism::CallNode) -> void
       def handle_example(node)
-        return unless in_spec_context?
+        description = extract_it_description(node)
+        line = node.location.start_line - 1
+        parent = latest_group
+        return unless parent.is_a?(Requests::Support::TestItem)
 
-        return if @describe_block_nesting.empty? && @nesting.empty?
-
-        description = extract_description(node)
-        return unless description
-
-        add_to_parent_test_group(description, node)
-      end
-
-      #: (description: String, node: Prism::CallNode) -> void
-      def add_to_parent_test_group(description, node)
-        parent_test_group = find_parent_test_group
-        return unless parent_test_group
+        id = "#{parent.id}##{format("test_%04d_%s", line, description)}"
 
         test_item = Requests::Support::TestItem.new(
-          description,
+          id,
           description,
           @uri,
           range_from_node(node),
           framework: :minitest,
         )
-        parent_test_group.add(test_item)
-      end
-
-      #: -> Requests::Support::TestItem?
-      def find_parent_test_group
-        root_group_name, nested_describe_groups = if @nesting.empty?
-          [@describe_block_nesting.first, @describe_block_nesting[1..]]
-        else
-          [RubyIndexer::Index.actual_nesting(@nesting, nil).join("::"), @describe_block_nesting]
-        end
-        return unless root_group_name
 
-        test_group = @response_builder[root_group_name] #: Requests::Support::TestItem?
-        return unless test_group
+        parent.add(test_item)
+        @response_builder.add_code_lens(test_item)
+      end
 
-        return test_group unless nested_describe_groups
+      #: (Prism::CallNode) -> String?
+      def extract_description(node)
+        arguments = node.arguments&.arguments
+        return unless arguments
 
-        nested_describe_groups.each do |description|
-          test_group = test_group[description]
-        end
+        parts = arguments.map { |arg| extract_argument_content(arg) }
+        return if parts.empty?
 
-        test_group
+        parts.join("::")
       end
 
-      #: (node: Prism::CallNode) -> String?
-      def extract_description(node)
+      #: (Prism::CallNode) -> String
+      def extract_it_description(node)
+        # Minitest formats the descriptions into test method names by using the count of examples with the description
+        # We are not guaranteed to discover examples in the exact order using static analysis, so we use the line number
+        # instead. Note that anonymous examples mixed with meta-programming will not be handled correctly
         first_argument = node.arguments&.arguments&.first
-        return unless first_argument
+        return "anonymous" unless first_argument
+
+        extract_argument_content(first_argument) || "anonymous"
+      end
 
-        case first_argument
+      #: (Prism::Node) -> String?
+      def extract_argument_content(arg)
+        case arg
         when Prism::StringNode
-          first_argument.content
+          arg.content
+        when Prism::SymbolNode
+          arg.value
         when Prism::ConstantReadNode, Prism::ConstantPathNode
-          constant_name(first_argument)
+          constant_name(arg)
         else
-          first_argument.slice
+          arg.slice
         end
       end
 
+      #: -> (Requests::Support::TestItem | ResponseBuilders::TestCollection)?
+      def latest_group
+        # If we haven't found anything yet, then return the response builder
+        return @response_builder if @spec_group_id_stack.compact.empty?
+        # If we found something that isn't a group last, then we're inside a random module or class, but not a spec
+        # group
+        return unless @spec_group_id_stack.last
+
+        # Specs using at least one class as a group require special handling
+        closest_class_index = @spec_group_id_stack.rindex { |i| i.is_a?(ClassGroup) }
+
+        if closest_class_index
+          first_class_index = @spec_group_id_stack.index { |i| i.is_a?(ClassGroup) } #: as !nil
+          first_class = @spec_group_id_stack[first_class_index] #: as !nil
+          item = @response_builder[first_class.id] #: as !nil
+
+          # Descend into child items from the beginning all the way to the latest class group, ignoring describes
+          @spec_group_id_stack[first_class_index + 1..closest_class_index] #: as !nil
+            .each do |group|
+            next unless group.is_a?(ClassGroup)
+
+            item = item[group.id] #: as !nil
+          end
+
+          # From the class forward, we must take describes into account
+          @spec_group_id_stack[closest_class_index + 1..] #: as !nil
+            .each do |group|
+            next unless group
+
+            item = item[group.id] #: as !nil
+          end
+
+          return item
+        end
+
+        # Specs only using describes
+        first_group_index = @spec_group_id_stack.index { |i| i.is_a?(DescribeGroup) }
+        return unless first_group_index
+
+        first_group = @spec_group_id_stack[first_group_index] #: as !nil
+        item = @response_builder[first_group.id] #: as !nil
+
+        @spec_group_id_stack[first_group_index + 1..] #: as !nil
+          .each do |group|
+          next unless group.is_a?(DescribeGroup)
+
+          item = item[group.id] #: as !nil
+        end
+
+        item
+      end
+
       #: -> bool
       def in_spec_context?
-        return true if @nesting.empty?
-
-        @spec_class_stack.last #: as !nil
+        @nesting.empty? || @spec_group_id_stack.any? { |id| id }
       end
     end
   end

data/lib/ruby_lsp/listeners/test_discovery.rb

@@ -3,32 +3,23 @@
 
 module RubyLsp
   module Listeners
+    # @abstract
     class TestDiscovery
-      extend T::Helpers
-      abstract!
-
       include Requests::Support::Common
 
       DYNAMIC_REFERENCE_MARKER = "<dynamic_reference>"
 
-      #: (ResponseBuilders::TestCollection response_builder, GlobalState global_state, Prism::Dispatcher dispatcher, URI::Generic uri) -> void
-      def initialize(response_builder, global_state, dispatcher, uri)
+      #: (ResponseBuilders::TestCollection response_builder, GlobalState global_state, URI::Generic uri) -> void
+      def initialize(response_builder, global_state, uri)
         @response_builder = response_builder
         @uri = uri
         @index = global_state.index #: RubyIndexer::Index
         @visibility_stack = [:public] #: Array[Symbol]
         @nesting = [] #: Array[String]
-
-        dispatcher.register(
-          self,
-          :on_class_node_leave,
-          :on_module_node_enter,
-          :on_module_node_leave,
-        )
       end
 
       #: (Prism::ModuleNode node) -> void
-      def on_module_node_enter(node)
+      def on_module_node_enter(node) # rubocop:disable RubyLsp/UseRegisterWithHandlerMethod
         @visibility_stack << :public
 
         name = constant_name(node.constant_path)
@@ -38,19 +29,31 @@ module RubyLsp
       end
 
       #: (Prism::ModuleNode node) -> void
-      def on_module_node_leave(node)
+      def on_module_node_leave(node) # rubocop:disable RubyLsp/UseRegisterWithHandlerMethod
         @visibility_stack.pop
         @nesting.pop
       end
 
       #: (Prism::ClassNode node) -> void
-      def on_class_node_leave(node)
+      def on_class_node_leave(node) # rubocop:disable RubyLsp/UseRegisterWithHandlerMethod
         @visibility_stack.pop
         @nesting.pop
       end
 
       private
 
+      #: (Prism::Dispatcher, *Symbol) -> void
+      def register_events(dispatcher, *events)
+        unique_events = events.dup.push(
+          :on_class_node_leave,
+          :on_module_node_enter,
+          :on_module_node_leave,
+        )
+
+        unique_events.uniq!
+        dispatcher.register(self, *unique_events)
+      end
+
       #: (String? name) -> String
       def calc_fully_qualified_name(name)
         RubyIndexer::Index.actual_nesting(@nesting, name).join("::")
@@ -58,11 +61,26 @@ module RubyLsp
 
       #: (Prism::ClassNode node, String fully_qualified_name) -> Array[String]
       def calc_attached_ancestors(node, fully_qualified_name)
-        @index.linearized_ancestors_of(fully_qualified_name)
-      rescue RubyIndexer::Index::NonExistingNamespaceError
-        # When there are dynamic parts in the constant path, we will not have indexed the namespace. We can still
-        # provide test functionality if the class inherits directly from Test::Unit::TestCase or Minitest::Test
-        [node.superclass&.slice].compact
+        superclass = node.superclass
+
+        begin
+          ancestors = @index.linearized_ancestors_of(fully_qualified_name)
+          # If the project has no bundle and a test class inherits from `Minitest::Test`, the linearized ancestors will
+          # not include the parent class because we never indexed it in the first place. Here we add the superclass
+          # directly, so that we can support running tests in projects without a bundle
+          return ancestors if ancestors.length > 1
+
+          # If all we found is the class itself, then manually include the parent class
+          if ancestors.first == fully_qualified_name && superclass
+            return [*ancestors, superclass.slice]
+          end
+
+          ancestors
+        rescue RubyIndexer::Index::NonExistingNamespaceError
+          # When there are dynamic parts in the constant path, we will not have indexed the namespace. We can still
+          # provide test functionality if the class inherits directly from Test::Unit::TestCase or Minitest::Test
+          [superclass&.slice].compact
+        end
       end
 
       #: (Prism::ConstantPathNode | Prism::ConstantReadNode | Prism::ConstantPathTargetNode | Prism::CallNode | Prism::MissingNode node) -> String
@@ -71,7 +89,7 @@ module RubyLsp
         slice.gsub(/((?<=::)|^)[a-z]\w*/, DYNAMIC_REFERENCE_MARKER)
       end
 
-      #: (Prism::ClassNode node, ^(String name, Array[String] ancestors) -> void block) -> void
+      #: (Prism::ClassNode node) { (String name, Array[String] ancestors) -> void } -> void
       def with_test_ancestor_tracking(node, &block)
         @visibility_stack << :public
         name = constant_name(node.constant_path)

data/lib/ruby_lsp/listeners/test_style.rb

@@ -33,18 +33,20 @@ module RubyLsp
 
             if tags.include?("test_dir")
               if children.empty?
-                full_files.concat(Dir.glob(
-                  "#{path}/**/{*_test,test_*}.rb",
-                  File::Constants::FNM_EXTGLOB | File::Constants::FNM_PATHNAME,
-                ))
+                full_files.concat(
+                  Dir.glob(
+                    "#{path}/**/{*_test,test_*,*_spec}.rb",
+                    File::Constants::FNM_EXTGLOB | File::Constants::FNM_PATHNAME,
+                  ).map! { |p| Shellwords.escape(p) },
+                )
               end
             elsif tags.include?("test_file")
-              full_files << path if children.empty?
+              full_files << Shellwords.escape(path) if children.empty?
             elsif tags.include?("test_group")
               # If all of the children of the current test group are other groups, then there's no need to add it to the
               # aggregated examples
               unless children.any? && children.all? { |child| child[:tags].include?("test_group") }
-                aggregated_tests[path][item[:label]] = { tags: tags, examples: [] }
+                aggregated_tests[path][item[:id]] = { tags: tags, examples: [] }
               end
             else
               class_name, method_name = item[:id].split("#")
@@ -74,7 +76,10 @@ module RubyLsp
           end
 
           unless full_files.empty?
-            commands << "#{BASE_COMMAND} -Itest -e \"ARGV.each { |f| require f }\" #{full_files.join(" ")}"
+            specs, tests = full_files.partition { |path| spec?(path) }
+
+            commands << "#{COMMAND} -Itest -e \"ARGV.each { |f| require f }\" #{tests.join(" ")}" if tests.any?
+            commands << "#{COMMAND} -Ispec -e \"ARGV.each { |f| require f }\" #{specs.join(" ")}" if specs.any?
           end
 
           commands
@@ -82,10 +87,15 @@ module RubyLsp
 
         private
 
+        #: (String) -> bool
+        def spec?(path)
+          File.fnmatch?("**/spec/**/*_spec.rb", path, File::FNM_PATHNAME | File::FNM_EXTGLOB)
+        end
+
         #: (String, Hash[String, Hash[Symbol, untyped]]) -> String
         def handle_minitest_groups(file_path, groups_and_examples)
           regexes = groups_and_examples.flat_map do |group, info|
-            examples = info[:examples]
+            examples = info[:examples].map { |e| Shellwords.escape(e).gsub(/test_\d{4}/, "test_\\d{4}") }
             group_regex = Shellwords.escape(group).gsub(
               Shellwords.escape(TestDiscovery::DYNAMIC_REFERENCE_MARKER),
               ".*",
@@ -93,9 +103,9 @@ module RubyLsp
             if examples.empty?
               "^#{group_regex}(#|::)"
             elsif examples.length == 1
-              "^#{group_regex}##{examples[0]}$"
+              "^#{group_regex}##{examples[0]}\\$"
             else
-              "^#{group_regex}#(#{examples.join("|")})$"
+              "^#{group_regex}#(#{examples.join("|")})\\$"
             end
           end
 
@@ -105,7 +115,8 @@ module RubyLsp
             "(#{regexes.join("|")})"
           end
 
-          "#{BASE_COMMAND} -Itest #{file_path} --name \"/#{regex}/\""
+          load_path = spec?(file_path) ? "-Ispec" : "-Itest"
+          "#{COMMAND} #{load_path} #{Shellwords.escape(file_path)} --name \"/#{regex}/\""
         end
 
         #: (String, Hash[String, Hash[Symbol, untyped]]) -> Array[String]
@@ -116,13 +127,13 @@ module RubyLsp
               Shellwords.escape(TestDiscovery::DYNAMIC_REFERENCE_MARKER),
               ".*",
             )
-            command = +"#{BASE_COMMAND} -Itest #{file_path} --testcase \"/^#{group_regex}$/\""
+            command = +"#{COMMAND} -Itest #{Shellwords.escape(file_path)} --testcase \"/^#{group_regex}\\$/\""
 
             unless examples.empty?
               command << if examples.length == 1
-                " --name \"/#{examples[0]}$/\""
+                " --name \"/#{examples[0]}\\$/\""
               else
-                " --name \"/(#{examples.join("|")})$/\""
+                " --name \"/(#{examples.join("|")})\\$/\""
               end
             end
 
@@ -135,23 +146,24 @@ module RubyLsp
 
       MINITEST_REPORTER_PATH = File.expand_path("../test_reporters/minitest_reporter.rb", __dir__) #: String
       TEST_UNIT_REPORTER_PATH = File.expand_path("../test_reporters/test_unit_reporter.rb", __dir__) #: String
-      ACCESS_MODIFIERS = [:public, :private, :protected].freeze
       BASE_COMMAND = begin
-        Bundler.with_original_env { Bundler.default_lockfile }
+        Bundler.with_unbundled_env { Bundler.default_lockfile }
         "bundle exec ruby"
       rescue Bundler::GemfileNotFound
         "ruby"
       end #: String
+      COMMAND = "#{BASE_COMMAND} -r#{MINITEST_REPORTER_PATH} -r#{TEST_UNIT_REPORTER_PATH}" #: String
+      ACCESS_MODIFIERS = [:public, :private, :protected].freeze
 
-      #: (ResponseBuilders::TestCollection response_builder, GlobalState global_state, Prism::Dispatcher dispatcher, URI::Generic uri) -> void
+      #: (ResponseBuilders::TestCollection, GlobalState, Prism::Dispatcher, URI::Generic) -> void
       def initialize(response_builder, global_state, dispatcher, uri)
-        super
+        super(response_builder, global_state, uri)
 
         @framework = :minitest #: Symbol
+        @parent_stack = [@response_builder] #: Array[(Requests::Support::TestItem | ResponseBuilders::TestCollection)?]
 
-        dispatcher.register(
-          self,
-          # Common handlers registered in parent class
+        register_events(
+          dispatcher,
           :on_class_node_enter,
           :on_def_node_enter,
           :on_call_node_enter,
@@ -160,48 +172,70 @@ module RubyLsp
       end
 
       #: (Prism::ClassNode node) -> void
-      def on_class_node_enter(node)
+      def on_class_node_enter(node) # rubocop:disable RubyLsp/UseRegisterWithHandlerMethod
         with_test_ancestor_tracking(node) do |name, ancestors|
           @framework = :test_unit if ancestors.include?("Test::Unit::TestCase")
 
           if @framework == :test_unit || non_declarative_minitest?(ancestors, name)
-            @response_builder.add(Requests::Support::TestItem.new(
+            test_item = Requests::Support::TestItem.new(
               name,
               name,
               @uri,
               range_from_node(node),
               framework: @framework,
-            ))
+            )
+
+            last_test_group.add(test_item)
+            @response_builder.add_code_lens(test_item)
+            @parent_stack << test_item
+          else
+            @parent_stack << nil
           end
         end
       end
 
+      #: (Prism::ClassNode node) -> void
+      def on_class_node_leave(node) # rubocop:disable RubyLsp/UseRegisterWithHandlerMethod
+        @parent_stack.pop
+        super
+      end
+
+      #: (Prism::ModuleNode node) -> void
+      def on_module_node_enter(node) # rubocop:disable RubyLsp/UseRegisterWithHandlerMethod
+        @parent_stack << nil
+        super
+      end
+
+      #: (Prism::ModuleNode node) -> void
+      def on_module_node_leave(node) # rubocop:disable RubyLsp/UseRegisterWithHandlerMethod
+        @parent_stack.pop
+        super
+      end
+
       #: (Prism::DefNode node) -> void
-      def on_def_node_enter(node)
+      def on_def_node_enter(node) # rubocop:disable RubyLsp/UseRegisterWithHandlerMethod
         return if @visibility_stack.last != :public
 
         name = node.name.to_s
         return unless name.start_with?("test_")
 
         current_group_name = RubyIndexer::Index.actual_nesting(@nesting, nil).join("::")
+        parent = @parent_stack.last
+        return unless parent.is_a?(Requests::Support::TestItem)
 
-        # If we're finding a test method, but for the wrong framework, then the group test item will not have been
-        # previously pushed and thus we return early and avoid adding items for a framework this listener is not
-        # interested in
-        test_item = @response_builder[current_group_name]
-        return unless test_item
-
-        test_item.add(Requests::Support::TestItem.new(
+        example_item = Requests::Support::TestItem.new(
           "#{current_group_name}##{name}",
           name,
           @uri,
           range_from_node(node),
           framework: @framework,
-        ))
+        )
+        parent.add(example_item)
+        @response_builder.add_code_lens(example_item)
       end
 
       #: (Prism::CallNode node) -> void
-      def on_call_node_enter(node)
+      def on_call_node_enter(node) # rubocop:disable RubyLsp/UseRegisterWithHandlerMethod
         name = node.name
         return unless ACCESS_MODIFIERS.include?(name)
 
@@ -209,7 +243,7 @@ module RubyLsp
       end
 
       #: (Prism::CallNode node) -> void
-      def on_call_node_leave(node)
+      def on_call_node_leave(node) # rubocop:disable RubyLsp/UseRegisterWithHandlerMethod
         name = node.name
         return unless ACCESS_MODIFIERS.include?(name)
         return unless node.arguments&.arguments
@@ -219,6 +253,12 @@ module RubyLsp
 
       private
 
+      #: -> (Requests::Support::TestItem | ResponseBuilders::TestCollection)
+      def last_test_group
+        index = @parent_stack.rindex { |i| i } #: as !nil
+        @parent_stack[index] #: as Requests::Support::TestItem | ResponseBuilders::TestCollection
+      end
+
       #: (Array[String] attached_ancestors, String fully_qualified_name) -> bool
       def non_declarative_minitest?(attached_ancestors, fully_qualified_name)
         return false unless attached_ancestors.include?("Minitest::Test")

data/lib/ruby_lsp/rbs_document.rb

@@ -2,11 +2,8 @@
 # frozen_string_literal: true
 
 module RubyLsp
+  #: [ParseResultType = Array[RBS::AST::Declarations::Base]]
   class RBSDocument < Document
-    extend T::Generic
-
-    ParseResultType = type_member { { fixed: T::Array[RBS::AST::Declarations::Base] } }
-
     #: (source: String, version: Integer, uri: URI::Generic, global_state: GlobalState) -> void
     def initialize(source:, version:, uri:, global_state:)
       @syntax_error = false #: bool
@@ -36,9 +33,9 @@ module RubyLsp
     end
 
     # @override
-    #: -> LanguageId
+    #: -> Symbol
     def language_id
-      LanguageId::RBS
+      :rbs
     end
   end
 end