view_component 3.23.2 → 4.0.2

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

@@ -32,23 +32,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,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
@@ -109,7 +102,7 @@ module ViewComponent # :nodoc:
       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

@@ -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_original_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_original_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
@@ -101,15 +97,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)

data/lib/view_component/slotable.rb

@@ -12,12 +12,10 @@ module ViewComponent
       singular: %i[content render].freeze,
       plural: %i[contents renders].freeze
     }.freeze
+    private_constant :RESERVED_NAMES
 
-    # Setup component slot state
     included do
-      # Hash of registered Slots
-      class_attribute :registered_slots
-      self.registered_slots = {}
+      class_attribute :registered_slots, default: {}
     end
 
     class_methods do
@@ -75,26 +73,25 @@ module ViewComponent
       #
       #   <%= render_inline(MyComponent.new.with_header_content("Foo")) %>
       def renders_one(slot_name, callable = nil)
-        validate_singular_slot_name(slot_name)
+        __vc_validate_singular_slot_name(slot_name)
 
         if callable.is_a?(Hash) && callable.key?(:types)
-          register_polymorphic_slot(slot_name, callable[:types], collection: false)
+          __vc_register_polymorphic_slot(slot_name, callable[:types], collection: false)
         else
-          validate_plural_slot_name(ActiveSupport::Inflector.pluralize(slot_name).to_sym)
+          __vc_validate_plural_slot_name(ActiveSupport::Inflector.pluralize(slot_name).to_sym)
 
           setter_method_name = :"with_#{slot_name}"
 
-          define_method setter_method_name do |*args, &block|
-            set_slot(slot_name, nil, *args, &block)
+          define_method setter_method_name do |*args, **kwargs, &block|
+            __vc_set_slot(slot_name, nil, *args, **kwargs, &block)
           end
-          ruby2_keywords(setter_method_name) if respond_to?(:ruby2_keywords, true)
 
           self::GeneratedSlotMethods.define_method slot_name do
-            get_slot(slot_name)
+            __vc_get_slot(slot_name)
           end
 
           self::GeneratedSlotMethods.define_method :"#{slot_name}?" do
-            get_slot(slot_name).present?
+            __vc_get_slot(slot_name).present?
           end
 
           define_method :"with_#{slot_name}_content" do |content|
@@ -103,7 +100,7 @@ module ViewComponent
             self
           end
 
-          register_slot(slot_name, collection: false, callable: callable)
+          __vc_register_slot(slot_name, collection: false, callable: callable)
         end
       end
 
@@ -145,20 +142,19 @@ module ViewComponent
       #     <% end %>
       #   <% end %>
       def renders_many(slot_name, callable = nil)
-        validate_plural_slot_name(slot_name)
+        __vc_validate_plural_slot_name(slot_name)
 
         if callable.is_a?(Hash) && callable.key?(:types)
-          register_polymorphic_slot(slot_name, callable[:types], collection: true)
+          __vc_register_polymorphic_slot(slot_name, callable[:types], collection: true)
         else
           singular_name = ActiveSupport::Inflector.singularize(slot_name)
-          validate_singular_slot_name(ActiveSupport::Inflector.singularize(slot_name).to_sym)
+          __vc_validate_singular_slot_name(ActiveSupport::Inflector.singularize(slot_name).to_sym)
 
           setter_method_name = :"with_#{singular_name}"
 
-          define_method setter_method_name do |*args, &block|
-            set_slot(slot_name, nil, *args, &block)
+          define_method setter_method_name do |*args, **kwargs, &block|
+            __vc_set_slot(slot_name, nil, *args, **kwargs, &block)
           end
-          ruby2_keywords(setter_method_name) if respond_to?(:ruby2_keywords, true)
 
           define_method :"with_#{singular_name}_content" do |content|
             send(setter_method_name) { content.to_s }
@@ -169,22 +165,22 @@ module ViewComponent
           define_method :"with_#{slot_name}" do |collection_args = nil, &block|
             collection_args.map do |args|
               if args.respond_to?(:to_hash)
-                set_slot(slot_name, nil, **args, &block)
+                __vc_set_slot(slot_name, nil, **args, &block)
               else
-                set_slot(slot_name, nil, *args, &block)
+                __vc_set_slot(slot_name, nil, *args, &block)
               end
             end
           end
 
           self::GeneratedSlotMethods.define_method slot_name do
-            get_slot(slot_name)
+            __vc_get_slot(slot_name)
           end
 
           self::GeneratedSlotMethods.define_method :"#{slot_name}?" do
-            get_slot(slot_name).present?
+            __vc_get_slot(slot_name).present?
           end
 
-          register_slot(slot_name, collection: true, callable: callable)
+          __vc_register_slot(slot_name, collection: true, callable: callable)
         end
       end
 
@@ -215,13 +211,30 @@ module ViewComponent
         super
       end
 
