solargraph-rspec 0.1.0

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

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+require_relative 'walker_base'
+
+module Solargraph
+  module Rspec
+    module Correctors
+      # A corrector of RSpec parsed pins by 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)
+            original_block_pin_index = source_map.pins.index(original_block_pin)
+            location = Util.build_location(ast, source_map.filename)
+
+            # Define a dynamic module for the example group block
+            # Example:
+            #   RSpec.describe Foo::Bar do  # => module RSpec::ExampleGroups::FooBar
+            #     context 'some context' do # => module RSpec::ExampleGroups::FooBar::SomeContext
+            #     end
+            #   end
+            namespace_pin = Solargraph::Pin::Namespace.new(
+              name: namespace_name,
+              location: location
+            )
+
+            fixed_namespace_block_pin = Solargraph::Pin::Block.new(
+              closure: namespace_pin,
+              location: original_block_pin.location,
+              receiver: original_block_pin.receiver,
+              scope: original_block_pin.scope
+            )
+
+            source_map.pins[original_block_pin_index] = fixed_namespace_block_pin
+
+            # 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_pin,
+              root_example_group_namespace_pin.name,
+              location
+            )
+
+            # 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_pin,
+              parent_namespace_name,
+              location
+            )
+
+            namespace_pins << namespace_pin
+            if block_given?
+              yield [
+                namespace_include_pin,
+                namespace_extend_pin
+              ]
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+require_relative 'walker_base'
+
+module Solargraph
+  module Rspec
+    module Correctors
+      class DescribedClassCorrector < WalkerBase
+        # @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)
+            next unless namespace_pin
+
+            described_class_pin = rspec_described_class_method(namespace_pin, ast, described_class_name)
+            yield [described_class_pin].compact if block_given?
+          end
+        end
+
+        private
+
+        # @param namespace [Pin::Namespace]
+        # @param ast [Parser::AST::Node]
+        # @param described_class_name [String]
+        # @return [Pin::Method, nil]
+        def rspec_described_class_method(namespace, ast, described_class_name)
+          Util.build_public_method(
+            namespace,
+            'described_class',
+            types: ["Class<#{described_class_name}>"],
+            location: Util.build_location(ast, namespace.filename),
+            scope: :instance
+          )
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+require_relative 'walker_base'
+
+module Solargraph
+  module Rspec
+    module Correctors
+      class DslMethodsCorrector < WalkerBase
+        # @param namespace_pins [Array<Solargraph::Pin::Base>]
+        # @param rspec_walker [Solargraph::Rspec::SpecWalker]
+        # @param config [Solargraph::Rspec::Config]
+        def initialize(namespace_pins:, rspec_walker:, config:)
+          super(namespace_pins: namespace_pins, rspec_walker: rspec_walker)
+          @config = config
+        end
+
+        # @param source_map [Solargraph::SourceMap]
+        # @return [void]
+        def correct(_source_map)
+          rspec_walker.after_walk do
+            if block_given?
+              yield namespace_pins.flat_map { |namespace_pin| add_context_dsl_methods(namespace_pin) }
+              yield namespace_pins.flat_map { |namespace_pin| add_methods_with_example_binding(namespace_pin) }
+            end
+          end
+        end
+
+        private
+
+        # @return [Solargraph::Rspec::Config]
+        attr_reader :config
+
+        # RSpec executes example and hook blocks (eg. it, before, after)in the context of the example group.
+        # @yieldsef changes the binding of the block to correct class.
+        # @return [Array<Solargraph::Pin::Method>]
+        def add_methods_with_example_binding(namespace_pin)
+          rspec_context_block_methods.map do |method|
+            Util.build_public_method(
+              namespace_pin,
+              method.to_s,
+              comments: ["@yieldself [#{namespace_pin.path}]"], # Fixes the binding of the block to the correct class
+              scope: :class
+            )
+          end
+        end
+
+        # TODO: DSL methods should be defined once in the root example group and extended to all example groups.
+        #   Fix this once Solargraph supports extending class methods.
+        # @param namespace_pin [Solargraph::Pin::Base]
+        # @return [Array<Solargraph::Pin::Base>]
+        def add_context_dsl_methods(namespace_pin)
+          Rspec::CONTEXT_METHODS.map do |method|
+            Util.build_public_method(
+              namespace_pin,
+              method.to_s,
+              scope: :class
+            )
+          end
+        end
+
+        # @return [Array<String>]
+        def rspec_context_block_methods
+          config.let_methods + Rspec::HOOK_METHODS + Rspec::EXAMPLE_METHODS
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+require_relative 'walker_base'
+
+module Solargraph
+  module Rspec
+    module Correctors
+      # Sets the correct namespace binding for example group blocks (it, example, etc.) and
+      # hook blocks (before, after, around)
+      class ExampleAndHookBlocksBindingCorrector < WalkerBase
+        # @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)
+
+            yield [] if block_given?
+          end
+
+          rspec_walker.on_hook_block do |block_ast|
+            bind_closest_namespace(block_ast, source_map)
+
+            yield [] if block_given?
+          end
+
+          rspec_walker.on_let_method do |let_method_ast|
+            bind_closest_namespace(let_method_ast, source_map)
+
+            yield [] if block_given?
+          end
+
+          rspec_walker.on_blocks_in_examples do |block_ast|
+            bind_closest_namespace(block_ast, source_map)
+
+            yield [] if block_given?
+          end
+        end
+
+        private
+
+        # @param block_ast [Parser::AST::Node]
+        # @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)
+          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_index = source_map.pins.index(original_block_pin)
+          fixed_namespace_block_pin = Solargraph::Pin::Block.new(
+            closure: example_run_method(namespace_pin),
+            location: original_block_pin.location,
+            receiver: original_block_pin.receiver,
+            scope: original_block_pin.scope
+          )
+
+          source_map.pins[original_block_pin_index] = fixed_namespace_block_pin
+        end
+
+        # @param namespace_pin [Solargraph::Pin::Namespace]
+        # @return [Solargraph::Pin::Method]
+        def example_run_method(namespace_pin)
+          Util.build_public_method(
+            namespace_pin,
+            'run',
+            # https://github.com/rspec/rspec-core/blob/main/lib/rspec/core/example.rb#L246
+            location: Solargraph::Location.new('lib/rspec/core/example.rb', Solargraph::Range.from_to(246, 1, 297, 1))
+          )
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+require_relative 'let_methods_corrector'
+
+module Solargraph
+  module Rspec
+    module Correctors
+      # Defines let-like methods in the example group block
+      class ImplicitSubjectMethodCorrector < Base
+        # @return [Pin::Method]
+        attr_reader :described_class_pin
+
+        # @param namespace_pins [Array<Pin::Namespace>]
+        # @param described_class_pin [Pin::Method]
+        def initialize(namespace_pins:, described_class_pin:)
+          super(namespace_pins: namespace_pins)
+
+          @described_class_pin = described_class_pin
+        end
+
+        # @param source_map [Solargraph::SourceMap]
+        # @return [void]
+        def correct(_source_map)
+          namespace_pin = closest_namespace_pin(namespace_pins, described_class_pin.location.range.start.line)
+
+          yield [implicit_subject_pin(described_class_pin, namespace_pin)] if block_given? && namespace_pin
+        end
+
+        private
+
+        # @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
+
+          Util.build_public_method(
+            namespace_pin,
+            'subject',
+            types: [described_class],
+            location: described_class_pin.location,
+            scope: :instance
+          )
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+require_relative 'walker_base'
+
+module Solargraph
+  module Rspec
+    module Correctors
+      # Defines let-like methods in the example group block
+      class LetMethodsCorrector < WalkerBase
+        # @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)
+            next unless namespace_pin
+
+            pin = rspec_let_method(namespace_pin, ast)
+            yield [pin] if block_given?
+          end
+        end
+
+        private
+
+        # @param namespace [Pin::Namespace]
+        # @param ast [Parser::AST::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(
+            namespace,
+            method_name,
+            types: types,
+            location: Util.build_location(ast, namespace.filename),
+            scope: :instance
+          )
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+require_relative 'let_methods_corrector'
+
+module Solargraph
+  module Rspec
+    module Correctors
+      # Defines let-like methods in the example group block
+      class SubjectMethodCorrector < LetMethodsCorrector
+        # @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)
+            next unless namespace_pin
+
+            subject_pin = rspec_let_method(namespace_pin, ast)
+            yield [subject_pin].compact if block_given?
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+require_relative 'base'
+
+# A corrector that walks through RSpec AST nodes and corrects them
+module Solargraph
+  module Rspec
+    module Correctors
+      # A corrector of RSpec parsed pins by Solargraph
+      # @abstract
+      class WalkerBase < Base
+        # @return [Array<Solargraph::Pin::Namespace>]
+        attr_reader :namespace_pins
+
+        # @return [Solargraph::Rspec::SpecWalker]
+        attr_reader :rspec_walker
+
+        # @param namespace_pins [Array<Solargraph::Pin::Base>]
+        # @param rspec_walker [Solargraph::Rspec::SpecWalker]
+        def initialize(namespace_pins:, rspec_walker:)
+          super(namespace_pins: namespace_pins)
+          @rspec_walker = rspec_walker
+        end
+      end
+    end
+  end
+end

