view_component 3.23.2 → 4.0.0.alpha1

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
@@ -84,10 +82,9 @@ module ViewComponent
 
           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|
+            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)
@@ -155,10 +152,9 @@ module ViewComponent
 
           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|
+            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 }
@@ -215,6 +211,21 @@ module ViewComponent
         super
       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 register_polymorphic_slot(slot_name, types, collection:)
         self::GeneratedSlotMethods.define_method(slot_name) do
           get_slot(slot_name)
@@ -250,10 +261,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|
+            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,21 +278,6 @@ 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:)
         slot = {collection: collection}
         return slot unless callable
@@ -370,7 +365,7 @@ module ViewComponent
       end
     end
 
-    def set_slot(slot_name, slot_definition = nil, *args, &block)
+    def set_slot(slot_name, slot_definition = nil, *args, **kwargs, &block)
       slot_definition ||= self.class.registered_slots[slot_name]
       slot = Slot.new(self)
 
@@ -387,11 +382,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 +395,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 +421,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 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 +431,7 @@ module ViewComponent
 
       poly_def = slot_definition[:renderable_hash][poly_type]
 
-      set_slot(slot_name, poly_def, *args, &block)
+      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_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

data/lib/view_component/template.rb

@@ -2,69 +2,115 @@
 
 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
