view_component 2.52.0 → 2.62.0

data/lib/view_component/base.rb

@@ -9,14 +9,17 @@ require "view_component/polymorphic_slots"
 require "view_component/previewable"
 require "view_component/slotable"
 require "view_component/slotable_v2"
+require "view_component/translatable"
 require "view_component/with_content_helper"
 
 module ViewComponent
   class Base < ActionView::Base
     include ActiveSupport::Configurable
     include ViewComponent::ContentAreas
+    include ViewComponent::PolymorphicSlots
     include ViewComponent::Previewable
     include ViewComponent::SlotableV2
+    include ViewComponent::Translatable
     include ViewComponent::WithContentHelper
 
     ViewContextCalledBeforeRenderError = Class.new(StandardError)
@@ -29,8 +32,25 @@ module ViewComponent
     class_attribute :content_areas
     self.content_areas = [] # class_attribute:default doesn't work until Rails 5.2
 
+    # Config option that strips trailing whitespace in templates before compiling them.
+    class_attribute :__vc_strip_trailing_whitespace, instance_accessor: false, instance_predicate: false
+    self.__vc_strip_trailing_whitespace = false # class_attribute:default doesn't work until Rails 5.2
+
     attr_accessor :__vc_original_view_context
 
+    # Components render in their own view context. Helpers and other functionality
+    # require a reference to the original Rails view context, an instance of
+    # `ActionView::Base`. Use this method to set a reference to the original
+    # view context. Objects that implement this method will render in the component's
+    # view context, while objects that don't will render in the original view context
+    # so helpers, etc work as expected.
+    #
+    # @param view_context [ActionView::Base] The original view context.
+    # @return [void]
+    def set_original_view_context(view_context)
+      self.__vc_original_view_context = view_context
+    end
+
     # EXPERIMENTAL: This API is experimental and may be removed at any time.
     # Hook for allowing components to do work as part of the compilation process.
     #
@@ -66,10 +86,12 @@ module ViewComponent
     #
     # @return [String]
     def render_in(view_context, &block)
+      self.class.compile(raise_errors: true)
+
       @view_context = view_context
       self.__vc_original_view_context ||= view_context
 
-      @output_buffer = ActionView::OutputBuffer.new unless @global_buffer_in_use
+      @output_buffer = ActionView::OutputBuffer.new
 
       @lookup_context ||= view_context.lookup_context
 
@@ -104,7 +126,7 @@ module ViewComponent
       before_render
 
       if render?
-        perform_render
+        render_template_for(@__vc_variant).to_s + _output_postamble
       else
         ""
       end
@@ -112,19 +134,20 @@ module ViewComponent
       @current_template = old_current_template
     end
 
-    def perform_render
-      render_template_for(@__vc_variant).to_s + _output_postamble
-    end
-
-    # :nocov:
-    def render_template_for(variant = nil)
-      # Force compilation here so the compiler always redefines render_template_for.
-      # This is mostly a safeguard to prevent infinite recursion.
-      self.class.compile(raise_errors: true, force: true)
-      # .compile replaces this method; call the new one
-      render_template_for(variant)
+    # Subclass components that call `super` inside their template code will cause a
+    # double render if they emit the result:
+    #
+    # ```erb
+    # <%= super %> # double-renders
+    # <% super %> # does not double-render
+    # ```
+    #
+    # Calls `super`, returning `nil` to avoid rendering the result twice.
+    def render_parent
+      mtd = @__vc_variant ? "call_#{@__vc_variant}" : "call"
+      method(mtd).super_method.call
+      nil
     end
-    # :nocov:
 
     # EXPERIMENTAL: Optional content to be returned after the rendered template.
     #
@@ -157,7 +180,8 @@ module ViewComponent
     end
 
     # @private
-    def initialize(*); end
+    def initialize(*)
+    end
 
     # Re-use original view_context if we're not rendering a component.
     #
@@ -167,8 +191,8 @@ module ViewComponent
     #
     # @private
     def render(options = {}, args = {}, &block)
-      if options.is_a? ViewComponent::Base
-        options.__vc_original_view_context = __vc_original_view_context
+      if options.respond_to?(:set_original_view_context)
+        options.set_original_view_context(self.__vc_original_view_context)
         super
       else
         __vc_original_view_context.render(options, args, &block)
@@ -285,7 +309,9 @@ module ViewComponent
 
     # Set the controller used for testing components:
     #
-    #     config.view_component.test_controller = "MyTestController"
+    # ```ruby
+    # config.view_component.test_controller = "MyTestController"
+    # ```
     #
     # Defaults to ApplicationController. Can also be configured on a per-test
     # basis using `with_controller_class`.
