1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
|
# frozen_string_literal: true
require "action_view/dependency_tracker"
module ActionView
class Digestor
@@digest_mutex = Mutex.new
module PerExecutionDigestCacheExpiry
def self.before(target)
ActionView::LookupContext::DetailsKey.clear
end
end
class << self
# Supported options:
#
# * <tt>name</tt> - Template name
# * <tt>finder</tt> - An instance of <tt>ActionView::LookupContext</tt>
# * <tt>dependencies</tt> - An array of dependent views
def digest(name:, finder:, dependencies: [])
dependencies ||= []
cache_key = [ name, finder.rendered_format, dependencies ].flatten.compact.join(".")
# this is a correctly done double-checked locking idiom
# (Concurrent::Map's lookups have volatile semantics)
finder.digest_cache[cache_key] || @@digest_mutex.synchronize do
finder.digest_cache.fetch(cache_key) do # re-check under lock
partial = name.include?("/_")
root = tree(name, finder, partial)
dependencies.each do |injected_dep|
root.children << Injected.new(injected_dep, nil, nil)
end
finder.digest_cache[cache_key] = root.digest(finder)
end
end
end
def logger
ActionView::Base.logger || NullLogger
end
# Create a dependency tree for template named +name+.
def tree(name, finder, partial = false, seen = {})
logical_name = name.gsub(%r|/_|, "/")
if template = find_template(finder, logical_name, [], partial, [])
finder.rendered_format ||= template.formats.first
if node = seen[template.identifier] # handle cycles in the tree
node
else
node = seen[template.identifier] = Node.create(name, logical_name, template, partial)
deps = DependencyTracker.find_dependencies(name, template, finder.view_paths)
deps.uniq { |n| n.gsub(%r|/_|, "/") }.each do |dep_file|
node.children << tree(dep_file, finder, true, seen)
end
node
end
else
unless name.include?("#") # Dynamic template partial names can never be tracked
logger.error " Couldn't find template for digesting: #{name}"
end
seen[name] ||= Missing.new(name, logical_name, nil)
end
end
private
def find_template(finder, name, prefixes, partial, keys)
finder.disable_cache do
format = finder.rendered_format
result = finder.find_all(name, prefixes, partial, keys, formats: [format]).first if format
result || finder.find_all(name, prefixes, partial, keys).first
end
end
end
class Node
attr_reader :name, :logical_name, :template, :children
def self.create(name, logical_name, template, partial)
klass = partial ? Partial : Node
klass.new(name, logical_name, template, [])
end
def initialize(name, logical_name, template, children = [])
@name = name
@logical_name = logical_name
@template = template
@children = children
end
def digest(finder, stack = [])
ActiveSupport::Digest.hexdigest("#{template.source}-#{dependency_digest(finder, stack)}")
end
def dependency_digest(finder, stack)
children.map do |node|
if stack.include?(node)
false
else
finder.digest_cache[node.name] ||= begin
stack.push node
node.digest(finder, stack).tap { stack.pop }
end
end
end.join("-")
end
def to_dep_map
children.any? ? { name => children.map(&:to_dep_map) } : name
end
end
class Partial < Node; end
class Missing < Node
def digest(finder, _ = []) "" end
end
class Injected < Node
def digest(finder, _ = []) name end
end
class NullLogger
def self.debug(_); end
def self.error(_); end
end
end
end
|
