view_component 4.20.0 → 4.21.0

data/lib/view_component/cache_digest.rb

@@ -4,6 +4,7 @@ require "active_support/dependencies/autoload"
 require "action_view/digestor"
 require "action_view/render_parser"
 require "prism"
+require "strscan"
 
 module ViewComponent
   # Integrates ViewComponents into Rails' template digest tree.
@@ -44,10 +45,6 @@ module ViewComponent
     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+)/
 
@@ -112,6 +109,35 @@ module ViewComponent
         Thread.current[COMPILED_SOURCES]&.dig(template.handler, source) || template.handler.call(template, source)
       end
 
+      # Skip literal templates and ERB markup before compiling Ruby for analysis.
+      # Other handlers keep a conservative check because their code syntax varies.
+      #
+      # @param source [String]
+      # @param handler [#call]
+      #
+      # @return [Boolean]
+      def template_dependencies?(source, handler)
+        return false unless source.match?(/render|[A-Z]/)
+
+        case handler
+        when ActionView::Template::Handlers::Raw, ActionView::Template::Handlers::Html
+          false
+        when ActionView::Template::Handlers::ERB
+          # Never restart the search at another opener after an unterminated tag.
+          scanner = StringScanner.new(source)
+          while scanner.skip_until(/<%/)
+            code = scanner.scan_until(/%>/)
+            return false unless code
+            next if code.start_with?("#", "%")
+
+            return true if code.match?(/render|[A-Z]/)
+          end
+          false
+        else
+          true
+        end
+      end
+
       # Find the components Ruby source references and the partials it
       # renders.
       #
@@ -126,42 +152,36 @@ module ViewComponent
       #
       # @param source [String] Ruby source
       # @param name [String] virtual path the source is being digested under
+      # @param view_paths [ActionView::PathSet, nil] paths to check dynamic partial guesses against
+      # @param nesting [Array<Module>] lexical scope of compiled template source
       # @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)]
+      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]
       end
 
-      # Find the components Ruby source renders, along with the partials Action
-      # View infers from them.
+      # Find the components Ruby source renders, along with partial guesses
+      # Action View should discard.
       #
       # 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.
+      # rendered some other way aren't returned. Unresolved guesses from other
+      # dynamic renders are discarded when view paths are available.
       #
       # @param source [String] Ruby source
       # @param name [String] virtual path the source is being digested under
+      # @param view_paths [ActionView::PathSet, nil] paths to check dynamic partial guesses against
       # @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?
+      def template_renders_in(source, name, view_paths: nil)
+        components, component_calls, other_calls = partition_render_calls(Prism.parse(source).value)
 
         [
-          component_paths(components.values),
-          partials_rendered_by(components.keys, name) - partials_rendered_by(other_calls, name)
+          component_paths(components),
+          (partials_rendered_by(component_calls, name) - partials_rendered_by(other_calls, name)) |
+            unresolved_partials_rendered_by(other_calls, name, view_paths)
         ]
       end
 
@@ -213,24 +233,28 @@ module ViewComponent
       # Compute the digest of a component using Rails' digest tree.
       #
       # @param component [Class] a component class
-      # @param finder [ActionView::LookupContext]
+      # @param finder [ActionView::LookupContext, nil]
       # @param format [Symbol]
+      #
       # @return [String]
-      def digest(component, finder: default_finder, format: :html)
+      def digest(component, finder: nil, format: :html)
         register(component)
         virtual_path = virtual_path_for(component)
         return "" unless virtual_path
 
+        finder ||= default_finder(format: format)
         ActionView::Digestor.digest(name: virtual_path, format: format, finder: finder)
       end
 
       # A lookup context for digesting components outside a request, where no
       # view context (and therefore no finder) exists.
       #
+      # @param format [Symbol]
+      #
       # @return [ActionView::LookupContext]
-      def default_finder
+      def default_finder(format: :html)
         # Not memoized across reloads: view paths change when the app reloads.
-        ActionView::LookupContext.new(ActionController::Base.view_paths)
+        ActionView::LookupContext.new(ActionController::Base.view_paths, formats: [format])
       end
 
       # Wire the tracker and resolver into Action View.
@@ -292,37 +316,54 @@ module ViewComponent
 
       private
 
-      # Receiverless `render` and `render_to_string` calls, split into those
-      # that render a component and the rest.
+      # Component references and receiverless render calls, split into those
+      # that render a component directly and the rest.
       #
-      # @return [Array(Hash{Prism::CallNode => Class}, Array<Prism::CallNode>)]
-      def partition_render_calls(program)
-        components = {}
+      # @return [Array(Array<Class>, Array<Prism::CallNode>, Array<Prism::CallNode>)]
+      def partition_render_calls(program, nesting = [])
+        names = []
+        component_calls = []
         other_calls = []
 
