view_component 4.20.0 → 4.21.0

data/lib/view_component/base.rb

@@ -32,6 +32,9 @@ end
 
 module ViewComponent
   class Base
+    EMPTY_OUTPUT = "".html_safe.freeze
+    private_constant :EMPTY_OUTPUT
+
     class << self
       # A digest of the component's source, ancestors, and rendered dependencies.
       #
@@ -42,7 +45,7 @@ module ViewComponent
       def cache_digest(finder: nil, format: :html)
         ViewComponent::CacheDigest.digest(
           self,
-          finder: finder || ViewComponent::CacheDigest.default_finder,
+          finder: finder,
           format: format
         )
       end
@@ -121,86 +124,14 @@ module ViewComponent
     # @return [String]
     def render_in(view_context, **, &block)
       self.class.__vc_compile(raise_errors: true) unless self.class.__vc_compiled?
-
-      if self.class.__vc_cache_output && !@__vc_cache_bypassed
-        return __vc_render_cached(view_context, block)
-      end
-
       __vc_check_reused_instance!
-      __vc_reset_render_state!
-
-      @view_context = view_context
-      @old_virtual_path = view_context.instance_variable_get(:@virtual_path)
-      self.__vc_original_view_context = view_context
-
-      @output_buffer = view_context.output_buffer
-
-      @lookup_context = view_context.lookup_context
-
-      # For content_for
-      @view_flow = view_context.view_flow
-
-      # For i18n
-      @virtual_path ||= virtual_path
-
-      # Describes the inferred request constraints (locales, formats, variants)
-      @__vc_requested_details = @lookup_context.vc_requested_details
-
-      # For caching, such as #cache_if
-      @current_template = nil unless defined?(@current_template)
-      old_current_template = @current_template
 
-      if block && defined?(@__vc_content_set_by_with_content)
-        raise DuplicateContentError.new(self.class.name)
-      end
-
-      @__vc_content_evaluated = false
-      remove_instance_variable(:@__vc_content) if defined?(@__vc_content)
-      @__vc_render_in_block = block
-      @view_context.instance_variable_set(:@virtual_path, virtual_path)
-
-      before_render
-
-      if render?
-        value = nil
-
-        @output_buffer.with_buffer do
-          inner_rendered_template = nil
-          around_rendered_template = around_render do
-            inner_rendered_template = render_template_for(@__vc_requested_details).to_s
-          end
-
-          # If `around_render` returned the same object the block yielded, the inner
-          # template's escaping is authoritative and we can trust the result. If the
-          # user replaced/wrapped the value, re-check HTML safety to prevent
-          # bypassing the escaping applied to normal `#call` return values
-          # (GHSA-97jw-64cj-jc58).
-          rendered_template = if around_rendered_template.equal?(inner_rendered_template)
-            around_rendered_template
-          else
-            __vc_safe_around_render_output(around_rendered_template)
-          end
-
-          # Avoid allocating new string when output_preamble and output_postamble are blank
-          value = if output_preamble.blank? && output_postamble.blank?
-            rendered_template
-          else
-            __vc_safe_output_preamble + rendered_template + __vc_safe_output_postamble
-          end
-        end
-
-        if ActionView::Base.annotate_rendered_view_with_filenames && current_template.inline_call? && request&.format == :html
-          identifier = defined?(Rails.root) ? self.class.identifier.sub("#{Rails.root}/", "") : self.class.identifier
-          value = "<!-- BEGIN #{identifier} -->".html_safe + value + "<!-- END #{identifier} -->".html_safe
-        end
-
-        value
+      if self.class.__vc_cache_output
+        __vc_render_cached(view_context, block)
       else
-        "".html_safe
+        __vc_render_uncached(view_context, &block)
       end
     ensure
-      view_context.instance_variable_set(:@virtual_path, @old_virtual_path)
-      @current_template = old_current_template
       @__vc_rendered = true
     end
 
@@ -232,14 +163,21 @@ module ViewComponent
     # When rendering the parent inside an .erb template, use `#render_parent` instead.
     def render_parent_to_string
       @__vc_parent_render_level ||= 0 # ensure a good starting value
+      old_current_template = @current_template
 
       begin
         target_render = self.class.instance_variable_get(:@__vc_ancestor_calls)[@__vc_parent_render_level]
         @__vc_parent_render_level += 1
 
+        unless target_render.owner.__vc_compiled?
+          target_render.owner.__vc_compile(raise_errors: true)
+          target_render = target_render.owner.instance_method(:render_template_for)
+        end
+
         target_render.bind_call(self, @__vc_requested_details)
       ensure
         @__vc_parent_render_level -= 1
+        @current_template = old_current_template
       end
     end
 
