view_component 4.21.0 → 4.22.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 829de474217e06e2148d92de68ef3d93dd8a31e314b40073fc292440508731b8
-  data.tar.gz: 1dfb4a41b58c47814b115b72e6cfc736e3239886376632e7177cadfa024c8582
+  metadata.gz: 347185365d72f04ae47e10751bdaafc79ca1b92a5cc60659464cd91ea3fe5b1d
+  data.tar.gz: 8cc35ca70babcf15504c6cf3329357045b92cf5bce0b7059a376b465b9d82b3a
 SHA512:
-  metadata.gz: 644364f5c6e4375b130074078de4e692dfdc4fca34ceca1bfedd307a135cfe9bd8ed81b111f08e1222af4d334afcb81fee48ee50a9b92bc21df591f783230314
-  data.tar.gz: d7902711e70321bc27f0b4b9bbf5dbd7f75864444dcaacf4bdfc762c765c87f688463b9f65edcf01656aea723fc82baf421edcf6f35989ce60c9875ebb91c699
+  metadata.gz: 1f65ef1db7168f46ff4c0e41bcd7d329e30f5da9cfb05b06500c67686eaef0705b9b26433f644b39138c79ecf5d904176451c511f8dc48438cae9d9d6cbe81f8
+  data.tar.gz: 5b8df5a1f324a0fb481da6c822333e08e0bd424535310d851634da151702cb50a6a92d56be23f49f573c66aa5b9f9b8137a288969d85f4d5cec47ea59c114cca

data/docs/CHANGELOG.md

@@ -10,6 +10,32 @@ nav_order: 6
 
 ## main
 
+## 4.22.0
+
+* Comment on release pull requests with benchmark results compared to the previous release.
+
+    *Joel Hawksley*
+
+* Reduce source-file reads and dependency-scanning allocations during cold cache digests and boot-time precomputation.
+
+    *Joel Hawksley*
+
+* Share sidecar directory listings and source reads during cold cache digests, and hash shared Ruby and sidecar files once per digest computation or boot-time precomputation.
+
+    *Joel Hawksley*
+
+* Avoid missing-template digest errors for unresolvable interpolated render paths in components and included helpers.
+
+    *Joel Hawksley*
+
+* Cover shared helper dependencies in the boot benchmark and add a cold cache digest benchmark to the CI performance check.
+
+    *Joel Hawksley*
+
+* Speed up cache digests of components that render shared dependencies, such as a helper module included by most components. The Digestor looks a template up once per edge of the tree rather than once per component, so each synthetic template was rebuilt, and its sources re-parsed, for every place it was rendered from, and every component digested at boot rebuilt the tree of everything it renders. Templates, dependencies and parsed sources are now shared within one digest computation and across boot-time precomputation, and dependencies whose digest is already known are no longer walked again. On an app with 1,547 components, one cold digest drops from 70 s to 0.5 s and boot-time precomputation from 144 s to 13 s, with identical digests.
+
+    *Erik Axel Nielsen*
+
 ## 4.21.0
 
 * Avoid `NameError` during eager loading when components include modules with temporary names.

data/lib/view_component/base.rb

