view_component 3.22.0 → 4.0.0.alpha1

data/lib/view_component/compiler.rb

@@ -8,7 +8,7 @@ module ViewComponent
     # * true (a blocking mode which ensures thread safety when redefining the `call` method for components,
     #                default in Rails development and test mode)
     # * false(a non-blocking mode, default in Rails production mode)
-    class_attribute :development_mode, default: false
+    class_attribute :__vc_development_mode, default: false
 
     def initialize(component)
       @component = component
@@ -30,8 +30,8 @@ module ViewComponent
 
         gather_templates
 
-        if self.class.development_mode && @templates.any?(&:requires_compiled_superclass?)
-          @component.superclass.compile(raise_errors: raise_errors)
+        if self.class.__vc_development_mode && @templates.any?(&:requires_compiled_superclass?)
+          @component.superclass.__vc_compile(raise_errors: raise_errors)
         end
 
         if template_errors.present?
@@ -42,19 +42,36 @@ module ViewComponent
         end
 
         if raise_errors
-          @component.validate_initialization_parameters!
-          @component.validate_collection_parameter!
+          @component.__vc_validate_initialization_parameters!
+          @component.__vc_validate_collection_parameter!
         end
 
         define_render_template_for
 
         @component.register_default_slots
-        @component.build_i18n_backend
+        @component.__vc_build_i18n_backend
 
         CompileCache.register(@component)
       end
     end
 
+    # @return all matching compiled templates, in priority order based on the requested details from LookupContext
+    #
+    # @param [ActionView::TemplateDetails::Requested] requested_details i.e. locales, formats, variants
+    def find_templates_for(requested_details)
+      filtered_templates = @templates.select do |template|
+        template.details.matches?(requested_details)
+      end
+
+      if filtered_templates.count > 1
+        filtered_templates.sort_by! do |template|
+          template.details.sort_key_for(requested_details)
+        end
+      end
+
+      filtered_templates
+    end
+
     private
 
     attr_reader :templates
@@ -64,40 +81,25 @@ module ViewComponent
         template.compile_to_component
       end
 
-      method_body =
-        if @templates.one?
-          @templates.first.safe_method_name_call
-        elsif (template = @templates.find(&:inline?))
-          template.safe_method_name_call
-        else
-          branches = []
-
-          @templates.each do |template|
-            conditional =
-              if template.inline_call?
-                "variant&.to_sym == #{template.variant.inspect}"
-              else
-                [
-                  template.default_format? ? "(format == #{ViewComponent::Base::VC_INTERNAL_DEFAULT_FORMAT.inspect} || format.nil?)" : "format == #{template.format.inspect}",
-                  template.variant.nil? ? "variant.nil?" : "variant&.to_sym == #{template.variant.inspect}"
-                ].join(" && ")
-              end
-
-            branches << [conditional, template.safe_method_name_call]
-          end
+      @component.silence_redefinition_of_method(:render_template_for)
 
-          out = branches.each_with_object(+"") do |(conditional, branch_body), memo|
-            memo << "#{(!memo.present?) ? "if" : "elsif"} #{conditional}\n  #{branch_body}\n"
+      if @templates.one?
+        template = @templates.first
+        safe_call = template.safe_method_name_call
+        @component.define_method(:render_template_for) do |_|
+          @current_template = template
+          instance_exec(&safe_call)
+        end
+      else
+        compiler = self
+        @component.define_method(:render_template_for) do |details|
+          if (@current_template = compiler.find_templates_for(details).first)
+            instance_exec(&@current_template.safe_method_name_call)
+          else
+            raise MissingTemplateError.new(self.class.name, details)
           end
-          out << "else\n  #{templates.find { _1.variant.nil? && _1.default_format? }.safe_method_name_call}\nend"
         end
-
-      @component.silence_redefinition_of_method(:render_template_for)
-      @component.class_eval <<-RUBY, __FILE__, __LINE__ + 1
-      def render_template_for(variant = nil, format = nil)
-        #{method_body}
       end
-      RUBY
     end
 
     def template_errors
@@ -168,30 +170,18 @@ module ViewComponent
 
     def gather_templates
       @templates ||=
-        begin
+        if @component.inline_template.present?
+          [Template::Inline.new(
+            component: @component,
+            inline_template: @component.inline_template
+          )]
+        else
+          path_parser = ActionView::Resolver::PathParser.new
           templates = @component.sidecar_files(
             ActionView::Template.template_handler_extensions
           ).map do |path|
-            # Extract format and variant from template filename
-            this_format, variant =
-              File
-                .basename(path)     # "variants_component.html+mini.watch.erb"
-                .split(".")[1..-2]  # ["html+mini", "watch"]
-                .join(".")          # "html+mini.watch"
-                .split("+")         # ["html", "mini.watch"]
-                .map(&:to_sym)      # [:html, :"mini.watch"]
-
-            out = Template.new(
-              component: @component,
-              type: :file,
-              path: path,
-              lineno: 0,
-              extension: path.split(".").last,
-              this_format: this_format.to_s.split(".").last&.to_sym, # strip locale from this_format, see #2113
-              variant: variant
-            )
-
-            out
+            details = path_parser.parse(path).details
+            Template::File.new(component: @component, path: path, details: details)
           end
 
           component_instance_methods_on_self = @component.instance_methods(false)
@@ -201,24 +191,10 @@ module ViewComponent
           ).flat_map { |ancestor| ancestor.instance_methods(false).grep(/^call(_|$)/) }
             .uniq
             .each do |method_name|