@@ -247,14 +185,14 @@ module ViewComponent
     #
     # @return [String]
     def output_preamble
-      @@default_output_preamble ||= "".html_safe
+      EMPTY_OUTPUT
     end
 
     # Optional content to be returned after the rendered template.
     #
     # @return [String]
     def output_postamble
-      @@default_output_postamble ||= "".html_safe
+      EMPTY_OUTPUT
     end
 
     # Called before rendering the component. Override to perform operations that
@@ -289,7 +227,7 @@ module ViewComponent
     #
     # @private
     def render(options = {}, args = {}, &block)
-      if options.respond_to?(:set_original_view_context)
+      if options.is_a?(ViewComponent::Base) || options.respond_to?(:set_original_view_context)
         options.set_original_view_context(__vc_original_view_context)
 
         # We assume options is a component, so there's no need to evaluate the
@@ -448,20 +386,99 @@ module ViewComponent
     # @private
     def digest_path_from_template(template)
       component_path = self.class.virtual_path
-      return super unless component_path && template.virtual_path == component_path
+      return super unless component_path && template.is_a?(ViewComponent::Template)
 
       digest = self.class.cache_digest(
         finder: lookup_context,
         format: template.format || lookup_context.formats.first || :html
       )
 
-      digest.present? ? "#{component_path}:#{digest}" : component_path
+      digest.present? ? "#{template.virtual_path}:#{digest}" : template.virtual_path
     end
 
     private
 
     attr_reader :view_context
 
+    def __vc_render_uncached(view_context, &block)
+      old_virtual_path = view_context.instance_variable_get(:@virtual_path)
+      __vc_reset_render_state!
+
+      @view_context = view_context
+      @old_virtual_path = old_virtual_path
+      self.__vc_original_view_context = view_context
+
+      @output_buffer = view_context.output_buffer
+
+      @lookup_context = view_context.lookup_context
+
+      # For content_for
+      @view_flow = view_context.view_flow
+
+      # For i18n
+      component_virtual_path = virtual_path
+      @virtual_path ||= component_virtual_path
+
+      # Describes the inferred request constraints (locales, formats, variants)
+      @__vc_requested_details = @lookup_context.vc_requested_details
+
+      # For caching, such as #cache_if
+      @current_template = nil unless defined?(@current_template)
+      old_current_template = @current_template
+
+      if block && defined?(@__vc_content_set_by_with_content)
+        raise DuplicateContentError.new(self.class.name)
+      end
+
+      @__vc_content_evaluated = false
+      remove_instance_variable(:@__vc_content) if defined?(@__vc_content)
+      @__vc_render_in_block = block
+      @view_context.instance_variable_set(:@virtual_path, component_virtual_path)
+
+      before_render
+
+      if render?
+        value = nil
+
+        @output_buffer.with_buffer do
+          inner_rendered_template = nil
+          around_rendered_template = around_render do
+            inner_rendered_template = render_template_for(@__vc_requested_details).to_s
+          end
+
+          # If `around_render` returned the same object the block yielded, the inner
+          # template's escaping is authoritative and we can trust the result. If the
+          # user replaced/wrapped the value, re-check HTML safety to prevent
+          # bypassing the escaping applied to normal `#call` return values
+          # (GHSA-97jw-64cj-jc58).
+          rendered_template = if around_rendered_template.equal?(inner_rendered_template)
+            around_rendered_template
+          else
+            __vc_safe_around_render_output(around_rendered_template)
+          end
+
+          # Avoid allocating new string when output_preamble and output_postamble are blank
+          value = if output_preamble.blank? && output_postamble.blank?
+            rendered_template
+          else
+            __vc_safe_output_preamble + rendered_template + __vc_safe_output_postamble
+          end
+        end
+
+        if ActionView::Base.annotate_rendered_view_with_filenames && current_template.inline_call? && request&.format == :html
+          identifier = defined?(Rails.root) ? self.class.identifier.sub("#{Rails.root}/", "") : self.class.identifier
+          value = "<!-- BEGIN #{identifier} -->".html_safe + value + "<!-- END #{identifier} -->".html_safe
+        end
+
+        value
+      else
+        "".html_safe
+      end
+    ensure
+      view_context.instance_variable_set(:@virtual_path, old_virtual_path)
+      @current_template = old_current_template
+    end
+
     def __vc_render_in_block_provided?
       defined?(@view_context) && @view_context && @__vc_render_in_block
     end
@@ -471,15 +488,12 @@ module ViewComponent
     end
 
     def __vc_maybe_escape_html(text)
+      return text if text.html_safe?
       return text if @current_template && !@current_template.html?
       return text if text.blank?
 
