view_component 4.19.0 → 4.20.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d29069cd53a93e2e3b1e2285612ecd25985bae4458a842227922a1a5bdb18b96
-  data.tar.gz: 6063a6b520fc62961f61e36b30bbbf47eaf5728580a61a5af68231b11c5f7dc4
+  metadata.gz: 04ae333990353bff3c4671c78db517fbe53ddcb15d9bfeb4448bc2d52c710f5b
+  data.tar.gz: ef958403f0326485a5f2035a9d744c878197c041247df3f76e68cf2712b9a652
 SHA512:
-  metadata.gz: 2741959ff497e91a4fd792959667ad0e6ca57f3378e460a8ec6db74c013b09acf4eeb2bfbcbfbfab9b81f92613c29107562c838502b61b5a3b8503e4c75978ed
-  data.tar.gz: 8b54025874d993b7fe3b61f565bff74c463ac683f66b0427b05cc3e5791ec1d4b526fd9807010669e641203505c0d0e58376ffab3c6d96e2a1e68bc746e1e4cc
+  metadata.gz: 68e6ae32b57a9c1323ed64eb82c866e9595f2aeca16009b532f4922e85abe72536b06dc61d75328a202faef438f57e4d9deebef8ace06c96a3c7d609ad946a38
+  data.tar.gz: 52ef898174f4270dbc4bdcc91c0d841d35fe12c04c8b46e0639b0b1cb1a43b2789d24174cf70f2bc4ee3718eae536448b24833247cdd9a0f891c33678186060f

data/app/views/test_mailer/test_multipart_email.html.erb

@@ -0,0 +1 @@
+<%= render MultipartMailerComponent.new %>

data/app/views/test_mailer/test_multipart_email.text.erb

@@ -0,0 +1 @@
+<%= render MultipartMailerComponent.new %>

data/docs/CHANGELOG.md

@@ -10,6 +10,56 @@ nav_order: 6
 
 ## main
 
+## 4.20.0
+
+* Fix `invalid byte sequence in UTF-8` errors when precomputing cache digests for components loaded from encrypted or binary source files.
+
+    *Joel Junström*
+
+* Fix cache digests missing components rendered through a slot declared with the component's class, through a method or variable that holds the component, or through a module the component includes. Any constant naming a component in a component's Ruby or templates now counts as a dependency, and included modules are digested like superclasses.
+
+    *Erik Axel Nielsen*
+
+* Add an informational CI check that runs added and modified tests without a pull request's implementation changes to identify regression coverage.
+
+    *Joel Hawksley*
+
+* Speed up rendering with direct compiled-template calls and avoid intermediate method allocations when invoking lambda-backed slots.
+
+    *Joel Hawksley*
+
+* Fix `Couldn't find template for digesting` errors when computing cache digests for templates that render components. Action View inferred a partial from `render SomeComponent.new`, so partials inferred from component renders are now discarded. Component renders are found with Prism rather than a regular expression, adding a dependency on the `prism` gem.
+
+    *Joel Hawksley*
+
+* Fix components rendering the template for the first format a lookup context rendered in, instead of the current one. An Action Mailer email that declares `format.text` before `format.html` rendered the text template of each component into its HTML part. Components now reuse the details key Action View memoizes, which Action View resets whenever a detail such as `formats` changes. Regression from 4.16.0.
+
+    *Jan Schilbach*
+
+* Look up each component's sidecar templates and translations once while eager loading, instead of again when it compiles, loads its translations, and computes its cache digest, and for each of its subclasses. Time spent in ViewComponent during the boot benchmark drops by about a quarter.
+
+    *Clément Joubert*
+
+* Measure cache digest precomputation in the boot benchmark by disabling class reloading in the benchmark app and having each generated component render another.
+
+    *Joel Hawksley*
+
+* Add a CI performance check that fails a pull request when any benchmark scenario's component/partial render-time ratio, or ViewComponent's share of app boot time, regresses by more than 5% against the base branch on Rails 8.1 or Rails main.
+
+    *Joel Hawksley*
+
+* Fail the test suite when a gem in the Gemfile or gemspec isn't loaded.
+
+    *Joel Hawksley*
+
+* Remove the unused `selenium-webdriver` and `tailwindcss-rails` development dependencies.
+
+    *Joel Hawksley*
+
+* Speed up `sidecar_files`, which 4.18's cache digest precomputation calls for every component and superclass at boot, by globbing each directory once instead of once per extension. On an app with 302 components, `compile.view_component` drops from 2.3 s to 1.2 s.
+
+    *Clément Joubert*
+
 ## 4.19.0
 
 * Remove the unused `concurrent-ruby` dependency. `require "concurrent-ruby"` loaded every concurrent-ruby class at boot, a leftover from the `Concurrent::ReadWriteLock` the compiler no longer uses.

