rubocop-view_component 0.6.0 → 0.8.0

data/lib/rubocop/cop/view_component/prefer_composition.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require_relative "template_analyzer"
+
 module RuboCop
   module Cop
     module ViewComponent
@@ -7,6 +9,13 @@ module RuboCop
       # instead of using composition. Inheriting one component from another
       # causes confusion when each has its own template.
       #
+      # A parent is only flagged when its name follows the component convention
+      # (the `Component` suffix, or a configured `ComponentNamespaces` prefix)
+      # and the project index confirms it is a ViewComponent with its own
+      # template. Abstract bases without a template, such as
+      # `ApplicationComponent`, are allowed, as are classes the index resolves
+      # to something other than a ViewComponent.
+      #
       # @example
       #   # bad
       #   class UserCardComponent < BaseCardComponent
@@ -19,31 +28,55 @@ module RuboCop
       #
       class PreferComposition < RuboCop::Cop::Base
         include ViewComponent::Base
+        include TemplateAnalyzer
 
         MSG = "Avoid inheriting from another ViewComponent."
 
         def on_class(node)
           parent_class = node.parent_class
-          return unless parent_class
-          return if view_component_parent?(parent_class)
-          return unless component_like_parent?(parent_class)
+          return unless parent_class&.const_type?
+          return unless inheritance_violation?(parent_class)
 
           add_offense(parent_class)
         end
 
         private
 
-        def component_like_parent?(node)
-          return false unless node.const_type?
+        # The name heuristic decides which parents are worth checking; the
+        # project index then confirms whether the parent really is a concrete
+        # ViewComponent. A parent the index can't resolve falls back to the name
+        # heuristic so projects without gem indexing are unaffected.
+        def inheritance_violation?(parent_class)
+          return false unless component_like_parent?(parent_class)
+
+          declaration = resolved_index_declaration(parent_class)
+          return true if declaration.nil?
+          return false unless view_component_parent?(parent_class)
+
+          parent_has_template?(declaration)
+        end
+
+        def parent_has_template?(declaration)
+          declaration.definitions.any? do |definition|
+            path = definition_source_path(definition)
+            path && template_paths_for(path).any?
+          end
+        rescue StandardError
+          false
+        end
+
+        def definition_source_path(definition)
+          location = definition.location
+          return nil unless location.uri.start_with?("file://")
+
+          location.to_file_path
+        end
 
+        def component_like_parent?(node)
           source = node.source
           source.end_with?("Component") ||
             component_namespaces.any? { |ns| source.start_with?(ns) }
         end
-
-        def component_namespaces
-          cop_config.fetch("ComponentNamespaces", [])
-        end
       end
     end
   end

data/lib/rubocop/cop/view_component/prefer_private_methods.rb

@@ -44,28 +44,68 @@ module RuboCop
           return unless body
 
           children = body.begin_type? ? body.children : [body]
-          check_children(children, methods_called_in_templates)
+          check_children(children, methods_called_in_templates, indexed_visibilities(class_node))
         end
 
-        def check_children(children, template_method_calls)
+        def check_children(children, template_method_calls, indexed_visibilities)
           current_visibility = :public
 
           children.each do |child|
-            if visibility_modifier?(child)
+            if bare_visibility_modifier?(child)
               current_visibility = child.method_name
-            elsif should_flag?(child, current_visibility, template_method_calls)
+            elsif child.def_type?
+              visibility = indexed_visibilities.fetch(child.method_name, current_visibility)
+              next unless should_flag?(child, visibility, template_method_calls)
+
               add_offense(child, message: format(MSG, method_name: child.method_name))
             end
           end
         end
 
         def should_flag?(child, visibility, template_method_calls)
-          child.def_type? &&
-            visibility == :public &&
+          visibility == :public &&
             !allowed_public_method?(child.method_name) &&
             !template_method_calls.include?(child.method_name)
         end
 