-      def register_polymorphic_slot(slot_name, types, collection:)
+      # @private
+      # Called by the compiler, as instance methods are not defined when slots are first registered
+      def __vc_register_default_slots
+        registered_slots.each do |slot_name, config|
+          default_method_name = :"default_#{slot_name}"
+          config[:default_method] = instance_methods.find { |method_name| method_name == default_method_name }
+
+          registered_slots[slot_name] = config
+        end
+      end
+
+      private
+
+      def __vc_register_slot(slot_name, **kwargs)
+        registered_slots[slot_name] = __vc_define_slot(slot_name, **kwargs)
+      end
+
+      def __vc_register_polymorphic_slot(slot_name, types, collection:)
         self::GeneratedSlotMethods.define_method(slot_name) do
-          get_slot(slot_name)
+          __vc_get_slot(slot_name)
         end
 
         self::GeneratedSlotMethods.define_method(:"#{slot_name}?") do
-          get_slot(slot_name).present?
+          __vc_get_slot(slot_name).present?
         end
 
         renderable_hash = types.each_with_object({}) do |(poly_type, poly_attributes_or_callable), memo|
@@ -240,7 +253,7 @@ module ViewComponent
               "#{slot_name}_#{poly_type}"
             end
 
-          memo[poly_type] = define_slot(
+          memo[poly_type] = __vc_define_slot(
             poly_slot_name, collection: collection, callable: poly_callable
           )
 
@@ -250,10 +263,9 @@ module ViewComponent
             raise AlreadyDefinedPolymorphicSlotSetterError.new(setter_method_name, poly_slot_name)
           end
 
-          define_method(setter_method_name) do |*args, &block|
-            set_polymorphic_slot(slot_name, poly_type, *args, &block)
+          define_method(setter_method_name) do |*args, **kwargs, &block|
+            __vc_set_polymorphic_slot(slot_name, poly_type, *args, **kwargs, &block)
           end
-          ruby2_keywords(setter_method_name) if respond_to?(:ruby2_keywords, true)
 
           define_method :"with_#{poly_slot_name}_content" do |content|
             send(setter_method_name) { content.to_s }
@@ -268,22 +280,7 @@ module ViewComponent
         }
       end
 
-      # Called by the compiler, as instance methods are not defined when slots are first registered
-      def register_default_slots
-        registered_slots.each do |slot_name, config|
-          config[:default_method] = instance_methods.find { |method_name| method_name == :"default_#{slot_name}" }
-
-          registered_slots[slot_name] = config
-        end
-      end
-
-      private
-
-      def register_slot(slot_name, **kwargs)
-        registered_slots[slot_name] = define_slot(slot_name, **kwargs)
-      end
-
-      def define_slot(slot_name, collection:, callable:)
+      def __vc_define_slot(slot_name, collection:, callable:)
         slot = {collection: collection}
         return slot unless callable
 
@@ -306,18 +303,18 @@ module ViewComponent
         slot
       end
 
-      def validate_plural_slot_name(slot_name)
+      def __vc_validate_plural_slot_name(slot_name)
         if RESERVED_NAMES[:plural].include?(slot_name.to_sym)
           raise ReservedPluralSlotNameError.new(name, slot_name)
         end
 
-        raise_if_slot_name_uncountable(slot_name)
-        raise_if_slot_conflicts_with_call(slot_name)
-        raise_if_slot_ends_with_question_mark(slot_name)
-        raise_if_slot_registered(slot_name)
+        __vc_raise_if_slot_name_uncountable(slot_name)
+        __vc_raise_if_slot_conflicts_with_call(slot_name)
+        __vc_raise_if_slot_ends_with_question_mark(slot_name)
+        __vc_raise_if_slot_registered(slot_name)
       end
 
-      def validate_singular_slot_name(slot_name)
+      def __vc_validate_singular_slot_name(slot_name)
         if slot_name.to_sym == :content
           raise ContentSlotNameError.new(name)
         end
@@ -326,28 +323,28 @@ module ViewComponent
           raise ReservedSingularSlotNameError.new(name, slot_name)
         end
 
-        raise_if_slot_conflicts_with_call(slot_name)
-        raise_if_slot_ends_with_question_mark(slot_name)
-        raise_if_slot_registered(slot_name)
+        __vc_raise_if_slot_conflicts_with_call(slot_name)
+        __vc_raise_if_slot_ends_with_question_mark(slot_name)
+        __vc_raise_if_slot_registered(slot_name)
       end
 
-      def raise_if_slot_registered(slot_name)
+      def __vc_raise_if_slot_registered(slot_name)
         if registered_slots.key?(slot_name)
           raise RedefinedSlotError.new(name, slot_name)
         end
       end
 
-      def raise_if_slot_ends_with_question_mark(slot_name)
+      def __vc_raise_if_slot_ends_with_question_mark(slot_name)
         raise SlotPredicateNameError.new(name, slot_name) if slot_name.to_s.end_with?("?")
       end
 
-      def raise_if_slot_conflicts_with_call(slot_name)
+      def __vc_raise_if_slot_conflicts_with_call(slot_name)
         if slot_name.start_with?("call_")
           raise InvalidSlotNameError, "Slot cannot start with 'call_'. Please rename #{slot_name}"
         end
       end
 
