solargraph-rspec 0.1.1 → 0.2.1

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

@@ -10,13 +10,53 @@ 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|
+            namespace_pin = closest_namespace_pin(namespace_pins, location_range.start.line)
             next unless namespace_pin
 
-            subject_pin = rspec_let_method(namespace_pin, ast)
-            yield [subject_pin].compact if block_given?
+            subject_pin = rspec_subject_method(namespace_pin, subject_name, location_range, fake_method_ast)
+            add_pin(subject_pin)
           end
+
+          rspec_walker.after_walk do
+            next unless described_class_pin
+
+            namespace_pin = closest_namespace_pin(namespace_pins, described_class_pin.location.range.start.line)
+
+            add_pin(implicit_subject_pin(described_class_pin, namespace_pin)) if namespace_pin
+          end
+        end
+
+        private
+
+        # @return [Pin::Method, nil]
+        def described_class_pin
+          @described_class_pin ||= added_pins.find { |pin| pin.is_a?(Pin::Method) && pin.name == 'described_class' }
+        end
+
+        # @param namespace_pin [Pin::Namespace]
+        # @param subject_name [String, nil]
+        # @param location_range [Solargraph::Range]
+        # @param fake_method_ast [Parser::AST::Node]
+        # @return [Pin::Method]
+        def rspec_subject_method(namespace_pin, subject_name, location_range, fake_method_ast)
+          method_name = subject_name || 'subject'
+          rspec_let_method(namespace_pin, method_name, location_range, fake_method_ast)
+        end
+
+        # @param described_class_pin [Pin::Method]
+        # @param namespace_pin [Pin::Namespace]
+        # @return [Pin::Method]
+        def implicit_subject_pin(described_class_pin, namespace_pin)
+          described_class = described_class_pin.return_type.first.subtypes.first.name
+
+          PinFactory.build_public_method(
+            namespace_pin,
+            'subject',
+            types: ["::#{described_class}"],
+            location: described_class_pin.location,
+            scope: :instance
+          )
         end
       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,72 +194,22 @@ 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
 
+          # @HACK: When we describe `SomeClass` without a namespace, Solargraph confuses described_class with the
+          # `RSpec::ExampleGroups::SomeClass` constant. To avoid this, we append the root namespace with "Test"
+          block_name = "Test#{block_name}" if parent_namespace == Rspec::ROOT_NAMESPACE
+
           parent_namespace = namespace_name = "#{parent_namespace}::#{block_name}"
           block&.call(namespace_name, block_ast)
           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.1'
   end
 end