view_component 3.14.0 → 3.15.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7ef8c603bedd61511ed3eb2da02cd7aaccc5b890ad20badac0cfc9a3e7d4af1e
-  data.tar.gz: f756c5bd11f44e7e8984d6cb6b29ec409dc082d83864ee4bd82c50adc784310c
+  metadata.gz: 25e2163752aa77abea2905cb28191358f69e1f8f473bbfa05db10d89d3fe4543
+  data.tar.gz: 4641471ff3338d4132c409d28a9f4ce5d77677525be98737550288b8b22f3693
 SHA512:
-  metadata.gz: 8815314944335c3b69196bf5ba8779e10ec78a3146e8cc51d4d278d5e444035c8bc50858315c45e5556337e925ab94f4afee6b3283839079db6892292bec3581
-  data.tar.gz: 42c9159369779c50a9904525239d5bf3daa62ed5373104cb11f80251b9481a8225290421d0d9a5663e9f7c7e0bd4d73c63a53bc44845dc4b5bc23a0419869301
+  metadata.gz: f780668314e90a1f3584e77785d6f514c30996fa6f94dc994c670d96c75df681f368c50a3cb1615cfa0e86224a5f7524afd03e323f4c0a9ed32394c6cd04022a
+  data.tar.gz: 89fa4c33d4fd03f1f63ac1e0dac274379d37cc11ee9fdb250d12ebb377c6aadfeae1d87edc69c1fcf65e800401b4f195d129f4ef20d937c62245064b4ac927be

data/docs/CHANGELOG.md

@@ -10,6 +10,48 @@ nav_order: 5
 
 ## main
 
+## 3.15.0
+
+* Add basic internal testing for memory allocations.
+
+    *Joel Hawksley*
+
+* Add support for request formats.
+
+    *Joel Hawksley*
+
+* Add `rendered_json` test helper.
+
+    *Joel Hawksley*
+
+* Add `with_format` test helper.
+
+    *Joel Hawksley*
+
+* Warn if using Ruby < 3.2 or Rails < 7.1, which won't be supported by ViewComponent v4, to be released no earlier than April 1, 2025.
+
+    *Joel Hawksley*
+
+* Add Kicksite to list of companies using ViewComponent.
+
+    *Adil Lari*
+
+* Allow overridden slot methods to use `super`.
+
+    *Andrew Schwartz*
+
+* Add Rails engine support to generators.
+
+    *Tomasz Kowalewski*
+
+* Register stats directories with `Rails::CodeStatistics.register_directory` to support `rails stats` in Rails 8.
+
+    *Petrik de Heus*
+
+* Fixed type declaration for `ViewComponent::TestHelpers.with_controller_class` parameter.
+
+    *Graham Rogers*
+
 ## 3.14.0
 
 * Defer to built-in caching for language environment setup, rather than manually using `actions/cache` in CI.

data/lib/rails/generators/component/templates/component.rb.tt

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+<% module_namespacing do -%>
 class <%= class_name %>Component < <%= parent_class %>
 <%- if initialize_signature -%>
   def initialize(<%= initialize_signature %>)
@@ -11,5 +12,5 @@ class <%= class_name %>Component < <%= parent_class %>
     content_tag :h1, "Hello world!"<%= ", data: { controller: \"#{stimulus_controller}\" }" if options["stimulus"] %>
   end
 <%- end -%>
-
 end
+<% end -%>

data/lib/rails/generators/preview/templates/component_preview.rb.tt

@@ -1,7 +1,9 @@
 # frozen_string_literal: true
 
+<% module_namespacing do -%>
 class <%= class_name %>ComponentPreview < ViewComponent::Preview
   def default
     render(<%= class_name %>Component.new<%= "(#{render_signature})" if render_signature %>)
   end
 end
+<% end -%>

data/lib/rails/generators/rspec/templates/component_spec.rb.tt

@@ -2,7 +2,7 @@
 
 require "rails_helper"
 
-RSpec.describe <%= class_name %>Component, type: :component do
+RSpec.describe <%= namespaced? ? "#{namespace.name}::" : '' %><%= class_name %>Component, type: :component do
   pending "add some examples to (or delete) #{__FILE__}"
 
   # it "renders something useful" do