+        # The effective visibility of each method defined in the class, taken
+        # from the project index. This covers the forms an in-file walk cannot
+        # see: `private :name`, `private def name`, `public :name`, and
+        # visibility applied in another file. Empty when the class is not in
+        # the index (for example with `ComponentNamespaces`, which does not
+        # require one), in which case the in-file keyword below is used
+        # instead.
+        def indexed_visibilities(class_node)
+          return {} unless project_index && class_node.identifier
+
+          declaration = resolved_index_declaration(class_node.identifier)
+          return {} unless declaration.is_a?(Rubydex::Namespace)
+
+          declaration.members.each_with_object({}) do |member, visibilities|
+            next unless member.is_a?(Rubydex::Method)
+
+            visibilities[member_method_name(member)] = member.visibility
+          end
+        rescue StandardError
+          {}
+        end
+
+        def member_method_name(member)
+          member.unqualified_name.sub(/\(.*\)\z/, "").to_sym
+        end
+
+        # A `private`/`protected`/`public` call with no arguments, which
+        # changes the visibility of every method that follows it. Forms that
+        # name their methods do not change it: `private :name` and
+        # `private def name` are handled by the index above.
+        def bare_visibility_modifier?(node)
+          return false unless node.send_type?
+          return false unless node.receiver.nil?
+          return false unless %i[private protected public].include?(node.method_name)
+
+          node.arguments.empty?
+        end
+
         def allowed_public_method?(method_name)
           allowed_public_methods.include?(method_name.to_s) ||
             allowed_public_method_patterns.any? { |pattern| method_name.to_s.match?(pattern) }
@@ -91,13 +131,6 @@ module RuboCop
           warn "Warning: Failed to analyze templates: #{e.message}" if ENV["RUBOCOP_DEBUG"]
           Set.new
         end
-
-        def visibility_modifier?(node)
-          return false unless node.send_type?
-          return false unless node.receiver.nil?
-
-          %i[private protected public].include?(node.method_name)
-        end
       end
     end
   end

data/lib/rubocop/cop/view_component/rspec_scope.rb

@@ -0,0 +1,98 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module ViewComponent
+      # Helpers for navigating the RSpec example-group structure of a spec file.
+      #
+      # RSpec specs often build a component indirectly, through `described_class`
+      # inside a `describe SomeComponent` block or through a `let`/`subject`
+      # helper. This module locates those constructs without knowing whether the
+      # referenced constant is actually a ViewComponent; that judgement is left
+      # to the cop, which has access to the project index.
+      module RSpecScope
+        EXAMPLE_METHODS = %i[it specify example].freeze
+        EXAMPLE_GROUP_METHODS = %i[describe context feature example_group].freeze
+        MEMOIZED_HELPER_METHODS = %i[let let! subject subject!].freeze
+
+        def rspec_example_block?(node)
+          EXAMPLE_METHODS.include?(node.send_node&.method_name)
+        end
+
+        # The constant argument of the nearest enclosing `describe` block, if any.
+        # `each_ancestor` yields the closest ancestor first, so an inner
+        # `describe` wins over an outer one.
+        def enclosing_described_class(node)
+          node.each_ancestor(:block) do |ancestor|
+            send_node = ancestor.send_node
+            next unless send_node&.method?(:describe)
+
+            first_argument = send_node.first_argument
+            return first_argument if first_argument&.const_type?
+          end
+
+          nil
+        end
+
+        def described_class_reference?(node)
+          node.send_type? && node.method?(:described_class)
+        end
+
+        # Bare method calls (no receiver, no arguments) within +node+, e.g.
+        # `component` in `expect(component.title)`.
+        def referenced_helper_names(node)
+          node.each_node(:send).filter_map do |send_node|
+            next unless send_node.receiver.nil?
+            next unless send_node.arguments.empty?
+
+            send_node.method_name
+          end
+        end
+
+        # Maps helper name to block body for every `let`/`subject` defined in an
+        # enclosing example group. Inner definitions are visited first and win
+        # over outer ones, matching how the name resolves at runtime.
+        def helper_definitions(node)
+          node.each_ancestor(:block).with_object({}) do |ancestor, definitions|
+            next unless example_group_block?(ancestor)
+
+            each_helper_definition(ancestor) do |name, body|
+              definitions[name] ||= body
+            end
+          end
+        end
+
+        private
+
+        def each_helper_definition(group)
+          return unless group.body
+
+          statements_of(group.body).each do |statement|
+            next unless statement.block_type?
+
+            name = helper_name(statement.send_node)
+            yield(name, statement.body) if name
+          end
+        end
+
+        def statements_of(node)
+          node.begin_type? ? node.children : [node]
+        end
+
+        def helper_name(send_node)
+          return nil unless MEMOIZED_HELPER_METHODS.include?(send_node&.method_name)
+
+          first_argument = send_node.first_argument
+          return first_argument.value if first_argument&.sym_type?
+          return :subject if %i[subject subject!].include?(send_node.method_name)
+
+          nil
+        end
+
+        def example_group_block?(node)
+          EXAMPLE_GROUP_METHODS.include?(node.send_node&.method_name)
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/view_component/supplementary_index.rb