data/lib/view_component/base.rb

@@ -624,7 +624,10 @@ module ViewComponent
         return [] unless identifier
         return [] unless name
 
-        extensions = extensions.join(",")
+        # One glob per directory, filtered by extension, rather than a brace
+        # pattern per extension: Dir expands braces into one directory listing
+        # per extension.
+        extensions = extensions.map(&:to_s)
 
         # view files in a directory named like the component
         directory = File.dirname(identifier)
@@ -643,19 +646,29 @@ module ViewComponent
         # Without this, `MyOtherComponent` will not look for `my_component/my_other_component.html.erb`
         nested_component_files =
           if name.include?("::") && component_name != filename
-            Dir["#{directory}/#{filename}/#{component_name}.*{#{extensions}}"]
+            __vc_files_ending_with(extensions, "#{directory}/#{filename}/#{component_name}.*")
           else
             []
           end
 
         # view files in the same directory as the component
-        sidecar_files = Dir["#{directory}/#{component_name}.*{#{extensions}}"]
+        sidecar_files = __vc_files_ending_with(extensions, "#{directory}/#{component_name}.*")
 
-        sidecar_directory_files = Dir["#{directory}/#{component_name}/#{filename}.*{#{extensions}}"]
+        sidecar_directory_files = __vc_files_ending_with(extensions, "#{directory}/#{component_name}/#{filename}.*")
 
         (sidecar_files - [identifier] + sidecar_directory_files + nested_component_files).uniq
       end
 
+      # `sidecar_files`, looked up once per component while eager loading:
+      # every component looks up its superclasses' templates and translations
+      # too, when it compiles, loads its translations, and computes its cache
+      # digest.
+      #
+      # @private
+      def __vc_sidecar_files(extensions)
+        CompileCache.sidecar_files_for(self, extensions) { sidecar_files(extensions) }
+      end
+
       # Render a component for each element in a collection ([documentation](/guide/collections)):
       #
       # ```ruby
@@ -901,6 +914,11 @@ module ViewComponent
         signatures
       end
 
+      def __vc_files_ending_with(extensions, pattern)
+        paths = Dir[pattern]
+        extensions.flat_map { |extension| paths.select { |path| path.end_with?(extension) } }
+      end
+
       attr_reader :__vc_provided_collection_parameter
     end
 

data/lib/view_component/cache_digest/dependency_tracking.rb

@@ -26,7 +26,15 @@ module ViewComponent
           dependencies = dependencies - [declared] + [virtual_path]
         end
 
-        dependencies + CacheDigest.dependencies_in(template)
+        # Swap the partials Action View wrongly infers from component renders,
+        # such as `news/new` from `render ChildComponent.new`, for the
+        # components themselves.
+        return dependencies unless CacheDigest::CONSTANT_RENDER.match?(source)
+
+        component_paths, inferred_partials =
+          CacheDigest.component_renders_in(CacheDigest.compiled_source(template), name)
+
+        (dependencies - inferred_partials + component_paths).uniq
       end
 
       # @private

data/lib/view_component/cache_digest/resolver.rb

@@ -18,6 +18,10 @@ module ViewComponent
       # Extensions whose contents are hashed into the synthetic source.
       SIDECAR_EXTENSIONS = %w[yml yaml].freeze
 
+      # Where ViewComponent's own modules, such as the ones it includes into
+      # every component, are defined.
+      VIEW_COMPONENT_LIB = "#{::File.expand_path("..", __dir__)}/".freeze
+
       class << self
         def instance
           INSTANCE
@@ -49,30 +53,33 @@ module ViewComponent
       # @return [String]
       def source_for(component)
         parts = []
+        templates = template_sources(component)
 
         # Safety net: this template should never be rendered, only digested.
         parts << "<% raise ViewComponent::CacheDigestTemplateError.new(#{component.name.inspect}) %>"
 
         # Content hashes of the Ruby files and sidecar files backing the
-        # component and its component superclasses. Hashing rather than
-        # inlining keeps the source small and avoids embedding Ruby that a
-        # tracker might misread as a render call.
+        # component, its component superclasses, and the modules they include.
+        # Hashing rather than inlining keeps the source small and avoids
+        # embedding Ruby that a tracker might misread as a render call.
         source_files(component).each do |path|
           parts << "<%# Resolved Dependency: #{path} #{file_digest(path)} %>"
         end
 