data/lib/rails/generators/test_unit/templates/component_test.rb.tt

@@ -2,7 +2,7 @@
 
 require "test_helper"
 
-class <%= class_name %>ComponentTest < ViewComponent::TestCase
+class <%= namespaced? ? "#{namespace.name}::" : '' %><%= class_name %>ComponentTest < ViewComponent::TestCase
   def test_component_renders_something_useful
     # assert_equal(
     #   %(<span>Hello, components!</span>),

data/lib/view_component/base.rb

@@ -11,6 +11,7 @@ require "view_component/inline_template"
 require "view_component/preview"
 require "view_component/slotable"
 require "view_component/slotable_default"
+require "view_component/template"
 require "view_component/translatable"
 require "view_component/with_content_helper"
 require "view_component/use_helpers"
@@ -35,6 +36,7 @@ module ViewComponent
     include ViewComponent::WithContentHelper
 
     RESERVED_PARAMETER = :content
+    VC_INTERNAL_DEFAULT_FORMAT = :html
 
     # For CSRF authenticity tokens in forms
     delegate :form_authenticity_token, :protect_against_forgery?, :config, to: :helpers
@@ -106,9 +108,16 @@ module ViewComponent
       before_render
 
       if render?
-        # Avoid allocating new string when output_preamble and output_postamble are blank
-        rendered_template = safe_render_template_for(@__vc_variant).to_s
+        rendered_template =
+          if compiler.renders_template_for?(@__vc_variant, request&.format&.to_sym)
+            render_template_for(@__vc_variant, request&.format&.to_sym)
+          else
+            maybe_escape_html(render_template_for(@__vc_variant, request&.format&.to_sym)) 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.to_s
 
+        # Avoid allocating new string when output_preamble and output_postamble are blank
         if output_preamble.blank? && output_postamble.blank?
           rendered_template
         else
@@ -330,16 +339,6 @@ module ViewComponent
       end
     end
 
-    def safe_render_template_for(variant)
-      if compiler.renders_template_for_variant?(variant)
-        render_template_for(variant)
-      else
-        maybe_escape_html(render_template_for(variant)) 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 safe_output_preamble
       maybe_escape_html(output_preamble) do
         Kernel.warn("WARNING: The #{self.class} component was provided an HTML-unsafe preamble. The preamble will be automatically escaped, but you may want to investigate.")
@@ -500,13 +499,6 @@ module ViewComponent
         Collection.new(self, collection, **args)
       end
 
-      # Provide identifier for ActionView template annotations
-      #
-      # @private
-      def short_identifier
-        @short_identifier ||= defined?(Rails.root) ? source_location.sub("#{Rails.root}/", "") : source_location
-      end
-
       # @private
       def inherited(child)
         # Compile so child will inherit compiled `call_*` template methods that
@@ -519,12 +511,12 @@ module ViewComponent
         # meaning it will not be called for any children and thus not compile their templates.
         if !child.instance_methods(false).include?(:render_template_for) && !child.compiled?
           child.class_eval <<~RUBY, __FILE__, __LINE__ + 1
-            def render_template_for(variant = nil)
+            def render_template_for(variant = nil, format = 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)
+              render_template_for(variant, format)
             end
           RUBY
         end
@@ -572,10 +564,6 @@ module ViewComponent
         compile unless compiled?
       end
 
-      # Compile templates to instance methods, assuming they haven't been compiled already.
-      #
-      # Do as much work as possible in this step, as doing so reduces the amount
-      # of work done each time a component is rendered.
       # @private
       def compile(raise_errors: false, force: false)
         compiler.compile(raise_errors: raise_errors, force: force)
@@ -586,22 +574,6 @@ module ViewComponent
         @__vc_compiler ||= Compiler.new(self)
       end
 
-      # we'll eventually want to update this to support other types
-      # @private
-      def type
-        "text/html"
-      end
-
-      # @private
-      def format
-        :html
-      end
-
-      # @private
-      def identifier
-        source_location
-      end
-
       # Set the parameter name used when rendering elements of a collection ([documentation](/guide/collections)):
       #
       # ```ruby