data/lib/solargraph/rspec/spec_walker.rb

@@ -0,0 +1,247 @@
+# frozen_string_literal: true
+
+require_relative 'walker'
+
+module Solargraph
+  module Rspec
+    class SpecWalker
+      # @param source_map [SourceMap]
+      # @param config [Config]
+      def initialize(source_map:, config:)
+        @source_map = source_map
+        @config = config
+        @walker = Rspec::Walker.from_source(source_map.source)
+        @handlers = {
+          on_described_class: [],
+          on_let_method: [],
+          on_subject: [],
+          on_each_context_block: [],
+          on_example_block: [],
+          on_hook_block: [],
+          on_blocks_in_examples: [],
+          after_walk: []
+        }
+      end
+
+      # @return [Walker]
+      attr_reader :walker
+
+      # @return [Config]
+      attr_reader :config
+
+      # @param block [Proc]
+      # @return [void]
+      def on_described_class(&block)
+        @handlers[:on_described_class] << block
+      end
+
+      # @param block [Proc]
+      # @return [void]
+      def on_let_method(&block)
+        @handlers[:on_let_method] << block
+      end
+
+      # @param block [Proc]
+      # @return [void]
+      def on_subject(&block)
+        @handlers[:on_subject] << block
+      end
+
+      # @param block [Proc]
+      # @return [void]
+      def on_each_context_block(&block)
+        @handlers[:on_each_context_block] << block
+      end
+
+      #
+      # @param block [Proc]
+      # @return [void]
+      def on_example_block(&block)
+        @handlers[:on_example_block] << block
+      end
+
+      # @param block [Proc]
+      # @return [void]
+      def on_hook_block(&block)
+        @handlers[:on_hook_block] << block
+      end
+
+      # @param block [Proc]
+      # @return [void]
+      def on_blocks_in_examples(&block)
+        @handlers[:on_blocks_in_examples] << block
+      end
+
+      # @param block [Proc]
+      # @return [void]
+      def after_walk(&block)
+        @handlers[:after_walk] << block
+      end
+
+      # @return [void]
+      def walk!
+        each_context_block(@walker.ast, Rspec::ROOT_NAMESPACE) do |namespace_name, ast|
+          @handlers[:on_each_context_block].each do |handler|
+            handler.call(namespace_name, 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)
+          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
+          end
+        end
+
+        walker.on :send, [nil, :subject] do |ast|
+          @handlers[:on_subject].each do |handler|
+            handler.call(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)
+
+          @handlers[:on_example_block].each do |handler|
+            handler.call(block_ast)
+          end
+
+          # @param blocks_in_examples [Parser::AST::Node]
+          each_block(block_ast.children[2]) do |blocks_in_examples|
+            @handlers[:on_blocks_in_examples].each do |handler|
+              handler.call(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)
+
+          @handlers[:on_hook_block].each do |handler|
+            handler.call(block_ast)
+          end
+
+          # @param blocks_in_examples [Parser::AST::Node]
+          each_block(block_ast.children[2]) do |blocks_in_examples|
+            @handlers[:on_blocks_in_examples].each do |handler|
+              handler.call(blocks_in_examples)
+            end
+          end
+        end
+
+        walker.walk
+
+        @handlers[:after_walk].each(&:call)
+      end
+
+      private
+
+      # @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)
+
+        is_a_block = ast.type == :block && ast.children[0].type == :send
+
+        if is_a_block
+          result = block&.call(ast, parent_result)
+          parent_result = result if result
+        end
+
+        ast.children.each { |child| each_block(child, parent_result, &block) }
+      end
+
+      # Find all describe/context blocks in the AST.
+      # @param ast [Parser::AST::Node]
+      # @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])
+
+          next unless is_a_context
+
+          description_node = block_ast.children[0].children[2]
+          block_name = rspec_describe_class_name(description_node)
+          next unless block_name
+
+          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