+
+    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:)
+        super(
+          component: component,
+          details: details,
+          path: path,
+          lineno: 0
+        )
+      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
+    end
+
+    class Inline < Template
+      attr_reader :source
+
+      def initialize(component:, inline_template:)
+        details = ActionView::TemplateDetails.new(nil, inline_template.language.to_sym, nil, nil)
+
+        super(
+          component: component,
+          details: details,
+          path: inline_template.path,
+          lineno: inline_template.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
+          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?
-
-      "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.\") } "
+      m = safe_method_name
+      proc { send(m) }
     end
 
     def requires_compiled_superclass?
@@ -72,63 +118,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

data/lib/view_component/test_helpers.rb

@@ -18,18 +18,7 @@ module ViewComponent
       def assert_component_rendered
         assert_selector("body")
       end
-    rescue LoadError
-      # We don't have a test case for running an application without capybara installed.
-      # It's probably fine to leave this without coverage.
-      # :nocov:
-      if ENV["DEBUG"]
-        warn(
-          "WARNING in `ViewComponent::TestHelpers`: Add `capybara` " \
-          "to Gemfile to use Capybara assertions."
-        )
-      end
-
-      # :nocov:
+    rescue LoadError # We don't have a test case for running an application without capybara installed.
     end
 
     # Returns the result of a render_inline call.
@@ -46,21 +35,12 @@ module ViewComponent
     # ```
     #
     # @param component [ViewComponent::Base, ViewComponent::Collection] The instance of the component to be rendered.
-    # @return [Nokogiri::HTML]
+    # @return [Nokogiri::HTML5]
     def render_inline(component, **args, &block)
       @page = nil
-      @rendered_content =
-        if Rails.version.to_f >= 6.1
-          vc_test_controller.view_context.render(component, args, &block)
-
-        # :nocov:
-        else
-          vc_test_controller.view_context.render_component(component, &block)
-        end
+      @rendered_content = vc_test_controller.view_context.render(component, args, &block)
 
-      # :nocov:
-
-      Nokogiri::HTML.fragment(@rendered_content)
+      Nokogiri::HTML5.fragment(@rendered_content)
     end
 
     # `JSON.parse`-d component output.
@@ -91,7 +71,7 @@ module ViewComponent
     # @param name [String] The name of the preview to be rendered.
     # @param from [ViewComponent::Preview] The class of the preview to be rendered.
     # @param params [Hash] Parameters to be passed to the preview.
-    # @return [Nokogiri::HTML]
+    # @return [Nokogiri::HTML5]
     def render_preview(name, from: __vc_test_helpers_preview_class, params: {})
       previews_controller = __vc_test_helpers_build_controller(Rails.application.config.view_component.preview_controller.constantize)
 
@@ -107,7 +87,7 @@ module ViewComponent
 
       @rendered_content = result
 
-      Nokogiri::HTML.fragment(@rendered_content)
+      Nokogiri::HTML5.fragment(@rendered_content)
     end
 
     # Execute the given block in the view context (using `instance_exec`).
@@ -121,12 +101,11 @@ module ViewComponent
     #
     # assert_text("Hello, World!")
     # ```
-    def render_in_view_context(*args, &block)
+    def render_in_view_context(...)
       @page = nil
-      @rendered_content = vc_test_controller.view_context.instance_exec(*args, &block)
-      Nokogiri::HTML.fragment(@rendered_content)
+      @rendered_content = vc_test_controller.view_context.instance_exec(...)
+      Nokogiri::HTML5.fragment(@rendered_content)
     end
-    ruby2_keywords(:render_in_view_context) if respond_to?(:ruby2_keywords, true)
 
     # Set the Action Pack request variant for the given block:
     #
@@ -136,11 +115,11 @@ module ViewComponent
     # end
     # ```
     #
-    # @param variant [Symbol] The variant to be set for the provided block.
-    def with_variant(variant)
+    # @param variants [Symbol[]] The variants to be set for the provided block.
+    def with_variant(*variants)
       old_variants = vc_test_controller.view_context.lookup_context.variants
 
-      vc_test_controller.view_context.lookup_context.variants = variant
+      vc_test_controller.view_context.lookup_context.variants += variants
       yield
     ensure
       vc_test_controller.view_context.lookup_context.variants = old_variants
@@ -173,9 +152,14 @@ module ViewComponent
     # end
     # ```
     #
-    # @param format [Symbol] The format to be set for the provided block.
-    def with_format(format)
-      with_request_url("/", format: format) { yield }
+    # @param formats [Symbol[]] The format(s) to be set for the provided block.
+    def with_format(*formats)
+      old_formats = vc_test_controller.view_context.lookup_context.formats
+
+      vc_test_controller.view_context.lookup_context.formats = formats
+      yield
+    ensure
+      vc_test_controller.view_context.lookup_context.formats = old_formats
     end
 
     # Set the URL of the current request (such as when using request-dependent path helpers):
@@ -205,7 +189,7 @@ module ViewComponent
     # @param full_path [String] The path to set for the current request.
     # @param host [String] The host to set for the current request.
     # @param method [String] The request method to set for the current request.
-    def with_request_url(full_path, host: nil, method: nil, format: ViewComponent::Base::VC_INTERNAL_DEFAULT_FORMAT)
+    def with_request_url(full_path, host: nil, method: nil)
       old_request_host = vc_test_request.host
       old_request_method = vc_test_request.request_method
       old_request_path_info = vc_test_request.path_info
@@ -225,7 +209,6 @@ module ViewComponent
       vc_test_request.set_header("action_dispatch.request.query_parameters",
         Rack::Utils.parse_nested_query(query).with_indifferent_access)
       vc_test_request.set_header(Rack::QUERY_STRING, query)
-      vc_test_request.format = format
       yield
     ensure
       vc_test_request.host = old_request_host
@@ -284,11 +267,9 @@ module ViewComponent
 
     def __vc_test_helpers_preview_class
       result = if respond_to?(:described_class)
-        # :nocov:
-        raise "`render_preview` expected a described_class, but it is nil." if described_class.nil?
+        raise ArgumentError.new("`render_preview` expected a described_class, but it is nil.") if described_class.nil?
 
         "#{described_class}Preview"
-        # :nocov:
       else
         self.class.name.gsub("Test", "Preview")
       end
@@ -296,6 +277,5 @@ module ViewComponent
     rescue NameError
       raise NameError, "`render_preview` expected to find #{result}, but it does not exist."
     end
-    # :nocov:
   end
 end

data/lib/view_component/translatable.rb

@@ -1,7 +1,6 @@
 # frozen_string_literal: true
 
 require "erb"
-require "set"
 require "i18n"
 require "active_support/concern"
 
@@ -10,19 +9,22 @@ module ViewComponent
     extend ActiveSupport::Concern
 
     HTML_SAFE_TRANSLATION_KEY = /(?:_|\b)html\z/
+    private_constant :HTML_SAFE_TRANSLATION_KEY
+
     TRANSLATION_EXTENSIONS = %w[yml yaml].freeze
+    private_constant :TRANSLATION_EXTENSIONS
 
     included do
-      class_attribute :i18n_backend, instance_writer: false, instance_predicate: false
+      class_attribute :__vc_i18n_backend, instance_writer: false, instance_predicate: false
     end
 
     class_methods do
-      def i18n_scope
-        @i18n_scope ||= virtual_path.sub(%r{^/}, "").gsub(%r{/_?}, ".")
+      def __vc_i18n_scope
+        @__vc_i18n_scope ||= virtual_path.sub(%r{^/}, "").gsub(%r{/_?}, ".")
       end
 
-      def build_i18n_backend
-        return if compiled?
+      def __vc_build_i18n_backend
+        return if __vc_compiled?
 
         # We need to load the translations files from the ancestors so a component
         # can inherit translations from its parent and is able to overwrite them.
@@ -33,31 +35,31 @@ module ViewComponent
         end
 
         # In development it will become nil if the translations file is removed
-        self.i18n_backend = if translation_files.any?
+        self.__vc_i18n_backend = if translation_files.any?
           I18nBackend.new(
-            i18n_scope: i18n_scope,
+            scope: __vc_i18n_scope,
             load_paths: translation_files
           )
         end
       end
 
-      def i18n_key(key, scope = nil)
+      def __vc_i18n_key(key, scope = nil)
         scope = scope.join(".") if scope.is_a? Array
         key = key&.to_s unless key.is_a?(String)
         key = "#{scope}.#{key}" if scope
-        key = "#{i18n_scope}#{key}" if key.start_with?(".")
+        key = "#{__vc_i18n_scope}#{key}" if key.start_with?(".")
         key
       end
 
       def translate(key = nil, **options)
         return key.map { |k| translate(k, **options) } if key.is_a?(Array)
 
-        ensure_compiled
+        __vc_ensure_compiled
 
         locale = options.delete(:locale) || ::I18n.locale
-        key = i18n_key(key, options.delete(:scope))
+        key = __vc_i18n_key(key, options.delete(:scope))
 
-        i18n_backend.translate(locale, key, options)
+        __vc_i18n_backend.translate(locale, key, options)
       end
 
       alias_method :t, :translate
@@ -66,8 +68,8 @@ module ViewComponent
     class I18nBackend < ::I18n::Backend::Simple
       EMPTY_HASH = {}.freeze
 
-      def initialize(i18n_scope:, load_paths:)
-        @i18n_scope = i18n_scope.split(".").map(&:to_sym)
+      def initialize(scope:, load_paths:)
+        @__vc_i18n_scope = scope.split(".").map(&:to_sym)
         @load_paths = load_paths
       end
 
@@ -77,7 +79,7 @@ module ViewComponent
       end
 
       def scope_data(data)
-        @i18n_scope.reverse_each do |part|
+        @__vc_i18n_scope.reverse_each do |part|
           data = {part => data}
         end
         data
@@ -91,19 +93,19 @@ module ViewComponent
     def translate(key = nil, **options)
       raise ViewComponent::TranslateCalledBeforeRenderError if view_context.nil?
 
-      return super unless i18n_backend
+      return super unless __vc_i18n_backend
       return key.map { |k| translate(k, **options) } if key.is_a?(Array)
 
       locale = options.delete(:locale) || ::I18n.locale
-      key = self.class.i18n_key(key, options.delete(:scope))
+      key = self.class.__vc_i18n_key(key, options.delete(:scope))
       as_html = HTML_SAFE_TRANSLATION_KEY.match?(key)
 
       html_escape_translation_options!(options) if as_html
 
-      if key.start_with?(i18n_scope + ".")
+      if key.start_with?(__vc_i18n_scope + ".")
         translated =
           catch(:exception) do
-            i18n_backend.translate(locale, key, options)
+            __vc_i18n_backend.translate(locale, key, options)
           end
 
         # Fallback to the global translations
@@ -119,9 +121,8 @@ module ViewComponent
     end
     alias_method :t, :translate
 
-    # Exposes .i18n_scope as an instance method
-    def i18n_scope
-      self.class.i18n_scope
+    def __vc_i18n_scope
+      self.class.__vc_i18n_scope
     end
 
     private