data/lib/view_component/collection.rb

@@ -7,7 +7,6 @@ module ViewComponent
     include Enumerable
     attr_reader :component
 
-    delegate :format, to: :component
     delegate :size, to: :@collection
 
     attr_accessor :__vc_original_view_context
@@ -41,6 +40,12 @@ module ViewComponent
       components.each(&block)
     end
 
+    # Rails expects us to define `format` on all renderables,
+    # but we do not know the `format` of a ViewComponent until runtime.
+    def format
+      nil
+    end
+
     private
 
     def initialize(component, object, **options)

data/lib/view_component/compiler.rb

@@ -4,308 +4,228 @@ require "concurrent-ruby"
 
 module ViewComponent
   class Compiler
-    # Compiler mode. Can be either:
-    # * development (a blocking mode which ensures thread safety when redefining the `call` method for components,
+    # Compiler development mode. Can be either:
+    # * true (a blocking mode which ensures thread safety when redefining the `call` method for components,
     #                default in Rails development and test mode)
-    # * production (a non-blocking mode, default in Rails production mode)
-    DEVELOPMENT_MODE = :development
-    PRODUCTION_MODE = :production
+    # * false(a non-blocking mode, default in Rails production mode)
+    class_attribute :development_mode, default: false
 
-    class_attribute :mode, default: PRODUCTION_MODE
-
-    def initialize(component_class)
-      @component_class = component_class
+    def initialize(component)
+      @component = component
       @redefinition_lock = Mutex.new
-      @variants_rendering_templates = Set.new
+      @rendered_templates = Set.new
     end
 
     def compiled?
-      CompileCache.compiled?(component_class)
-    end
-
-    def development?
-      self.class.mode == DEVELOPMENT_MODE
+      CompileCache.compiled?(@component)
     end
 
     def compile(raise_errors: false, force: false)
       return if compiled? && !force
-      return if component_class == ViewComponent::Base
-
-      component_class.superclass.compile(raise_errors: raise_errors) if should_compile_superclass?
-
-      if template_errors.present?
-        raise TemplateError.new(template_errors) if raise_errors
+      return if @component == ViewComponent::Base
 
-        return false
-      end
+      gather_templates
 
-      if raise_errors
-        component_class.validate_initialization_parameters!
-        component_class.validate_collection_parameter!
+      if self.class.development_mode && @templates.any?(&:requires_compiled_superclass?)
+        @component.superclass.compile(raise_errors: raise_errors)
       end
 
-      if has_inline_template?
-        template = component_class.inline_template
-
-        redefinition_lock.synchronize do
-          component_class.silence_redefinition_of_method("call")
-          # rubocop:disable Style/EvalWithLocation
-          component_class.class_eval <<-RUBY, template.path, template.lineno
-          def call
-            #{compiled_inline_template(template)}
-          end
-          RUBY
-          # rubocop:enable Style/EvalWithLocation
-
-          component_class.define_method(:"_call_#{safe_class_name}", component_class.instance_method(:call))
+      return if gather_template_errors(raise_errors).any?
 
-          component_class.silence_redefinition_of_method("render_template_for")
-          component_class.class_eval <<-RUBY, __FILE__, __LINE__ + 1
-          def render_template_for(variant = nil)
-            _call_#{safe_class_name}
-          end
-          RUBY
-        end
-      else
-        templates.each do |template|
-          method_name = call_method_name(template[:variant])
-          @variants_rendering_templates << template[:variant]
-
-          redefinition_lock.synchronize do
-            component_class.silence_redefinition_of_method(method_name)
-            # 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
-        end
-
-        define_render_template_for
+      if raise_errors
+        @component.validate_initialization_parameters!
+        @component.validate_collection_parameter!
       end
 
-      component_class.registered_slots.each do |slot_name, config|
-        config[:default_method] = component_class.instance_methods.find { |method_name| method_name == :"default_#{slot_name}" }
+      define_render_template_for
 
