rubocop-view_component 0.1.0

data/config/default.yml

@@ -0,0 +1,33 @@
+ViewComponent/ComponentSuffix:
+  Description: 'Enforce -Component suffix for ViewComponent classes.'
+  Enabled: true
+  VersionAdded: '0.1'
+  Severity: warning
+  StyleGuide: 'https://viewcomponent.org/best_practices.html'
+
+ViewComponent/NoGlobalState:
+  Description: 'Avoid accessing global state (params, request, session, cookies, flash) directly.'
+  Enabled: true
+  VersionAdded: '0.1'
+  Severity: warning
+  StyleGuide: 'https://viewcomponent.org/best_practices.html'
+
+ViewComponent/PreferPrivateMethods:
+  Description: 'Suggest making helper methods private.'
+  Enabled: true
+  VersionAdded: '0.1'
+  Severity: convention
+  StyleGuide: 'https://viewcomponent.org/best_practices.html'
+  AllowedPublicMethods:
+    - initialize
+    - call
+    - before_render
+    - before_render_check
+    - render?
+
+ViewComponent/PreferSlots:
+  Description: 'Prefer slots over HTML string parameters.'
+  Enabled: true
+  VersionAdded: '0.1'
+  Severity: warning
+  StyleGuide: 'https://viewcomponent.org/best_practices.html'

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

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module ViewComponent
+      # Shared helper methods for ViewComponent cops
+      module Base
+        # Check if a class node inherits from ViewComponent::Base or ApplicationComponent
+        def view_component_class?(node)
+          return false unless node&.class_type?
+
+          parent_class = node.parent_class
+          return false unless parent_class
+
+          view_component_parent?(parent_class)
+        end
+
+        # Check if node represents ViewComponent::Base or ApplicationComponent
+        def view_component_parent?(node)
+          return false unless node.const_type?
+
+          source = node.source
+          source == "ViewComponent::Base" || source == "ApplicationComponent"
+        end
+
+        # Find the enclosing class node
+        def enclosing_class(node)
+          node.each_ancestor(:class).first
+        end
+
+        # Check if node is within a ViewComponent class
+        def inside_view_component?(node)
+          klass = enclosing_class(node)
+          return false unless klass
+
+          view_component_class?(klass)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module ViewComponent
+      # Enforces that ViewComponent classes end with the `Component` suffix.
+      #
+      # @example
+      #   # bad
+      #   class FooBar < ViewComponent::Base
+      #   end
+      #
+      #   # good
+      #   class FooBarComponent < ViewComponent::Base
+      #   end
+      #
+      class ComponentSuffix < RuboCop::Cop::Base
+        include ViewComponent::Base
+
+        MSG = "ViewComponent class names should end with `Component`."
+
+        def on_class(node)
+          return unless view_component_class?(node)
+
+          class_name = node.identifier.source
+          return if class_name.end_with?("Component")
+
+          add_offense(node.identifier)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module ViewComponent
+      # Prevents direct access to global state within ViewComponent classes.
+      #
+      # @example
+      #   # bad
+      #   class UserComponent < ViewComponent::Base
+      #     def admin?
+      #       params[:admin]
+      #     end
+      #   end
+      #
+      #   # good
+      #   class UserComponent < ViewComponent::Base
+      #     def initialize(admin:)
+      #       @admin = admin
+      #     end
+      #
+      #     def admin?
+      #       @admin
+      #     end
+      #   end
+      #
+      class NoGlobalState < RuboCop::Cop::Base
+        include ViewComponent::Base
+
+        MSG = "Avoid accessing `%<method>s` directly in ViewComponents. " \
+              "Pass necessary data through the constructor instead."
+
+        GLOBAL_STATE_METHODS = %i[
+          params
+          request
+          session
+          cookies
+          flash
+        ].freeze
+
+        RESTRICT_ON_SEND = GLOBAL_STATE_METHODS
+
+        def_node_matcher :global_state_access?, <<~PATTERN
+          (send nil? ${:params :request :session :cookies :flash} ...)
+        PATTERN
+
+        def on_send(node)
+          return unless inside_view_component?(node)
+
+          method_name = global_state_access?(node)
+          return unless method_name
+
+          add_offense(node, message: format(MSG, method: method_name))
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module ViewComponent
+      # Suggests making helper methods private in ViewComponents.
+      #
+      # @example
+      #   # bad
+      #   class CardComponent < ViewComponent::Base
+      #     def formatted_title
+      #       @title.upcase
+      #     end
+      #   end
+      #
+      #   # good
+      #   class CardComponent < ViewComponent::Base
+      #     private
+      #
+      #     def formatted_title
+      #       @title.upcase
+      #     end
+      #   end
+      #
+      class PreferPrivateMethods < RuboCop::Cop::Base
+        include ViewComponent::Base
+
+        MSG = "Consider making this method private. " \
+              "Only ViewComponent interface methods should be public."
+
+        ALLOWED_PUBLIC_METHODS = %i[
+          initialize
+          call
+          before_render
+          before_render_check
+          render?
+        ].freeze
+
+        def on_class(node)
+          return unless view_component_class?(node)
+
+          check_public_methods(node)
+        end
+
+        private
+
+        def check_public_methods(class_node)
+          current_visibility = :public
+
+          class_node.body&.each_child_node do |child|
+            if visibility_modifier?(child)
+              current_visibility = child.method_name
+              next
+            end
+
+            next unless child.def_type?
+            next unless current_visibility == :public
+            next if ALLOWED_PUBLIC_METHODS.include?(child.method_name)
+
+            add_offense(child)
+          end
+        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
+end

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

