add template digetor that usses an ast

Author: reeganviljoen

lib/view_component/cache_digestor.rb

@@ -1,19 +1,85 @@
 # # frozen_string_literal: true
 
+require 'view_component/templat_dependency_extractor'
+
 module ViewComponent
   class CacheDigestor
-    @@digest_mutex = Mutex.new
+    def initialize(component:)
+    @component= component.class
+    end
 
-    class << self
-      def digest(name:, finder:, format: nil, dependencies: nil)
-        if dependencies.nil? || dependencies.empty?
-          cache_key = "#{name}.#{format}"
+    def digest
+      gather_templates
+      @templates.map do |template|
+        if template.type == :file
+          template_string = template.send(:source)
+          ViewComponent::TemplateDependencyExtractor.new(template_string, template.extension.to_sym).extract
         else
-          dependencies_suffix = dependencies.flatten.tap(&:compact!).join(".")
-          cache_key = "#{name}.#{format}.#{dependencies_suffix}"
+          # A digest cant be built for inline calls as there is no template to parse
+          []
         end
-        cache_key
       end
     end
+
+    def gather_templates
+      @templates ||=
+        begin
+          templates = @component.sidecar_files(
+            ActionView::Template.template_handler_extensions
+          ).map do |path|
+            # Extract format and variant from template filename
+            this_format, variant =
+              File
+                .basename(path)     # "variants_component.html+mini.watch.erb"
+                .split(".")[1..-2]  # ["html+mini", "watch"]
+                .join(".")          # "html+mini.watch"
+                .split("+")         # ["html", "mini.watch"]
+                .map(&:to_sym)      # [:html, :"mini.watch"]
+
+            out = Template.new(
+              component: @component,
+              type: :file,
+              path: path,
+              lineno: 0,
+              extension: path.split(".").last,
+              this_format: this_format.to_s.split(".").last&.to_sym, # strip locale from this_format, see #2113
+              variant: variant
+            )
+
+            out
+          end
+
+          component_instance_methods_on_self = @component.instance_methods(false)
+
+          (
+            @component.ancestors.take_while { |ancestor| ancestor != ViewComponent::Base } - @component.included_modules
+          ).flat_map { |ancestor| ancestor.instance_methods(false).grep(/^call(_|$)/) }
+            .uniq
+            .each do |method_name|
+              templates << Template.new(
+                component: @component,
+                type: :inline_call,
+                this_format: ViewComponent::Base::VC_INTERNAL_DEFAULT_FORMAT,
+                variant: method_name.to_s.include?("call_") ? method_name.to_s.sub("call_", "").to_sym : nil,
+                method_name: method_name,
+                defined_on_self: component_instance_methods_on_self.include?(method_name)
+              )
+            end
+
+          if @component.inline_template.present?
+            templates << Template.new(
+              component: @component,
+              type: :inline,
+              path: @component.inline_template.path,
+              lineno: @component.inline_template.lineno,
+              source: @component.inline_template.source.dup,
+              extension: @component.inline_template.language
+            )
+          end
+
+          templates
+        end
+    end
+
   end
 end

lib/view_component/cacheable.rb

@@ -8,23 +8,29 @@ module ViewComponent::Cacheable
   extend ActiveSupport::Concern
 
   included do
-    class_attribute :__vc_cache_dependencies, default: Set[:format, :__vc_format, :identifier]
+
+    class_attribute :__vc_cache_options, default: Set[:identifier]
+    class_attribute :__vc_cache_dependencies, default: Set.new
 
     # For caching, such as #cache_if
     #
     # @private
     def view_cache_dependencies
-      return if __vc_cache_dependencies.blank? || __vc_cache_dependencies.none? || __vc_cache_dependencies.nil?
+      self.class.__vc_cache_dependencies.map { |dep| public_send(dep) }
+    end
 
-      computed_view_cache_dependencies = __vc_cache_dependencies.map { |dep| if respond_to?(dep) then public_send(dep) end }
-      combined_fragment_cache_key(ActiveSupport::Cache.expand_cache_key(computed_view_cache_dependencies))
+    def view_cache_options
+      return if __vc_cache_options.blank?
+
+      computed_view_cache_options = __vc_cache_options.map { |opt| if respond_to?(opt) then public_send(opt) end }
+      combined_fragment_cache_key(ActiveSupport::Cache.expand_cache_key(computed_view_cache_options + component_digest))
     end
 
     # Render component from cache if possible
     #
     # @private
     def __vc_render_cacheable(rendered_template)
-      if __vc_cache_dependencies != [:format, :__vc_format]
+      if __vc_cache_options.any?
         ViewComponent::CachingRegistry.track_caching do
           template_fragment(rendered_template)
         end
@@ -34,7 +40,7 @@ def __vc_render_cacheable(rendered_template)
     end
 
     def template_fragment(rendered_template)
-      if content = read_fragment(rendered_template)
+      if content = read_fragment
         @view_renderer.cache_hits[@current_template&.virtual_path] = :hit if defined?(@view_renderer)
         content
       else
@@ -43,13 +49,13 @@ def template_fragment(rendered_template)
       end
     end
 
-    def read_fragment(rendered_template)
-      Rails.cache.fetch(component_digest)
+    def read_fragment
+      Rails.cache.fetch(view_cache_options)
     end
 
     def write_fragment(rendered_template)
       content = __vc_render_template(rendered_template)
-      Rails.cache.fetch(component_digest) do
+      Rails.cache.fetch(view_cache_options) do
         content
       end
       content
@@ -63,20 +69,19 @@ def combined_fragment_cache_key(key)
     end
 
     def component_digest