-        component_class.registered_slots[slot_name] = config
-      end
+      @component.register_default_slots
+      @component.build_i18n_backend
 
-      component_class.build_i18n_backend
-
-      CompileCache.register(component_class)
+      CompileCache.register(@component)
     end
 
-    def renders_template_for_variant?(variant)
-      @variants_rendering_templates.include?(variant)
+    def renders_template_for?(variant, format)
+      @rendered_templates.include?([variant, format])
     end
 
     private
 
-    attr_reader :component_class, :redefinition_lock
+    attr_reader :templates
 
     def define_render_template_for
-      variant_elsifs = variants.compact.uniq.map do |variant|
-        safe_name = "_call_variant_#{normalized_variant_name(variant)}_#{safe_class_name}"
-        component_class.define_method(safe_name, component_class.instance_method(call_method_name(variant)))
-
-        "elsif variant.to_sym == :'#{variant}'\n    #{safe_name}"
-      end.join("\n")
-
-      component_class.define_method(:"_call_#{safe_class_name}", component_class.instance_method(:call))
+      @templates.each do |template|
+        @redefinition_lock.synchronize do
+          template.compile_to_component
+        end
+      end
 
-      body = <<-RUBY
-        if variant.nil?
-          _call_#{safe_class_name}
-        #{variant_elsifs}
+      method_body =
+        if @templates.one?
+          @templates.first.safe_method_name
+        elsif (template = @templates.find(&:inline?))
+          template.safe_method_name
         else
-          _call_#{safe_class_name}
+          branches = []
+
+          @templates.each do |template|
+            conditional =
+              if template.inline_call?
+                "variant&.to_sym == #{template.variant.inspect}"
+              else
+                [
+                  template.default_format? ? "(format == #{ViewComponent::Base::VC_INTERNAL_DEFAULT_FORMAT.inspect} || format.nil?)" : "format == #{template.format.inspect}",
+                  template.variant.nil? ? "variant.nil?" : "variant&.to_sym == #{template.variant.inspect}"
+                ].join(" && ")
+              end
+
+            branches << [conditional, template.safe_method_name]
+          end
+
+          out = branches.each_with_object(+"") do |(conditional, branch_body), memo|
+            memo << "#{(!memo.present?) ? "if" : "elsif"} #{conditional}\n  #{branch_body}\n"
+          end
+          out << "else\n  #{templates.find { _1.variant.nil? && _1.default_format? }.safe_method_name}\nend"
         end
-      RUBY
 
-      redefinition_lock.synchronize do
-        component_class.silence_redefinition_of_method(:render_template_for)
-        component_class.class_eval <<-RUBY, __FILE__, __LINE__ + 1
-        def render_template_for(variant = nil)
-          #{body}
+      @redefinition_lock.synchronize do
+        @component.silence_redefinition_of_method(:render_template_for)
+        @component.class_eval <<-RUBY, __FILE__, __LINE__ + 1
+        def render_template_for(variant = nil, format = nil)
+          #{method_body}
         end
         RUBY
       end
     end
 
-    def has_inline_template?
-      component_class.respond_to?(:inline_template) && component_class.inline_template.present?
-    end
+    def gather_template_errors(raise_errors)
+      errors = []
 
-    def template_errors
-      @__vc_template_errors ||=
-        begin
-          errors = []
+      errors << "Couldn't find a template file or inline render method for #{@component}." if @templates.empty?
 
-          if (templates + inline_calls).empty? && !has_inline_template?
-            errors << "Couldn't find a template file or inline render method for #{component_class}."
-          end
+      # We currently allow components to have both an inline call method and a template for a variant, with the
+      # inline call method overriding the template. We should aim to change this in v4 to instead
+      # raise an error.
+      @templates.reject(&:inline_call?)
+        .map { |template| [template.variant, template.format] }
+        .tally
+        .select { |_, count| count > 1 }
+        .each do |tally|
+        variant, this_format = tally.first
 
-          if templates.count { |template| template[:variant].nil? } > 1
-            errors <<
-              "More than one template found for #{component_class}. " \
-              "There can only be one default template file per component."
-          end
+        variant_string = " for variant `#{variant}`" if variant.present?
 