@@ -0,0 +1,105 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module ViewComponent
+      # Detects parameters that accept HTML content and suggests using slots.
+      #
+      # @example
+      #   # bad
+      #   class ModalComponent < ViewComponent::Base
+      #     def initialize(title:, body_html:)
+      #       @title = title
+      #       @body_html = body_html
+      #     end
+      #   end
+      #
+      #   # good
+      #   class ModalComponent < ViewComponent::Base
+      #     renders_one :body
+      #
+      #     def initialize(title:)
+      #       @title = title
+      #     end
+      #   end
+      #
+      class PreferSlots < RuboCop::Cop::Base
+        include ViewComponent::Base
+
+        MSG = "Consider using `%<slot_method>s` instead of passing HTML " \
+              "as a parameter. This maintains Rails' automatic HTML escaping."
+
+        HTML_PARAM_PATTERNS = [
+          /_html$/,
+          /_content$/,
+          /^html_/,
+          /^content$/
+        ].freeze
+
+        # Exclude common non-HTML parameters
+        EXCLUDED_PARAMS = %i[
+          html_class
+          html_classes
+          html_id
+          html_tag
+        ].freeze
+
+        def_node_search :html_safe_call?, "(send _ :html_safe)"
+
+        def on_class(node)
+          return unless view_component_class?(node)
+
+          initialize_method = find_initialize(node)
+          return unless initialize_method
+
+          check_initialize_params(initialize_method)
+        end
+
+        private
+
+        def find_initialize(class_node)
+          class_node.each_descendant(:def).find do |def_node|
+            def_node.method_name == :initialize
+          end
+        end
+
+        def check_initialize_params(initialize_node)
+          initialize_node.arguments.each do |arg|
+            next unless arg.kwoptarg_type? || arg.kwarg_type?
+
+            param_name = arg.children[0]
+
+            # Skip excluded parameters
+            next if EXCLUDED_PARAMS.include?(param_name)
+
+            # Check parameter name patterns
+            if html_param_name?(param_name)
+              suggested_slot = suggest_slot_name(param_name)
+              add_offense(arg, message: format(MSG, slot_method: suggested_slot))
+              next
+            end
+
+            # Check for html_safe in default value
+            if arg.kwoptarg_type? && html_safe_call?(arg)
+              suggested_slot = suggest_slot_name(param_name)
+              add_offense(arg, message: format(MSG, slot_method: suggested_slot))
+            end
+          end
+        end
+
+        def html_param_name?(name)
+          HTML_PARAM_PATTERNS.any? { |pattern| pattern.match?(name.to_s) }
+        end
+
+        def suggest_slot_name(param_name)
+          clean_name = param_name.to_s
+            .sub(/_html$/, "")
+            .sub(/_content$/, "")
+            .sub(/^html_/, "")
+
+          "renders_one :#{clean_name}"
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/view_component_cops.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+require_relative "view_component/base"
+require_relative "view_component/component_suffix"
+require_relative "view_component/no_global_state"
+require_relative "view_component/prefer_private_methods"
+require_relative "view_component/prefer_slots"

