solargraph-rspec 0.1.1 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 46e92fa0735bc1e0b1129ce3c06208969dd8917a28e70286876d7f6307928e8c
-  data.tar.gz: 718485f0ea53780cb3ee6d076cb5be112d160d1c39866c91334142d1abff515a
+  metadata.gz: 1f73a95cc73aa3ce52cff1e5e4e8e06509f3a59ccf6a3371b9087fad38e135b0
+  data.tar.gz: 221342fb0163f67fce1648aa4b14310b31907aacc9637def0b61e690b8ff750e
 SHA512:
-  metadata.gz: '06580663bc8c5424219a171e4f61121d98d04dfe9048bfaa3595c7717bdd2a88b6dcd5055218cbf2fe3c50f7ade5a148811a7c23b780c86d9f0bae8ea554a236'
-  data.tar.gz: 28ea8fe4be4f3402ca3079a747764013d6154adac0b114c2f9f23afe81599b403f0bb024856c3744ce7e8b64f80898eba210962cec68253e0edf25c90f3ce1d6
+  metadata.gz: 47f84a714dc459f67e354b68ff1c037e0ee9170a364db3fb4aa8e7a04cef1ce81952fade0a109a41de91f57b0b18201d3d8ab95b901f94de679357688bc9e41f
+  data.tar.gz: a5bff062303a4fd717315083944c19dbe1c21a94ee795e9f29d5e2971d574038bb75677c596645dacd5861f5f624a7a36a93347c48e443a549ab7decc387dae3

data/CHANGELOG.md

