view_component 2.49.1 → 3.23.2

data/lib/view_component/template.rb

@@ -0,0 +1,134 @@
+# frozen_string_literal: true
+
+module ViewComponent
+  class Template
+    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
+    )
+      @component = component
+      @type = type
+      @this_format = this_format
+      @variant = variant&.to_sym
+      @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
+    end
+
+    def compile_to_component
+      if !inline_call?
+        @component.silence_redefinition_of_method(@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
+
+      @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.\") } "
+    end
+
+    def requires_compiled_superclass?
+      inline_call? && !defined_on_self?
+    end
+
+    def inline_call?
+      @type == :inline_call
+    end
+
+    def inline?
+      @type == :inline
+    end
+
+    def default_format?
+      @this_format == ViewComponent::Base::VC_INTERNAL_DEFAULT_FORMAT
+    end
+
+    def format
+      @this_format
+    end
+
+    def safe_method_name
+      "_#{@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
+    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)
+      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]
+
+      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:
+    end
+  end
+end

data/lib/view_component/test_helpers.rb

@@ -4,31 +4,38 @@ module ViewComponent
   module TestHelpers
     begin
       require "capybara/minitest"
+
       include Capybara::Minitest::Assertions
 
       def page
-        Capybara::Node::Simple.new(@rendered_component)
+        @page ||= Capybara::Node::Simple.new(rendered_content)
       end
 
       def refute_component_rendered
         assert_no_selector("body")
       end
+
+      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`: You must add `capybara` " \
-          "to your Gemfile to use Capybara assertions."
+          "WARNING in `ViewComponent::TestHelpers`: Add `capybara` " \
+          "to Gemfile to use Capybara assertions."
         )
       end
 
       # :nocov:
     end
 
-    # @private
-    attr_reader :rendered_component
+    # Returns the result of a render_inline call.
+    #
+    # @return [ActionView::OutputBuffer]
+    attr_reader :rendered_content
 
     # Render a component inline. Internally sets `page` to be a `Capybara::Node::Simple`,
     # allowing for Capybara assertions to be used:
@@ -41,31 +48,86 @@ module ViewComponent
     # @param component [ViewComponent::Base, ViewComponent::Collection] The instance of the component to be rendered.
     # @return [Nokogiri::HTML]
     def render_inline(component, **args, &block)
-      @rendered_component =
+      @page = nil
+      @rendered_content =
         if Rails.version.to_f >= 6.1
-          controller.view_context.render(component, args, &block)
+          vc_test_controller.view_context.render(component, args, &block)
+
+        # :nocov:
         else
-          controller.view_context.render_component(component, &block)
+          vc_test_controller.view_context.render_component(component, &block)
         end
 
-      Nokogiri::HTML.fragment(@rendered_component)
+      # :nocov:
+
+      Nokogiri::HTML.fragment(@rendered_content)
     end
 
-    # @private
-    def controller
-      @controller ||= build_controller(Base.test_controller.constantize)
+    # `JSON.parse`-d component output.
+    #
+    # ```ruby
+    # render_inline(MyJsonComponent.new)
+    # assert_equal(rendered_json["hello"], "world")
+    # ```
+    def rendered_json
+      JSON.parse(rendered_content)
     end
 
-    # @private
-    def request
-      @request ||=
-        begin
-          request = ActionDispatch::TestRequest.create
-          request.session = ActionController::TestSession.new
-          request
-        end
+    # Render a preview inline. Internally sets `page` to be a `Capybara::Node::Simple`,
+    # allowing for Capybara assertions to be used:
+    #
+    # ```ruby
+    # render_preview(:default)
+    # assert_text("Hello, World!")
+    # ```
+    #
+    # Note: `#rendered_preview` expects a preview to be defined with the same class
+    # name as the calling test, but with `Test` replaced with `Preview`:
+    #
+    # MyComponentTest -> MyComponentPreview etc.
+    #
+    # In RSpec, `Preview` is appended to `described_class`.
+    #
+    # @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]
+    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)
+
+      # From what I can tell, it's not possible to overwrite all request parameters
+      # at once, so we set them individually here.
+      params.each do |k, v|
+        previews_controller.request.params[k] = v
+      end
+
+      previews_controller.request.params[:path] = "#{from.preview_name}/#{name}"
+      previews_controller.set_response!(ActionDispatch::Response.new)
+      result = previews_controller.previews
+
+      @rendered_content = result
+
+      Nokogiri::HTML.fragment(@rendered_content)
     end
 
