view_component 2.83.0 → 3.21.0

data/lib/view_component/system_test_helpers.rb

@@ -10,12 +10,12 @@ module ViewComponent
     # @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)
-      # Add './tmp/view_components/' directory if it doesn't exist to store the rendered component HTML
-      FileUtils.mkdir_p("./tmp/view_components/") unless Dir.exist?("./tmp/view_components/")
-
-      file = Tempfile.new(["rendered_#{fragment.class.name}", ".html"], "tmp/view_components/")
+      file = Tempfile.new(
+        ["rendered_#{fragment.class.name}", ".html"],
+        ViewComponentsSystemTestController.temp_dir
+      )
       begin
-        file.write(controller.render_to_string(html: fragment.to_html.html_safe, layout: layout))
+        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}")

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

@@ -14,6 +14,10 @@ module ViewComponent
       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.
@@ -28,17 +32,10 @@ module ViewComponent
       # :nocov:
     end
 
-    # @private
-    attr_reader :rendered_content
-
     # Returns the result of a render_inline call.
     #
-    # @return [String]
-    def rendered_component
-      ViewComponent::Deprecation.deprecation_warning("`rendered_component`", :"`page`")
-
-      rendered_content
-    end
+    # @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:
@@ -54,14 +51,28 @@ module ViewComponent
       @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
 
+      # :nocov:
+
       Nokogiri::HTML.fragment(@rendered_content)
     end
 
+    # `JSON.parse`-d component output.
+    #
+    # ```ruby
+    # render_inline(MyJsonComponent.new)
+    # assert_equal(rendered_json["hello"], "world")
+    # ```
+    def rendered_json
+      JSON.parse(rendered_content)
+    end
+
     # Render a preview inline. Internally sets `page` to be a `Capybara::Node::Simple`,
     # allowing for Capybara assertions to be used:
     #
@@ -81,8 +92,8 @@ module ViewComponent
     # @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: preview_class, params: {})
-      previews_controller = build_controller(Rails.application.config.view_component.preview_controller.constantize)
+    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.
@@ -104,7 +115,7 @@ module ViewComponent
     # Capybara assertions to be used. All arguments are forwarded to the block.
     #
     # ```ruby
-    # render_in_view_context(arg1, arg2:) do |arg1, arg2:|
+    # render_in_view_context(arg1, arg2: nil) do |arg1, arg2:|
     #   render(MyComponent.new(arg1, arg2))
     # end
     #
@@ -112,26 +123,11 @@ module ViewComponent
     # ```
     def render_in_view_context(*args, &block)
       @page = nil
-      @rendered_content = controller.view_context.instance_exec(*args, &block)
+      @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)
 
-    # @private
-    def controller
-      @controller ||= build_controller(Base.test_controller.constantize)
-    end
-
-    # @private
-    def request
-      @request ||=
-        begin
-          request = ActionDispatch::TestRequest.create
-          request.session = ActionController::TestSession.new
-          request
-        end
-    end
-
     # Set the Action Pack request variant for the given block:
     #
     # ```ruby
@@ -142,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,
@@ -159,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):
@@ -177,40 +186,109 @@ 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
-
-      path, query = path.split("?", 2)
-      request.path_info = path
-      request.path_parameters = Rails.application.routes.recognize_path_with_request(request, path, {})
-      request.set_header("action_dispatch.request.query_parameters", Rack::Utils.parse_nested_query(query))
-      request.set_header(Rack::QUERY_STRING, query)
+    # 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 preview_class
+    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
@@ -218,5 +296,6 @@ 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

@@ -10,6 +10,7 @@ module ViewComponent
     extend ActiveSupport::Concern
 
     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,17 +22,45 @@ module ViewComponent
       end
 
       def build_i18n_backend
-        return if CompileCache.compiled? self
+        return if compiled?
 
-        self.i18n_backend = if (translation_files = sidecar_files(%w[yml yaml])).any?
-          # Returning nil cleans up if translations file has been removed since the last compilation
+        # 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
 
+        # 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
           )
         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
@@ -60,19 +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
-      scope = options.delete(:scope)
-      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?(".")
-
-      if HTML_SAFE_TRANSLATION_KEY.match?(key)
-        html_escape_translation_options!(options)
-      end
+      key = self.class.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 + ".")
         translated =
@@ -85,10 +111,7 @@ module ViewComponent
           return super(key, locale: locale, **options)
         end
 
-        if HTML_SAFE_TRANSLATION_KEY.match?(key)
-          translated = html_safe_translation(translated)
-        end
-
+        translated = html_safe_translation(translated) if as_html
         translated
       else
         super(key, locale: locale, **options)
@@ -101,6 +124,8 @@ module ViewComponent
       self.class.i18n_scope
     end
 
+    private
+
     def html_safe_translation(translation)
       if translation.respond_to?(:map)
         translation.map { |element| html_safe_translation(element) }
@@ -112,18 +137,12 @@ module ViewComponent
       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 = 83
+    MAJOR = 3
+    MINOR = 21
     PATCH = 0
+    PRE = nil
 
-    STRING = [MAJOR, MINOR, PATCH].join(".")
+    STRING = [MAJOR, MINOR, PATCH, PRE].compact.join(".")
   end
 end
 

data/lib/view_component/with_content_helper.rb

@@ -3,14 +3,9 @@
 module ViewComponent
   module WithContentHelper
     def with_content(value)
-      if value.nil?
-        raise ArgumentError.new(
-          "No content provided to `#with_content` for #{self}.\n\n" \
-          "To fix this issue, pass a value."
-        )
-      else
-        @__vc_content_set_by_with_content = value
-      end
+      raise NilWithContentError if value.nil?
+
+      @__vc_content_set_by_with_content = value
 
       self
     end

data/lib/view_component.rb

@@ -7,29 +7,20 @@ 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 :PreviewTemplateError
   autoload :TestHelpers
   autoload :SystemTestHelpers
   autoload :TestCase
   autoload :SystemTestCase
-  autoload :TemplateError
   autoload :Translatable
 end
 
-# :nocov:
-if defined?(ViewComponent::Engine)
-  ViewComponent::Deprecation.deprecation_warning(
-    "Manually loading the engine",
-    "remove `require \"view_component/engine\"`"
-  )
-elsif defined?(Rails::Engine)
-  require "view_component/engine"
-end
-# :nocov:
+require "view_component/engine" if defined?(Rails::Engine)