-          invalid_variants =
-            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)} " \
-              "#{invalid_variants.map { |v| "'#{v}'" }.to_sentence} in #{component_class}. " \
-              "There can only be one template file per variant."
-          end
+        errors << "More than one #{this_format.upcase} template found#{variant_string} for #{@component}. "
+      end
 
-          if templates.find { |template| template[:variant].nil? } && inline_calls_defined_on_self.include?(:call)
-            errors <<
-              "Template file and inline render method found for #{component_class}. " \
-              "There can only be a template file or inline render method per component."
-          end
+      default_template_types = @templates.each_with_object(Set.new) do |template, memo|
+        next if template.variant
 
-          duplicate_template_file_and_inline_variant_calls =
-            templates.pluck(:variant) & variants_from_inline_calls(inline_calls_defined_on_self)
+        memo << :template_file if !template.inline_call?
+        memo << :inline_render if template.inline_call? && template.defined_on_self?
 
-          unless duplicate_template_file_and_inline_variant_calls.empty?
-            count = duplicate_template_file_and_inline_variant_calls.count
+        memo
+      end
 
-            errors <<
-              "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."
-          end
+      if default_template_types.length > 1
+        errors <<
+          "Template file and inline render method found for #{@component}. " \
+          "There can only be a template file or inline render method per component."
+      end
 
-          uniq_variants = variants.compact.uniq
-          normalized_variants = uniq_variants.map { |variant| normalized_variant_name(variant) }
+      # If a template has inline calls, they can conflict with template files the component may use
+      # to render. This attempts to catch and raise that issue before run time. For example,
+      # `def render_mobile` would conflict with a sidecar template of `component.html+mobile.erb`
+      duplicate_template_file_and_inline_call_variants =
+        @templates.reject(&:inline_call?).map(&:variant) &
+        @templates.select { _1.inline_call? && _1.defined_on_self? }.map(&:variant)
+
+      unless duplicate_template_file_and_inline_call_variants.empty?
+        count = duplicate_template_file_and_inline_call_variants.count
+
+        errors <<
+          "Template #{"file".pluralize(count)} and inline render #{"method".pluralize(count)} " \
+          "found for #{"variant".pluralize(count)} " \
+          "#{duplicate_template_file_and_inline_call_variants.map { |v| "'#{v}'" }.to_sentence} " \
+          "in #{@component}. There can only be a template file or inline render method per variant."
+      end
 
-          colliding_variants = uniq_variants.select do |variant|
-            normalized_variants.count(normalized_variant_name(variant)) > 1
-          end
+      @templates.select(&:variant).each_with_object(Hash.new { |h, k| h[k] = Set.new }) do |template, memo|
+        memo[template.normalized_variant_name] << template.variant
+        memo
+      end.each do |_, variant_names|
+        next unless variant_names.length > 1
 
-          unless colliding_variants.empty?
-            errors <<
-              "Colliding templates #{colliding_variants.sort.map { |v| "'#{v}'" }.to_sentence} " \
-              "found in #{component_class}."
-          end
+        errors << "Colliding templates #{variant_names.sort.map { |v| "'#{v}'" }.to_sentence} found in #{@component}."
+      end
 
-          errors
-        end
+      raise TemplateError.new(errors) if errors.any? && raise_errors
+
+      errors
     end
 
-    def templates
+    def gather_templates
       @templates ||=
         begin