+    # Execute the given block in the view context (using `instance_exec`).
+    # Internally sets `page` to be a `Capybara::Node::Simple`, allowing for
+    # Capybara assertions to be used. All arguments are forwarded to the block.
+    #
+    # ```ruby
+    # render_in_view_context(arg1, arg2: nil) do |arg1, arg2:|
+    #   render(MyComponent.new(arg1, arg2))
+    # end
+    #
+    # assert_text("Hello, World!")
+    # ```
+    def render_in_view_context(*args, &block)
+      @page = nil
+      @rendered_content = vc_test_controller.view_context.instance_exec(*args, &block)
+      Nokogiri::HTML.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:
     #
     # ```ruby
@@ -76,12 +138,12 @@ module ViewComponent
     #
     # @param variant [Symbol] The variant to be set for the provided block.
     def with_variant(variant)
-      old_variants = controller.view_context.lookup_context.variants
+      old_variants = vc_test_controller.view_context.lookup_context.variants
 
-      controller.view_context.lookup_context.variants = variant
+      vc_test_controller.view_context.lookup_context.variants = variant
       yield
     ensure
-      controller.view_context.lookup_context.variants = old_variants
+      vc_test_controller.view_context.lookup_context.variants = old_variants
     end
 
     # Set the controller to be used while executing the given block,
@@ -93,14 +155,27 @@ module ViewComponent
     # end
     # ```
     #
-    # @param klass [ActionController::Base] The controller to be used.
+    # @param klass [Class<ActionController::Base>] The controller to be used.
     def with_controller_class(klass)
-      old_controller = defined?(@controller) && @controller
+      old_controller = defined?(@vc_test_controller) && @vc_test_controller
 
-      @controller = build_controller(klass)
+      @vc_test_controller = __vc_test_helpers_build_controller(klass)
       yield
     ensure
-      @controller = old_controller
+      @vc_test_controller = old_controller
+    end
+
+    # Set format of the current request
+    #
+    # ```ruby
+    # with_format(:json) do
+    #   render_inline(MyComponent.new)
+    # end
+    # ```
+    #
+    # @param format [Symbol] The format to be set for the provided block.
+    def with_format(format)
+      with_request_url("/", format: format) { yield }
     end
 
     # Set the URL of the current request (such as when using request-dependent path helpers):
@@ -111,30 +186,116 @@ module ViewComponent
     # end
     # ```
     #
-    # @param path [String] The path to set for the current request.
-    def with_request_url(path)
-      old_request_path_info = request.path_info
-      old_request_path_parameters = request.path_parameters
-      old_request_query_parameters = request.query_parameters
-      old_request_query_string = request.query_string
-      old_controller = defined?(@controller) && @controller
-
-      request.path_info = path
-      request.path_parameters = Rails.application.routes.recognize_path(path)
-      request.set_header("action_dispatch.request.query_parameters", Rack::Utils.parse_query(path.split("?")[1]))
-      request.set_header(Rack::QUERY_STRING, path.split("?")[1])
+    # To use a specific host, pass the host param:
+    #
+    # ```ruby
+    # with_request_url("/users/42", host: "app.example.com") do
+    #   render_inline(MyComponent.new)
+    # end
+    # ```
+    #
+    # To specify a request method, pass the method param:
+    #
+    # ```ruby
+    # with_request_url("/users/42", method: "POST") do
+    #   render_inline(MyComponent.new)
+    # end
+    # ```
+    #
+    # @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)
+      old_request_host = vc_test_request.host
+      old_request_method = vc_test_request.request_method
+      old_request_path_info = vc_test_request.path_info
+      old_request_path_parameters = vc_test_request.path_parameters
+      old_request_query_parameters = vc_test_request.query_parameters
+      old_request_query_string = vc_test_request.query_string
+      old_request_format = vc_test_request.format.symbol
+      old_controller = defined?(@vc_test_controller) && @vc_test_controller
+
+      path, query = full_path.split("?", 2)
+      vc_test_request.instance_variable_set(:@fullpath, full_path)
+      vc_test_request.instance_variable_set(:@original_fullpath, full_path)
+      vc_test_request.host = host if host
+      vc_test_request.request_method = method if method
+      vc_test_request.path_info = path
+      vc_test_request.path_parameters = Rails.application.routes.recognize_path_with_request(vc_test_request, path, {})
+      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
-      request.path_info = old_request_path_info
-      request.path_parameters = old_request_path_parameters
-      request.set_header("action_dispatch.request.query_parameters", old_request_query_parameters)
-      request.set_header(Rack::QUERY_STRING, old_request_query_string)
-      @controller = old_controller
+      vc_test_request.host = old_request_host
+      vc_test_request.request_method = old_request_method
+      vc_test_request.path_info = old_request_path_info
+      vc_test_request.path_parameters = old_request_path_parameters
+      vc_test_request.set_header("action_dispatch.request.query_parameters", old_request_query_parameters)
+      vc_test_request.set_header(Rack::QUERY_STRING, old_request_query_string)
+      vc_test_request.format = old_request_format
+      @vc_test_controller = old_controller
     end
 
