view_component 3.23.2 → 4.12.0

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,20 +253,19 @@ 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
           )
 
           setter_method_name = :"with_#{poly_slot_name}"
 
-          if instance_methods.include?(setter_method_name)
+          if method_defined?(setter_method_name)
             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,24 +352,35 @@ 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)
+      captured_block_virtual_path = nil
 
       # Passing the block to the sub-component wrapper like this has two
       # benefits:
@@ -383,15 +391,21 @@ module ViewComponent
       # 2. Since we have to pass block content to components when calling
       # `render`, evaluating the block here would require us to call
       # `view_context.capture` twice, which is slower
-      slot.__vc_content_block = block if block
+      if block
+        slot.__vc_content_block = block
+        # Capture the virtual path at the time the block is defined, so that
+        # translations resolve relative to where the block was created, not where it's rendered
+        captured_block_virtual_path = view_context.instance_variable_get(:@virtual_path)
+        slot.__vc_content_block_virtual_path = captured_block_virtual_path
+      end
 
       # 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 +414,13 @@ module ViewComponent
         renderable_function = slot_definition[:renderable_function].bind(self)
         renderable_value =
           if block
-            renderable_function.call(*args) do |*rargs|
-              view_context.capture(*rargs, &block)
+            renderable_function.call(*args, **kwargs) do |*rargs|
+              with_captured_virtual_path(captured_block_virtual_path) do
+                view_context.capture(*rargs, &block)
+              end
             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 +442,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 +452,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,10 +4,10 @@ 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.