-          extensions = ActionView::Template.template_handler_extensions
-
-          component_class.sidecar_files(extensions).each_with_object([]) do |path, memo|
-            pieces = File.basename(path).split(".")
-            memo << {
+          templates = @component.sidecar_files(
+            ActionView::Template.template_handler_extensions
+          ).map do |path|
+            # Extract format and variant from template filename
+            this_format, variant =
+              File
+                .basename(path)     # "variants_component.html+mini.watch.erb"
+                .split(".")[1..-2]  # ["html+mini", "watch"]
+                .join(".")          # "html+mini.watch"
+                .split("+")         # ["html", "mini.watch"]
+                .map(&:to_sym)      # [:html, :"mini.watch"]
+
+            out = Template.new(
+              component: @component,
+              type: :file,
               path: path,
-              variant: pieces[1..-2].join(".").split("+").second&.to_sym,
-              handler: pieces.last
-            }
-          end
-        end
-    end
-
-    def inline_calls
-      @inline_calls ||=
-        begin
-          # Fetch only ViewComponent ancestor classes to limit the scope of
-          # finding inline calls
-          view_component_ancestors =
-            (
-              component_class.ancestors.take_while { |ancestor| ancestor != ViewComponent::Base } -
-              component_class.included_modules
+              lineno: 0,
+              extension: path.split(".").last,
+              this_format: this_format,
+              variant: variant
             )
 
-          view_component_ancestors.flat_map { |ancestor| ancestor.instance_methods(false).grep(/^call(_|$)/) }.uniq
-        end
-    end
-
-    def inline_calls_defined_on_self
-      @inline_calls_defined_on_self ||= component_class.instance_methods(false).grep(/^call(_|$)/)
-    end
-
-    def variants
-      @__vc_variants = (
-        templates.map { |template| template[:variant] } + variants_from_inline_calls(inline_calls)
-      ).compact.uniq
-    end
-
-    def variants_from_inline_calls(calls)
-      calls.reject { |call| call == :call }.map do |variant_call|
-        variant_call.to_s.sub("call_", "").to_sym
-      end
-    end
-
-    def compiled_inline_template(template)
-      handler = ActionView::Template.handler_for_extension(template.language)
-      template = template.source.dup
+            # TODO: We should consider inlining the HTML output safety logic into the compiled render_template_for
+            # instead of this indirect approach
+            @rendered_templates << [out.variant, out.this_format]
 
-      compile_template(template, handler)
-    end
-
-    def compiled_template(file_path)
-      handler = ActionView::Template.handler_for_extension(File.extname(file_path).delete("."))
-      template = File.read(file_path)
-
-      compile_template(template, handler)
-    end
-
-    def compile_template(template, handler)
-      template.rstrip! if component_class.strip_trailing_whitespace?
-
-      if handler.method(:call).parameters.length > 1
-        handler.call(component_class, template)
-      # :nocov:
-      else
-        handler.call(
-          OpenStruct.new(
-            source: template,
-            identifier: component_class.identifier,
-            type: component_class.type
-          )
-        )
-      end
-      # :nocov:
-    end
-
-    def call_method_name(variant)
-      if variant.present? && variants.include?(variant)
-        "call_#{normalized_variant_name(variant)}"
-      else
-        "call"
-      end
-    end
-
-    def normalized_variant_name(variant)
-      variant.to_s.gsub("-", "__").gsub(".", "___")
-    end
+            out
+          end
 
-    def safe_class_name
-      @safe_class_name ||= component_class.name.underscore.gsub("/", "__")
-    end
+          component_instance_methods_on_self = @component.instance_methods(false)
+
+          (
+            @component.ancestors.take_while { |ancestor| ancestor != ViewComponent::Base } - @component.included_modules
+          ).flat_map { |ancestor| ancestor.instance_methods(false).grep(/^call(_|$)/) }
+            .uniq
+            .each do |method_name|
+              templates << Template.new(
+                component: @component,
+                type: :inline_call,
+                this_format: ViewComponent::Base::VC_INTERNAL_DEFAULT_FORMAT,
+                variant: method_name.to_s.include?("call_") ? method_name.to_s.sub("call_", "").to_sym : nil,
+                method_name: method_name,
+                defined_on_self: component_instance_methods_on_self.include?(method_name)
+              )
+            end
 
-    def should_compile_superclass?
-      development? && templates.empty? && !has_inline_template? && !call_defined?
-    end
+          if @component.inline_template.present?
+            templates << Template.new(
+              component: @component,
+              type: :inline,
+              path: @component.inline_template.path,
+              lineno: @component.inline_template.lineno,
+              source: @component.inline_template.source.dup,
+              extension: @component.inline_template.language
+            )
+          end
 
-    def call_defined?
-      component_class.instance_methods(false).include?(:call) ||
-        component_class.private_instance_methods(false).include?(:call)
+          templates
+        end
     end
   end
 end

data/lib/view_component/config.rb

@@ -168,11 +168,29 @@ module ViewComponent
       # Defaults to `false`.
 
       def default_preview_paths
+        (default_rails_preview_paths + default_rails_engines_preview_paths).uniq
+      end
+
+      def default_rails_preview_paths
         return [] unless defined?(Rails.root) && Dir.exist?("#{Rails.root}/test/components/previews")
 
         ["#{Rails.root}/test/components/previews"]
       end
 
+      def default_rails_engines_preview_paths
+        return [] unless defined?(Rails::Engine)
+
+        registered_rails_engines_with_previews.map do |descendant|
+          "#{descendant.root}/test/components/previews"
+        end
+      end
+
+      def registered_rails_engines_with_previews
+        Rails::Engine.descendants.select do |descendant|
+          defined?(descendant.root) && Dir.exist?("#{descendant.root}/test/components/previews")
+        end
+      end
+
       def default_generate_options
         options = ActiveSupport::OrderedOptions.new(false)
         options.preview_path = ""

data/lib/view_component/engine.rb

@@ -8,8 +8,16 @@ module ViewComponent
   class Engine < Rails::Engine # :nodoc:
     config.view_component = ViewComponent::Config.current
 
-    rake_tasks do
-      load "view_component/rails/tasks/view_component.rake"
+    if Rails.version.to_f < 8.0
+      rake_tasks do
+        load "view_component/rails/tasks/view_component.rake"
+      end
+    else
+      initializer "view_component.stats_directories" do |app|
+        require "rails/code_statistics"
+        dir = ViewComponent::Base.view_component_path
+        Rails::CodeStatistics.register_directory("ViewComponents", dir)
+      end
     end
 
     initializer "view_component.set_configs" do |app|
@@ -128,11 +136,7 @@ module ViewComponent
     end
 
     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 = (Rails.env.development? || Rails.env.test?)
     end
 
     config.after_initialize do |app|
@@ -165,12 +169,12 @@ module ViewComponent
       end
 
       # :nocov:
-      if RUBY_VERSION < "3.0.0"
-        ViewComponent::Deprecation.deprecation_warning("Support for Ruby versions < 3.0.0", "ViewComponent 4.0 will remove support for Ruby versions < 3.0.0 ")
+      if RUBY_VERSION < "3.2.0"
+        ViewComponent::Deprecation.deprecation_warning("Support for Ruby versions < 3.2.0", "ViewComponent v4 will remove support for Ruby versions < 3.2.0 no earlier than April 1, 2025")
       end
 
-      if Rails.version.to_f < 6.1
-        ViewComponent::Deprecation.deprecation_warning("Support for Rails versions < 6.1", "ViewComponent 4.0 will remove support for Rails versions < 6.1 ")
+      if Rails.version.to_f < 7.1
+        ViewComponent::Deprecation.deprecation_warning("Support for Rails versions < 7.1", "ViewComponent v4 will remove support for Rails versions < 7.1 no earlier than April 1, 2025")
       end
       # :nocov:
 

data/lib/view_component/errors.rb

@@ -18,7 +18,7 @@ module ViewComponent
 
   class TemplateError < StandardError
     def initialize(errors)
-      super(errors.join(", "))
+      super(errors.join("\n"))
     end
   end
 

data/lib/view_component/instrumentation.rb

@@ -13,7 +13,7 @@ module ViewComponent # :nodoc:
         notification_name,
         {
           name: self.class.name,
-          identifier: self.class.identifier
+          identifier: self.class.source_location
         }
       ) do
         super