-        each_node(program) do |node|
-          next unless render_call?(node)
-
-          if (component = rendered_component(node))
-            components[node] = component
-          else
-            other_calls << node
+        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)
+          elsif render_call?(node)
+            if rendered_component(node, scope)
+              component_calls << node
+            else
+              other_calls << node
+            end
           end
         end
 
-        [components, other_calls]
+        components = names.uniq.filter_map { |constant_name, scope| constantize_component(constant_name, scope) }
+        [components, component_calls, 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!)
+      # 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
+          yield node, scope
+
+          body = nil
+          body_scope = scope
+          if node.is_a?(Prism::ClassNode) || node.is_a?(Prism::ModuleNode)
+            body = node.body
+            namespace = resolve_constant(node.constant_path.slice, scope)
+            body_scope = [namespace, *scope] if namespace.is_a?(Module)
+          end
+
+          node.compact_child_nodes.reverse_each do |child|
+            nodes << [child, child.equal?(body) ? body_scope : scope]
+          end
         end
       end
 
@@ -331,13 +372,13 @@ module ViewComponent
       # `FooComponent.with_collection(...)`, and so on.
       #
       # @return [Class, nil]
-      def rendered_component(call)
+      def rendered_component(call, nesting = [])
         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)
+          constantize_component(node.slice, nesting)
         end
       end
 
@@ -363,11 +404,59 @@ module ViewComponent
         return [] if calls.empty?
 
         source = calls.map { |call| "#{call.name}(#{call.arguments&.slice})" }.join("\n")
+        partial_paths_in(source, name)
+      end
+
+      def partial_paths_in(source, name)
         RENDER_PARSER.new(name, source).render_calls
           .map { |path| path.gsub(%r{/_}, "/") }
           .uniq
       end
 
+      # 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.
+      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?
+
+        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|
+          declared.include?(path) || finder.exists?(path, [], true)
+        end
+      end
+
+      def render_targets(call)
+        arguments = call.arguments&.arguments || []
+        targets = arguments.flat_map do |argument|
+          if argument.is_a?(Prism::KeywordHashNode) || argument.is_a?(Prism::HashNode)
+            argument.elements.filter_map do |element|
+              next unless element.is_a?(Prism::AssocNode) && element.key.is_a?(Prism::SymbolNode)
+              next unless %w[partial template layout spacer_template].include?(element.key.unescaped)
+
+              element.value
+            end
+          elsif argument.equal?(arguments.first)
+            argument
+          end
+        end.compact
+
+        targets.map do |target|
+          while target.is_a?(Prism::ParenthesesNode) && target.body.is_a?(Prism::StatementsNode) && target.body.body.one?
+            target = target.body.body.first
+          end
+          target
+        end
+      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)
@@ -389,12 +478,31 @@ module ViewComponent
       # Returns nil for anything else, including constants that don't exist.
       # Autoloading here is safe: the template is about to render this constant
       # anyway.
-      def constantize_component(constant_name)
-        component = constant_name.safe_constantize
+      def constantize_component(constant_name, nesting = [])
+        component = resolve_constant(constant_name, nesting)
         return unless component.is_a?(Class) && component < ViewComponent::Base
 
         component
       end
+
+      def resolve_constant(name, nesting)
+        return unless CONSTANT_NAME.match?(name)
+        return name.safe_constantize if nesting.empty? || name.start_with?("::")
+
+        first, *rest = name.split("::")
+        # Lexical constants precede inherited constants. Once a name resolves,
+        # do not fall back to a top-level component if it names something else.
+        owner = nesting.find { |namespace| namespace.const_defined?(first, false) }
+        owner ||= nesting.first if nesting.first.const_defined?(first)
+        owner ||= Object if Object.const_defined?(first)
+        return unless owner
+
+        constant = owner.const_get(first)
+        return constant if rest.empty?
+        return unless constant.is_a?(Module) && constant.name
+
+        "#{constant.name}::#{rest.join("::")}".safe_constantize
+      end
     end
 
     # Resolved once at load time rather than memoized, so no class-level state

data/lib/view_component/cacheable.rb

@@ -117,25 +117,32 @@ module ViewComponent
     # The cache key for this rendering of the component.
     #
     # Combines the component's identity, its source digest, the requested
-    # format and variant, the current locale, and the values declared with
-    # `cache_on`. Override for full control.
+    # ordered formats, variants and partial lookup prefixes, the current locale,
+    # and the values declared with `cache_on`. Override for full control.
     #
     # @param view_context [ActionView::Base]
     # @return [String]
     def cache_key(view_context = nil)
       lookup_context = view_context&.lookup_context