-      if text.html_safe?
-        text
-      else
-        yield
-        html_escape(text)
-      end
+      yield
+      html_escape(text)
     end
 
     def __vc_safe_output_preamble
@@ -508,16 +522,10 @@ module ViewComponent
     # slot setters or `with_content`); reuse of an instance that has slot or
     # `with_content` state is guarded against separately by
     # `__vc_check_reused_instance!`.
-    RENDER_STATE_IVARS = %i[
-      @__vc_controller
-      @__vc_helpers
-      @__vc_request
-    ].freeze
-
     def __vc_reset_render_state!
-      RENDER_STATE_IVARS.each do |ivar|
-        remove_instance_variable(ivar) if instance_variable_defined?(ivar)
-      end
+      remove_instance_variable(:@__vc_controller) if defined?(@__vc_controller)
+      remove_instance_variable(:@__vc_helpers) if defined?(@__vc_helpers)
+      remove_instance_variable(:@__vc_request) if defined?(@__vc_request)
     end
 
     # Raises when a component instance is rendered more than once.
@@ -733,7 +741,7 @@ module ViewComponent
 
       # @private
       def __vc_compiled?
-        __vc_compiler.compiled?
+        CompileCache.compiled?(self)
       end
 
       # Hook called by the compiler after a component is compiled.
@@ -915,7 +923,7 @@ module ViewComponent
       end
 
       def __vc_files_ending_with(extensions, pattern)
-        paths = Dir[pattern]
+        paths = CompileCache.sidecar_files_matching(pattern)
         extensions.flat_map { |extension| paths.select { |path| path.end_with?(extension) } }
       end
 

data/lib/view_component/cache_digest/dependency_tracking.rb

@@ -26,15 +26,15 @@ module ViewComponent
           dependencies = dependencies - [declared] + [virtual_path]
         end
 
-        # 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)
+        # 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.component_renders_in(CacheDigest.compiled_source(template), name)
+          CacheDigest.template_renders_in(CacheDigest.compiled_source(template), name, view_paths: view_paths)
+        declared = source.scan(CacheDigest::EXPLICIT_DEPENDENCY).flatten
 
-        (dependencies - inferred_partials + component_paths).uniq
+        (dependencies - (inferred_partials - declared) + component_paths).uniq
       end
 
       # @private

data/lib/view_component/cache_digest/digestor_lookup.rb

@@ -24,7 +24,9 @@ module ViewComponent
       private
 
       def find_template(finder, name, prefixes, partial, keys)
-        Resolver.instance.find_templates(name, prefixes.first, partial, {formats: finder.formats}).first || super
+        Resolver.instance.find_templates(
+          name, prefixes.first, partial, {formats: finder.formats}, view_paths: finder.view_paths
+        ).first || super
       end
     end
   end

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
 
+      RELATIVE_PARTIAL_PREFIX = "view_component/relative_partial/"
+      RELATIVE_DEPENDENCY = /<%# Relative Template Dependency: (\S+) %>/
+      private_constant :RELATIVE_PARTIAL_PREFIX, :RELATIVE_DEPENDENCY
+
       # Where ViewComponent's own modules, such as the ones it includes into
       # every component, are defined.
       VIEW_COMPONENT_LIB = "#{::File.expand_path("..", __dir__)}/".freeze
@@ -28,12 +32,12 @@ module ViewComponent
         end
       end
 
-      def find_templates(name, prefix, partial, details, locals = [])
+      def find_templates(name, prefix, partial, details, locals = [], view_paths: ActionController::Base.view_paths)
         virtual_path = [prefix.presence, name].compact.join("/")
         component = CacheDigest.component_for(virtual_path)
         return [] unless component
 
-        [build_template(component, virtual_path, details)]
+        [build_template(component, virtual_path, details, view_paths)]
       end
 
       def to_s
@@ -74,7 +78,11 @@ module ViewComponent
         # the template sources, where they'd also infer partials from component
         # renders.
         dependencies(component, templates).each do |dependency|
-          parts << "<%# Template Dependency: #{dependency} %>"
+          parts << if dependency.start_with?(RELATIVE_PARTIAL_PREFIX)
+            "<%# Relative Template Dependency: #{dependency.delete_prefix(RELATIVE_PARTIAL_PREFIX)} %>"
+          else
+            "<%# Template Dependency: #{dependency} %>"
+          end
         end
 
         # Content hashes of the templates, including inline ones.
@@ -87,9 +95,10 @@ module ViewComponent
 
       private
 