@@ -295,13 +321,17 @@ module ViewComponent
 
     # Set if render monkey patches should be included or not in Rails <6.1:
     #
-    #     config.view_component.render_monkey_patch_enabled = false
+    # ```ruby
+    # config.view_component.render_monkey_patch_enabled = false
+    # ```
     #
     mattr_accessor :render_monkey_patch_enabled, instance_writer: false, default: true
 
     # Path for component files
     #
-    #     config.view_component.view_component_path = "app/my_components"
+    # ```ruby
+    # config.view_component.view_component_path = "app/my_components"
+    # ```
     #
     # Defaults to `app/components`.
     #
@@ -309,7 +339,9 @@ module ViewComponent
 
     # Parent class for generated components
     #
-    #     config.view_component.component_parent_class = "MyBaseComponent"
+    # ```ruby
+    # config.view_component.component_parent_class = "MyBaseComponent"
+    # ```
     #
     # Defaults to nil. If this is falsy, generators will use
     # "ApplicationComponent" if defined, "ViewComponent::Base" otherwise.
@@ -325,25 +357,33 @@ module ViewComponent
     #
     # Always generate a component with a sidecar directory:
     #
-    #     config.view_component.generate.sidecar = true
+    # ```ruby
+    # config.view_component.generate.sidecar = true
+    # ```
     #
     # #### #stimulus_controller
     #
     # Always generate a Stimulus controller alongside the component:
     #
-    #     config.view_component.generate.stimulus_controller = true
+    # ```ruby
+    # config.view_component.generate.stimulus_controller = true
+    # ```
     #
     # #### #locale
     #
     # Always generate translations file alongside the component:
     #
-    #     config.view_component.generate.locale = true
+    # ```ruby
+    # config.view_component.generate.locale = true
+    # ```
     #
     # #### #distinct_locale_files
     #
     # Always generate as many translations files as available locales:
     #
-    #     config.view_component.generate.distinct_locale_files = true
+    # ```ruby
+    # config.view_component.generate.distinct_locale_files = true
+    # ```
     #
     # One file will be generated for each configured `I18n.available_locales`,
     # falling back to `[:en]` when no `available_locales` is defined.
@@ -352,7 +392,9 @@ module ViewComponent
     #
     # Always generate preview alongside the component:
     #
-    #      config.view_component.generate.preview = true
+    # ```ruby
+    # config.view_component.generate.preview = true
+    # ```
     #
     #  Defaults to `false`.
     mattr_accessor :generate, instance_writer: false, default: ActiveSupport::OrderedOptions.new(false)
@@ -406,7 +448,9 @@ module ViewComponent
 
       # Render a component for each element in a collection ([documentation](/guide/collections)):
       #
-      #     render(ProductsComponent.with_collection(@products, foo: :bar))
+      # ```ruby
+      # render(ProductsComponent.with_collection(@products, foo: :bar))
+      # ```
       #
       # @param collection [Enumerable] A list of items to pass the ViewComponent one at a time.
       # @param args [Arguments] Arguments to pass to the ViewComponent every time.
@@ -502,13 +546,35 @@ module ViewComponent
 
       # Set the parameter name used when rendering elements of a collection ([documentation](/guide/collections)):
       #
-      #     with_collection_parameter :item
+      # ```ruby
+      # with_collection_parameter :item
+      # ```
       #
       # @param parameter [Symbol] The parameter name used when rendering elements of a collection.
       def with_collection_parameter(parameter)
         @provided_collection_parameter = parameter
       end
 
+      # Strips trailing whitespace from templates before compiling them.
+      #
+      # ```ruby
+      # class MyComponent < ViewComponent::Base
+      #   strip_trailing_whitespace
+      # end
+      # ```
+      #
+      # @param value [Boolean] Whether or not to strip newlines.
+      def strip_trailing_whitespace(value = true)
+        self.__vc_strip_trailing_whitespace = value
+      end
+
+      # Whether trailing whitespace will be stripped before compilation.
+      #
+      # @return [Boolean]
+      def strip_trailing_whitespace?
+        __vc_strip_trailing_whitespace
+      end
+
       # Ensure the component initializer accepts the
       # collection parameter. By default, we don't
       # validate that the default parameter name
@@ -556,11 +622,7 @@ module ViewComponent
 
       # @private
       def collection_parameter
-        if provided_collection_parameter
-          provided_collection_parameter
-        else
-          name && name.demodulize.underscore.chomp("_component").to_sym
-        end
+        provided_collection_parameter || name && name.demodulize.underscore.chomp("_component").to_sym
       end
 
       # @private