-    # @private
-    def build_controller(klass)
-      klass.new.tap { |c| c.request = request }.extend(Rails.application.routes.url_helpers)
+    # Access the controller used by `render_inline`:
+    #
+    # ```ruby
+    # test "logged out user sees login link" do
+    #   vc_test_controller.expects(:logged_in?).at_least_once.returns(false)
+    #   render_inline(LoginComponent.new)
+    #   assert_selector("[aria-label='You must be signed in']")
+    # end
+    # ```
+    #
+    # @return [ActionController::Base]
+    def vc_test_controller
+      @vc_test_controller ||= __vc_test_helpers_build_controller(Base.test_controller.constantize)
+    end
+
+    # Access the request used by `render_inline`:
+    #
+    # ```ruby
+    # test "component does not render in Firefox" do
+    #   request.env["HTTP_USER_AGENT"] = "Mozilla/5.0"
+    #   render_inline(NoFirefoxComponent.new)
+    #   refute_component_rendered
+    # end
+    # ```
+    #
+    # @return [ActionDispatch::TestRequest]
+    def vc_test_request
+      require "action_controller/test_case"
+
+      @vc_test_request ||=
+        begin
+          out = ActionDispatch::TestRequest.create
+          out.session = ActionController::TestSession.new
+          out
+        end
+    end
+
+    # Note: We prefix private methods here to prevent collisions in consumer's tests.
+    private
+
+    def __vc_test_helpers_build_controller(klass)
+      klass.new.tap { |c| c.request = vc_test_request }.extend(Rails.application.routes.url_helpers)
+    end
+
+    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?
+
+        "#{described_class}Preview"
+        # :nocov:
+      else
+        self.class.name.gsub("Test", "Preview")
+      end
+      result = result.constantize
+    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

@@ -3,14 +3,14 @@
 require "erb"
 require "set"
 require "i18n"
-require "action_view/helpers/translation_helper"
 require "active_support/concern"
 
 module ViewComponent
   module Translatable
     extend ActiveSupport::Concern
 
-    HTML_SAFE_TRANSLATION_KEY = /(?:_|\b)html\z/.freeze
+    HTML_SAFE_TRANSLATION_KEY = /(?:_|\b)html\z/
+    TRANSLATION_EXTENSIONS = %w[yml yaml].freeze
 
     included do
       class_attribute :i18n_backend, instance_writer: false, instance_predicate: false
@@ -21,21 +21,46 @@ module ViewComponent
         @i18n_scope ||= virtual_path.sub(%r{^/}, "").gsub(%r{/_?}, ".")
       end
 
-      def _after_compile
-        super
+      def build_i18n_backend
+        return if compiled?
 
-        return if CompileCache.compiled? self
+        # 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.
+        translation_files = ancestors.reverse_each.with_object([]) do |ancestor, files|
+          if ancestor.is_a?(Class) && ancestor < ViewComponent::Base
+            files.concat(ancestor.sidecar_files(TRANSLATION_EXTENSIONS))
+          end
+        end
 