-      component_name = self.class.name.demodulize.underscore
-      ViewComponent::CacheDigestor.digest(name: component_name, format: format, finder: @lookup_context, dependencies: view_cache_dependencies)
+      ViewComponent::CacheDigestor.new(component: self).digest
     end
   end
 
   class_methods do
     # For caching the component
     def cache_on(*args)
-      __vc_cache_dependencies.merge(args)
+      __vc_cache_options.merge(args)
     end
 
     def inherited(child)
-      child.__vc_cache_dependencies = __vc_cache_dependencies.dup
-
+      child.__vc_cache_options = __vc_cache_options.dup
+      
       super
     end
   end

lib/view_component/prism_render_dependency_extractor.rb

@@ -0,0 +1,70 @@
+
+# frozen_string_literal: true
+
+require 'prism'
+
+module ViewComponent
+  class PrismRenderDependencyExtractor
+    def initialize(code)
+      @code = code
+      @dependencies = []
+    end
+
+    def extract
+      result = Prism.parse(@code)
+      walk(result.value)
+      @dependencies
+    end
+
+    private
+
+    def walk(node)
+      return unless node.respond_to?(:child_nodes)
+
+      if node.is_a?(Prism::CallNode) && render_call?(node)
+        extract_render_target(node)
+      end
+
+      node.child_nodes.each { |child| walk(child) if child }
+    end
+
+    def render_call?(node)
+      node.receiver.nil? && node.name == :render
+    end
+
+    def extract_render_target(node)
+      args = node.arguments&.arguments
+      return unless args && !args.empty?
+
+      first_arg = args.first
+
+      if first_arg.is_a?(Prism::CallNode) &&
+         first_arg.name == :new &&
+         first_arg.receiver.is_a?(Prism::ConstantPathNode) || first_arg.receiver.is_a?(Prism::ConstantReadNode)
+
+        const = extract_constant_path(first_arg.receiver)
+        @dependencies << const if const
+      end
+    end
+
+    def extract_constant_path(const_node)
+      parts = []
+      current = const_node
+
+      while current
+        case current
+        when Prism::ConstantPathNode
+          parts.unshift(current.child.name)
+          current = current.parent
+        when Prism::ConstantReadNode
+          parts.unshift(current.name)
+          break
+        else
+          break
+        end
+      end
+
+      parts.join("::")
+    end
+  end
+end

lib/view_component/templat_dependency_extractor.rb

@@ -0,0 +1,46 @@
+
+# frozen_string_literal: true
+
+require_relative 'template_ast_builder'
+require_relative 'prism_render_dependency_extractor'
+
+module ViewComponent
+  class TemplateDependencyExtractor
+    def initialize(template_string, engine)
+      @template_string = template_string
+      @engine = engine
+      @dependencies = []
+    end
+
+    def extract
+      ast = TemplateAstBuilder.build(@template_string, @engine)
+      walk(ast.split(';'))
+      @dependencies.uniq
+    end
+
+    private
+
+    def walk(node)
+      return unless node.is_a?(Array)
+
+      node.each { extract_from_ruby(_1) if _1.is_a?(String) }
+    end
+
+    def extract_from_ruby(ruby_code)
+      return unless ruby_code.include?("render")
+
+      @dependencies.concat PrismRenderDependencyExtractor.new(ruby_code).extract
+      extract_partial_or_layout(ruby_code)
+    end
+
+    def extract_partial_or_layout(code)
+      partial_match = code.match(/partial:\s*["']([^"']+)["']/)
+      layout_match  = code.match(/layout:\s*["']([^"']+)["']/)
+      direct_render = code.match(/render\s*\(?\s*["']([^"']+)["']/)
+
+      @dependencies << partial_match[1] if partial_match
+      @dependencies << layout_match[1] if layout_match
+      @dependencies << direct_render[1] if direct_render
+    end
+  end
+end

lib/view_component/template.rb

@@ -5,7 +5,7 @@ class Template
     DataWithSource = Struct.new(:format, :identifier, :short_identifier, :type, keyword_init: true)
     DataNoSource = Struct.new(:source, :identifier, :type, keyword_init: true)
 
-    attr_reader :variant, :this_format, :type
+    attr_reader :variant, :this_format, :type, :extension
 
     def initialize(
       component:,

lib/view_component/template_ast_builder.rb

@@ -0,0 +1,39 @@
+
+# frozen_string_literal: true
+
+require 'temple'
+require 'slim'
+require 'haml'
+require 'erb'
+
+module ViewComponent
+  class TemplateAstBuilder
+    class HamlTempleWrapper < Temple::Engine
+      def call(template)
+        engine = Haml::Engine.new(template, format: :xhtml)
+        html = engine.render
+        [:multi, [:static, html]]
+      end
+    end
+
+    class ErbTempleWrapper < Temple::Engine
+      def call(template)
+        Temple::ERB::Engine.new.call(template)
+      end
+    end
+
+    ENGINE_MAP = {
+      slim: -> { Slim::Engine.new },
+      haml: -> { HamlTempleWrapper.new },
+      erb:  -> { ErbTempleWrapper.new }
+    }
+
+    def self.build(template_string, engine_name)
+      engine = ENGINE_MAP.fetch(engine_name.to_sym) do
+        raise ArgumentError, "Unsupported engine: #{engine_name.inspect}"
+      end.call
+
+      engine.call(template_string)
+    end
+  end
+end

test/sandbox/app/components/cache_component.html.erb

@@ -1,2 +1,4 @@
 <p class='cache-component__cache-key'><%= view_cache_dependencies %></p>
 <p class='cache-component__cache-message' data-time=data-time="<%= Time.zone.now %>"><%= "#{foo} #{bar}" %></p>
+
+<%= render(ButtonToComponent.new) %>