data/lib/view_component/slotable.rb

@@ -89,11 +89,11 @@ module ViewComponent
           end
           ruby2_keywords(setter_method_name) if respond_to?(:ruby2_keywords, true)
 
-          define_method slot_name do
+          self::GeneratedSlotMethods.define_method slot_name do
             get_slot(slot_name)
           end
 
-          define_method :"#{slot_name}?" do
+          self::GeneratedSlotMethods.define_method :"#{slot_name}?" do
             get_slot(slot_name).present?
           end
 
@@ -176,11 +176,11 @@ module ViewComponent
             end
           end
 
-          define_method slot_name do
+          self::GeneratedSlotMethods.define_method slot_name do
             get_slot(slot_name)
           end
 
-          define_method :"#{slot_name}?" do
+          self::GeneratedSlotMethods.define_method :"#{slot_name}?" do
             get_slot(slot_name).present?
           end
 
@@ -199,19 +199,28 @@ module ViewComponent
         end
       end
 
-      # Clone slot configuration into child class
-      # see #test_slots_pollution
       def inherited(child)
+        # Clone slot configuration into child class
+        # see #test_slots_pollution
         child.registered_slots = registered_slots.clone
+
+        # Add a module for slot methods, allowing them to be overriden by the component class
+        # see #test_slot_name_can_be_overriden
+        unless child.const_defined?(:GeneratedSlotMethods, false)
+          generated_slot_methods = Module.new
+          child.const_set(:GeneratedSlotMethods, generated_slot_methods)
+          child.include generated_slot_methods
+        end
+
         super
       end
 
       def register_polymorphic_slot(slot_name, types, collection:)