-      def build_template(component, virtual_path, details)
+      def build_template(component, virtual_path, details, view_paths)
+        source = component.__vc_cache_digest_source || source_for(component)
         ActionView::Template.new(
-          component.__vc_cache_digest_source || source_for(component),
+          resolve_relative_dependencies(source, view_paths),
           "view_component cache digest for #{component.name}",
           ActionView::Template.handler_for_extension(:erb),
           locals: [],
@@ -98,15 +107,32 @@ module ViewComponent
         )
       end
 
+      # A relative render uses the calling controller's prefixes. Track all
+      # matching partials so precomputed sources work for every controller.
+      def resolve_relative_dependencies(source, view_paths)
+        return source unless source.include?("Relative Template Dependency:")
+
+        paths = view_paths.flat_map(&:all_template_paths).uniq
+        source.gsub(RELATIVE_DEPENDENCY) do
+          name = Regexp.last_match(1)
+          matches = paths.filter_map do |path|
+            path.to_s if path.partial? && ::File.fnmatch?(name.delete_prefix("_"), path.name)
+          end.sort
+          matches = [name] if matches.empty?
+          matches.map { |path| "<%# Template Dependency: #{path} %>" }.join("\n")
+        end
+      end
+
       # The component and any component superclasses, nearest first. Including
       # ancestors means editing `ApplicationComponent` invalidates every
       # component that inherits from it.
       def component_ancestors(component)
-        component.ancestors.select do |ancestor|
-          ancestor.is_a?(Class) &&
-            ancestor <= ViewComponent::Base &&
-            ancestor != ViewComponent::Base
+        ancestors = []
+        until component == ViewComponent::Base
+          ancestors << component
+          component = component.superclass
         end
+        ancestors
       end
 
       # Modules the component and its component superclasses include, such as
@@ -119,7 +145,11 @@ module ViewComponent
         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)
+          begin
+            path, _line = Object.const_source_location(ancestor.name)
+          rescue NameError
+            next
+          end
           path unless path.nil? || path.start_with?(VIEW_COMPONENT_LIB)
         }.uniq
       end
@@ -134,26 +164,20 @@ module ViewComponent
           .compact.uniq.select { |path| ::File.exist?(path) }
       end
 
-      def template_files(component)
-        component_ancestors(component)
-          .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
+      # @return [Array<Array(String, String, Class)>] source, extension, and defining component
       def template_sources(component)
-        sources = template_files(component).map { |path| [::File.read(path), ::File.extname(path).delete_prefix(".")] }
-
-        component_ancestors(component).each do |ancestor|
+        component_ancestors(component).flat_map do |ancestor|
+          sources = ancestor.__vc_sidecar_files(ActionView::Template::Handlers.extensions).filter_map do |path|
+            [CompileCache.read_file(path), ::File.extname(path).delete_prefix("."), ancestor] if ::File.exist?(path)
+          end
           inline_template = ancestor.__vc_inline_template
-          sources << [inline_template.source, inline_template.language.to_s] if inline_template
-        end
+          sources << [inline_template.source, inline_template.language.to_s, ancestor] if inline_template
 
-        sources.uniq
+          sources
+        end.uniq
       end
 
       def explicit_dependencies(sources)
@@ -173,42 +197,39 @@ module ViewComponent
       # 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)
+        virtual_path = "#{RELATIVE_PARTIAL_PREFIX}template"
         ruby = ruby_sources(component)
         own_paths = component_ancestors(component).filter_map { |ancestor| CacheDigest.virtual_path_for(ancestor) }
 
         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) }
+          templates.flat_map { |source, extension, owner| template_dependencies(owner, 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'))
-        }
+        CacheDigest.renders_in(source, virtual_path, view_paths: ActionController::Base.view_paths).flatten
       end
 
       def template_dependencies(component, source, extension, virtual_path)
-        return [] unless source.include?("render")
+        handler = ActionView::Template.handler_for_extension(extension)
+        return [] unless CacheDigest.template_dependencies?(source, handler)
 
         template = ActionView::Template.new(
           source,
           "view_component cache digest for #{component.name}",
-          ActionView::Template.handler_for_extension(extension),
+          handler,
           locals: [],
           format: nil,
           virtual_path: virtual_path
         )
-        CacheDigest.renders_in(CacheDigest.compiled_source(template), virtual_path).flatten
+        CacheDigest.renders_in(
+          CacheDigest.compiled_source(template), virtual_path,
+          view_paths: ActionController::Base.view_paths, nesting: [component]
+        ).flatten
       end
 
       # Components loaded from encrypted files, as some commercial gems ship
@@ -216,7 +237,7 @@ module ViewComponent
       # hashed by `file_digest`.
       def ruby_sources(component)
         ruby_files(component).filter_map { |path|
-          source = ::File.read(path)
+          source = CompileCache.read_file(path)
           source if source.valid_encoding?
         }
       end