data/lib/rubocop/view_component/plugin.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+require "lint_roller"
+
+module RuboCop
+  module ViewComponent
+    # A plugin that integrates rubocop-view_component with RuboCop's plugin system.
+    class Plugin < LintRoller::Plugin
+      def about
+        LintRoller::About.new(
+          name: "rubocop-view_component",
+          version: VERSION,
+          homepage: "TODO: Put your plugin's homepage URL here.",
+          description: "TODO: Put your plugin's description here."
+        )
+      end
+
+      def supported?(context)
+        context.engine == :rubocop
+      end
+
+      def rules(_context)
+        LintRoller::Rules.new(
+          type: :path,
+          config_format: :rubocop,
+          value: Pathname.new(__dir__).join("../../../config/default.yml")
+        )
+      end
+    end
+  end
+end

data/lib/rubocop/view_component/version.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module ViewComponent
+    VERSION = "0.1.0"
+  end
+end

data/lib/rubocop/view_component.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+require_relative "view_component/version"
+
+module RuboCop
+  module ViewComponent
+    class Error < StandardError; end
+    # Your code goes here...
+  end
+end

data/lib/rubocop-view_component.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+require "rubocop"
+
+require_relative "rubocop/view_component"
+require_relative "rubocop/view_component/version"
+require_relative "rubocop/view_component/plugin"
+
+require_relative "rubocop/cop/view_component_cops"

data/spec/rubocop/cop/view_component/component_suffix_spec.rb

@@ -0,0 +1,86 @@
+# frozen_string_literal: true
+
+RSpec.describe RuboCop::Cop::ViewComponent::ComponentSuffix, :config do
+  let(:config) { RuboCop::Config.new }
+
+  context "when class inherits from ViewComponent::Base" do
+    it "registers an offense when class name does not end with Component" do
+      expect_offense(<<~RUBY)
+        class FooBar < ViewComponent::Base
+              ^^^^^^ ViewComponent/ComponentSuffix: ViewComponent class names should end with `Component`.
+        end
+      RUBY
+    end
+
+    it "does not register offense when class name ends with Component" do
+      expect_no_offenses(<<~RUBY)
+        class FooBarComponent < ViewComponent::Base
+        end
+      RUBY
+    end
+  end
+
+  context "when class inherits from ApplicationComponent" do
+    it "registers an offense when class name does not end with Component" do
+      expect_offense(<<~RUBY)
+        class UserCard < ApplicationComponent
+              ^^^^^^^^ ViewComponent/ComponentSuffix: ViewComponent class names should end with `Component`.
+        end
+      RUBY
+    end
+
+    it "does not register offense when class name ends with Component" do
+      expect_no_offenses(<<~RUBY)
+        class UserCardComponent < ApplicationComponent
+        end
+      RUBY
+    end
+  end
+
+  context "when class does not inherit from ViewComponent" do
+    it "does not register offense for regular classes" do
+      expect_no_offenses(<<~RUBY)
+        class FooBar < SomeOtherBase
+        end
+      RUBY
+    end
+
+    it "does not register offense for plain classes" do
+      expect_no_offenses(<<~RUBY)
+        class FooBar
+        end
+      RUBY
+    end
+  end
+
+  context "with namespaced components" do
+    it "checks the final component name" do
+      expect_offense(<<~RUBY)
+        module Admin
+          class UserCard < ViewComponent::Base
+                ^^^^^^^^ ViewComponent/ComponentSuffix: ViewComponent class names should end with `Component`.
+          end
+        end
+      RUBY
+    end
+
+    it "allows namespaced component with Component suffix" do
+      expect_no_offenses(<<~RUBY)
+        module Admin
+          class UserCardComponent < ViewComponent::Base
+          end
+        end
+      RUBY
+    end
+  end
+
+  context "with compact nested class syntax" do
+    it "registers offense for compact syntax" do
+      expect_offense(<<~RUBY)
+        class Admin::UserCard < ViewComponent::Base
+              ^^^^^^^^^^^^^^^ ViewComponent/ComponentSuffix: ViewComponent class names should end with `Component`.
+        end
+      RUBY
+    end
+  end
+end