data/lib/view_component/collection.rb

@@ -10,10 +10,17 @@ module ViewComponent
     delegate :format, to: :component
     delegate :size, to: :@collection
 
+    attr_accessor :__vc_original_view_context
+
+    def set_original_view_context(view_context)
+      self.__vc_original_view_context = view_context
+    end
+
     def render_in(view_context, &block)
       components.map do |component|
+        component.set_original_view_context(__vc_original_view_context)
         component.render_in(view_context, &block)
-      end.join.html_safe # rubocop:disable Rails/OutputSafety
+      end.join.html_safe
     end
 
     def components
@@ -54,7 +61,7 @@ module ViewComponent
     end
 
     def component_options(item, iterator)
-      item_options = { component.collection_parameter => item }
+      item_options = {component.collection_parameter => item}
       item_options[component.collection_counter_parameter] = iterator.index + 1 if component.counter_argument_present?
       item_options[component.collection_iteration_parameter] = iterator.dup if component.iteration_argument_present?
 

data/lib/view_component/compile_cache.rb

@@ -20,11 +20,10 @@ module ViewComponent
 
     def invalidate_class!(klass)
       cache.delete(klass)
-      klass.compiler.reset_render_template_for
     end
 
     def invalidate!
-      cache.each { |klass| invalidate_class!(klass) }
+      cache.clear
     end
   end
 end

data/lib/view_component/compiler.rb

@@ -31,7 +31,11 @@ module ViewComponent
       return if compiled? && !force
       return if component_class == ViewComponent::Base
 
+      component_class.superclass.compile(raise_errors: raise_errors) if should_compile_superclass?
+
       with_lock do
+        CompileCache.invalidate_class!(component_class)
+
         subclass_instance_methods = component_class.instance_methods(false)
 
         if subclass_instance_methods.include?(:with_content) && raise_errors
@@ -64,19 +68,22 @@ module ViewComponent
           # as Ruby warns when redefining a method.
           method_name = call_method_name(template[:variant])
 
-          if component_class.instance_methods(false).include?(method_name.to_sym)
-            component_class.send(:remove_method, method_name.to_sym)
+          if component_class.instance_methods.include?(method_name.to_sym)
+            component_class.send(:undef_method, method_name.to_sym)
           end
 
+          # rubocop:disable Style/EvalWithLocation
           component_class.class_eval <<-RUBY, template[:path], 0
           def #{method_name}
             #{compiled_template(template[:path])}
           end
           RUBY
+          # rubocop:enable Style/EvalWithLocation
         end
 
         define_render_template_for
 
+        component_class.build_i18n_backend
         component_class._after_compile
 
         CompileCache.register(component_class)
@@ -91,18 +98,14 @@ module ViewComponent
       end
     end
 
-    def reset_render_template_for
-      if component_class.instance_methods(false).include?(:render_template_for)
-        component_class.send(:remove_method, :render_template_for)
-      end
-    end
-
     private
 
     attr_reader :component_class
 
     def define_render_template_for
-      reset_render_template_for
+      if component_class.instance_methods.include?(:render_template_for)
+        component_class.send(:undef_method, :render_template_for)
+      end
 
       variant_elsifs = variants.compact.uniq.map do |variant|
         "elsif variant.to_sym == :#{variant}\n    #{call_method_name(variant)}"
@@ -150,15 +153,15 @@ module ViewComponent
           end
 
           invalid_variants =
-            templates.
-            group_by { |template| template[:variant] }.
-            map { |variant, grouped| variant if grouped.length > 1 }.
-            compact.
-            sort
+            templates
+              .group_by { |template| template[:variant] }
+              .map { |variant, grouped| variant if grouped.length > 1 }
+              .compact
+              .sort
 
           unless invalid_variants.empty?
             errors <<
-              "More than one template found for #{'variant'.pluralize(invalid_variants.count)} " \
+              "More than one template found for #{"variant".pluralize(invalid_variants.count)} " \
               "#{invalid_variants.map { |v| "'#{v}'" }.to_sentence} in #{component_class}. " \
               "There can only be one template file per variant."
           end
@@ -176,8 +179,8 @@ module ViewComponent
             count = duplicate_template_file_and_inline_variant_calls.count
 
             errors <<
-              "Template #{'file'.pluralize(count)} and inline render #{'method'.pluralize(count)} " \
-              "found for #{'variant'.pluralize(count)} " \
+              "Template #{"file".pluralize(count)} and inline render #{"method".pluralize(count)} " \
+              "found for #{"variant".pluralize(count)} " \
               "#{duplicate_template_file_and_inline_variant_calls.map { |v| "'#{v}'" }.to_sentence} " \
               "in #{component_class}. " \
               "There can only be a template file or inline render method per variant."
