view_component 3.23.2 → 4.0.2

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, :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:)
+        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
+          __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?
-
-      "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,22 @@ 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_view_context.render(component, args, &block)
 
-      # :nocov:
+      fragment = Nokogiri::HTML5.fragment(@rendered_content)
+      @vc_test_view_context = nil
+      fragment
+    end
 
-      Nokogiri::HTML.fragment(@rendered_content)
+    # Returns the view context used to render components in tests. Note that the view context
+    # is reset after each call to `render_inline`.
+    #
+    # @return [ActionView::Base]
+    def vc_test_view_context
+      @vc_test_view_context ||= vc_test_controller.view_context
     end
 
     # `JSON.parse`-d component output.
@@ -91,9 +81,9 @@ 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)
+      previews_controller = __vc_test_helpers_build_controller(Rails.application.config.view_component.previews.controller.constantize)
 
       # From what I can tell, it's not possible to overwrite all request parameters
       # at once, so we set them individually here.
@@ -107,7 +97,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 +111,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_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 +125,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 +162,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 +199,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 +219,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
@@ -250,7 +243,20 @@ module ViewComponent
     #
     # @return [ActionController::Base]
     def vc_test_controller
-      @vc_test_controller ||= __vc_test_helpers_build_controller(Base.test_controller.constantize)
+      @vc_test_controller ||= __vc_test_helpers_build_controller(vc_test_controller_class)
+    end
+
+    # Set the controller used by `render_inline`:
+    #
+    # ```ruby
+    # def vc_test_controller_class
+    #   MyTestController
+    # end
+    # ```
+    def vc_test_controller_class
+      return @__vc_test_controller_class if defined?(@__vc_test_controller_class)
+
+      defined?(ApplicationController) ? ApplicationController : ActionController::Base
     end
 
     # Access the request used by `render_inline`:
@@ -284,11 +290,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 +300,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,18 +68,18 @@ module ViewComponent
     class I18nBackend < ::I18n::Backend::Simple
       EMPTY_HASH = {}.freeze
 
-      def initialize(i18n_scope:, load_paths:)
-        @i18n_scope = i18n_scope.split(".").map(&:to_sym)
-        @load_paths = load_paths
+      def initialize(scope:, load_paths:)
+        @__vc_i18n_scope = scope.split(".").map(&:to_sym)
+        @__vc_load_paths = load_paths
       end
 
       # Ensure the Simple backend won't load paths from ::I18n.load_path
       def load_translations
-        super(@load_paths)
+        super(@__vc_load_paths)
       end
 
       def scope_data(data)
-        @i18n_scope.reverse_each do |part|
+        @__vc_i18n_scope.reverse_each do |part|
           data = {part => data}
         end
         data
@@ -91,44 +93,43 @@ module ViewComponent
     def translate(key = nil, **options)
       raise ViewComponent::TranslateCalledBeforeRenderError if view_context.nil?
 
-      return super unless i18n_backend
+      return @view_context.translate(key, **options) 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
+      __vc_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
         if translated.is_a? ::I18n::MissingTranslation
-          return super(key, locale: locale, **options)
+          return @view_context.translate(key, locale: locale, **options)
         end
 
-        translated = html_safe_translation(translated) if as_html
+        translated = __vc_html_safe_translation(translated) if as_html
         translated
       else
-        super(key, locale: locale, **options)
+        @view_context.translate(key, locale: locale, **options)
       end
     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
 
-    def html_safe_translation(translation)
+    def __vc_html_safe_translation(translation)
       if translation.respond_to?(:map)
-        translation.map { |element| html_safe_translation(element) }
+        translation.map { |element| __vc_html_safe_translation(element) }
       else
         # It's assumed here that objects loaded by the i18n backend will respond to `#html_safe?`.
         # It's reasonable that if we're in Rails, `active_support/core_ext/string/output_safety.rb`
@@ -137,7 +138,7 @@ module ViewComponent
       end
     end
 
-    def html_escape_translation_options!(options)
+    def __vc_html_escape_translation_options!(options)
       options.except(*::I18n::RESERVED_KEYS).each do |name, value|
         next if name == :count && value.is_a?(Numeric)
 

data/lib/view_component/version.rb

@@ -2,8 +2,8 @@
 
 module ViewComponent
   module VERSION
-    MAJOR = 3
-    MINOR = 23
+    MAJOR = 4
+    MINOR = 0
     PATCH = 2
     PRE = nil
 

data/lib/view_component.rb

@@ -7,20 +7,22 @@ module ViewComponent
   extend ActiveSupport::Autoload
 
   autoload :Base
-  autoload :CaptureCompatibility
   autoload :Compiler
   autoload :CompileCache
-  autoload :ComponentError
   autoload :Config
   autoload :Deprecation
   autoload :InlineTemplate
   autoload :Instrumentation
   autoload :Preview
-  autoload :TestHelpers
-  autoload :SystemTestHelpers
-  autoload :TestCase
-  autoload :SystemTestCase
   autoload :Translatable
+
+  if Rails.env.test?
+    autoload :TestHelpers
+    autoload :SystemSpecHelpers
+    autoload :SystemTestHelpers
+    autoload :TestCase
+    autoload :SystemTestCase
+  end
 end
 
 require "view_component/engine" if defined?(Rails::Engine)