-        # Everything the component renders from Ruby rather than from a
-        # template: `# Template Dependency:` declarations, components rendered
-        # from `#call` methods, and partials referenced by string path.
-        # Re-emitted so the Digestor resolves them as tree nodes.
-        ruby_dependencies(component).each do |dependency|
+        # Everything the component renders: `# Template Dependency:`
+        # declarations, the components its slots are declared with, and the
+        # components and partials referenced from its templates, in any
+        # language, and from its Ruby. Emitted as declarations so the Digestor
+        # resolves them as tree nodes without trackers having to find them in
+        # the template sources, where they'd also infer partials from component
+        # renders.
+        dependencies(component, templates).each do |dependency|
           parts << "<%# Template Dependency: #{dependency} %>"
         end
 
-        # Template sources verbatim, so trackers can discover the partials and
-        # components they render.
-        template_sources(component).each do |source|
-          parts << source
+        # Content hashes of the templates, including inline ones.
+        templates.each do |source, _extension|
+          parts << "<%# Template Digest: #{ActiveSupport::Digest.hexdigest(source)} %>"
         end
 
         parts.join("\n")
@@ -102,34 +109,55 @@ module ViewComponent
         end
       end
 
+      # Modules the component and its component superclasses include, such as
+      # a module of helpers that render other components. Modules included
+      # into `ViewComponent::Base` and above are left out, as superclasses
+      # are, and so are the modules ViewComponent adds to every component.
+      #
+      # @return [Array<String>] the files the modules are defined in
+      def module_files(component)
+        component.ancestors.take_while { |ancestor| ancestor != ViewComponent::Base }.filter_map { |ancestor|
+          next if ancestor.is_a?(Class) || ancestor.name.nil?
+
+          path, _line = Object.const_source_location(ancestor.name)
+          path unless path.nil? || path.start_with?(VIEW_COMPONENT_LIB)
+        }.uniq
+      end
+
       def source_files(component)
-        component_ancestors(component).flat_map { |ancestor|
-          [ancestor.identifier, *ancestor.sidecar_files(SIDECAR_EXTENSIONS)]
-        }.compact.uniq.select { |path| ::File.exist?(path) }
+        sidecars = component_ancestors(component).flat_map { |ancestor| ancestor.__vc_sidecar_files(SIDECAR_EXTENSIONS) }
+        (ruby_files(component) + sidecars).uniq.select { |path| ::File.exist?(path) }
+      end
+
+      def ruby_files(component)
+        component_ancestors(component).map(&:identifier).concat(module_files(component))
+          .compact.uniq.select { |path| ::File.exist?(path) }
       end
 
       def template_files(component)
         component_ancestors(component)
-          .flat_map { |ancestor| ancestor.sidecar_files(ActionView::Template::Handlers.extensions) }
+          .flat_map { |ancestor| ancestor.__vc_sidecar_files(ActionView::Template::Handlers.extensions) }
           .uniq
           .select { |path| ::File.exist?(path) }
       end
 
       # Sidecar template files plus inline templates, which live in the Ruby
       # file and so are invisible to Action View's trackers.
+      #
+      # @return [Array<Array(String, String)>] pairs of source and extension
       def template_sources(component)
-        sources = template_files(component).map { |path| ::File.read(path) }
+        sources = template_files(component).map { |path| [::File.read(path), ::File.extname(path).delete_prefix(".")] }
 
         component_ancestors(component).each do |ancestor|
           inline_template = ancestor.__vc_inline_template
-          sources << inline_template.source if inline_template
+          sources << [inline_template.source, inline_template.language.to_s] if inline_template
         end
 
         sources.uniq
       end
 