@@ -7,7 +7,20 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
-- 
+## [0.2.0] - 2024-05-20
+
+### Added
+
+- `let` and `subject` type inference 🚀 (Resolves: [Issue #1](https://github.com/lekemula/solargraph-rspec/issues/1))
+
+### Changed
+
+- Migrate from `parser` gem to using ruby's built-in RubyVM::AbstractSyntaxTree ([see why](https://github.com/castwide/solargraph/issues/522#issuecomment-993016664))
+
+### Fixed
+
+- Fix subject without name block completion: `subject { ... }`
+- Fix subject return class overlap with `Rspec::ExampleGroups::` when class has no namespace
 
 ## [0.1.1] - 2024-05-13
 

data/README.md

@@ -7,15 +7,18 @@
 
 RSpec is a testing framework of choice for many Ruby developers. But at the same time is highly dynamic and heavily relying on metaprogramming making it hard to provide accurate code completion and type inference. 
 
-This gem aims to provide a better support for RSpec in Solargraph and it supports the following features:
+This gem aims to provide better support for RSpec in Solargraph and it supports the following features:
   - `describe` and `it` methods completion
   - memoized `let` and `let!` methods completion 
   - implicit and explicit `subject` methods
   - `described_class` with appropriate type inference
   - `RSpec::Matchers` methods completion
+  - type inference 🚀
   - and more to come...
 
-  ![solargraph-rspec_smaller](https://github.com/lekemula/solargraph-rspec/assets/9197495/66f86e5b-258e-4d8c-8a64-0685d15ece00)
+![solargraph-rspec-with-types](https://github.com/lekemula/solargraph-rspec/assets/9197495/077e74f8-a800-4e90-8922-fa5351adcda3)
+![solargraph-rspec-with-types-vs-code](https://github.com/lekemula/solargraph-rspec/assets/9197495/6a942460-256d-46ca-82de-9869a65309ec)
+
 
 ## Installation
 

data/lib/solargraph/rspec/convention.rb

@@ -10,7 +10,7 @@ require_relative 'correctors/subject_method_corrector'
 require_relative 'correctors/context_block_methods_corrector'
 require_relative 'correctors/implicit_subject_method_corrector'
 require_relative 'correctors/dsl_methods_corrector'
-require_relative 'util'
+require_relative 'pin_factory'
 
 module Solargraph
   module Rspec
@@ -121,14 +121,20 @@ module Solargraph
 
         # @type [Pin::Method, nil]
         described_class_pin = nil
-        Correctors::DescribedClassCorrector.new(namespace_pins: namespace_pins, rspec_walker: rspec_walker).correct(
+        Correctors::DescribedClassCorrector.new(
+          namespace_pins: namespace_pins,
+          rspec_walker: rspec_walker
+        ).correct(
           source_map
         ) do |pins_to_add|
           described_class_pin = pins_to_add.first
           pins += pins_to_add
         end
 
-        Correctors::LetMethodsCorrector.new(namespace_pins: namespace_pins, rspec_walker: rspec_walker).correct(
+        Correctors::LetMethodsCorrector.new(
+          namespace_pins: namespace_pins,
+          rspec_walker: rspec_walker
+        ).correct(
           source_map
         ) do |pins_to_add|
           pins += pins_to_add
@@ -136,7 +142,10 @@ module Solargraph
 
         # @type [Pin::Method, nil]
         subject_pin = nil
-        Correctors::SubjectMethodCorrector.new(namespace_pins: namespace_pins, rspec_walker: rspec_walker).correct(
+        Correctors::SubjectMethodCorrector.new(
+          namespace_pins: namespace_pins,
+          rspec_walker: rspec_walker
+        ).correct(
           source_map
         ) do |pins_to_add|
           subject_pin = pins_to_add.first
@@ -199,7 +208,7 @@ module Solargraph
       # @return [Array<Pin::Base>]
       def include_helper_pins(helper_modules: HELPER_MODULES)
         helper_modules.map do |helper_module|
-          Util.build_module_include(
+          PinFactory.build_module_include(
             root_example_group_namespace_pin,
             helper_module,
             root_example_group_namespace_pin.location
@@ -216,7 +225,7 @@ module Solargraph
       def root_example_group_namespace_pin
         Solargraph::Pin::Namespace.new(
           name: ROOT_NAMESPACE,
-          location: Util.dummy_location('lib/rspec/core/example_group.rb')
+          location: PinFactory.dummy_location('lib/rspec/core/example_group.rb')
         )
       end
     end

data/lib/solargraph/rspec/correctors/base.rb

@@ -27,7 +27,7 @@ module Solargraph
         def root_example_group_namespace_pin
           Solargraph::Pin::Namespace.new(
             name: ROOT_NAMESPACE,
-            location: Util.dummy_location('lib/rspec/core/example_group.rb')
+            location: PinFactory.dummy_location('lib/rspec/core/example_group.rb')
           )
         end
 

data/lib/solargraph/rspec/correctors/context_block_namespace_corrector.rb

@@ -9,10 +9,11 @@ module Solargraph
       class ContextBlockNamespaceCorrector < WalkerBase
         # @param source_map [Solargraph::SourceMap]
         def correct(source_map)
-          rspec_walker.on_each_context_block do |namespace_name, ast|
-            original_block_pin = source_map.locate_block_pin(ast.location.begin.line, ast.location.begin.column)
+          # @param location_range [Solargraph::Range]
+          rspec_walker.on_each_context_block do |namespace_name, location_range|
+            original_block_pin = source_map.locate_block_pin(location_range.start.line, location_range.start.column)
             original_block_pin_index = source_map.pins.index(original_block_pin)
-            location = Util.build_location(ast, source_map.filename)
+            location = PinFactory.build_location(location_range, source_map.filename)
 
             # Define a dynamic module for the example group block
             # Example:
@@ -36,7 +37,7 @@ module Solargraph
 
             # Include DSL methods in the example group block
             # TOOD: This does not work on solagraph! Class methods are not included from parent class.
-            namespace_extend_pin = Util.build_module_extend(
+            namespace_extend_pin = PinFactory.build_module_extend(
               namespace_pin,
               root_example_group_namespace_pin.name,
               location
@@ -44,7 +45,7 @@ module Solargraph
 
             # Include parent example groups to share let definitions
             parent_namespace_name = namespace_name.split('::')[0..-2].join('::')
-            namespace_include_pin = Util.build_module_include(
+            namespace_include_pin = PinFactory.build_module_include(
               namespace_pin,
               parent_namespace_name,
               location

data/lib/solargraph/rspec/correctors/described_class_corrector.rb

@@ -9,11 +9,11 @@ module Solargraph
         # @param source_map [Solargraph::SourceMap]
         # @return [void]
         def correct(_source_map)
-          rspec_walker.on_described_class do |ast, described_class_name|
-            namespace_pin = closest_namespace_pin(namespace_pins, ast.loc.line)
+          rspec_walker.on_described_class do |described_class_name, location_range|
+            namespace_pin = closest_namespace_pin(namespace_pins, location_range.start.line)
             next unless namespace_pin
 
-            described_class_pin = rspec_described_class_method(namespace_pin, ast, described_class_name)
+            described_class_pin = rspec_described_class_method(namespace_pin, location_range, described_class_name)
             yield [described_class_pin].compact if block_given?
           end
         end
@@ -21,15 +21,15 @@ module Solargraph
         private
 
         # @param namespace [Pin::Namespace]
-        # @param ast [Parser::AST::Node]
+        # @param location_range [Solargraph::Range]
         # @param described_class_name [String]
         # @return [Pin::Method, nil]
-        def rspec_described_class_method(namespace, ast, described_class_name)
-          Util.build_public_method(
+        def rspec_described_class_method(namespace, location_range, described_class_name)
+          PinFactory.build_public_method(
             namespace,
             'described_class',
-            types: ["Class<#{described_class_name}>"],
-            location: Util.build_location(ast, namespace.filename),
+            types: ["Class<::#{described_class_name}>"],
+            location: PinFactory.build_location(location_range, namespace.filename),
             scope: :instance
           )
         end

data/lib/solargraph/rspec/correctors/dsl_methods_corrector.rb

@@ -35,7 +35,7 @@ module Solargraph
         # @return [Array<Solargraph::Pin::Method>]
         def add_methods_with_example_binding(namespace_pin)
           rspec_context_block_methods.map do |method|
-            Util.build_public_method(
+            PinFactory.build_public_method(
               namespace_pin,
               method.to_s,
               comments: ["@yieldself [#{namespace_pin.path}]"], # Fixes the binding of the block to the correct class
@@ -50,7 +50,7 @@ module Solargraph
         # @return [Array<Solargraph::Pin::Base>]
         def add_context_dsl_methods(namespace_pin)
           Rspec::CONTEXT_METHODS.map do |method|
-            Util.build_public_method(
+            PinFactory.build_public_method(
               namespace_pin,
               method.to_s,
               scope: :class

data/lib/solargraph/rspec/correctors/example_and_hook_blocks_binding_corrector.rb

@@ -11,32 +11,32 @@ module Solargraph
         # @param source_map [Solargraph::SourceMap]
         # @return [void]
         def correct(source_map)
-          rspec_walker.on_example_block do |block_ast|
-            bind_closest_namespace(block_ast, source_map)
+          rspec_walker.on_example_block do |location_range|
+            bind_closest_namespace(location_range, source_map)
 
             yield [] if block_given?
           end
 
-          rspec_walker.on_hook_block do |block_ast|
-            bind_closest_namespace(block_ast, source_map)
+          rspec_walker.on_hook_block do |location_range|
+            bind_closest_namespace(location_range, source_map)
 
             yield [] if block_given?
           end
 
-          rspec_walker.on_let_method do |let_method_ast|
-            bind_closest_namespace(let_method_ast, source_map)
+          rspec_walker.on_let_method do |_method_name, location_range|
+            bind_closest_namespace(location_range, source_map)
 
             yield [] if block_given?
           end
 
-          rspec_walker.on_blocks_in_examples do |block_ast|
-            bind_closest_namespace(block_ast, source_map)
+          rspec_walker.on_blocks_in_examples do |location_range|
+            bind_closest_namespace(location_range, source_map)
 
             yield [] if block_given?
           end
 
-          rspec_walker.on_subject do |subject_ast|
-            bind_closest_namespace(subject_ast, source_map)
+          rspec_walker.on_subject do |_method_name, location_range|
+            bind_closest_namespace(location_range, source_map)
 
             yield [] if block_given?
           end
@@ -44,15 +44,15 @@ module Solargraph
 
         private
 
-        # @param block_ast [Parser::AST::Node]
+        # @param location_range [Solargraph::Range]
         # @param source_map [Solargraph::SourceMap]
         # @return [void]
-        def bind_closest_namespace(block_ast, source_map)
-          namespace_pin = closest_namespace_pin(namespace_pins, block_ast.loc.line)
+        def bind_closest_namespace(location_range, source_map)
+          namespace_pin = closest_namespace_pin(namespace_pins, location_range.start.line)
           return unless namespace_pin
 
-          original_block_pin = source_map.locate_block_pin(block_ast.location.begin.line,
-                                                           block_ast.location.begin.column)
+          original_block_pin = source_map.locate_block_pin(location_range.start.line,
+                                                           location_range.start.column)
           original_block_pin_index = source_map.pins.index(original_block_pin)
           fixed_namespace_block_pin = Solargraph::Pin::Block.new(
             closure: example_run_method(namespace_pin),
@@ -67,7 +67,7 @@ module Solargraph
         # @param namespace_pin [Solargraph::Pin::Namespace]
         # @return [Solargraph::Pin::Method]
         def example_run_method(namespace_pin)
-          Util.build_public_method(
+          PinFactory.build_public_method(
             namespace_pin,
             'run',
             # https://github.com/rspec/rspec-core/blob/main/lib/rspec/core/example.rb#L246

data/lib/solargraph/rspec/correctors/implicit_subject_method_corrector.rb

@@ -34,10 +34,10 @@ module Solargraph
         def implicit_subject_pin(described_class_pin, namespace_pin)
           described_class = described_class_pin.return_type.first.subtypes.first.name
 
-          Util.build_public_method(
+          PinFactory.build_public_method(
             namespace_pin,
             'subject',
-            types: [described_class],
+            types: ["::#{described_class}"],
             location: described_class_pin.location,
             scope: :instance
           )

data/lib/solargraph/rspec/correctors/let_methods_corrector.rb

@@ -10,11 +10,11 @@ module Solargraph
         # @param source_map [Solargraph::SourceMap]
         # @return [void]
         def correct(_source_map)
-          rspec_walker.on_let_method do |ast|
-            namespace_pin = closest_namespace_pin(namespace_pins, ast.loc.line)
+          rspec_walker.on_let_method do |let_name, location_range, fake_method_ast|
+            namespace_pin = closest_namespace_pin(namespace_pins, location_range.start.line)
             next unless namespace_pin
 
-            pin = rspec_let_method(namespace_pin, ast)
+            pin = rspec_let_method(namespace_pin, let_name, location_range, fake_method_ast)
             yield [pin] if block_given?
           end
         end
@@ -22,19 +22,17 @@ module Solargraph
         private
 
         # @param namespace [Pin::Namespace]
-        # @param ast [Parser::AST::Node]
+        # @param method_name [String]
+        # @param node [RubyVM::AbstractSyntaxTree::Node]
         # @param types [Array<String>, nil]
         # @return [Pin::Method, nil]
-        def rspec_let_method(namespace, ast, types: nil)
-          return unless ast.children
-          return unless ast.children[2]&.children
-
-          method_name = ast.children[2].children[0]&.to_s or return
-          Util.build_public_method(
+        def rspec_let_method(namespace, method_name, location_range, node = nil, types: nil)
+          PinFactory.build_public_method(
             namespace,
             method_name,
+            node: node,
             types: types,
-            location: Util.build_location(ast, namespace.filename),
+            location: PinFactory.build_location(location_range, namespace.filename),
             scope: :instance
           )
         end

data/lib/solargraph/rspec/correctors/subject_method_corrector.rb

@@ -10,11 +10,13 @@ module Solargraph
         # @param source_map [Solargraph::SourceMap]
         # @return [void]
         def correct(_source_map)
-          rspec_walker.on_subject do |ast|
-            namespace_pin = closest_namespace_pin(namespace_pins, ast.loc.line)
+          rspec_walker.on_subject do |subject_name, location_range, fake_method_ast|
+            next unless subject_name
+
+            namespace_pin = closest_namespace_pin(namespace_pins, location_range.start.line)
             next unless namespace_pin
 
-            subject_pin = rspec_let_method(namespace_pin, ast)
+            subject_pin = rspec_let_method(namespace_pin, subject_name, location_range, fake_method_ast)
             yield [subject_pin].compact if block_given?
           end
         end

data/lib/solargraph/rspec/pin_factory.rb

@@ -0,0 +1,100 @@
+# frozen_string_literal: true
+
+# Credits: This file is a copy of the file from the solargraph-rspec gem
+
+module Solargraph
+  module Rspec
+    # Factory class for building pins and references.
+    module PinFactory
+      # @param namespace [Solargraph::Pin::Namespace]
+      # @param name [String]
+      # @param types [Array<String>]
+      # @param location [Solargraph::Location]
+      # @param comments [Array<String>]
+      # @param attribute [Boolean]
+      # @param scope [:instance, :class]
+      # @return [Solargraph::Pin::Method]
+      def self.build_public_method(
+        namespace,
+        name,
+        types: nil,
+        location: nil,
+        comments: [],
+        attribute: false,
+        scope: :instance,
+        node: nil
+      )
+        opts = {
+          name: name,
+          location: location,
+          closure: namespace,
+          scope: scope,
+          attribute: attribute,
+          comments: [],
+          node: node
+        }
+
+        comments << "@return [#{types.join(",")}]" if types
+
+        opts[:comments] = comments.join("\n")
+
+        Solargraph::Pin::Method.new(**opts)
+      end
+
+      # @param namespace [Solargraph::Pin::Namespace]
+      # @param name [String]
+      # @param location [Solargraph::Location]
+      # @return [Solargraph::Pin::Reference::Include]
+      def self.build_module_include(namespace, module_name, location)
+        Solargraph::Pin::Reference::Include.new(
+          closure: namespace,
+          name: module_name,
+          location: location
+        )
+      end
+
+      # @param namespace [Solargraph::Pin::Namespace]
+      # @param module_name [String]
+      # @param location [Solargraph::Location]
+      # @return [Solargraph::Pin::Reference::Extend]
+      def self.build_module_extend(namespace, module_name, location)
+        Solargraph::Pin::Reference::Extend.new(
+          closure: namespace,
+          name: module_name,
+          location: location
+        )
+      end
+
+      # @param path [String]
+      # @return [Solargraph::Location]
+      def self.dummy_location(path)
+        Solargraph::Location.new(
+          File.expand_path(path),
+          Solargraph::Range.from_to(0, 0, 0, 0)
+        )
+      end
+
+      # @param ast [RubyVM::AbstractSyntaxTree::Node]
+      # @see [RubyVM::AbstractSyntaxTree::NodeWrapper] - for why we need -1 for lineno
+      # @return [Solargraph::Range]
+      def self.build_location_range(ast)
+        Solargraph::Range.from_to(
+          ast.first_lineno - 1,
+          ast.first_column,
+          ast.last_lineno - 1,
+          ast.last_column
+        )
+      end
+
+      # @param location_range [Solargraph::Range]
+      # @param path [String]
+      # @return [Solargraph::Location]
+      def self.build_location(location_range, path)
+        Solargraph::Location.new(
+          File.expand_path(path),
+          location_range
+        )
+      end
+    end
+  end
+end

data/lib/solargraph/rspec/spec_walker/fake_let_method.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module Solargraph
+  module Rspec
+    class SpecWalker
+      class FakeLetMethod
+        MATCH_BODY = Regexp.union(
+          /do(.*)end/m,
+          /{(.*)}/m
+        )
+
+        # @param block_ast [RubyVM::AbstractSyntaxTree::Node]
+        # @return [RubyVM::AbstractSyntaxTree::Node]
+        def self.transform_block(block_ast, code, method_name = nil)
+          method_name ||= NodeTypes.let_method_name(block_ast)
+          block_body = block_ast.children[1]
+          matches = code.lines[block_body.first_lineno - 1..block_body.last_lineno - 1].join.match(MATCH_BODY)
+          method_body = (matches[1] || matches[2]).strip
+
+          ast = RubyVM::AbstractSyntaxTree.parse <<~RUBY
+            def #{method_name}
+              #{method_body}
+            end
+          RUBY
+
+          ast.children[2]
+        rescue SyntaxError
+          raise "Failed to build fake let method: #{block_ast.inspect}, message: #{e.message}"
+        ensure
+          nil
+        end
+      end
+    end
+  end
+end

data/lib/solargraph/rspec/spec_walker/full_constant_name.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Solargraph
+  module Rspec
+    class SpecWalker
+      class FullConstantName
+        class << self
+          # @param ast [RubyVM::AbstractSyntaxTree::Node]
+          # @return [String]
+          def from_ast(ast)
+            raise 'Node is not a constant' unless NodeTypes.a_constant?(ast)
+
+            if ast.type == :CONST
+              ast.children[0].to_s
+            elsif ast.type == :COLON2
+              name = ast.children[1].to_s
+              "#{from_ast(ast.children[0])}::#{name}"
+            end
+          end
+
+          def from_context_block_ast(block_ast)
+            ast = NodeTypes.context_description_node(block_ast)
+            from_ast(ast)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/solargraph/rspec/spec_walker/node_types.rb

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+module Solargraph
+  module Rspec
+    class SpecWalker
+      class NodeTypes
+        # @param ast [RubyVM::AbstractSyntaxTree::Node]
+        # @return [Boolean]
+        def self.a_block?(ast)
+          return false unless ast.is_a?(RubyVM::AbstractSyntaxTree::Node)
+
+          %i[ITER LAMBDA].include?(ast.type)
+        end
+
+        # @param ast [RubyVM::AbstractSyntaxTree::Node]
+        # @return [Boolean]
+        def self.a_context_block?(block_ast)
+          Solargraph::Rspec::CONTEXT_METHODS.include?(method_with_block_name(block_ast))
+        end
+
+        # @param ast [RubyVM::AbstractSyntaxTree::Node]
+        # @return [Boolean]
+        def self.a_subject_block?(block_ast)
+          Solargraph::Rspec::SUBJECT_METHODS.include?(method_with_block_name(block_ast))
+        end
+
+        # @param ast [RubyVM::AbstractSyntaxTree::Node]
+        # @return [Boolean]
+        def self.a_example_block?(block_ast)
+          Solargraph::Rspec::EXAMPLE_METHODS.include?(method_with_block_name(block_ast))
+        end
+
+        # @param ast [RubyVM::AbstractSyntaxTree::Node]
+        # @param config [Config]
+        # @return [Boolean]
+        def self.a_let_block?(block_ast, config)
+          config.let_methods.map(&:to_s).include?(method_with_block_name(block_ast))
+        end
+
+        # @param ast [RubyVM::AbstractSyntaxTree::Node]
+        # @return [Boolean]
+        def self.a_hook_block?(block_ast)
+          Solargraph::Rspec::HOOK_METHODS.include?(method_with_block_name(block_ast))
+        end
+
+        def self.a_constant?(ast)
+          %i[CONST COLON2].include?(ast.type)
+        end
+
+        # @param block_ast [RubyVM::AbstractSyntaxTree::Node]
+        # @return [String, nil]
+        def self.method_with_block_name(block_ast)
+          return nil unless a_block?(block_ast)
+
+          method_call = %i[CALL FCALL].include?(block_ast.children[0].type)
+          return nil unless method_call
+
+          block_ast.children[0].children.select { |child| child.is_a?(Symbol) }.first&.to_s
+        end
+
+        # @param block_ast [RubyVM::AbstractSyntaxTree::Node]
+        # @return [RubyVM::AbstractSyntaxTree::Node]
+        def self.context_description_node(block_ast)
+          return nil unless a_context_block?(block_ast)
+
+          case block_ast.children[0].type
+          when :CALL # RSpec.describe "something" do end
+            block_ast.children[0].children[2].children[0]
+          when :FCALL # describe "something" do end
+            block_ast.children[0].children[1].children[0]
+          end
+        end
+
+        # @param block_ast [RubyVM::AbstractSyntaxTree::Node]
+        # @return [String]
+        def self.let_method_name(block_ast)
+          block_ast.children[0].children[1]&.children&.[](0)&.children&.[](0)&.to_s
+        end
+      end
+    end
+  end
+end

data/lib/solargraph/rspec/spec_walker/rspec_context_namespace.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+module Solargraph
+  module Rspec
+    class SpecWalker
+      class RspecContextNamespace
+        class << self
+          # @param block_ast [RubyVM::AbstractSyntaxTree::Node]
+          # @return [String, nil]
+          def from_block_ast(block_ast)
+            return unless block_ast.is_a?(RubyVM::AbstractSyntaxTree::Node)
+
+            ast = NodeTypes.context_description_node(block_ast)
+            if ast.type == :STR
+              string_to_const_name(ast)
+            elsif NodeTypes.a_constant?(ast)
+              FullConstantName.from_ast(ast).gsub('::', '')
+            else
+              Solargraph.logger.warn "[RSpec] Unexpected AST type #{ast.type}"
+              nil
+            end
+          end
+
+          private
+
+          # @see https://github.com/rspec/rspec-core/blob/1eeadce5aa7137ead054783c31ff35cbfe9d07cc/lib/rspec/core/example_group.rb#L862
+          # @param ast [Parser::AST::Node]
+          # @return [String]
+          def string_to_const_name(string_ast)
+            return unless string_ast.type == :STR
+
+            name = string_ast.children[0]
+            return 'Anonymous'.dup if name.empty?
+
+            # Convert to CamelCase.
+            name = +" #{name}"
+            name.gsub!(/[^0-9a-zA-Z]+([0-9a-zA-Z])/) do
+              match = ::Regexp.last_match[1]
+              match.upcase!
+              match
+            end
+
+            name.lstrip! # Remove leading whitespace
+            name.gsub!(/\W/, '') # JRuby, RBX and others don't like non-ascii in const names
+
+            # Ruby requires first const letter to be A-Z. Use `Nested`
+            # as necessary to enforce that.
+            name.gsub!(/\A([^A-Z]|\z)/, 'Nested\1')
+
+            name
+          end
+        end
+      end
+    end
+  end
+end

data/lib/solargraph/rspec/spec_walker.rb

@@ -1,6 +1,10 @@
 # frozen_string_literal: true
 
 require_relative 'walker'
+require_relative 'spec_walker/node_types'
+require_relative 'spec_walker/full_constant_name'
+require_relative 'spec_walker/rspec_context_namespace'
+require_relative 'spec_walker/fake_let_method'
 
 module Solargraph
   module Rspec
@@ -10,7 +14,7 @@ module Solargraph
       def initialize(source_map:, config:)
         @source_map = source_map
         @config = config
-        @walker = Rspec::Walker.from_source(source_map.source)
+        @walker = Rspec::Walker.new(source_map.source.node)
         @handlers = {
           on_described_class: [],
           on_let_method: [],
@@ -30,24 +34,34 @@ module Solargraph
       attr_reader :config
 
       # @param block [Proc]
+      # @yieldparam class_name [String]
+      # @yieldparam location_range [Solargraph::Range]
       # @return [void]
       def on_described_class(&block)
         @handlers[:on_described_class] << block
       end
 
       # @param block [Proc]
+      # @yieldparam method_name [String]
+      # @yieldparam location_range [Solargraph::Range]
+      # @yieldparam fake_method_ast [RubyVM::AbstractSyntaxTree::Node]
       # @return [void]
       def on_let_method(&block)
         @handlers[:on_let_method] << block
       end
 
       # @param block [Proc]
+      # @yieldparam method_name [String]
+      # @yieldparam location_range [Solargraph::Range]
+      # @yieldparam fake_method_ast [RubyVM::AbstractSyntaxTree::Node]
       # @return [void]
       def on_subject(&block)
         @handlers[:on_subject] << block
       end
 
       # @param block [Proc]
+      # @yieldparam namespace_name [String]
+      # @yieldparam location_range [Solargraph::Range]
       # @return [void]
       def on_each_context_block(&block)
         @handlers[:on_each_context_block] << block
@@ -55,18 +69,21 @@ module Solargraph
 
       #
       # @param block [Proc]
+      # @yieldparam location_range [Solargraph::Range]
       # @return [void]
       def on_example_block(&block)
         @handlers[:on_example_block] << block
       end
 
       # @param block [Proc]
+      # @yieldparam location_range [Solargraph::Range]
       # @return [void]
       def on_hook_block(&block)
         @handlers[:on_hook_block] << block
       end
 
       # @param block [Proc]
+      # @yieldparam location_range [Solargraph::Range]
       # @return [void]
       def on_blocks_in_examples(&block)
         @handlers[:on_blocks_in_examples] << block
@@ -80,77 +97,72 @@ module Solargraph
 
       # @return [void]
       def walk!
-        each_context_block(@walker.ast, Rspec::ROOT_NAMESPACE) do |namespace_name, ast|
+        each_context_block(@walker.ast, Rspec::ROOT_NAMESPACE) do |namespace_name, block_ast|
+          desc_node = NodeTypes.context_description_node(block_ast)
+
           @handlers[:on_each_context_block].each do |handler|
-            handler.call(namespace_name, ast)
+            handler.call(namespace_name, PinFactory.build_location_range(block_ast))
           end
-        end
 
-        rspec_const = ::Parser::AST::Node.new(:const, [nil, :RSpec])
-        walker.on :send, [rspec_const, :describe, :any] do |ast|
-          @handlers[:on_described_class].each do |handler|
-            class_ast = ast.children[2]
-            next unless class_ast
-
-            class_name = full_constant_name(class_ast)
-            handler.call(class_ast, class_name)
+          if NodeTypes.a_constant?(desc_node) # rubocop:disable Style/Next
+            @handlers[:on_described_class].each do |handler|
+              class_name_ast = NodeTypes.context_description_node(block_ast)
+              class_name = FullConstantName.from_ast(class_name_ast)
+              handler.call(class_name, PinFactory.build_location_range(class_name_ast))
+            end
           end
         end
 
-        config.let_methods.each do |let_method|
-          walker.on :send, [nil, let_method] do |ast|
-            @handlers[:on_let_method].each do |handler|
-              handler.call(ast)
-            end
+        walker.on :ITER do |block_ast|
+          next unless NodeTypes.a_let_block?(block_ast, config)
+
+          method_name = NodeTypes.let_method_name(block_ast)
+          next unless method_name
+
+          fake_method_ast = FakeLetMethod.transform_block(block_ast, @source_map.source.code)
+
+          @handlers[:on_let_method].each do |handler|
+            handler.call(method_name, PinFactory.build_location_range(block_ast.children[0]), fake_method_ast)
           end
         end
 
-        walker.on :block do |block_ast|
-          next if block_ast.children.first.type != :send
+        walker.on :ITER do |block_ast|
+          next unless NodeTypes.a_subject_block?(block_ast)
 
-          method_ast = block_ast.children.first
-          method_name = method_ast.children[1]
-          next unless Rspec::SUBJECT_METHODS.include?(method_name.to_s)
+          method_name = NodeTypes.let_method_name(block_ast)
+          fake_method_ast = FakeLetMethod.transform_block(block_ast, @source_map.source.code, method_name || 'subject')
 
           @handlers[:on_subject].each do |handler|
-            handler.call(method_ast)
+            handler.call(method_name, PinFactory.build_location_range(block_ast.children[0]), fake_method_ast)
           end
         end
 
-        walker.on :block do |block_ast|
-          next if block_ast.children.first.type != :send
-
-          method_ast = block_ast.children.first
-          method_name = method_ast.children[1]
-          next unless Rspec::EXAMPLE_METHODS.include?(method_name.to_s)
+        walker.on :ITER do |block_ast|
+          next unless NodeTypes.a_example_block?(block_ast)
 
           @handlers[:on_example_block].each do |handler|
-            handler.call(block_ast)
+            handler.call(PinFactory.build_location_range(block_ast))
           end
 
-          # @param blocks_in_examples [Parser::AST::Node]
-          each_block(block_ast.children[2]) do |blocks_in_examples|
+          # @param blocks_in_examples [RubyVM::AbstractSyntaxTree::Node]
+          each_block(block_ast.children[1]) do |blocks_in_examples|
             @handlers[:on_blocks_in_examples].each do |handler|
-              handler.call(blocks_in_examples)
+              handler.call(PinFactory.build_location_range(blocks_in_examples))
             end
           end
         end
 
-        walker.on :block do |block_ast|
-          next if block_ast.children.first.type != :send
-
-          method_ast = block_ast.children.first
-          method_name = method_ast.children[1]
-          next unless Rspec::HOOK_METHODS.include?(method_name.to_s)
+        walker.on :ITER do |block_ast|
+          next unless NodeTypes.a_hook_block?(block_ast)
 
           @handlers[:on_hook_block].each do |handler|
-            handler.call(block_ast)
+            handler.call(PinFactory.build_location_range(block_ast))
           end
 
-          # @param blocks_in_examples [Parser::AST::Node]
-          each_block(block_ast.children[2]) do |blocks_in_examples|
+          # @param blocks_in_examples [RubyVM::AbstractSyntaxTree::Node]
+          each_block(block_ast.children[1]) do |blocks_in_examples|
             @handlers[:on_blocks_in_examples].each do |handler|
-              handler.call(blocks_in_examples)
+              handler.call(PinFactory.build_location_range(blocks_in_examples))
             end
           end
         end
@@ -165,9 +177,9 @@ module Solargraph
       # @param ast [Parser::AST::Node]
       # @param parent_result [Object]
       def each_block(ast, parent_result = nil, &block)
-        return unless ast.is_a?(::Parser::AST::Node)
+        return unless ast.is_a?(RubyVM::AbstractSyntaxTree::Node)
 
-        is_a_block = ast.type == :block && ast.children[0].type == :send
+        is_a_block = NodeTypes.a_block?(ast)
 
         if is_a_block
           result = block&.call(ast, parent_result)
@@ -182,12 +194,11 @@ module Solargraph
       # @yield [String, Parser::AST::Node]
       def each_context_block(ast, root_namespace = Rspec::ROOT_NAMESPACE, &block)
         each_block(ast, root_namespace) do |block_ast, parent_namespace|
-          is_a_context = %i[describe context].include?(block_ast.children[0].children[1])
+          is_a_context = NodeTypes.a_context_block?(block_ast)
 
           next unless is_a_context
 
-          description_node = block_ast.children[0].children[2]
-          block_name = rspec_describe_class_name(description_node)
+          block_name = RspecContextNamespace.from_block_ast(block_ast)
           next unless block_name
 
           parent_namespace = namespace_name = "#{parent_namespace}::#{block_name}"
@@ -195,59 +206,6 @@ module Solargraph
           next parent_namespace
         end
       end
-
-      # @param ast [Parser::AST::Node]
-      # @return [String, nil]
-      def rspec_describe_class_name(ast)
-        if ast.type == :str
-          string_to_const_name(ast)
-        elsif ast.type == :const
-          full_constant_name(ast).gsub('::', '')
-        else
-          Solargraph.logger.warn "[RSpec] Unexpected AST type #{ast.type}"
-          nil
-        end
-      end
-
-      # @param ast [Parser::AST::Node]
-      # @return [String]
-      def full_constant_name(ast)
-        raise 'Node is not a constant' unless ast.type == :const
-
-        name = ast.children[1].to_s
-        if ast.children[0].nil?
-          name
-        else
-          "#{full_constant_name(ast.children[0])}::#{name}"
-        end
-      end
-
-      # @see https://github.com/rspec/rspec-core/blob/1eeadce5aa7137ead054783c31ff35cbfe9d07cc/lib/rspec/core/example_group.rb#L862
-      # @param ast [Parser::AST::Node]
-      # @return [String]
-      def string_to_const_name(string_ast)
-        return unless string_ast.type == :str
-
-        name = string_ast.children[0]
-        return 'Anonymous'.dup if name.empty?
-
-        # Convert to CamelCase.
-        name = +" #{name}"
-        name.gsub!(/[^0-9a-zA-Z]+([0-9a-zA-Z])/) do
-          match = ::Regexp.last_match[1]
-          match.upcase!
-          match
-        end
-
-        name.lstrip! # Remove leading whitespace
-        name.gsub!(/\W/, '') # JRuby, RBX and others don't like non-ascii in const names
-
-        # Ruby requires first const letter to be A-Z. Use `Nested`
-        # as necessary to enforce that.
-        name.gsub!(/\A([^A-Z]|\z)/, 'Nested\1')
-
-        name
-      end
     end
   end
 end

data/lib/solargraph/rspec/version.rb

@@ -2,6 +2,6 @@
 
 module Solargraph
   module Rspec
-    VERSION = '0.1.1'
+    VERSION = '0.2.0'
   end
 end

data/lib/solargraph/rspec/walker.rb

@@ -1,10 +1,10 @@
 # frozen_string_literal: true
 
-# Credits: This file is a copy of the original file from the solargraph-rails gem.
-
 module Solargraph
   module Rspec
     class Walker
+      class ParsingError < StandardError; end
+
       class Hook
         attr_reader :node_type
 
@@ -17,7 +17,7 @@ module Solargraph
           @proc = Proc.new(&block)
         end
 
-        # @param node [Parser::AST::Node]
+        # @param node [RubyVM::AbstractSyntaxTree::Node]
         # @return [void]
         def visit(node)
           return unless matches?(node)
@@ -33,15 +33,15 @@ module Solargraph
 
         private
 
-        # @param node [Parser::AST::Node]
+        # @param node [RubyVM::AbstractSyntaxTree::Node]
         # @return [Boolean]
         def matches?(node)
           return false unless node.type == node_type
           return false unless node.children
           return true if @args.empty?
 
-          a_child_matches = node.children.first.is_a?(::Parser::AST::Node) && node.children.any? do |child|
-            child.is_a?(::Parser::AST::Node) &&
+          a_child_matches = node.children.first.is_a?(RubyVM::AbstractSyntaxTree::Node) && node.children.any? do |child|
+            child.is_a?(RubyVM::AbstractSyntaxTree::Node) &&
               match_children(child.children, @args[1..])
           end
 
@@ -50,12 +50,12 @@ module Solargraph
           match_children(node.children)
         end
 
-        # @param children [Array<Parser::AST::Node>]
+        # @param children [Array<RubyVM::AbstractSyntaxTree::Node>]
         def match_children(children, args = @args)
           args.each_with_index.all? do |arg, i|
             if arg == :any
               true
-            elsif children[i].is_a?(::Parser::AST::Node) && arg.is_a?(Symbol)
+            elsif children[i].is_a?(RubyVM::AbstractSyntaxTree::Node) && arg.is_a?(Symbol)
               children[i].type == arg
             else
               children[i] == arg
@@ -64,28 +64,9 @@ module Solargraph
         end
       end
 
-      # https://github.com/castwide/solargraph/issues/522
-      def self.normalize_ast(source)
-        ast = source.node
-
-        if ast.is_a?(::Parser::AST::Node)
-          ast
-        else
-          NodeParser.parse_with_comments(source.code, source.filename)
-        end
-      end
-
-      # @param source [Solargraph::Source]
-      def self.from_source(source)
-        new(*normalize_ast(source))
-      end
-
-      # @return ast [Parser::AST::Node]
-      attr_reader :ast
-      # @return comments [Hash]
-      attr_reader :comments
+      attr_reader :ast, :comments
 
-      # @param ast [Parser::AST::Node]
+      # @param ast [RubyVM::AbstractSyntaxTree::Node]
       # @param comments [Hash]
       def initialize(ast, comments = {})
         @comments = comments
@@ -93,23 +74,18 @@ module Solargraph
         @hooks = Hash.new([])
       end
 
-      # @param node_type [Symbol]
-      # @param args [Array]
-      # @param block [Proc]
       def on(node_type, args = [], &block)
         @hooks[node_type] << Hook.new(node_type, args, &block)
       end
 
-      # @return [void]
       def walk
         @ast.is_a?(Array) ? @ast.each { |node| traverse(node) } : traverse(@ast)
       end
 
       private
 
-      # @param node [Parser::AST::Node]
       def traverse(node)
-        return unless node.is_a?(::Parser::AST::Node)
+        return unless node.is_a?(RubyVM::AbstractSyntaxTree::Node)
 
         @hooks[node.type].each { |hook| hook.visit(node) }
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: solargraph-rspec
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.2.0
 platform: ruby
 authors:
 - Lekë Mula
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2024-05-13 00:00:00.000000000 Z
+date: 2024-05-20 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: solargraph
@@ -58,8 +58,12 @@ files:
 - lib/solargraph/rspec/correctors/let_methods_corrector.rb
 - lib/solargraph/rspec/correctors/subject_method_corrector.rb
 - lib/solargraph/rspec/correctors/walker_base.rb
+- lib/solargraph/rspec/pin_factory.rb
 - lib/solargraph/rspec/spec_walker.rb
-- lib/solargraph/rspec/util.rb
+- lib/solargraph/rspec/spec_walker/fake_let_method.rb
+- lib/solargraph/rspec/spec_walker/full_constant_name.rb
+- lib/solargraph/rspec/spec_walker/node_types.rb
+- lib/solargraph/rspec/spec_walker/rspec_context_namespace.rb
 - lib/solargraph/rspec/version.rb
 - lib/solargraph/rspec/walker.rb
 - lib/solargraph_rspec.rb

data/lib/solargraph/rspec/util.rb

@@ -1,77 +0,0 @@
-# frozen_string_literal: true
-
-# Credits: This file is a copy of the file from the solargraph-rspec gem
-
-# rubocop:disable Naming/MethodParameterName
-module Solargraph
-  module Rspec
-    # Utility methods for building pins and references.
-    module Util
-      def self.build_public_method(
-        ns,
-        name,
-        types: nil,
-        location: nil,
-        comments: [],
-        attribute: false,
-        scope: :instance
-      )
-        opts = {
-          name: name,
-          location: location,
-          closure: ns,
-          scope: scope,
-          attribute: attribute,
-          comments: []
-        }
-
-        comments << "@return [#{types.join(",")}]" if types
-
-        opts[:comments] = comments.join("\n")
-
-        Solargraph::Pin::Method.new(**opts)
-      end
-
-      def self.build_module_include(ns, module_name, location)
-        Solargraph::Pin::Reference::Include.new(
-          closure: ns,
-          name: module_name,
-          location: location
-        )
-      end
-
-      def self.build_module_extend(ns, module_name, location)
-        Solargraph::Pin::Reference::Extend.new(
-          closure: ns,
-          name: module_name,
-          location: location
-        )
-      end
-
-      def self.dummy_location(path)
-        Solargraph::Location.new(
-          File.expand_path(path),
-          Solargraph::Range.from_to(0, 0, 0, 0)
-        )
-      end
-
-      # @param ast [Parser::AST::Node]
-      def self.build_location(ast, path)
-        Solargraph::Location.new(
-          File.expand_path(path),
-          Solargraph::Range.from_to(
-            ast.location.first_line,
-            ast.location.column,
-            ast.location.last_line,
-            ast.location.last_column
-          )
-        )
-      end
-
-      def self.method_return(path, type)
-        Solargraph::Pin::Reference::Override.method_return(path, type)
-      end
-    end
-  end
-end
-# rubocop:enable Naming/MethodParameterName