@@ -0,0 +1,142 @@
+# frozen_string_literal: true
+
+require "digest"
+require "rubydex"
+require "uri"
+
+module RuboCop
+  module Cop
+    module ViewComponent
+      # Extends the project index with `AdditionalSourcePaths`: source
+      # directories the cops index themselves, so a chain that passes through a
+      # gem RuboCop does not index is still resolvable. The motivating case is a
+      # Rails engine's `app/components`, which `AllCops/ProjectIndexIncludesGems`
+      # misses because it only indexes a gem's `lib`.
+      module SupplementaryIndex
+        # A minimal stand-in for the framework base class, indexed alongside the
+        # configured paths so ancestry there can still reach
+        # `ViewComponent::Base` without indexing the whole view_component gem.
+        BASE_URI = "rubydex:view_component_base"
+        BASE_SOURCE = <<~RUBY
+          module ViewComponent
+            class Base
+            end
+          end
+        RUBY
+
+        # RuboCop's cache key, extended with the supplementary files' mtimes:
+        # those files are not part of RuboCop's own index documents, so a change
+        # to one would otherwise not invalidate a cached result.
+        def external_dependency_checksum
+          base = super
+          extra = supplementary_files_checksum
+          return base if extra.nil?
+          return extra if base.nil?
+
+          Digest::SHA1.hexdigest("#{base}:#{extra}")
+        end
+
+        private
+
+        # Resolve through RuboCop's project index first, then the supplementary one.
+        def resolve_constant_in_index(const_node)
+          super || resolve_constant_in_graph(supplementary_index, const_node)
+        end
+
+        def resolve_constant_in_graph(graph, const_node)
+          return nil unless graph
+
+          segments = const_node.const_name.split("::")
+          # The inspected file's lexical scopes live in the project index, not
+          # in the supplementary one, so resolving through them can fail (a
+          # scope name like `Ui` is simply absent here). Try them first, then
+          # resolve from the top level.
+          nesting_candidates(const_node).each do |nesting|
+            declaration = resolve_segments(graph, segments, nesting)
+            return declaration if declaration
+          end
+          nil
+        end
+
+        def nesting_candidates(const_node)
+          return [[]] if const_node.absolute?
+
+          [lexical_nesting_of(const_node), []].uniq
+        end
+
+        def resolve_segments(graph, segments, nesting)
+          declaration = graph.resolve_constant(segments.first, nesting)
+          return nil unless declaration
+
+          segments.drop(1).each do |segment|
+            return nil unless declaration.is_a?(Rubydex::Namespace)
+
+            declaration = declaration.find_member(segment)
+            return nil unless declaration
+          end
+          declaration
+        end
+
+        # Built once per cop and only when the option is set.
+        def supplementary_index
+          return @supplementary_index if defined?(@supplementary_index)
+
+          @supplementary_index = build_supplementary_index
+        end
+
+        def build_supplementary_index
+          files = supplementary_source_files
+          return nil if files.empty?
+
+          graph = Rubydex::Graph.new
+          graph.index_source(BASE_URI, BASE_SOURCE, "ruby")
+          index_files(graph, files)
+          graph.resolve
+          graph
+        rescue StandardError
+          nil
+        end
+
+        def index_files(graph, files)
+          # File by file, not `index_all`: in a forked RuboCop worker
+          # `index_all` crashes once the parent has built its own graph, while
+          # `index_source` is safe.
+          files.each do |file|
+            graph.index_source(file_uri(file), File.read(file), "ruby")
+          rescue StandardError
+            next
+          end
+        end
+
+        def file_uri(file)
+          "file://#{URI::DEFAULT_PARSER.escape(file)}"
+        end
+
+        def supplementary_source_files
+          configured_source_paths.flat_map { |path| Dir.glob(File.join(path, "**", "*.rb")) }.uniq.sort
+        end
+
+        def configured_source_paths
+          Array(cop_config["AdditionalSourcePaths"]).filter_map do |path|
+            expanded = File.expand_path(path, config.base_dir_for_path_parameters)
+            expanded if File.directory?(expanded)
+          end
+        end
+
+        def supplementary_files_checksum
+          files = supplementary_source_files
+          return nil if files.empty?
+
+          Digest::SHA1.hexdigest(files.map { |file| file_signature(file) }.join("\n"))
+        end
+
+        def file_signature(file)
+          stat = File.stat(file)
+          "#{file}:#{stat.mtime.to_f}:#{stat.size}"
+        rescue StandardError
+          file
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/view_component/test_rendered_output.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require_relative "rspec_scope"
+
 module RuboCop
   module Cop
     module ViewComponent