data/spec/rubocop/cop/view_component/no_global_state_spec.rb

@@ -0,0 +1,119 @@
+# frozen_string_literal: true
+
+RSpec.describe RuboCop::Cop::ViewComponent::NoGlobalState, :config do
+  let(:config) { RuboCop::Config.new }
+
+  context "when accessing params" do
+    it "registers an offense" do
+      expect_offense(<<~RUBY)
+        class UserComponent < ViewComponent::Base
+          def admin?
+            params[:admin]
+            ^^^^^^ ViewComponent/NoGlobalState: Avoid accessing `params` directly in ViewComponents. Pass necessary data through the constructor instead.
+          end
+        end
+      RUBY
+    end
+
+    it "registers offense for params method call" do
+      expect_offense(<<~RUBY)
+        class UserComponent < ViewComponent::Base
+          def admin?
+            params.fetch(:admin)
+            ^^^^^^ ViewComponent/NoGlobalState: Avoid accessing `params` directly in ViewComponents. Pass necessary data through the constructor instead.
+          end
+        end
+      RUBY
+    end
+  end
+
+  context "when accessing request" do
+    it "registers an offense" do
+      expect_offense(<<~RUBY)
+        class UserComponent < ViewComponent::Base
+          def user_agent
+            request.user_agent
+            ^^^^^^^ ViewComponent/NoGlobalState: Avoid accessing `request` directly in ViewComponents. Pass necessary data through the constructor instead.
+          end
+        end
+      RUBY
+    end
+  end
+
+  context "when accessing session" do
+    it "registers an offense" do
+      expect_offense(<<~RUBY)
+        class UserComponent < ViewComponent::Base
+          def current_user_id
+            session[:user_id]
+            ^^^^^^^ ViewComponent/NoGlobalState: Avoid accessing `session` directly in ViewComponents. Pass necessary data through the constructor instead.
+          end
+        end
+      RUBY
+    end
+  end
+
+  context "when accessing cookies" do
+    it "registers an offense" do
+      expect_offense(<<~RUBY)
+        class UserComponent < ViewComponent::Base
+          def preference
+            cookies[:theme]
+            ^^^^^^^ ViewComponent/NoGlobalState: Avoid accessing `cookies` directly in ViewComponents. Pass necessary data through the constructor instead.
+          end
+        end
+      RUBY
+    end
+  end
+
+  context "when accessing flash" do
+    it "registers an offense" do
+      expect_offense(<<~RUBY)
+        class UserComponent < ViewComponent::Base
+          def notice
+            flash[:notice]
+            ^^^^^ ViewComponent/NoGlobalState: Avoid accessing `flash` directly in ViewComponents. Pass necessary data through the constructor instead.
+          end
+        end
+      RUBY
+    end
+  end
+
+  context "when not accessing global state" do
+    it "does not register offense for instance variables" do
+      expect_no_offenses(<<~RUBY)
+        class UserComponent < ViewComponent::Base
+          def initialize(admin:)
+            @admin = admin
+          end
+
+          def admin?
+            @admin
+          end
+        end
+      RUBY
+    end
+
+    it "does not register offense for method arguments" do
+      expect_no_offenses(<<~RUBY)
+        class UserComponent < ViewComponent::Base
+          def format_params(params)
+            params[:admin]
+          end
+        end
+      RUBY
+    end
+  end
+
+  context "when not in a ViewComponent" do
+    it "does not register offense in regular classes" do
+      expect_no_offenses(<<~RUBY)
+        class RegularClass
+          def admin?
+            params[:admin]
+          end
+        end
+      RUBY
+    end
+  end
+end