-      format = __vc_cache_format(lookup_context)
+      formats = Array(lookup_context&.formats).presence || [:html]
+      values = __vc_cache_on_values.map do |value|
+        value.nil? ? nil : ActiveSupport::Cache.expand_cache_key(value)
+      end
 
       parts = [
         "view_component",
         self.class.virtual_path,
-        self.class.cache_digest(finder: lookup_context, format: format),
+        self.class.cache_digest(finder: lookup_context, format: formats.first),
         # Included in its own right, not just as a digest input: components that
         # render every format from one template have the same digest for each.
-        format,
-        __vc_cache_variant(lookup_context),
+        # Encode each list to keep format and variant boundaries distinct.
+        formats.to_json,
+        __vc_cache_variants(lookup_context).to_json,
+        Array(lookup_context&.prefixes).to_json,
         I18n.locale,
-        *__vc_cache_on_values
+        # Expand records using Rails' versioned keys, then preserve the boundaries
+        # between declared values, including nils and strings containing slashes.
+        values.to_json
       ]
 
       # Positions are significant, so nils are substituted rather than removed.
@@ -175,11 +182,6 @@ module ViewComponent
       end
     end
 
-    def __vc_render_uncached(view_context)
-      @__vc_cache_bypassed = true
-      render_in(view_context)
-    end
-
     # Slots set by the caller via `with_*`. Checked before rendering, so slots
     # a component fills in for itself with a `default_*` method — which resolve
     # lazily during the render — aren't counted.
@@ -227,12 +229,8 @@ module ViewComponent
       end
     end
 
-    def __vc_cache_format(lookup_context)
-      Array(lookup_context&.formats).first || :html
-    end
-
-    def __vc_cache_variant(lookup_context)
-      Array(lookup_context&.variants).first
+    def __vc_cache_variants(lookup_context)
+      Array(lookup_context&.variants)
     end
   end
 end

data/lib/view_component/collection.rb

@@ -41,12 +41,12 @@ module ViewComponent
     def components
       component.__vc_validate_collection_parameter!(validate_default: true)
 
-      iterator = ActionView::PartialIteration.new(@collection.size)
       collection_param = component.__vc_collection_parameter
       counter_present = component.__vc_counter_argument_present?
       counter_param = component.__vc_collection_counter_parameter if counter_present
       iteration_present = component.__vc_iteration_argument_present?
       iteration_param = component.__vc_collection_iteration_parameter if iteration_present
+      iterator = ActionView::PartialIteration.new(@collection.size) if counter_present || iteration_present
       item_options = @options.dup
 
       @collection.map do |item|
@@ -54,7 +54,7 @@ module ViewComponent
         item_options[counter_param] = iterator.index if counter_present
         item_options[iteration_param] = iterator.dup if iteration_present
         instance = component.new(**item_options)
-        iterator.iterate!
+        iterator&.iterate!
         instance
       end
     end
@@ -74,16 +74,11 @@ module ViewComponent
       end
     end
 
-    # Render the spacer through a fresh `dup` so a collection rendered multiple
-    # times does not reuse (and trip the single-render guard on) the spacer
-    # instance passed by the caller.
+    # Keep the caller's spacer unrendered, including its nested slot components.
     def rendered_spacer(view_context)
       return EMPTY_SPACER unless @spacer_component
 
-      spacer = @spacer_component.dup
-      if spacer.instance_variable_defined?(:@__vc_rendered)
-        spacer.remove_instance_variable(:@__vc_rendered)
-      end
+      spacer = @spacer_component.is_a?(Base) ? @spacer_component.__vc_dup_for_render : @spacer_component.dup
       spacer.render_in(view_context)
     end
   end

data/lib/view_component/compile_cache.rb

@@ -15,7 +15,7 @@ module ViewComponent
     end
 
     def compiled?(klass)
-      cache.include? klass
+      @@cache.include? klass
     end
 
     def invalidate_class!(klass)
@@ -26,14 +26,33 @@ 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.
+    # 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.
     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
+    end
+
+    def path_parser
+      # Its regular expression depends on registered handlers, formats and locales.
+      # Reuse it during eager loading, but not across reloads.
+      Fiber[:__vc_path_parser] || ActionView::Resolver::PathParser.new
+    end
+
+    def read_file(path)
+      files = Fiber[:__vc_source_files]
+      return File.read(path) unless files
+
+      (files[path] ||= File.read(path).freeze).dup
     end
 
     def sidecar_files_for(klass, extensions)