@@ -8,6 +10,11 @@ module RuboCop
       #
       # This cop is only enabled for test files by default (see config).
       #
+      # A test is considered to instantiate a component when it builds one
+      # directly (`UserComponent.new`), through `described_class.new` inside a
+      # `describe UserComponent` block, or by referencing a `let`/`subject`
+      # helper whose body instantiates a component.
+      #
       # @example
       #   # bad
       #   def test_formatted_title
@@ -21,10 +28,40 @@ module RuboCop
       #     assert_text "HELLO"
       #   end
       #
+      #   # bad
+      #   describe TitleComponent do
+      #     it "formats the title" do
+      #       component = described_class.new("hello")
+      #       expect(component.formatted_title).to eq("HELLO")
+      #     end
+      #   end
+      #
+      #   # good
+      #   describe TitleComponent do
+      #     it "formats the title" do
+      #       render_inline described_class.new("hello")
+      #       expect(page).to have_text("HELLO")
+      #     end
+      #   end
+      #
+      #   # bad
+      #   let(:component) { TitleComponent.new("hello") }
+      #
+      #   it "formats the title" do
+      #     expect(component.formatted_title).to eq("HELLO")
+      #   end
+      #
       class TestRenderedOutput < RuboCop::Cop::Base
+        include ViewComponent::Base
+        include RSpecScope
+
         MSG = "Test instantiates a component but doesn't use `render_inline` or `render_preview`. " \
               "Test the rendered output instead of component methods directly."
 
+        # `render_in_view_context` renders through a view context (it is what
+        # form-builder tests need), so it is a rendered-output test too.
+        RENDER_METHODS = %i[render_inline render_preview render_in_view_context].freeze
+
         # Check Minitest-style test methods
         def on_def(node)
           return unless within_test_paths?
@@ -32,7 +69,7 @@ module RuboCop
           method_name = node.method_name.to_s
           return unless method_name.start_with?("test_")
           return unless instantiates_component?(node)
-          return if contains_render_method?(node)
+          return if renders_output?(node)
 
           add_offense(node)
         end
@@ -40,13 +77,14 @@ module RuboCop
         # Check RSpec-style it blocks
         def on_block(node)
           return unless within_test_paths?
-          return unless rspec_it_block?(node)
+          return unless rspec_example_block?(node)
           return unless instantiates_component?(node)
-          return if contains_render_method?(node)
+          return if renders_output?(node)
 
           add_offense(node)
         end
         alias on_numblock on_block
+        alias on_itblock on_block
 
         private
 
@@ -59,24 +97,82 @@ module RuboCop
         end
 
         def instantiates_component?(node)
-          node.each_descendant(:send).any? do |send_node|
+          component_new_call?(node) ||
+            referenced_helper?(node) { |body| component_new_call?(body) }
+        end
+
+        def renders_output?(node)
+          render_call?(node) ||
+            referenced_helper?(node) { |body| render_call?(body) }
+        end
+
+        # True when the node calls `.new` on a component constant or on
+        # `described_class` within a `describe` block.
+        def component_new_call?(node)
+          node.each_node(:send).any? do |send_node|
             next unless send_node.method?(:new)
+            next if inside_error_expectation?(send_node)
 
-            send_node.receiver&.const_type?
+            component_receiver?(send_node.receiver)
           end
         end
 
-        def contains_render_method?(node)
-          node.each_descendant(:send).any? do |send_node|
-            %i[render_inline render_preview].include?(send_node.method_name)
+        # A component built inside an error assertion is exercising
+        # initialisation behaviour rather than rendered output, so there is
+        # nothing to render. Covers RSpec's `expect { ... }.to raise_error` and
+        # Minitest's `assert_raises`.
+        def inside_error_expectation?(node)
+          node.each_ancestor(:block).any? do |ancestor|
+            error_assertion?(ancestor)
           end
         end
 
-        def rspec_it_block?(node)
-          send_node = node.send_node
+        def error_assertion?(block)
+          send_node = block.send_node
           return false unless send_node
+          return true if send_node.method?(:assert_raises)
+
+          send_node.method?(:expect) && error_expectation?(block)
+        end
+
+        def error_expectation?(expect_block)
+          parent = expect_block.parent
+          return false unless parent&.send_type?
+          return false unless %i[to not_to].include?(parent.method_name)
+
+          error_matcher?(parent.first_argument)
+        end
+
+        def error_matcher?(matcher)
+          matcher = matcher.send_node if matcher&.block_type?
+          matcher&.send_type? &&
+            %i[raise_error raise_exception].include?(matcher.method_name)
+        end
 