@@ -667,10 +667,10 @@ module ViewComponent
         (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.
+      # `sidecar_files`, looked up once per component during eager loading or a
+      # digest computation: 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)

data/lib/view_component/cache_digest/dependency_tracking.rb

@@ -14,27 +14,33 @@ module ViewComponent
     #
     # @private
     module DependencyTracking
+      # Templates are memoized during a digest, so a template reached along
+      # many edges of the tree is scanned once.
       def find_dependencies(name, template, view_paths = nil)
-        dependencies = super
-        source = template.source
-
-        # `# Template Dependency: SomeComponent` names a class, which Rails
-        # would resolve as a template path and never find. Swap it for the path
-        # the component is digested under, so the declaration resolves instead
-        # of becoming a missing node.
-        CacheDigest.explicit_component_dependencies(source).each do |declared, virtual_path|
-          dependencies = dependencies - [declared] + [virtual_path]
+        CacheDigest.memoize([:dependencies, name, template, view_paths]) do
+          dependencies = super
+          source = template.source
+
+          # `# Template Dependency: SomeComponent` names a class, which Rails
+          # would resolve as a template path and never find. Swap it for the path
+          # the component is digested under, so the declaration resolves instead
+          # of becoming a missing node.
+          CacheDigest.explicit_component_dependencies(source).each do |declared, virtual_path|
+            dependencies = dependencies - [declared] + [virtual_path]
+          end
+
+          # Synthetic templates already declare every dependency found in their sources.
+          next dependencies if name.start_with?("#{CacheDigest::VIRTUAL_PATH_PREFIX}/")
+          next dependencies unless CacheDigest.template_dependencies?(source, template.handler)
+
+          component_paths, inferred_partials =
+            CacheDigest.template_renders_in(CacheDigest.compiled_source(template), name, view_paths: view_paths)
+          # Older ERB trackers omit the underscore on unqualified partial paths.
+          inferred_partials |= inferred_partials.map { |path| path.delete_prefix("_") }
+          declared = source.scan(CacheDigest::EXPLICIT_DEPENDENCY).flatten
+
+          (dependencies - (inferred_partials - declared) + component_paths).uniq
         end
-
-        # Synthetic templates already declare every dependency found in their sources.
-        return dependencies if name.start_with?("#{CacheDigest::VIRTUAL_PATH_PREFIX}/")
-        return dependencies unless CacheDigest.template_dependencies?(source, template.handler)
-
-        component_paths, inferred_partials =
-          CacheDigest.template_renders_in(CacheDigest.compiled_source(template), name, view_paths: view_paths)
-        declared = source.scan(CacheDigest::EXPLICIT_DEPENDENCY).flatten
-
-        (dependencies - (inferred_partials - declared) + component_paths).uniq
       end
 
       # @private

data/lib/view_component/cache_digest/digestor_lookup.rb

@@ -21,12 +21,56 @@ module ViewComponent
         digestor.prepend(self)
       end
 
+      def digest(finder:, **)
+        CacheDigest.memoizing do
+          previous = CacheDigest.memo[:pruned]
+          loop do
+            pruned = CacheDigest.memo[:pruned] = {}
+            digest = super
+
+            # A component that registered while the tree was built expired the
+            # digests the pruned nodes stood in for, so this one, and the
+            # digests computed for them since, are missing their dependencies.
+            break digest if pruned.all? { |name, cached| finder.digest_cache[name].equal?(cached) }
+
+            finder.digest_cache.clear
+          end
+        ensure
+          CacheDigest.memo[:pruned] = previous
+        end
+      end
+
+      # A dependency whose digest is cached already becomes a leaf:
+      # `Node#dependency_digest` reads the cache and never walks its children.
+      # Without this, every component digested at boot rebuilds the tree of
+      # everything it renders, which for components rendering a shared helper
+      # module is most of the application.
+      def tree(name, finder, partial = false, seen = {})
+        CompileCache.with_sidecar_files_cache do
+          pruned = CacheDigest.memo&.fetch(:pruned, nil)
+          cached = finder.digest_cache[name] if pruned && partial
+          next super unless cached
+
+          path = ActionView::TemplatePath.parse(name)
+          template = find_template(finder, path.name, [path.prefix], partial, [])
+          next super unless template
+
+          pruned[name] = cached
+          seen[template.identifier] ||= ActionView::Digestor::Node.create(name, name.gsub(%r{/_}, "/"), template, partial)
+        end
+      end
+
       private
 
       def find_template(finder, name, prefixes, partial, keys)
-        Resolver.instance.find_templates(
-          name, prefixes.first, partial, {formats: finder.formats}, view_paths: finder.view_paths
-        ).first || super
+        key = [:template, name, prefixes.first, partial, finder.formats, finder.view_paths]
+        template = CacheDigest.memoize(key) do
+          Resolver.instance.find_templates(
+            name, prefixes.first, partial, {formats: finder.formats}, view_paths: finder.view_paths
+          ).first
+        end
+
+        template || super
       end
     end
   end

data/lib/view_component/cache_digest/resolver.rb

@@ -160,8 +160,10 @@ module ViewComponent
       end
 
       def ruby_files(component)
-        component_ancestors(component).map(&:identifier).concat(module_files(component))
-          .compact.uniq.select { |path| ::File.exist?(path) }
+        CacheDigest.memoize([:ruby_files, component]) do
+          component_ancestors(component).map(&:identifier).concat(module_files(component))
+            .compact.uniq.select { |path| ::File.exist?(path) }
+        end
       end
 
       # Sidecar template files plus inline templates, which live in the Ruby
@@ -243,7 +245,16 @@ module ViewComponent
       end
 
       def file_digest(path)
-        ActiveSupport::Digest.hexdigest(::File.binread(path))
+        CacheDigest.memoize([:file_digest, path]) do
+          # Reuse source reads unless text mode can transcode or translate newlines.
+          source = if ::File::ALT_SEPARATOR.nil? &&
+              (Encoding.default_internal.nil? || Encoding.default_internal == Encoding.default_external)
+            CompileCache.read_file(path)
+          else
+            ::File.binread(path)
+          end
+          ActiveSupport::Digest.hexdigest(source)
+        end
       end
 
       # Built once at load time rather than memoized, so no class-level state

data/lib/view_component/cache_digest.rb

@@ -43,7 +43,8 @@ module ViewComponent
     RENDER_METHODS = %i[render render_to_string].freeze
 
     COMPILED_SOURCES = :view_component_cache_digest_compiled_sources
-    private_constant :COMPILED_SOURCES
+    MEMO = :view_component_cache_digest_memo
+    private_constant :COMPILED_SOURCES, :MEMO
 
     # Rails' escape hatch for dependencies static analysis can't see.
     EXPLICIT_DEPENDENCY = /#\s*Template Dependency:\s*(\S+)/
@@ -157,9 +158,13 @@ module ViewComponent
       # @return [Array(Array<String>, Array<String>)] synthetic virtual paths of
       #   components and partial virtual paths
       def renders_in(source, name, view_paths: nil, nesting: [])
-        components, _component_calls, other_calls = partition_render_calls(Prism.parse(source).value, nesting)
-        partials = partials_rendered_by(other_calls, name) - unresolved_partials_rendered_by(other_calls, name, view_paths)
-        [component_paths(components), partials]
+        # Shared by every component that includes a module or inherits from
+        # the same superclass, so it's scanned once per digest computation.
+        memoize([:renders_in, source, name, view_paths, nesting]) do
+          components, _component_calls, other_calls = partition_render_calls(Prism.parse(source).value, nesting)
+          partials = partials_rendered_by(other_calls, name) - unresolved_partials_rendered_by(other_calls, name, view_paths)
+          [component_paths(components), partials]
+        end
       end
 
       # Find the components Ruby source renders, along with partial guesses
@@ -280,6 +285,40 @@ module ViewComponent
         Thread.current[COMPILED_SOURCES] = nil
       end
 
+      # Share synthetic templates between every lookup in the block.
+      #
+      # The Digestor looks a template up once per edge of the tree, before it
+      # checks whether it has seen the template already. Action View's own
+      # resolvers cache their templates, but building a synthetic one reads and
+      # parses the component's sources, so a component rendered from many
+      # places was rebuilt once per place. Kept for one digest computation
+      # only, so a source edited between requests is still seen.
+      #
+      # @private
+      def memoizing
+        return yield if Thread.current[MEMO]
+
+        begin
+          Thread.current[MEMO] = {}
+          yield
+        ensure
+          Thread.current[MEMO] = nil
+        end
+      end
+
+      # @private
+      def memo
+        Thread.current[MEMO]
+      end
+
+      # @private
+      def memoize(key)
+        memo = Thread.current[MEMO]
+        return yield unless memo
+
+        memo.fetch(key) { memo[key] = yield }
+      end
+
       # @private
       def compiled(handler, source, compiled_source)
         sources = Thread.current[COMPILED_SOURCES]
@@ -300,16 +339,18 @@ module ViewComponent
         # digest, so registering midway would discard digests already warmed.
         components.each { |component| register(component) }
 
-        components.each do |component|
-          component.__vc_cache_digest_source = Resolver.instance.source_for(component).freeze
-        end
+        memoizing do
+          components.each do |component|
+            component.__vc_cache_digest_source = Resolver.instance.source_for(component).freeze
+          end
 
-        # Warms the same digest cache requests read, since a lookup context's
-        # cache is shared by every context with the same details.
-        components.each do |component|
-          component.__vc_template_formats.each do |format|
-            finder = ActionView::LookupContext.new(ActionController::Base.view_paths, formats: [format])
-            component.cache_digest(finder: finder, format: format)
+          # Warms the same digest cache requests read, since a lookup context's
+          # cache is shared by every context with the same details.
+          components.each do |component|
+            component.__vc_template_formats.each do |format|
+              finder = ActionView::LookupContext.new(ActionController::Base.view_paths, formats: [format])
+              component.cache_digest(finder: finder, format: format)
+            end
           end
         end
       end
@@ -327,7 +368,8 @@ module ViewComponent
 
         each_node(program, nesting) do |node, scope|
           if node.is_a?(Prism::ConstantReadNode) || node.is_a?(Prism::ConstantPathNode)
-            names << [node.slice, scope] if CONSTANT_NAME.match?(node.slice)
+            name = node.slice
+            names << [name, scope] if CONSTANT_NAME.match?(name)
           elsif render_call?(node)
             if rendered_component(node, scope)
               component_calls << node
@@ -348,9 +390,10 @@ module ViewComponent
       # Class/module bodies add one lexical scope, even for qualified names:
       # `class UI::Card` adds Card, not UI, to Module.nesting.
       def each_node(program, nesting = [])
-        nodes = [[program, nesting]]
-        while (entry = nodes.pop)
-          node, scope = entry
+        # Keep scopes and nodes in one stack rather than allocating a pair per node.
+        nodes = [nesting, program]
+        while (node = nodes.pop)
+          scope = nodes.pop
           yield node, scope
 
           body = nil
@@ -362,7 +405,7 @@ module ViewComponent
           end
 
           node.compact_child_nodes.reverse_each do |child|
-            nodes << [child, child.equal?(body) ? body_scope : scope]
+            nodes.push(child.equal?(body) ? body_scope : scope, child)
           end
         end
       end
@@ -416,20 +459,29 @@ module ViewComponent
       # Dynamic renders can return components without naming their classes,
       # such as `render UI.button`. Keep Action View's guess only if it resolves,
       # without executing application methods to discover what they return.
+      # Interpolated paths are discarded if Rails cannot expand their wildcards.
       def unresolved_partials_rendered_by(calls, name, view_paths)
-        return [] unless view_paths
-
         targets = calls.flat_map { |call| render_targets(call) }
         literal, dynamic = targets.partition do |target|
           target.is_a?(Prism::StringNode) || target.is_a?(Prism::InterpolatedStringNode)
         end
-        return [] if dynamic.empty?
+        interpolated = literal.grep(Prism::InterpolatedStringNode)
+        unresolved = []
+        if interpolated.any?
+          paths = partial_paths_in(interpolated.map { |target| "render(#{target.slice})" }.join("\n"), name)
+          # Rails expands only directory wildcards with a literal prefix.
+          # Older parsers can return truncated paths without any wildcard.
+          unresolved = paths.reject { |path| path.match?(%r{\A[^*]+/\*\z}) }
+          static = literal.grep(Prism::StringNode)
+          unresolved -= partial_paths_in(static.map { |target| "render(#{target.slice})" }.join("\n"), name)
+        end
+        return unresolved unless view_paths && dynamic.any?
 
         inferred = partial_paths_in(dynamic.map { |target| "render(#{target.slice})" }.join("\n"), name)
         declared = partial_paths_in(literal.map { |target| "render(#{target.slice})" }.join("\n"), name)
         finder = ActionView::LookupContext.new(view_paths, variants: :any, locale: I18n.available_locales)
 
-        inferred.reject do |path|
+        unresolved | inferred.reject do |path|
           declared.include?(path) || finder.exists?(path, [], true)
         end
       end

data/lib/view_component/compile_cache.rb

@@ -26,25 +26,28 @@ module ViewComponent
       cache.clear
     end
 
-    # Source files can't change while the application eager loads: share
-    # directory listings, sidecar lookups, and file contents within the block.
-    # Fiber storage keeps the caches from surviving boot.
+    # Share directory listings, sidecar lookups, and file contents within one
+    # eager load or digest computation, but never across reloads.
     def with_sidecar_files_cache
-      Fiber[:__vc_sidecar_files] = {}
-      Fiber[:__vc_sidecar_directories] = {}
-      Fiber[:__vc_source_files] = {}
-      Fiber[:__vc_path_parser] = ActionView::Resolver::PathParser.new
-      yield
-    ensure
-      Fiber[:__vc_sidecar_files] = nil
-      Fiber[:__vc_sidecar_directories] = nil
-      Fiber[:__vc_source_files] = nil
-      Fiber[:__vc_path_parser] = nil
+      return yield if Fiber[:__vc_sidecar_files]
+
+      begin
+        Fiber[:__vc_sidecar_files] = {}
+        Fiber[:__vc_sidecar_directories] = {}
+        Fiber[:__vc_source_files] = {}
+        Fiber[:__vc_path_parser] = ActionView::Resolver::PathParser.new
+        yield
+      ensure
+        Fiber[:__vc_sidecar_files] = nil
+        Fiber[:__vc_sidecar_directories] = nil
+        Fiber[:__vc_source_files] = nil
+        Fiber[:__vc_path_parser] = nil
+      end
     end
 
     def path_parser
       # Its regular expression depends on registered handlers, formats and locales.
-      # Reuse it during eager loading, but not across reloads.
+      # Reuse it during eager loading or a digest computation, but not across reloads.
       Fiber[:__vc_path_parser] || ActionView::Resolver::PathParser.new
     end
 

data/lib/view_component/version.rb

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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: view_component
 version: !ruby/object:Gem::Version
-  version: 4.21.0
+  version: 4.22.0
 platform: ruby
 authors:
 - ViewComponent Team