-              templates << Template.new(
-                component: @component,
-                type: :inline_call,
-                this_format: ViewComponent::Base::VC_INTERNAL_DEFAULT_FORMAT,
-                variant: method_name.to_s.include?("call_") ? method_name.to_s.sub("call_", "").to_sym : nil,
-                method_name: method_name,
-                defined_on_self: component_instance_methods_on_self.include?(method_name)
-              )
-            end
-
-          if @component.inline_template.present?
-            templates << Template.new(
+            templates << Template::InlineCall.new(
               component: @component,
-              type: :inline,
-              path: @component.inline_template.path,
-              lineno: @component.inline_template.lineno,
-              source: @component.inline_template.source.dup,
-              extension: @component.inline_template.language
+              method_name: method_name,
+              defined_on_self: component_instance_methods_on_self.include?(method_name)
             )
           end
 

data/lib/view_component/config.rb

@@ -15,10 +15,7 @@ module ViewComponent
           generate: default_generate_options,
           preview_controller: "ViewComponentsController",
           preview_route: "/rails/view_components",
-          show_previews_source: false,
           instrumentation_enabled: false,
-          use_deprecated_instrumentation_name: true,
-          render_monkey_patch_enabled: true,
           view_component_path: "app/components",
           component_parent_class: nil,
           show_previews: Rails.env.development? || Rails.env.test?,
@@ -109,29 +106,11 @@ module ViewComponent
       # The entry route for component previews.
       # Defaults to `"/rails/view_components"`.
 
-      # @!attribute show_previews_source
-      # @return [Boolean]
-      # Whether to display source code previews in component previews.
-      # Defaults to `false`.
-
       # @!attribute instrumentation_enabled
       # @return [Boolean]
       # Whether ActiveSupport notifications are enabled.
       # Defaults to `false`.
 
-      # @!attribute use_deprecated_instrumentation_name
-      # @return [Boolean]
-      # Whether ActiveSupport Notifications use the private name `"!render.view_component"`
-      # or are made more publicly available via `"render.view_component"`.
-      # Will default to `false` in next major version.
-      # Defaults to `true`.
-
-      # @!attribute render_monkey_patch_enabled
-      # @return [Boolean] Whether the #render method should be monkey patched.
-      # If this is disabled, use `#render_component` or
-      # `#render_component_to_string` instead.
-      # Defaults to `true`.
-
       # @!attribute view_component_path
       # @return [String]
       # The path in which components, their templates, and their sidecars should

data/lib/view_component/deprecation.rb

@@ -3,6 +3,6 @@
 require "active_support/deprecation"
 
 module ViewComponent
-  DEPRECATION_HORIZON = "4.0.0"
+  DEPRECATION_HORIZON = "5.0.0"
   Deprecation = ActiveSupport::Deprecation.new(DEPRECATION_HORIZON, "ViewComponent")
 end

data/lib/view_component/engine.rb

@@ -29,11 +29,10 @@ module ViewComponent
     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 preview_controller preview_route].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?
 
       if options.show_previews
@@ -41,40 +40,22 @@ module ViewComponent
         options.preview_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
@@ -87,62 +68,12 @@ module ViewComponent
 
     initializer "view_component.eager_load_actions" do
       ActiveSupport.on_load(:after_initialize) do
-        ViewComponent::Base.descendants.each(&:compile) if Rails.application.config.eager_load
-      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
-
-      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
-
-    initializer "view_component.include_render_component" do |_app|
-      next if Rails.version.to_f >= 6.1
-
-      # :nocov:
-      ViewComponent::Deprecation.deprecation_warning("using `render_component`", "ViewComponent 4.0 will remove `render_component`")
-
-      ActiveSupport.on_load(:action_view) do
-        require "view_component/render_component_helper"
-        ActionView::Base.include ViewComponent::RenderComponentHelper
-      end
-
-      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
-      end
-      # :nocov:
-    end
-
-    initializer "static assets" do |app|
-      if serve_static_preview_assets?(app.config)
-        app.middleware.use(::ActionDispatch::Static, "#{root}/app/assets/vendor")
+        ViewComponent::Base.descendants.each(&:__vc_compile) if Rails.application.config.eager_load
       end
     end
 
-    def serve_static_preview_assets?(app_config)
-      app_config.view_component.show_previews && app_config.public_file_server.enabled
-    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|
@@ -174,16 +105,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, " \
@@ -202,28 +218,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

@@ -32,7 +32,6 @@ 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
@@ -42,13 +41,13 @@ module ViewComponent # :nodoc:
         @__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,12 +5,14 @@ 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)
+      return super if !Rails.application.config.view_component.instrumentation_enabled.present?
+
       ActiveSupport::Notifications.instrument(
-        notification_name,
+        "render.view_component",
         {
           name: self.class.name,
           identifier: self.class.identifier
@@ -19,13 +21,5 @@ module ViewComponent # :nodoc:
         super
       end
     end
-
-    private
-
-    def notification_name
-      return "!render.view_component" if ViewComponent::Base.config.use_deprecated_instrumentation_name
-
-      "render.view_component"
-    end
   end
 end

data/lib/view_component/preview.rb

@@ -30,12 +30,10 @@ 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
@@ -94,13 +92,8 @@ 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 }
         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

@@ -101,15 +101,12 @@ module ViewComponent
     #   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)