-        define_method(slot_name) do
+        self::GeneratedSlotMethods.define_method(slot_name) do
           get_slot(slot_name)
         end
 
-        define_method(:"#{slot_name}?") do
+        self::GeneratedSlotMethods.define_method(:"#{slot_name}?") do
           get_slot(slot_name).present?
         end
 
@@ -259,6 +268,15 @@ module ViewComponent
         }
       end
 
+      # Called by the compiler, as instance methods are not defined when slots are first registered
+      def register_default_slots
+        registered_slots.each do |slot_name, config|
+          config[:default_method] = instance_methods.find { |method_name| method_name == :"default_#{slot_name}" }
+
+          registered_slots[slot_name] = config
+        end
+      end
+
       private
 
       def register_slot(slot_name, **kwargs)

data/lib/view_component/template.rb

@@ -0,0 +1,123 @@
+require "ostruct"
+
+module ViewComponent
+  class Template
+    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 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(
+          OpenStruct.new(format: @this_format, identifier: @path, short_identifier: short_identifier, type: type),
+          this_source
+        )
+      # :nocov:
+      # TODO: Remove in v4
+      else
+        handler.call(OpenStruct.new(source: this_source, identifier: @path, type: type))
+      end
+      # :nocov:
+    end
+  end
+end

data/lib/view_component/test_helpers.rb

@@ -63,6 +63,16 @@ module ViewComponent
       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:
     #
@@ -145,7 +155,7 @@ 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?(@vc_test_controller) && @vc_test_controller
 
@@ -155,6 +165,19 @@ module ViewComponent
       @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):
     #
     # ```ruby
@@ -182,7 +205,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: :html)
+    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

data/lib/view_component/version.rb

@@ -3,7 +3,7 @@
 module ViewComponent
   module VERSION
     MAJOR = 3
-    MINOR = 14
+    MINOR = 15
     PATCH = 0
     PRE = nil
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: view_component
 version: !ruby/object:Gem::Version
-  version: 3.14.0
+  version: 3.15.0
 platform: ruby
 authors:
 - ViewComponent Team
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2024-08-26 00:00:00.000000000 Z
+date: 2024-09-27 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -58,6 +58,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '1.0'
+- !ruby/object:Gem::Dependency
+  name: allocation_stats
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.1.5
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.1.5
 - !ruby/object:Gem::Dependency
   name: appraisal
   requirement: !ruby/object:Gem::Requirement
@@ -547,6 +561,7 @@ files:
 - lib/view_component/slotable_default.rb
 - lib/view_component/system_test_case.rb
 - lib/view_component/system_test_helpers.rb
+- lib/view_component/template.rb
 - lib/view_component/test_case.rb
 - lib/view_component/test_helpers.rb
 - lib/view_component/translatable.rb