@@ -235,8 +238,9 @@ module ViewComponent
     end
 
     def compiled_template(file_path)
-      handler = ActionView::Template.handler_for_extension(File.extname(file_path).gsub(".", ""))
+      handler = ActionView::Template.handler_for_extension(File.extname(file_path).delete("."))
       template = File.read(file_path)
+      template.rstrip! if component_class.strip_trailing_whitespace?
 
       if handler.method(:call).parameters.length > 1
         handler.call(component_class, template)
@@ -258,5 +262,14 @@ module ViewComponent
         "call"
       end
     end
+
+    def should_compile_superclass?
+      development? &&
+        templates.empty? &&
+        !(
+          component_class.instance_methods(false).include?(:call) ||
+            component_class.private_instance_methods(false).include?(:call)
+        )
+    end
   end
 end

data/lib/view_component/content_areas.rb

@@ -21,7 +21,7 @@ module ViewComponent
         )
       end
 
-      if block_given?
+      if block
         content = view_context.capture(&block)
       end
 

data/lib/view_component/docs_builder_component.rb

@@ -28,7 +28,7 @@ module ViewComponent
       end
 
       def types
-        " → [#{@method.tag(:return).types.join(',')}]" if @method.tag(:return)&.types && show_types?
+        " → [#{@method.tag(:return).types.join(",")}]" if @method.tag(:return)&.types && show_types?
       end
 
       def signature_or_name

data/lib/view_component/engine.rb

@@ -20,7 +20,6 @@ module ViewComponent
       options.instrumentation_enabled = false if options.instrumentation_enabled.nil?
       options.preview_route ||= ViewComponent::Base.preview_route
       options.preview_controller ||= ViewComponent::Base.preview_controller