-      def raise_if_slot_name_uncountable(slot_name)
+      def __vc_raise_if_slot_name_uncountable(slot_name)
         slot_name = slot_name.to_s
         if slot_name.pluralize == slot_name.singularize
           raise UncountableSlotNameError.new(name, slot_name)
@@ -355,22 +352,32 @@ module ViewComponent
       end
     end
 
-    def get_slot(slot_name)
-      content unless content_evaluated? # ensure content is loaded so slots will be defined
-
-      slot = self.class.registered_slots[slot_name]
+    def __vc_get_slot(slot_name)
       @__vc_set_slots ||= {}
+      content unless defined?(@__vc_content_evaluated) && @__vc_content_evaluated # ensure content is loaded so slots will be defined
 
-      if @__vc_set_slots[slot_name]
-        return @__vc_set_slots[slot_name]
-      end
+      # If the slot is set, return it
+      return @__vc_set_slots[slot_name] if @__vc_set_slots[slot_name]
 
-      if slot[:collection]
+      # If there is a default method for the slot, call it
+      if (default_method = registered_slots[slot_name][:default_method])
+        renderable_value = send(default_method)
+        slot = Slot.new(self)
+
+        if renderable_value.respond_to?(:render_in)
+          slot.__vc_component_instance = renderable_value
+        else
+          slot.__vc_content = renderable_value
+        end
+
+        slot
+      elsif self.class.registered_slots[slot_name][:collection]
+        # If empty slot is a collection, return an empty array
         []
       end
     end
 
-    def set_slot(slot_name, slot_definition = nil, *args, &block)
+    def __vc_set_slot(slot_name, slot_definition = nil, *args, **kwargs, &block)
       slot_definition ||= self.class.registered_slots[slot_name]
       slot = Slot.new(self)
 
@@ -387,11 +394,11 @@ module ViewComponent
 
       # If class
       if slot_definition[:renderable]
-        slot.__vc_component_instance = slot_definition[:renderable].new(*args)
+        slot.__vc_component_instance = slot_definition[:renderable].new(*args, **kwargs)
       # If class name as a string
       elsif slot_definition[:renderable_class_name]
         slot.__vc_component_instance =
-          self.class.const_get(slot_definition[:renderable_class_name]).new(*args)
+          self.class.const_get(slot_definition[:renderable_class_name]).new(*args, **kwargs)
       # If passed a lambda
       elsif slot_definition[:renderable_function]
         # Use `bind(self)` to ensure lambda is executed in the context of the
@@ -400,11 +407,11 @@ module ViewComponent
         renderable_function = slot_definition[:renderable_function].bind(self)
         renderable_value =
           if block
-            renderable_function.call(*args) do |*rargs|
+            renderable_function.call(*args, **kwargs) do |*rargs|
               view_context.capture(*rargs, &block)
             end
           else
-            renderable_function.call(*args)
+            renderable_function.call(*args, **kwargs)
           end
 
         # Function calls can return components, so if it's a component handle it specially
@@ -426,9 +433,8 @@ module ViewComponent
 
       slot
     end
-    ruby2_keywords(:set_slot) if respond_to?(:ruby2_keywords, true)
 
-    def set_polymorphic_slot(slot_name, poly_type = nil, *args, &block)
+    def __vc_set_polymorphic_slot(slot_name, poly_type = nil, *args, **kwargs, &block)
       slot_definition = self.class.registered_slots[slot_name]
 
       if !slot_definition[:collection] && defined?(@__vc_set_slots) && @__vc_set_slots[slot_name]
@@ -437,8 +443,7 @@ module ViewComponent
 
       poly_def = slot_definition[:renderable_hash][poly_type]
 
-      set_slot(slot_name, poly_def, *args, &block)
+      __vc_set_slot(slot_name, poly_def, *args, **kwargs, &block)
     end
-    ruby2_keywords(:set_polymorphic_slot) if respond_to?(:ruby2_keywords, true)
   end
 end

data/lib/view_component/system_spec_helpers.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module ViewComponent
+  module SystemSpecHelpers
+    include SystemTestHelpers
+
+    def page
+      Capybara.current_session
+    end
+  end
+end

data/lib/view_component/system_test_helpers.rb

@@ -4,7 +4,6 @@ module ViewComponent
   module SystemTestHelpers
     include TestHelpers
 
-    #
     # Returns a block that can be used to visit the path of the inline rendered component.
     # @param fragment [Nokogiri::Fragment] The fragment returned from `render_inline`.
     # @param layout [String] The (optional) layout to use.
@@ -18,7 +17,7 @@ module ViewComponent
         file.write(vc_test_controller.render_to_string(html: fragment.to_html.html_safe, layout: layout))
         file.rewind
 
-        block.call("/_system_test_entrypoint?file=#{file.path.split("/").last}")
+        yield("/_system_test_entrypoint?file=#{file.path.split("/").last}")
       ensure
         file.unlink
       end