-      def explicit_dependencies(component)
-        ruby_sources(component).flat_map { |source|
+      def explicit_dependencies(sources)
+        sources.flat_map { |source|
           declared = source.scan(CacheDigest::EXPLICIT_DEPENDENCY).flatten
 
           # Component class names are translated to the path they're digested
@@ -142,29 +170,59 @@ module ViewComponent
         }.uniq
       end
 
-      # Everything a component renders from Ruby code rather than from a
-      # template. Action View's trackers only read templates, so a `#call`
-      # method that renders another component or a partial would otherwise go
-      # unnoticed.
-      def ruby_dependencies(component)
+      # Everything but the component and its superclasses, which a component
+      # references in its own source but are digested as part of it already.
+      def dependencies(component, templates)
         virtual_path = CacheDigest.virtual_path_for(component)
+        ruby = ruby_sources(component)
+        own_paths = component_ancestors(component).filter_map { |ancestor| CacheDigest.virtual_path_for(ancestor) }
 
-        explicit_dependencies(component) |
-          ruby_sources(component).flat_map { |source|
-            CacheDigest.component_paths_in(source) |
-              CacheDigest.partial_paths_in(source, virtual_path)
-          }.uniq
+        dependencies = explicit_dependencies(ruby + templates.map(&:first)) |
+          ruby.flat_map { |source| ruby_dependencies(source, virtual_path) } |
+          CacheDigest.slot_renders_of(component) |
+          templates.flat_map { |source, extension| template_dependencies(component, source, extension, virtual_path) }
+
+        dependencies - own_paths
+      end
+
+      # Components and partials rendered from Ruby, such as a `#call` method.
+      # Partials are narrowed to paths that appear in the source, discarding
+      # the speculative `things/thing` Action View infers from dynamic renders
+      # like `render @thing`, which would resolve to nothing.
+      def ruby_dependencies(source, virtual_path)
+        components, partials = CacheDigest.renders_in(source, virtual_path)
+
+        components | partials.select { |path|
+          source.include?(path) || source.include?(path.sub(%r{[^/]+\z}, '_\0'))
+        }
+      end
+
+      def template_dependencies(component, source, extension, virtual_path)
+        return [] unless source.include?("render")
+
+        template = ActionView::Template.new(
+          source,
+          "view_component cache digest for #{component.name}",
+          ActionView::Template.handler_for_extension(extension),
+          locals: [],
+          format: nil,
+          virtual_path: virtual_path
+        )
+        CacheDigest.renders_in(CacheDigest.compiled_source(template), virtual_path).flatten
       end
 
+      # Components loaded from encrypted files, as some commercial gems ship
+      # them, have binary identifiers that can't be scanned. They're still
+      # hashed by `file_digest`.
       def ruby_sources(component)
-        component_ancestors(component).filter_map { |ancestor|
-          path = ancestor.identifier
-          ::File.read(path) if path && ::File.exist?(path)
+        ruby_files(component).filter_map { |path|
+          source = ::File.read(path)
+          source if source.valid_encoding?
         }
       end
 
       def file_digest(path)
-        ActiveSupport::Digest.hexdigest(::File.read(path))
+        ActiveSupport::Digest.hexdigest(::File.binread(path))
       end
 
       # Built once at load time rather than memoized, so no class-level state

data/lib/view_component/cache_digest.rb

@@ -3,6 +3,7 @@
 require "active_support/dependencies/autoload"
 require "action_view/digestor"
 require "action_view/render_parser"
+require "prism"
 
 module ViewComponent
   # Integrates ViewComponents into Rails' template digest tree.
@@ -38,23 +39,22 @@ module ViewComponent
     # application partial.
     VIRTUAL_PATH_PREFIX = "view_component/cache_digest"
 
-    # Matches `render FooComponent`, `render(Foo::BarComponent.new(...))`,
-    # `render FooComponent.with_collection(...)`, etc.
-    #
-    # Deliberately a plain source scan rather than a tracker-specific hook: it
-    # behaves identically for the ERB tracker, the Prism-based Ruby tracker, and
-    # third-party Haml/Slim trackers.
-    RENDER_CALL = /
-      \brender(?:_to_string)?\b   # render or render_to_string
-      \s*\(?\s*                   # optional opening paren
-      (?<const>
-        (?:::)?[A-Z]\w*           # a constant
-        (?:::[A-Z]\w*)*           # optionally namespaced
-      )
-    /x
+    RENDER_METHODS = %i[render render_to_string].freeze
+
+    COMPILED_SOURCES = :view_component_cache_digest_compiled_sources
+    private_constant :COMPILED_SOURCES
+
+    # A render call whose first argument starts with a constant, such as
+    # `render FooComponent.new` or `render(Foo::Bar.with_collection(...))`.
+    CONSTANT_RENDER = /\brender(?:_to_string)?[\s(]*(?:::)?[A-Z]/
 
     # Rails' escape hatch for dependencies static analysis can't see.
     EXPLICIT_DEPENDENCY = /#\s*Template Dependency:\s*(\S+)/
+
+    # A constant path made only of constants, such as `Foo` or `::Foo::Bar`,
+    # rather than one hanging off an expression, such as `self.class::Bar`.
+    CONSTANT_NAME = /\A(?:::)?[A-Z]\w*(?:::[A-Z]\w*)*\z/
+
     class << self
       # Virtual paths of components, mapped to their class names.
       #
@@ -102,46 +102,81 @@ module ViewComponent
         constantize_component(name)
       end
 
-      # Scan a template's source for renders of components.
+      # Compile a template to Ruby with its own handler, so ERB, Haml, Slim and
+      # any other template language can be analyzed the same way. Reuses the
+      # Ruby compiled at boot, when there is some.
       #
-      # @return [Array<String>] synthetic virtual paths
-      def dependencies_in(template)
-        component_paths_in(template.source)
+      # @return [String] Ruby source
+      def compiled_source(template)
+        source = template.source
+        Thread.current[COMPILED_SOURCES]&.dig(template.handler, source) || template.handler.call(template, source)
       end
 
-      # Scan arbitrary source (a template or a component's Ruby file) for
-      # renders of components.
+      # Find the components Ruby source references and the partials it
+      # renders.
       #
-      # @return [Array<String>] synthetic virtual paths
-      def component_paths_in(source)
-        return [] unless source.is_a?(String) && source.include?("render")
-
-        source.scan(RENDER_CALL).flatten.uniq.filter_map do |constant_name|
-          registered_path_for(constantize_component(constant_name))
+      # Every constant that names a component counts, not only one passed
+      # straight to `render`: a component can also be rendered from a method
+      # that builds it, from a local variable, or from a slot declared with its
+      # class. A component referenced without being rendered only makes the
+      # digest change more often than it needs to.
+      #
+      # Action View's render parser only sees the calls that don't render a
+      # component, so it can't infer partials from them.
+      #
+      # @param source [String] Ruby source
+      # @param name [String] virtual path the source is being digested under
+      # @return [Array(Array<String>, Array<String>)] synthetic virtual paths of
+      #   components and partial virtual paths
+      def renders_in(source, name)
+        names = []
+        other_calls = []
+
+        each_node(Prism.parse(source).value) do |node|
+          if node.is_a?(Prism::ConstantReadNode) || node.is_a?(Prism::ConstantPathNode)
+            names << node.slice if CONSTANT_NAME.match?(node.slice)
+          elsif render_call?(node) && !rendered_component(node)
+            other_calls << node
+          end
         end
+
+        components = names.uniq.filter_map { |constant_name| constantize_component(constant_name) }
+        [component_paths(components), partials_rendered_by(other_calls, name)]
       end
 
-      # Scan a component's Ruby source for partials referenced by string path,
-      # such as `render "posts/byline"` inside a `#call` method.
+      # Find the components Ruby source renders, along with the partials Action
+      # View infers from them.
       #
-      # Uses Rails' own render parser — the same one `RubyTracker` runs over
-      # compiled templates — rather than a second implementation of the same
-      # analysis. Its results are then narrowed to paths that appear verbatim in
-      # the source, which keeps string literals and discards the speculative
-      # `things/_thing` entries the parser infers from dynamic renders like
-      # `render @thing` or `render FooComponent.new`. Those would resolve to
-      # nothing and only add log noise; components rendered from Ruby are
-      # already found precisely by `component_paths_in`.
+      # Action View reads `render FooComponent.new` as a dynamic render of a
+      # partial named after the last method, inferring `news/new`. Partials also
+      # rendered some other way aren't returned.
       #
       # @param source [String] Ruby source
       # @param name [String] virtual path the source is being digested under
-      # @return [Array<String>] partial virtual paths
-      def partial_paths_in(source, name)
-        return [] unless source.is_a?(String) && source.include?("render")
+      # @return [Array(Array<String>, Array<String>)] synthetic virtual paths of
+      #   components and inferred partial virtual paths
+      def component_renders_in(source, name)
+        components, other_calls = partition_render_calls(Prism.parse(source).value)
+        return [[], []] if components.empty?
+
+        [
+          component_paths(components.values),
+          partials_rendered_by(components.keys, name) - partials_rendered_by(other_calls, name)
+        ]
+      end
 
-        RENDER_PARSER.new(name, source).render_calls.uniq.select do |path|
-          source.include?(path) || source.include?(path.sub(%r{(\A|/)_}, '\1'))
-        end
+      # Find the components a component's slots render, from the class each
+      # slot was declared with: `renders_one :header, HeaderComponent` or
+      # `renders_many :items, "ItemComponent"`. Read from the slot definitions
+      # rather than from source, since a class named by a string, or by a name
+      # relative to the component, resolves against the component at runtime.
+      #
+      # @param component [Class]
+      # @return [Array<String>] synthetic virtual paths of components
+      def slot_renders_of(component)
+        definitions = component.registered_slots.values.flat_map { |slot| slot[:renderable_hash]&.values || [slot] }
+
+        component_paths(definitions.filter_map { |slot| slot_component(component, slot) })
       end
 
       # Action View has shipped its render parser as a class (Rails 7.1, and
@@ -208,6 +243,25 @@ module ViewComponent
         DigestorLookup.install!
       end
 
+      # Keep the Ruby that templates compile to while the block runs, so
+      # `precompute!` can analyze templates components just compiled without
+      # compiling them again. Kept in a thread local rather than on the module,
+      # which isn't writable from other Ractors.
+      #
+      # @private
+      def retaining_compiled_sources
+        Thread.current[COMPILED_SOURCES] = {}
+        yield
+      ensure
+        Thread.current[COMPILED_SOURCES] = nil
+      end
+
+      # @private
+      def compiled(handler, source, compiled_source)
+        sources = Thread.current[COMPILED_SOURCES]
+        (sources[handler] ||= {})[source] = compiled_source if sources
+      end
+
       # Compute component digests at boot, so requests read them from memory
       # instead of reading and scanning source files.
       #
@@ -238,6 +292,82 @@ module ViewComponent
 
       private
 
+      # Receiverless `render` and `render_to_string` calls, split into those
+      # that render a component and the rest.
+      #
+      # @return [Array(Hash{Prism::CallNode => Class}, Array<Prism::CallNode>)]
+      def partition_render_calls(program)
+        components = {}
+        other_calls = []
+
+        each_node(program) do |node|
+          next unless render_call?(node)
+
+          if (component = rendered_component(node))
+            components[node] = component
+          else
+            other_calls << node
+          end
+        end
+
+        [components, other_calls]
+      end
+
+      def render_call?(node)
+        node.is_a?(Prism::CallNode) && node.receiver.nil? && RENDER_METHODS.include?(node.name)
+      end
+
+      # Visit every node of a Prism tree, in source order.
+      def each_node(program)
+        nodes = [program]
+        while (node = nodes.pop)
+          yield node
+          nodes.concat(node.compact_child_nodes.reverse!)
+        end
+      end
+
+      # The component a render call renders, from the constant at the root of
+      # its first argument: `FooComponent`, `FooComponent.new(...)`,
+      # `FooComponent.with_collection(...)`, and so on.
+      #
+      # @return [Class, nil]
+      def rendered_component(call)
+        node = call.arguments&.arguments&.first
+        node = node.receiver while node.is_a?(Prism::CallNode) && node.receiver
+
+        case node
+        when Prism::ConstantReadNode, Prism::ConstantPathNode
+          constantize_component(node.slice)
+        end
+      end
+
+      def component_paths(components)
+        components.uniq.filter_map { |component| registered_path_for(component) }
+      end
+
+      # The component a slot renders, resolving a class name the way the slot
+      # does when it's set. A name that doesn't resolve is left to fail there.
+      def slot_component(component, slot)
+        renderable = slot[:renderable]
+        name = slot[:renderable_class_name]
+        renderable ||= component.const_get(name) if name && component.const_defined?(name)
+
+        renderable if renderable.is_a?(Class) && renderable < ViewComponent::Base
+      end
+
+      # Partials Action View's render parser finds in the given calls,
+      # normalized to the form its trackers report. The calls are parsed
+      # together, so the parser runs once rather than once per call. Blocks are
+      # left out, as any renders inside them are calls of their own.
+      def partials_rendered_by(calls, name)
+        return [] if calls.empty?
+
+        source = calls.map { |call| "#{call.name}(#{call.arguments&.slice})" }.join("\n")
+        RENDER_PARSER.new(name, source).render_calls
+          .map { |path| path.gsub(%r{/_}, "/") }
+          .uniq
+      end
+
       # Record the actual class name rather than trying to reverse a virtual
       # path, which may contain acronyms or be overridden by the component.
       def registered_path_for(component)

data/lib/view_component/compile_cache.rb

@@ -26,6 +26,24 @@ module ViewComponent
       cache.clear
     end
 
+    # Sidecar files can't change while the application eager loads: within the
+    # block, each component's are looked up once. Fiber storage rather than
+    # module state, so the cache is gone once boot is done.
+    def with_sidecar_files_cache
+      Fiber[:__vc_sidecar_files] = {}
+      yield
+    ensure
+      Fiber[:__vc_sidecar_files] = nil
+    end
+
+    def sidecar_files_for(klass, extensions)
+      sidecar_files_by_component = Fiber[:__vc_sidecar_files]
+      return yield unless sidecar_files_by_component
+
+      sidecar_files = sidecar_files_by_component[klass] ||= {}
+      sidecar_files[extensions] ||= yield.freeze
+    end
+
     # Invalidates the cache when a template or a translation file is added,
     # changed, or removed. Changes to Ruby files reload the application instead.
     def template_watcher(file_watcher)

data/lib/view_component/compiler.rb

@@ -95,23 +95,38 @@ module ViewComponent
 
       @component.silence_redefinition_of_method(:render_template_for)
 
+      # Keep template references local to this method's owner, including when
+      # render_parent invokes it on an instance of a descendant component.
+      methods = Module.new
+      @templates.each_with_index { |template, index| methods.const_set(:"TEMPLATE_#{index}", template) }
+
       if @templates.one?
         template = @templates.first
-        safe_call = template.safe_method_name_call
-        @component.define_method(:render_template_for) do |_|
-          @current_template = template
-          instance_exec(&safe_call)
-        end
+        body = <<~RUBY
+          @current_template = TEMPLATE_0
+          #{template.safe_method_call}
+        RUBY
       else
-        compiler = self
-        @component.define_method(:render_template_for) do |details|
-          if (@current_template = compiler.find_templates_for(details).first)
-            instance_exec(&@current_template.safe_method_name_call)
+        methods.const_set(:COMPILER, self)
+        calls = @templates.each_with_index.map do |template, index|
+          "when TEMPLATE_#{index}\n#{template.safe_method_call}"
+        end.join("\n")
+        body = <<~RUBY
+          @current_template = COMPILER.find_templates_for(details).first
+          case @current_template
+          #{calls}
           else
-            raise MissingTemplateError.new(self.class.name, details)
+            raise ViewComponent::MissingTemplateError.new(self.class.name, details)
           end
-        end
+        RUBY
       end
+
+      methods.module_eval <<~RUBY, __FILE__, __LINE__ + 1
+        def render_template_for(details)
+          #{body}
+        end
+      RUBY
+      @component.define_method(:render_template_for, methods.instance_method(:render_template_for))
     end
 
     def template_errors
@@ -186,7 +201,7 @@ module ViewComponent
           )]
         else
           path_parser = ActionView::Resolver::PathParser.new
-          templates = @component.sidecar_files(
+          templates = @component.__vc_sidecar_files(
             ActionView::Template::Handlers.extensions
           ).map do |path|
             details = path_parser.parse(path).details

data/lib/view_component/engine.rb

@@ -94,11 +94,16 @@ module ViewComponent
       ActiveSupport.on_load(:after_initialize) do
         if Rails.application.config.eager_load
           ActiveSupport::Notifications.instrument("compile.view_component") do
-            components = ViewComponent::Base.descendants.reject(&:anonymous?)
-            components.each(&:__vc_compile)
+            CompileCache.with_sidecar_files_cache do
+              components = ViewComponent::Base.descendants.reject(&:anonymous?)
 
-            if ActionView::Base.cache_template_loading
-              ViewComponent::CacheDigest.precompute!(components.select(&:__vc_compiled?))
+              ViewComponent::CacheDigest.retaining_compiled_sources do
+                components.each(&:__vc_compile)
+
+                if ActionView::Base.cache_template_loading
+                  ViewComponent::CacheDigest.precompute!(components.select(&:__vc_compiled?))
+                end
+              end
             end
           end
         end

data/lib/view_component/request_details.rb

@@ -25,16 +25,11 @@ module ViewComponent
         # `render` accepts, but there's currently no mechanism for users to
         # provide these when calling render on a ViewComponent.
         if user_details.equal?(EMPTY_DETAILS)
-          # Fast path: memoize the empty-details Requested per LookupContext.
-          # Rendered many times with the same context, the tuple/Requested
-          # allocations from ActionView are then paid at most once.
-          cached = instance_variable_defined?(:@__vc_requested_details_cache) &&
-            @__vc_requested_details_cache
-          return cached if cached
-
-          details, from_cache = detail_args_for(EMPTY_DETAILS)
-          @__vc_requested_details_cache =
-            from_cache || ActionView::TemplateDetails::Requested.new(**details)
+          # Fast path: with template caching on, `details_key` is the
+          # Requested for the current details, memoized by ActionView and
+          # reset whenever a detail such as `formats` changes. Using it
+          # directly skips the tuple `detail_args_for` allocates.
+          details_key || ActionView::TemplateDetails::Requested.new(**@details)
         else
           details, from_cache = detail_args_for(user_details)
           from_cache || ActionView::TemplateDetails::Requested.new(**details)

data/lib/view_component/slotable.rb

@@ -408,19 +408,19 @@ module ViewComponent
           self.class.const_get(slot_definition[:renderable_class_name]).new(*args, **kwargs)
       # If passed a lambda
       elsif slot_definition[:renderable_function]
-        # Use `bind(self)` to ensure lambda is executed in the context of the
+        # Use `bind_call(self)` to ensure lambda is executed in the context of the
         # current component. This is necessary to allow the lambda to access helper
         # methods like `content_tag` as well as parent component state.
-        renderable_function = slot_definition[:renderable_function].bind(self)
+        renderable_function = slot_definition[:renderable_function]
         renderable_value =
           if block
-            renderable_function.call(*args, **kwargs) do |*rargs|
+            renderable_function.bind_call(self, *args, **kwargs) do |*rargs|
               with_captured_virtual_path(captured_block_virtual_path) do
                 view_context.capture(*rargs, &block)
               end
             end
           else
-            renderable_function.call(*args, **kwargs)
+            renderable_function.bind_call(self, *args, **kwargs)
           end
 
         # Function calls can return components, so if it's a component handle it specially

data/lib/view_component/template.rb

@@ -123,14 +123,13 @@ module ViewComponent
         @component.define_method(safe_method_name, @component.instance_method(@call_method_name))
       end
 
-      def safe_method_name_call
-        m = safe_method_name
-        proc do
-          __vc_maybe_escape_html(send(m)) do
-            Kernel.warn("WARNING: The #{self.class} component rendered HTML-unsafe output. " \
+      def safe_method_call
+        <<~RUBY
+          __vc_maybe_escape_html(#{super}) 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
+        RUBY
       end
 
       def defined_on_self?
@@ -156,9 +155,13 @@ module ViewComponent
       defined?(Coverage) && Coverage.running?
     end
 
-    def safe_method_name_call
-      m = safe_method_name
-      proc { send(m) }
+    def safe_method_call
+      method_name = safe_method_name
+      if /\A[a-zA-Z_]\w*[!?]?\z/.match?(method_name)
+        method_name
+      else
+        "send(#{method_name.to_sym.inspect})"
+      end
     end
 
     def requires_compiled_superclass?
@@ -208,14 +211,16 @@ module ViewComponent
 
     def compiled_source
       handler = details.handler_class
-      this_source = source
-      this_source.rstrip! if @component.strip_trailing_whitespace?
+      original_source = source
+      this_source = @component.strip_trailing_whitespace? ? original_source.rstrip : original_source
 
       short_identifier = defined?(Rails.root) ? @path.sub("#{Rails.root}/", "") : @path
       format = self.format || DEFAULT_FORMAT
       type = ActionView::Template::Types[format]
 
-      handler.call(DataWithSource.new(format:, identifier: @path, short_identifier:, type:), this_source)
+      handler.call(DataWithSource.new(format:, identifier: @path, short_identifier:, type:), this_source).tap do |compiled|
+        CacheDigest.compiled(handler, original_source, compiled)
+      end
     end
   end
 end

data/lib/view_component/translatable.rb

@@ -30,7 +30,7 @@ module ViewComponent
         # 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))
+            files.concat(ancestor.__vc_sidecar_files(TRANSLATION_EXTENSIONS))
           end
         end
 

data/lib/view_component/version.rb

@@ -3,7 +3,7 @@
 module ViewComponent
   module VERSION
     MAJOR = 4
-    MINOR = 19
+    MINOR = 20
     PATCH = 0
     PRE = nil
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: view_component
 version: !ruby/object:Gem::Version
-  version: 4.19.0
+  version: 4.20.0
 platform: ruby
 authors:
 - ViewComponent Team
@@ -37,6 +37,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: 7.1.0
+- !ruby/object:Gem::Dependency
+  name: prism
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '1.0'
 executables: []
 extensions: []
 extra_rdoc_files: []
@@ -48,6 +62,8 @@ files:
 - app/controllers/view_components_system_test_controller.rb
 - app/views/test_mailer/test_asset_email.html.erb
 - app/views/test_mailer/test_email.html.erb
+- app/views/test_mailer/test_multipart_email.html.erb
+- app/views/test_mailer/test_multipart_email.text.erb
 - app/views/test_mailer/test_url_email.html.erb
 - app/views/view_components/index.html.erb
 - app/views/view_components/preview.html.erb