-      options.use_global_output_buffer = false if options.use_global_output_buffer.nil?
 
       if options.show_previews
         options.preview_paths << "#{Rails.root}/test/components/previews" if defined?(Rails.root) && Dir.exist?(
@@ -58,26 +57,12 @@ module ViewComponent
       end
     end
 
-    initializer "view_component.enable_global_output_buffer" do |app|
-      ActiveSupport.on_load(:view_component) do
-        env_use_gob = ENV.fetch("VIEW_COMPONENT_USE_GLOBAL_OUTPUT_BUFFER", "false") == "true"
-        config_use_gob = app.config.view_component.use_global_output_buffer
-
-        if config_use_gob || env_use_gob
-          # :nocov:
-          app.config.view_component.use_global_output_buffer = true
-          ViewComponent::Base.prepend(ViewComponent::GlobalOutputBuffer)
-          ActionView::Base.prepend(ViewComponent::GlobalOutputBuffer::ActionViewMods)
-          # :nocov:
-        end
-      end
-    end
-
     initializer "view_component.set_autoload_paths" do |app|
       options = app.config.view_component
 
       if options.show_previews && !options.preview_paths.empty?
-        ActiveSupport::Dependencies.autoload_paths.concat(options.preview_paths)
+        paths_to_add = options.preview_paths - ActiveSupport::Dependencies.autoload_paths
+        ActiveSupport::Dependencies.autoload_paths.concat(paths_to_add) if paths_to_add.any?
       end
     end
 
@@ -133,10 +118,10 @@ module ViewComponent
 
     initializer "compiler mode" do |app|
       ViewComponent::Compiler.mode = if Rails.env.development? || Rails.env.test?
-                                       ViewComponent::Compiler::DEVELOPMENT_MODE
-                                     else
-                                       ViewComponent::Compiler::PRODUCTION_MODE
-                                     end
+        ViewComponent::Compiler::DEVELOPMENT_MODE
+      else
+        ViewComponent::Compiler::PRODUCTION_MODE
+      end
     end
 
     config.after_initialize do |app|

data/lib/view_component/polymorphic_slots.rb

@@ -5,6 +5,17 @@ module ViewComponent
     # In older rails versions, using a concern isn't a good idea here because they appear to not work with
     # Module#prepend and class methods.
     def self.included(base)
+      if base != ViewComponent::Base
+        # :nocov:
+        location = Kernel.caller_locations(1, 1)[0]
+
+        warn(
+          "warning: ViewComponent::PolymorphicSlots is now included in ViewComponent::Base by default " \
+          "and can be removed from #{location.path}:#{location.lineno}"
+        )
+        # :nocov:
+      end
+
       base.singleton_class.prepend(ClassMethods)
       base.include(InstanceMethods)
     end
@@ -46,12 +57,22 @@ module ViewComponent
             end
 
           define_method(setter_name) do |*args, &block|
+            ViewComponent::Deprecation.warn(
+              "polymorphic slot setters like `#{setter_name}` are deprecated and will be removed in " \
+              "ViewComponent v3.0.0.\n\nUse `with_#{setter_name}` instead."
+            )
+
             set_polymorphic_slot(slot_name, poly_type, *args, &block)
           end
           ruby2_keywords(setter_name.to_sym) if respond_to?(:ruby2_keywords, true)
+
+          define_method("with_#{setter_name}") do |*args, &block|
+            set_polymorphic_slot(slot_name, poly_type, *args, &block)
+          end
+          ruby2_keywords(:"with_#{setter_name}") if respond_to?(:ruby2_keywords, true)
         end
 
-        self.registered_slots[slot_name] = {
+        registered_slots[slot_name] = {
           collection: collection,
           renderable_hash: renderable_hash
         }

data/lib/view_component/preview.rb

@@ -14,7 +14,7 @@ module ViewComponent # :nodoc:
         block: block,
         component: component,
         locals: {},
-        template: "view_components/preview",
+        template: "view_components/preview"
       }
     end
 
@@ -30,7 +30,8 @@ module ViewComponent # :nodoc:
     class << self
       # Returns all component preview classes.
       def all
-        load_previews if descendants.empty?
+        load_previews
+
         descendants
       end
 
@@ -65,10 +66,12 @@ module ViewComponent # :nodoc:
         name.chomp("Preview").underscore
       end
 
+      # rubocop:disable Style/TrivialAccessors
       # Setter for layout name.
       def layout(layout_name)
         @layout = layout_name
       end
+      # rubocop:enable Style/TrivialAccessors
 
       # Returns the relative path (from preview_path) to the preview example template if the template exists
       def preview_example_template_path(example)
@@ -86,26 +89,26 @@ module ViewComponent # :nodoc:
         end
 
         path = Dir["#{preview_path}/#{preview_name}_preview/#{example}.html.*"].first
-        Pathname.new(path).
-          relative_path_from(Pathname.new(preview_path)).
-          to_s.
-          sub(/\..*$/, "")
+        Pathname.new(path)
+          .relative_path_from(Pathname.new(preview_path))
+          .to_s
+          .sub(/\..*$/, "")
       end
 
       # Returns the method body for the example from the preview file.
       def preview_source(example)
-        source = self.instance_method(example.to_sym).source.split("\n")
+        source = instance_method(example.to_sym).source.split("\n")
         source[1...(source.size - 1)].join("\n")
       end
 
-      private
-
       def load_previews
         Array(preview_paths).each do |preview_path|
           Dir["#{preview_path}/**/*_preview.rb"].sort.each { |file| require_dependency file }
         end
       end
 
+      private
+
       def preview_paths
         Base.preview_paths
       end

data/lib/view_component/render_component_to_string_helper.rb

@@ -3,7 +3,7 @@
 module ViewComponent
   module RenderComponentToStringHelper # :nodoc:
     def render_component_to_string(component)
-      component.render_in(self.view_context)
+      component.render_in(view_context)
     end
   end
 end

data/lib/view_component/render_preview_helper.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module ViewComponent
+  module RenderPreviewHelper
+    # 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 preview [String] The name of the preview to be rendered.
+    # @return [Nokogiri::HTML]
+    def render_preview(name)
+      begin
+        preview_klass = if respond_to?(:described_class)
+          if described_class.nil?
+            raise "`render_preview` expected a described_class, but it is nil."
+          end
+
+          "#{described_class}Preview"
+        else
+          self.class.name.gsub("Test", "Preview")
+        end
+        preview_klass = preview_klass.constantize
+      rescue NameError
+        raise NameError.new(
+          "`render_preview` expected to find #{preview_klass}, but it does not exist."
+        )
+      end
+
+      previews_controller = build_controller(ViewComponent::Base.preview_controller.constantize)
+      previews_controller.request.params[:path] = "#{preview_klass.preview_name}/#{name}"
+      previews_controller.response = ActionDispatch::Response.new
+      result = previews_controller.previews
+
+      @rendered_content = result
+
+      Nokogiri::HTML.fragment(@rendered_content)
+    end
+  end
+end

data/lib/view_component/render_to_string_monkey_patch.rb

@@ -4,7 +4,7 @@ module ViewComponent
   module RenderToStringMonkeyPatch # :nodoc:
     def render_to_string(options = {}, args = {})
       if options.respond_to?(:render_in)
-        options.render_in(self.view_context)
+        options.render_in(view_context)
       else
         super
       end