-          %i[it specify example].include?(send_node.method_name)
+        def component_receiver?(receiver)
+          return false unless receiver
+          return view_component_parent?(receiver) if receiver.const_type?
+          return false unless described_class_reference?(receiver)
+
+          described_class = enclosing_described_class(receiver)
+          described_class && view_component_parent?(described_class)
+        end
+
+        def render_call?(node)
+          node.each_node(:send).any? do |send_node|
+            RENDER_METHODS.include?(send_node.method_name)
+          end
+        end
+
+        # True when the node references a `let`/`subject` helper whose body
+        # satisfies the given block.
+        def referenced_helper?(node)
+          helper_bodies = helper_definitions(node)
+
+          referenced_helper_names(node).any? do |name|
+            body = helper_bodies[name]
+            body && yield(body)
+          end
         end
       end
     end

data/lib/rubocop/view_component/version.rb

@@ -2,6 +2,6 @@
 
 module RuboCop
   module ViewComponent
-    VERSION = "0.6.0"
+    VERSION = "0.8.0"
   end
 end

data/script/verify

@@ -49,7 +49,7 @@ def main
 
   Dir.chdir(config[:verification_dir]) do
     configure_rubocop(config[:config_file], config[:display_name])
-    add_gem_to_gemfile
+    replace_gemfile
 
     Bundler.with_unbundled_env do
       output = run_rubocop
@@ -89,29 +89,39 @@ def download_source(dir, tarball_url, display_name)
   system!("tar", "xz", "-C", dir, "--strip-components=1", "-f", "#{dir}/source.tar.gz")
 end
 
+# Replace the library's .rubocop.yml with a config that only runs our
+# ViewComponent cops. The library's own config may reference gems outside the
+# minimal bundle (see replace_gemfile), e.g. inherit_gem, require, or config
+# for cops from other RuboCop extensions.
 def configure_rubocop(config_file, display_name)
-  puts "Configuring .rubocop.yml with #{display_name} overrides..."
-  config = File.exist?(".rubocop.yml") ? YAML.load_file(".rubocop.yml") : {}
-  library_config = YAML.load_file(config_file)
-
-  # Merge the library config into the existing config
-  library_config.each do |key, value|
-    config[key] = if config[key].is_a?(Hash) && value.is_a?(Hash)
-                    config[key].merge(value)
-                  else
-                    value
-                  end
-  end
+  puts "Replacing .rubocop.yml with #{display_name} overrides..."
+  config = YAML.load_file(config_file)
+
+  # Silence warnings about unconfigured new cops - only ViewComponent cops run
+  config["AllCops"] ||= {}
+  config["AllCops"]["NewCops"] = "disable"
 
   File.write(".rubocop.yml", YAML.dump(config))
 end
 
-def add_gem_to_gemfile
-  puts "Adding rubocop-view_component gem to Gemfile..."
-  File.open("Gemfile", "a") { |f| f.puts "gem 'rubocop-view_component', path: '#{GEM_DIR}'" }
+# Replace the library's Gemfile with a minimal one. This avoids installing the
+# library's own dependencies, which are not needed for static analysis and can
+# fail to install or conflict with the rubocop version we require.
+# `view_component` must be present so the project index can resolve
+# `ViewComponent::Base` for ancestry-based detection.
+def replace_gemfile
+  puts "Replacing Gemfile with minimal setup..."
+  File.write("Gemfile", <<~RUBY)
+    source "https://rubygems.org"
+
+    gem "rubocop"
+    gem "rubocop-view_component", path: "#{GEM_DIR}"
+    gem "view_component"
+  RUBY
 end
 
 def run_rubocop
+  FileUtils.rm_f("Gemfile.lock")
   puts "Running bundle install..."
   system!("bundle", "install")
 
@@ -126,6 +136,9 @@ def run_rubocop
 
   puts "RuboCop exit status: #{status.exitstatus}"
 
+  # Exit status 0 means no offenses, 1 means offenses found (expected, since
+  # the libraries have known offenses). 2 means RuboCop itself failed.
+  abort "ERROR: RuboCop failed (exit status: #{status.exitstatus})" if status.exitstatus == 2
   abort "ERROR: RuboCop produced no output (exit status: #{status.exitstatus})" if output.strip.empty?
 
   output