view_component 3.23.2 → 4.12.0

data/lib/view_component/engine.rb

@@ -8,159 +8,109 @@ module ViewComponent
   class Engine < Rails::Engine # :nodoc:
     config.view_component = ViewComponent::Config.current
 
-    if Rails.version.to_f < 8.0
-      rake_tasks do
-        load "view_component/rails/tasks/view_component.rake"
-      end
-    else
-      initializer "view_component.stats_directories" do |app|
-        require "rails/code_statistics"
-
-        if Rails.root.join(ViewComponent::Base.view_component_path).directory?
-          Rails::CodeStatistics.register_directory("ViewComponents", ViewComponent::Base.view_component_path)
-        end
-
-        if Rails.root.join("test/components").directory?
-          Rails::CodeStatistics.register_directory("ViewComponent tests", "test/components", test_directory: true)
-        end
-      end
-    end
-
     initializer "view_component.set_configs" do |app|
       options = app.config.view_component
 
-      %i[generate preview_controller preview_route show_previews_source].each do |config_option|
+      %i[generate previews].each do |config_option|
         options[config_option] ||= ViewComponent::Base.public_send(config_option)
       end
       options.instrumentation_enabled = false if options.instrumentation_enabled.nil?
-      options.render_monkey_patch_enabled = true if options.render_monkey_patch_enabled.nil?
-      options.show_previews = (Rails.env.development? || Rails.env.test?) if options.show_previews.nil?
+      options.previews.enabled = (Rails.env.development? || Rails.env.test?) if options.previews.enabled.nil?
 
-      if options.show_previews
+      if options.previews.enabled
         # This is still necessary because when `config.view_component` is declared, `Rails.root` is unspecified.