@@ -44,13 +63,33 @@ module ViewComponent
       sidecar_files[extensions] ||= yield.freeze
     end
 
+    def sidecar_files_matching(pattern)
+      directories = Fiber[:__vc_sidecar_directories]
+      return Dir[pattern] unless directories
+
+      filename = File.basename(pattern)
+      prefix = filename.delete_suffix(".*")
+      return Dir[pattern] if prefix.match?(/[*?{}\[\]\\]/)
+
+      directory = File.dirname(pattern)
+      # Index the shared directory by component name instead of scanning all
+      # its entries again for every component and extension.
+      entries = directories[directory] ||= Dir.glob("#{directory}/*", File::FNM_DOTMATCH)
+        .group_by { |path| File.basename(path).split(".", 2).first }
+      candidates = entries.fetch(prefix.split(".", 2).first, [])
+      candidates.select { |path| File.fnmatch?(filename, File.basename(path)) }
+    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)
       extensions = ActionView::Template::Handlers.extensions.map(&:to_s) + %w[yml yaml]
       directories = ActiveSupport::Dependencies.autoload_paths.map(&:to_s).index_with(extensions)
 
-      file_watcher.new([], directories) { invalidate! }
+      file_watcher.new([], directories) do
+        invalidate!
+        ActionView::LookupContext::DetailsKey.clear
+      end
     end
   end
 end

data/lib/view_component/compiler.rb

@@ -26,10 +26,14 @@ module ViewComponent
         # early exit
         return if compiled? && !force
 
+        reset_templates
+
         gather_templates
 
-        if self.class.__vc_development_mode && @templates.any?(&:requires_compiled_superclass?)
+        if (self.class.__vc_development_mode || !@component.superclass.__vc_compiled?) && @templates.any?(&:requires_compiled_superclass?)
           @component.superclass.__vc_compile(raise_errors: raise_errors)
+          @templates = nil
+          gather_templates
         end
 
         if template_errors.present?
@@ -84,10 +88,31 @@ module ViewComponent
       gather_templates.map { |template| template.format || :html }.uniq
     end
 
+    # @private
+    def templates_for_call(method_name)
+      gather_templates.select { |template| template.call_method_name == method_name }
+    end
+
     private
 
     attr_reader :templates
 
+    def reset_templates
+      @templates&.each do |template|
+        next if template.inline_call?
+
+        call_method = template.call_method_name
+        safe_method = template.safe_method_name
+        next unless @component.method_defined?(call_method, false) && @component.method_defined?(safe_method, false)
+        next unless @component.instance_method(call_method) == @component.instance_method(safe_method)
+
+        @component.remove_method(call_method)
+      end
+
+      @templates = nil
+      @_template_errors = nil
+    end
+
     def define_render_template_for
       @templates.each do |template|
         template.compile_to_component
@@ -127,9 +152,18 @@ module ViewComponent
         end
       RUBY
       @component.define_method(:render_template_for, methods.instance_method(:render_template_for))
+
+      # Descendants retain these unbound methods for render_parent.
+      render_method = @component.instance_method(:render_template_for)
+      @component.descendants.each do |descendant|
+        ancestor_calls = descendant.instance_variable_get(:@__vc_ancestor_calls)
+        ancestor_calls&.map! { |call| (call.owner == @component) ? render_method : call }
+      end
     end
 
     def template_errors
+      return [] if @templates.one?
+
       @_template_errors ||= begin
         errors = []
 
@@ -200,7 +234,7 @@ module ViewComponent
             inline_template: @component.__vc_inline_template
           )]
         else
-          path_parser = ActionView::Resolver::PathParser.new
+          path_parser = CompileCache.path_parser
           templates = @component.__vc_sidecar_files(
             ActionView::Template::Handlers.extensions
           ).map do |path|
@@ -215,6 +249,20 @@ module ViewComponent
           ).flat_map { |ancestor| ancestor.instance_methods(false).grep(/^call(_|$)/) }
             .uniq
             .each do |method_name|
+            unless component_instance_methods_on_self.include?(method_name)
+              owner = @component.instance_method(method_name).owner
+              inherited = owner.respond_to?(:__vc_compiler) ? owner.__vc_compiler.templates_for_call(method_name) : []
+              if inherited.any?
+                # A format and a variant can share a public call_* alias.
+                inherited.each do |template|
+                  next if templates.any? { |own| own.variant == template.variant && own.format == template.format }
+
+                  templates << Template::Inherited.new(component: @component, template: template)
+                end
+                next
+              end
+            end
+
             templates << Template::InlineCall.new(
               component: @component,
               method_name: method_name,