+    #
     # @return [Proc] A block that can be used to visit the path of the inline rendered component.
     def with_rendered_component_path(fragment, layout: false, &block)
       file = Tempfile.new(
@@ -18,7 +18,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

data/lib/view_component/template.rb

@@ -2,69 +2,168 @@
 
 module ViewComponent
   class Template
+    DEFAULT_FORMAT = :html
+    private_constant :DEFAULT_FORMAT
+
     DataWithSource = Struct.new(:format, :identifier, :short_identifier, :type, keyword_init: true)
-    DataNoSource = Struct.new(:source, :identifier, :type, keyword_init: true)
-
-    attr_reader :variant, :this_format, :type
-
-    def initialize(
-      component:,
-      type:,
-      this_format: nil,
-      variant: nil,
-      lineno: nil,
-      path: nil,
-      extension: nil,
-      source: nil,
-      method_name: nil,
-      defined_on_self: true
-    )
+
+    attr_reader :details, :path
+
+    delegate :virtual_path, to: :@component
+    delegate :format, :variant, to: :@details
+
+    def initialize(component:, details:, lineno: nil, path: nil)
       @component = component
-      @type = type
-      @this_format = this_format
-      @variant = variant&.to_sym
+      @details = details
       @lineno = lineno
       @path = path
-      @extension = extension
-      @source = source
-      @method_name = method_name
-      @defined_on_self = defined_on_self
-
-      @source_originally_nil = @source.nil?
-
-      @call_method_name =
-        if @method_name
-          @method_name
-        else
-          out = +"call"
-          out << "_#{normalized_variant_name}" if @variant.present?
-          out << "_#{@this_format}" if @this_format.present? && @this_format != ViewComponent::Base::VC_INTERNAL_DEFAULT_FORMAT
-          out
+    end
+
+    class File < Template
+      def initialize(component:, details:, path:)
+        # If the template file has no format (e.g. .erb instead of .html.erb),
+        # assume the default format (html).
+        if details.format.nil?
+          Kernel.warn("WARNING: Template format for #{path} is missing, defaulting to :html.")
+          details = ActionView::TemplateDetails.new(details.locale, details.handler, DEFAULT_FORMAT, details.variant)
+        end
+
+        @strip_annotation_line = false
+
+        # Rails 8.1 added a newline to compiled ERB output (rails/rails#53731).
+        # Use -1 to compensate for correct line numbers in stack traces.
+        # However, negative line numbers cause segfaults when Ruby's coverage
+        # is enabled (bugs.ruby-lang.org/issues/19363). In that case, strip the
+        # annotation line from compiled source instead.
+        lineno =
+          if Rails::VERSION::MAJOR >= 8 && Rails::VERSION::MINOR > 0 && details.handler == :erb
+            if coverage_running?
+              # Can't use negative lineno with coverage (causes segfault on Linux).
+              # Strip annotation line if enabled to preserve correct line numbers.
+              @strip_annotation_line = ActionView::Base.annotate_rendered_view_with_filenames
+              0
+            else
+              -1
+            end
+          else
+            0
+          end
+
+        super(
+          component: component,
+          details: details,
+          path: path,
+          lineno: lineno
+        )
+      end
+
+      def type
+        :file
+      end
+
+      # Load file each time we look up #source in case the file has been modified
+      def source
+        ::File.read(@path)
+      end
+
+      private
+
+      def compiled_source
+        result = super
+        # Strip the annotation line to maintain correct line numbers when coverage
+        # is running (avoids segfault from negative lineno)
+        result = result.partition(";").last if @strip_annotation_line
+        result
+      end
+    end
+
+    class Inline < Template
+      attr_reader :source
+
+      def initialize(component:, inline_template:)
+        details = ActionView::TemplateDetails.new(nil, inline_template.language.to_sym, nil, nil)
+
+        # Rails 8.1 added a newline to compiled ERB output (rails/rails#53731).
+        # Subtract 1 to compensate for correct line numbers in stack traces.
+        # Inline templates start at line 2+ (defined inside a class), so this
+        # won't result in negative line numbers that cause segfaults with coverage.
+        lineno =
+          if Rails::VERSION::MAJOR >= 8 && Rails::VERSION::MINOR > 0 && details.handler == :erb
+            inline_template.lineno - 1
+          else
+            inline_template.lineno
+          end
+
+        super(
+          component: component,
+          details: details,
+          path: inline_template.path,
+          lineno: lineno,
+        )
+
+        @source = inline_template.source.dup
+      end
+
+      def type
+        :inline
+      end
+    end
+
+    class InlineCall < Template
+      def initialize(component:, method_name:, defined_on_self:)
+        variant = method_name.to_s.include?("call_") ? method_name.to_s.sub("call_", "").to_sym : nil
+        details = ActionView::TemplateDetails.new(nil, nil, nil, variant)
+
+        super(component: component, details: details)
+
+        @call_method_name = method_name
+        @defined_on_self = defined_on_self
+      end
+
+      def type
+        :inline_call
+      end
+
+      def compile_to_component
+        @component.define_method(safe_method_name, @component.instance_method(@call_method_name))
+      end
+
+      def safe_method_name_call
+        m = safe_method_name
+        proc do
+          __vc_maybe_escape_html(send(m)) do
+            Kernel.warn("WARNING: The #{self.class} component rendered HTML-unsafe output. " \
+                          "The output will be automatically escaped, but you may want to investigate.")
+          end
         end
+      end
+
+      def defined_on_self?
+        @defined_on_self
+      end
     end
 
     def compile_to_component
-      if !inline_call?
-        @component.silence_redefinition_of_method(@call_method_name)
+      @component.silence_redefinition_of_method(call_method_name)
 
-        # rubocop:disable Style/EvalWithLocation
-        @component.class_eval <<-RUBY, @path, @lineno
-        def #{@call_method_name}
+      # rubocop:disable Style/EvalWithLocation
+      @component.class_eval <<~RUBY, @path, @lineno
+        def #{call_method_name}
           #{compiled_source}
         end
-        RUBY
-        # rubocop:enable Style/EvalWithLocation
-      end
+      RUBY
+      # rubocop:enable Style/EvalWithLocation
 
       @component.define_method(safe_method_name, @component.instance_method(@call_method_name))
     end
 
-    def safe_method_name_call
-      return safe_method_name unless inline_call?
+    def coverage_running?
+      defined?(Coverage) && Coverage.running?
+    end
 
-      "maybe_escape_html(#{safe_method_name}) " \
-      "{ Kernel.warn(\"WARNING: The #{@component} component rendered HTML-unsafe output. " \
-      "The output will be automatically escaped, but you may want to investigate.\") } "
+    def safe_method_name_call
+      m = safe_method_name
+      proc { send(m) }
     end
 
     def requires_compiled_superclass?
@@ -72,63 +171,40 @@ module ViewComponent
     end
 
     def inline_call?
-      @type == :inline_call
-    end
-
-    def inline?
-      @type == :inline
+      type == :inline_call
     end
 
     def default_format?
-      @this_format == ViewComponent::Base::VC_INTERNAL_DEFAULT_FORMAT
+      format.nil? || format == DEFAULT_FORMAT
     end
+    alias_method :html?, :default_format?
 
-    def format
-      @this_format
+    def call_method_name
+      @call_method_name ||=
+        ["call", (normalized_variant_name if variant.present?), (format unless default_format?)]
+          .compact.join("_").to_sym
     end
 
     def safe_method_name
-      "_#{@call_method_name}_#{@component.name.underscore.gsub("/", "__")}"
+      "_#{call_method_name}_#{@component.name.underscore.gsub("/", "__")}"
     end
 
     def normalized_variant_name
-      @variant.to_s.gsub("-", "__").gsub(".", "___")
-    end
-
-    def defined_on_self?
-      @defined_on_self
+      variant.to_s.gsub("-", "__")
     end
 
     private
 
-    def source
-      if @source_originally_nil
-        # Load file each time we look up #source in case the file has been modified
-        File.read(@path)
-      else
-        @source
-      end
-    end
-
     def compiled_source
-      handler = ActionView::Template.handler_for_extension(@extension)
+      handler = details.handler_class
       this_source = source
       this_source.rstrip! if @component.strip_trailing_whitespace?
 
       short_identifier = defined?(Rails.root) ? @path.sub("#{Rails.root}/", "") : @path
-      type = ActionView::Template::Types[@this_format]
+      format = self.format || DEFAULT_FORMAT
+      type = ActionView::Template::Types[format]
 
-      if handler.method(:call).parameters.length > 1
-        handler.call(
-          DataWithSource.new(format: @this_format, identifier: @path, short_identifier: short_identifier, type: type),
-          this_source
-        )
-      # :nocov:
-      # TODO: Remove in v4
-      else
-        handler.call(DataNoSource.new(source: this_source, identifier: @path, type: type))
-      end
-      # :nocov:
+      handler.call(DataWithSource.new(format:, identifier: @path, short_identifier:, type:), this_source)
     end
   end
 end