-        if (translation_files = _sidecar_files(%w[yml yaml])).any?
-          self.i18n_backend = I18nBackend.new(
+        # In development it will become nil if the translations file is removed
+        self.i18n_backend = if translation_files.any?
+          I18nBackend.new(
             i18n_scope: i18n_scope,
-            load_paths: translation_files,
+            load_paths: translation_files
           )
-        else
-          # Cleanup if translations file has been removed since the last compilation
-          self.i18n_backend = nil
         end
       end
+
+      def 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
+      end
+
+      def translate(key = nil, **options)
+        return key.map { |k| translate(k, **options) } if key.is_a?(Array)
+
+        ensure_compiled
+
+        locale = options.delete(:locale) || ::I18n.locale
+        key = i18n_key(key, options.delete(:scope))
+
+        i18n_backend.translate(locale, key, options)
+      end
+
+      alias_method :t, :translate
     end
 
     class I18nBackend < ::I18n::Backend::Simple
@@ -53,7 +78,7 @@ module ViewComponent
 
       def scope_data(data)
         @i18n_scope.reverse_each do |part|
-          data = { part => data }
+          data = {part => data}
         end
         data
       end
@@ -64,16 +89,16 @@ module ViewComponent
     end
 
     def translate(key = nil, **options)
+      raise ViewComponent::TranslateCalledBeforeRenderError if view_context.nil?
+
       return super unless i18n_backend
       return key.map { |k| translate(k, **options) } if key.is_a?(Array)
 
       locale = options.delete(:locale) || ::I18n.locale
-      key = key&.to_s unless key.is_a?(String)
-      key = "#{i18n_scope}#{key}" if key.start_with?(".")
+      key = self.class.i18n_key(key, options.delete(:scope))
+      as_html = HTML_SAFE_TRANSLATION_KEY.match?(key)
 
-      if HTML_SAFE_TRANSLATION_KEY.match?(key)
-        html_escape_translation_options!(options)
-      end
+      html_escape_translation_options!(options) if as_html
 
       if key.start_with?(i18n_scope + ".")
         translated =
@@ -86,22 +111,21 @@ module ViewComponent
           return super(key, locale: locale, **options)
         end
 
-        if HTML_SAFE_TRANSLATION_KEY.match?(key)
-          translated = translated.html_safe # rubocop:disable Rails/OutputSafety
-        end
-
+        translated = html_safe_translation(translated) if as_html
         translated
       else
         super(key, locale: locale, **options)
       end
     end
-    alias :t :translate
+    alias_method :t, :translate
 
     # Exposes .i18n_scope as an instance method
     def i18n_scope
       self.class.i18n_scope
     end
 
+    private
+
     def html_safe_translation(translation)
       if translation.respond_to?(:map)
         translation.map { |element| html_safe_translation(element) }
@@ -109,22 +133,16 @@ module ViewComponent
         # 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`
         # will provide this to `Object`.
-        translation.html_safe # rubocop:disable Rails/OutputSafety
+        translation.html_safe
       end
     end
 
-    private
-
     def html_escape_translation_options!(options)
-      options.each do |name, value|
-        unless i18n_option?(name) || (name == :count && value.is_a?(Numeric))
-          options[name] = ERB::Util.html_escape(value.to_s)
-        end
-      end
-    end
+      options.except(*::I18n::RESERVED_KEYS).each do |name, value|
+        next if name == :count && value.is_a?(Numeric)
 
-    def i18n_option?(name)
-      (@i18n_option_names ||= I18n::RESERVED_KEYS.to_set).include?(name)
+        options[name] = ERB::Util.html_escape(value.to_s)
+      end
     end
   end
 end

data/lib/view_component/use_helpers.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module ViewComponent::UseHelpers
+  extend ActiveSupport::Concern
+
+  class_methods do
+    def use_helpers(*args, from: nil, prefix: false)
+      args.each { |helper_method| use_helper(helper_method, from: from, prefix: prefix) }
+    end
+
+    def use_helper(helper_method, from: nil, prefix: false)
+      helper_method_name = full_helper_method_name(helper_method, prefix: prefix, source: from)
+
+      class_eval(<<-RUBY, __FILE__, __LINE__ + 1)
+        def #{helper_method_name}(*args, &block)
+          raise HelpersCalledBeforeRenderError if view_context.nil?
+
+          #{define_helper(helper_method: helper_method, source: from)}
+        end
+      RUBY
+      ruby2_keywords(helper_method_name) if respond_to?(:ruby2_keywords, true)
+    end
+
+    private
+
+    def full_helper_method_name(helper_method, prefix: false, source: nil)
+      return helper_method unless prefix.present?
+
+      if !!prefix == prefix
+        "#{source.to_s.underscore}_#{helper_method}"
+      else
+        "#{prefix}_#{helper_method}"
+      end
+    end
+
+    def define_helper(helper_method:, source:)
+      return "__vc_original_view_context.#{helper_method}(*args, &block)" unless source.present?
+
+      "#{source}.instance_method(:#{helper_method}).bind(self).call(*args, &block)"
+    end
+  end
+end

data/lib/view_component/version.rb

@@ -2,11 +2,12 @@
 
 module ViewComponent
   module VERSION
-    MAJOR = 2
-    MINOR = 49
-    PATCH = 1
+    MAJOR = 3
+    MINOR = 23
+    PATCH = 2
+    PRE = nil
 
-    STRING = [MAJOR, MINOR, PATCH].join(".")
+    STRING = [MAJOR, MINOR, PATCH, PRE].compact.join(".")
   end
 end