-        options.preview_paths << "#{Rails.root}/test/components/previews" if defined?(Rails.root) && Dir.exist?(
+        options.previews.paths << "#{Rails.root}/test/components/previews" if defined?(Rails.root) && Dir.exist?(
           "#{Rails.root}/test/components/previews"
         )
-
-        if options.show_previews_source
-          require "method_source"
-
-          app.config.to_prepare do
-            MethodSource.instance_variable_set(:@lines_for_file, {})
-          end
-        end
       end
     end
 
     initializer "view_component.enable_instrumentation" do |app|
       ActiveSupport.on_load(:view_component) do
         if app.config.view_component.instrumentation_enabled.present?
-          # :nocov: Re-executing the below in tests duplicates initializers and causes order-dependent failures.
           ViewComponent::Base.prepend(ViewComponent::Instrumentation)
-          if app.config.view_component.use_deprecated_instrumentation_name
-            ViewComponent::Deprecation.deprecation_warning(
-              "!render.view_component",
-              "Use the new instrumentation key `render.view_component` instead. See https://viewcomponent.org/guide/instrumentation.html"
-            )
-          end
-          # :nocov:
         end
       end
     end
 
-    # :nocov:
-    initializer "view_component.enable_capture_patch" do |app|
-      ActiveSupport.on_load(:view_component) do
-        ActionView::Base.include(ViewComponent::CaptureCompatibility) if app.config.view_component.capture_compatibility_patch_enabled
-      end
-    end
-    # :nocov:
-
     initializer "view_component.set_autoload_paths" do |app|
       options = app.config.view_component
 
-      if options.show_previews && !options.preview_paths.empty?
-        paths_to_add = options.preview_paths - ActiveSupport::Dependencies.autoload_paths
+      if options.previews.enabled && !options.previews.paths.empty?
+        paths_to_add = options.previews.paths - ActiveSupport::Dependencies.autoload_paths
         ActiveSupport::Dependencies.autoload_paths.concat(paths_to_add) if paths_to_add.any?
       end
     end
 
-    initializer "view_component.eager_load_actions" do
-      ActiveSupport.on_load(:after_initialize) do
-        ViewComponent::Base.descendants.each(&:compile) if Rails.application.config.eager_load
+    initializer "view_component.propshaft_support" do |_app|
+      ActiveSupport.on_load(:view_component) do
+        if defined?(Propshaft)
+          include Propshaft::Helper
+        end
       end
     end
 
-    initializer "view_component.monkey_patch_render" do |app|
-      next if Rails.version.to_f >= 6.1 || !app.config.view_component.render_monkey_patch_enabled
-
-      # :nocov:
-      ViewComponent::Deprecation.deprecation_warning("Monkey patching `render`", "ViewComponent 4.0 will remove the `render` monkey patch")
-
-      ActiveSupport.on_load(:action_view) do
-        require "view_component/render_monkey_patch"
-        ActionView::Base.prepend ViewComponent::RenderMonkeyPatch
-      end
+    config.after_routes_loaded do
+      ActiveSupport.on_load(:view_component) do
+        if defined?(Sprockets::Rails)
+          include Sprockets::Rails::Helper
 
-      ActiveSupport.on_load(:action_controller) do
-        require "view_component/rendering_monkey_patch"
-        require "view_component/render_to_string_monkey_patch"
-        ActionController::Base.prepend ViewComponent::RenderingMonkeyPatch
-        ActionController::Base.prepend ViewComponent::RenderToStringMonkeyPatch
-      end
-      # :nocov:
-    end
+          app = Rails.application
 
-    initializer "view_component.include_render_component" do |_app|
-      next if Rails.version.to_f >= 6.1
+          # Copy relevant config to VC context
+          # See: https://github.com/rails/sprockets-rails/blob/266ec49f3c7c96018dd75f9dc4f9b62fe3f7eecf/lib/sprockets/railtie.rb#L245
+          self.debug_assets = app.config.assets.debug
+          self.digest_assets = app.config.assets.digest
+          self.assets_prefix = app.config.assets.prefix
+          self.assets_precompile = app.config.assets.precompile
 
-      # :nocov:
-      ViewComponent::Deprecation.deprecation_warning("using `render_component`", "ViewComponent 4.0 will remove `render_component`")
+          self.assets_environment = app.assets
+          self.assets_manifest = app.assets_manifest
 
-      ActiveSupport.on_load(:action_view) do
-        require "view_component/render_component_helper"
-        ActionView::Base.include ViewComponent::RenderComponentHelper
-      end
+          self.resolve_assets_with = app.config.assets.resolve_with
 
-      ActiveSupport.on_load(:action_controller) do
-        require "view_component/rendering_component_helper"
-        require "view_component/render_component_to_string_helper"
-        ActionController::Base.include ViewComponent::RenderingComponentHelper
-        ActionController::Base.include ViewComponent::RenderComponentToStringHelper
+          self.check_precompiled_asset = app.config.assets.check_precompiled_asset
+          self.unknown_asset_fallback = app.config.assets.unknown_asset_fallback
+          # Expose the app precompiled asset check to the view
+          self.precompiled_asset_checker = ->(logical_path) { app.asset_precompiled? logical_path }
+        end
       end
-      # :nocov:
     end
 
-    initializer "static assets" do |app|
-      if serve_static_preview_assets?(app.config)
-        app.middleware.use(::ActionDispatch::Static, "#{root}/app/assets/vendor")
-      end
-    end
+    initializer "view_component.eager_load_actions" do
+      ActiveSupport.on_load(:after_initialize) do
+        if Rails.application.config.eager_load
+          ActiveSupport::Notifications.instrument("compile.view_component") do
+            ViewComponent::Base.descendants.each do |component|
+              next if component.anonymous?
 
-    def serve_static_preview_assets?(app_config)
-      app_config.view_component.show_previews && app_config.public_file_server.enabled
+              component.__vc_compile
+            end
+          end
+        end
+      end
     end
 
     initializer "compiler mode" do |_app|
-      ViewComponent::Compiler.development_mode = (Rails.env.development? || Rails.env.test?)
+      ViewComponent::Compiler.__vc_development_mode = (Rails.env.development? || Rails.env.test?)
     end
 
     config.after_initialize do |app|
       options = app.config.view_component
 
-      if options.show_previews
+      if options.previews.enabled
         app.routes.prepend do
-          preview_controller = options.preview_controller.sub(/Controller$/, "").underscore
+          preview_controller = options.previews.controller.sub(/Controller$/, "").underscore
 
           get(
-            options.preview_route,
+            options.previews.route,
             to: "#{preview_controller}#index",
             as: :preview_view_components,
             internal: true
           )
 
           get(
-            "#{options.preview_route}/*path",
+            "#{options.previews.route}/*path",
             to: "#{preview_controller}#previews",
             as: :preview_view_component,
             internal: true
@@ -174,16 +124,6 @@ module ViewComponent
         end
       end
 
-      # :nocov:
-      if RUBY_VERSION < "3.2.0"
-        ViewComponent::Deprecation.deprecation_warning("Support for Ruby versions < 3.2.0", "ViewComponent v4 will remove support for Ruby versions < 3.2.0 no earlier than April 1, 2025")
-      end
-
-      if Rails.version.to_f < 7.1
-        ViewComponent::Deprecation.deprecation_warning("Support for Rails versions < 7.1", "ViewComponent v4 will remove support for Rails versions < 7.1 no earlier than April 1, 2025")
-      end
-      # :nocov:
-
       app.executor.to_run :before do
         CompileCache.invalidate! unless ActionView::Base.cache_template_loading
       end

data/lib/view_component/errors.rb

@@ -38,6 +38,22 @@ module ViewComponent
     end
   end
 
+  class MissingTemplateError < StandardError
+    MESSAGE =
+      "No templates for COMPONENT match the request DETAIL.\n\n" \
+      "To fix this issue, provide a suitable template."
+
+    def initialize(component, request_detail)
+      detail = {
+        locale: request_detail.locale,
+        formats: request_detail.formats,
+        variants: request_detail.variants,
+        handlers: request_detail.handlers
+      }
+      super(MESSAGE.gsub("COMPONENT", component).gsub("DETAIL", detail.inspect))
+    end
+  end
+
   class DuplicateContentError < StandardError
     MESSAGE =
       "It looks like a block was provided after calling `with_content` on COMPONENT, " \
@@ -49,18 +65,6 @@ module ViewComponent
     end
   end
 
-  class EmptyOrInvalidInitializerError < StandardError
-    MESSAGE =
-      "The COMPONENT initializer is empty or invalid. " \
-      "It must accept the parameter `PARAMETER` to render it as a collection.\n\n" \
-      "To fix this issue, update the initializer to accept `PARAMETER`.\n\n" \
-      "See [the collections docs](https://viewcomponent.org/guide/collections.html) for more information on rendering collections."
-
-    def initialize(klass_name, parameter)
-      super(MESSAGE.gsub("COMPONENT", klass_name.to_s).gsub("PARAMETER", parameter.to_s))
-    end
-  end
-
   class MissingCollectionArgumentError < StandardError
     MESSAGE =
       "The initializer for COMPONENT doesn't accept the parameter `PARAMETER`, " \
@@ -202,28 +206,6 @@ module ViewComponent
       "`#controller` to a [`#before_render` method](https://viewcomponent.org/api.html#before_render--void)."
   end
 
-  # :nocov:
-  class NoMatchingTemplatesForPreviewError < StandardError
-    MESSAGE = "Found 0 matches for templates for TEMPLATE_IDENTIFIER."
-
-    def initialize(template_identifier)
-      super(MESSAGE.gsub("TEMPLATE_IDENTIFIER", template_identifier))
-    end
-  end
-
-  class MultipleMatchingTemplatesForPreviewError < StandardError
-    MESSAGE = "Found multiple templates for TEMPLATE_IDENTIFIER."
-
-    def initialize(template_identifier)
-      super(MESSAGE.gsub("TEMPLATE_IDENTIFIER", template_identifier))
-    end
-  end
-  # :nocov:
-
-  class SystemTestControllerOnlyAllowedInTestError < BaseError
-    MESSAGE = "ViewComponent SystemTest controller must only be called in a test environment for security reasons."
-  end
-
   class SystemTestControllerNefariousPathError < BaseError
     MESSAGE = "ViewComponent SystemTest controller attempted to load a file outside of the expected directory."
   end

data/lib/view_component/inline_template.rb

@@ -3,6 +3,7 @@
 module ViewComponent # :nodoc:
   module InlineTemplate
     extend ActiveSupport::Concern
+
     Template = Struct.new(:source, :language, :path, :lineno)
 
     class_methods do
@@ -32,23 +33,22 @@ module ViewComponent # :nodoc:
 
         @__vc_inline_template_defined = true
       end
-      ruby2_keywords(:method_missing) if respond_to?(:ruby2_keywords, true)
 
       def respond_to_missing?(method, include_all = false)
         method.end_with?("_template") || super
       end
 
-      def inline_template
+      def __vc_inline_template
         @__vc_inline_template if defined?(@__vc_inline_template)
       end
 
-      def inline_template_language
+      def __vc_inline_template_language
         @__vc_inline_template_language if defined?(@__vc_inline_template_language)
       end
 
       def inherited(subclass)
         super
-        subclass.instance_variable_set(:@__vc_inline_template_language, inline_template_language)
+        subclass.instance_variable_set(:@__vc_inline_template_language, __vc_inline_template_language)
       end
     end
   end

data/lib/view_component/instrumentation.rb

@@ -5,27 +5,34 @@ require "active_support/notifications"
 module ViewComponent # :nodoc:
   module Instrumentation
     def self.included(mod)
-      mod.prepend(self) unless ancestors.include?(ViewComponent::Instrumentation)
+      mod.prepend(self) unless self <= ViewComponent::Instrumentation
     end
 
-    def render_in(view_context, &block)
+    def render_in(view_context, **_, &block)
+      return super if !Rails.application.config.view_component.instrumentation_enabled.present?
+
+      payload = {
+        name: self.class.name,
+        identifier: self.class.identifier,
+        view_identifier: nil
+      }
+
       ActiveSupport::Notifications.instrument(
-        notification_name,
-        {
-          name: self.class.name,
-          identifier: self.class.identifier
-        }
+        "render.view_component",
+        payload
       ) do
-        super
+        result = super
+        payload[:view_identifier] = @__vc_instrumentation_view_identifier
+        result
       end
+    ensure
+      @__vc_instrumentation_view_identifier = nil
     end
 
-    private
-
-    def notification_name
-      return "!render.view_component" if ViewComponent::Base.config.use_deprecated_instrumentation_name
-
-      "render.view_component"
+    def around_render
+      result = super
+      @__vc_instrumentation_view_identifier = current_template&.path
+      result
     end
   end
 end

data/lib/view_component/preview.rb

@@ -30,18 +30,18 @@ module ViewComponent # :nodoc:
       }
     end
 
-    alias_method :render_component, :render
-
     class << self
       # Returns all component preview classes.
       def all
-        load_previews
+        __vc_load_previews
 
         descendants
       end
 
       # Returns the arguments for rendering of the component in its layout
       def render_args(example, params: {})
+        raise AbstractController::ActionNotFound, "#{example} is not a valid preview example" unless examples.include?(example.to_s)
+
         example_params_names = instance_method(example).parameters.map(&:last)
         provided_params = params.slice(*example_params_names).to_h.symbolize_keys
         result = provided_params.empty? ? new.public_send(example) : new.public_send(example, **provided_params)
@@ -94,22 +94,17 @@ module ViewComponent # :nodoc:
           .sub(/\..*$/, "")
       end
 
-      # Returns the method body for the example from the preview file.
-      def preview_source(example)
-        source = instance_method(example.to_sym).source.split("\n")
-        source[1...(source.size - 1)].join("\n")
-      end
-
-      def load_previews
+      # @private
+      def __vc_load_previews
         Array(preview_paths).each do |preview_path|
-          Dir["#{preview_path}/**/*preview.rb"].sort.each { |file| require_dependency file }
+          Dir["#{preview_path}/**/*preview.rb"].sort.each { |file| require file }
         end
       end
 
       private
 
       def preview_paths
-        Base.preview_paths
+        Base.previews.paths
       end
     end
   end

data/lib/view_component/request_details.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module ViewComponent
+  # LookupContext computes and encapsulates @details for each request
+  # so that it doesn't need to be recomputed on each partial render.
+  # This data is wrapped in ActionView::TemplateDetails::Requested and
+  # used by instances of ActionView::Resolver to choose which template
+  # best matches the request.
+  #
+  # ActionView considers this logic internal to template/partial resolution.
+  # We're exposing it to the compiler via `refine` so that ViewComponent
+  # can match Rails' template picking logic.
+  module RequestDetails
+    refine ActionView::LookupContext do
+      # Return an abstraction for matching and sorting available templates
+      # based on the current lookup context details.
+      #
+      # @return ActionView::TemplateDetails::Requested
+      # @see ActionView::LookupContext#detail_args_for
+      # @see ActionView::FileSystemResolver#_find_all
+      def vc_requested_details(user_details = {})
+        # The hash `user_details` would normally be the standard arguments that
+        # `render` accepts, but there's currently no mechanism for users to
+        # provide these when calling render on a ViewComponent.
+        details, cached = detail_args_for(user_details)
+        cached || ActionView::TemplateDetails::Requested.new(**details)
+      end
+    end
+  end
+end

data/lib/view_component/slot.rb

@@ -6,7 +6,7 @@ module ViewComponent
   class Slot
     include ViewComponent::WithContentHelper
 
-    attr_writer :__vc_component_instance, :__vc_content_block, :__vc_content
+    attr_writer :__vc_component_instance, :__vc_content_block, :__vc_content, :__vc_content_block_virtual_path
 
     def initialize(parent)
       @parent = parent
@@ -58,13 +58,7 @@ module ViewComponent
           if defined?(@__vc_content_block)
             # render_in is faster than `parent.render`
             @__vc_component_instance.render_in(view_context) do |*args|
-              return @__vc_content_block.call(*args) if @__vc_content_block&.source_location.nil?
-
-              block_context = @__vc_content_block.binding.receiver
-
-              if block_context.class < ActionView::Base
-                block_context.capture(*args, &@__vc_content_block)
-              else
+              @parent.with_captured_virtual_path(@__vc_content_block_virtual_path) do
                 @__vc_content_block.call(*args)
               end
             end
@@ -74,7 +68,9 @@ module ViewComponent
         elsif defined?(@__vc_content)
           @__vc_content
         elsif defined?(@__vc_content_block)
-          view_context.capture(&@__vc_content_block)
+          @parent.with_captured_virtual_path(@__vc_content_block_virtual_path) do
+            view_context.capture(&@__vc_content_block)
+          end
         elsif defined?(@__vc_content_set_by_with_content)
           @__vc_content_set_by_with_content
         end
@@ -100,16 +96,12 @@ module ViewComponent
     #     end
     #   end
     # end
-    #
-    def method_missing(symbol, *args, &block)
-      @__vc_component_instance.public_send(symbol, *args, &block)
+    def method_missing(symbol, *args, **kwargs, &block)
+      @__vc_component_instance.public_send(symbol, *args, **kwargs, &block)
     end
-    ruby2_keywords(:method_missing) if respond_to?(:ruby2_keywords, true)
 
     def html_safe?
-      # :nocov:
       to_s.html_safe?
-      # :nocov:
     end
 
     def respond_to_missing?(symbol, include_all = false)