actionview 5.2.3

data/lib/action_view/buffers.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+require "active_support/core_ext/string/output_safety"
+
+module ActionView
+  class OutputBuffer < ActiveSupport::SafeBuffer #:nodoc:
+    def initialize(*)
+      super
+      encode!
+    end
+
+    def <<(value)
+      return self if value.nil?
+      super(value.to_s)
+    end
+    alias :append= :<<
+
+    def safe_expr_append=(val)
+      return self if val.nil?
+      safe_concat val.to_s
+    end
+
+    alias :safe_append= :safe_concat
+  end
+
+  class StreamingBuffer #:nodoc:
+    def initialize(block)
+      @block = block
+    end
+
+    def <<(value)
+      value = value.to_s
+      value = ERB::Util.h(value) unless value.html_safe?
+      @block.call(value)
+    end
+    alias :concat  :<<
+    alias :append= :<<
+
+    def safe_concat(value)
+      @block.call(value.to_s)
+    end
+    alias :safe_append= :safe_concat
+
+    def html_safe?
+      true
+    end
+
+    def html_safe
+      self
+    end
+  end
+end

data/lib/action_view/context.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module ActionView
+  module CompiledTemplates #:nodoc:
+    # holds compiled template code
+  end
+
+  # = Action View Context
+  #
+  # Action View contexts are supplied to Action Controller to render a template.
+  # The default Action View context is ActionView::Base.
+  #
+  # In order to work with ActionController, a Context must just include this module.
+  # The initialization of the variables used by the context (@output_buffer, @view_flow,
+  # and @virtual_path) is responsibility of the object that includes this module
+  # (although you can call _prepare_context defined below).
+  module Context
+    include CompiledTemplates
+    attr_accessor :output_buffer, :view_flow
+
+    # Prepares the context by setting the appropriate instance variables.
+    def _prepare_context
+      @view_flow     = OutputFlow.new
+      @output_buffer = nil
+      @virtual_path  = nil
+    end
+
+    # Encapsulates the interaction with the view flow so it
+    # returns the correct buffer on +yield+. This is usually
+    # overwritten by helpers to add more behavior.
+    def _layout_for(name = nil)
+      name ||= :layout
+      view_flow.get(name).html_safe
+    end
+  end
+end

data/lib/action_view/dependency_tracker.rb

@@ -0,0 +1,175 @@
+# frozen_string_literal: true
+
+require "concurrent/map"
+require "action_view/path_set"
+
+module ActionView
+  class DependencyTracker # :nodoc:
+    @trackers = Concurrent::Map.new
+
+    def self.find_dependencies(name, template, view_paths = nil)
+      tracker = @trackers[template.handler]
+      return [] unless tracker
+
+      tracker.call(name, template, view_paths)
+    end
+
+    def self.register_tracker(extension, tracker)
+      handler = Template.handler_for_extension(extension)
+      if tracker.respond_to?(:supports_view_paths?)
+        @trackers[handler] = tracker
+      else
+        @trackers[handler] = lambda { |name, template, _|
+          tracker.call(name, template)
+        }
+      end
+    end
+
+    def self.remove_tracker(handler)
+      @trackers.delete(handler)
+    end
+
+    class ERBTracker # :nodoc:
+      EXPLICIT_DEPENDENCY = /# Template Dependency: (\S+)/
+
+      # A valid ruby identifier - suitable for class, method and specially variable names
+      IDENTIFIER = /
+        [[:alpha:]_] # at least one uppercase letter, lowercase letter or underscore
+        [[:word:]]*  # followed by optional letters, numbers or underscores
+      /x
+
+      # Any kind of variable name. e.g. @instance, @@class, $global or local.
+      # Possibly following a method call chain
+      VARIABLE_OR_METHOD_CHAIN = /
+        (?:\$|@{1,2})?            # optional global, instance or class variable indicator
+        (?:#{IDENTIFIER}\.)*      # followed by an optional chain of zero-argument method calls
+        (?<dynamic>#{IDENTIFIER}) # and a final valid identifier, captured as DYNAMIC
+      /x
+
+      # A simple string literal. e.g. "School's out!"
+      STRING = /
+        (?<quote>['"]) # an opening quote
+        (?<static>.*?) # with anything inside, captured as STATIC
+        \k<quote>      # and a matching closing quote
+      /x
+
+      # Part of any hash containing the :partial key
+      PARTIAL_HASH_KEY = /
+        (?:\bpartial:|:partial\s*=>) # partial key in either old or new style hash syntax
+        \s*                          # followed by optional spaces
+      /x
+
+      # Part of any hash containing the :layout key
+      LAYOUT_HASH_KEY = /
+        (?:\blayout:|:layout\s*=>)   # layout key in either old or new style hash syntax
+        \s*                          # followed by optional spaces
+      /x
+
+      # Matches:
+      #   partial: "comments/comment", collection: @all_comments => "comments/comment"
+      #   (object: @single_comment, partial: "comments/comment") => "comments/comment"
+      #
+      #   "comments/comments"
+      #   'comments/comments'
+      #   ('comments/comments')
+      #
+      #   (@topic)         => "topics/topic"
+      #    topics          => "topics/topic"
+      #   (message.topics) => "topics/topic"
+      RENDER_ARGUMENTS = /\A
+        (?:\s*\(?\s*)                                  # optional opening paren surrounded by spaces
+        (?:.*?#{PARTIAL_HASH_KEY}|#{LAYOUT_HASH_KEY})? # optional hash, up to the partial or layout key declaration
+        (?:#{STRING}|#{VARIABLE_OR_METHOD_CHAIN})      # finally, the dependency name of interest
+      /xm
+
+      LAYOUT_DEPENDENCY = /\A
+        (?:\s*\(?\s*)                                  # optional opening paren surrounded by spaces
+        (?:.*?#{LAYOUT_HASH_KEY})                      # check if the line has layout key declaration
+        (?:#{STRING}|#{VARIABLE_OR_METHOD_CHAIN})      # finally, the dependency name of interest
+      /xm
+
+      def self.supports_view_paths? # :nodoc:
+        true
+      end
+
+      def self.call(name, template, view_paths = nil)
+        new(name, template, view_paths).dependencies
+      end
+
+      def initialize(name, template, view_paths = nil)
+        @name, @template, @view_paths = name, template, view_paths
+      end
+
+      def dependencies
+        render_dependencies + explicit_dependencies
+      end
+
+      attr_reader :name, :template
+      private :name, :template
+
+      private
+        def source
+          template.source
+        end
+
+        def directory
+          name.split("/")[0..-2].join("/")
+        end
+
+        def render_dependencies
+          render_dependencies = []
+          render_calls = source.split(/\brender\b/).drop(1)
+
+          render_calls.each do |arguments|
+            add_dependencies(render_dependencies, arguments, LAYOUT_DEPENDENCY)
+            add_dependencies(render_dependencies, arguments, RENDER_ARGUMENTS)
+          end
+
+          render_dependencies.uniq
+        end
+
+        def add_dependencies(render_dependencies, arguments, pattern)
+          arguments.scan(pattern) do
+            add_dynamic_dependency(render_dependencies, Regexp.last_match[:dynamic])
+            add_static_dependency(render_dependencies, Regexp.last_match[:static])
+          end
+        end
+
+        def add_dynamic_dependency(dependencies, dependency)
+          if dependency
+            dependencies << "#{dependency.pluralize}/#{dependency.singularize}"
+          end
+        end
+
+        def add_static_dependency(dependencies, dependency)
+          if dependency
+            if dependency.include?("/")
+              dependencies << dependency
+            else
+              dependencies << "#{directory}/#{dependency}"
+            end
+          end
+        end
+
+        def resolve_directories(wildcard_dependencies)
+          return [] unless @view_paths
+
+          wildcard_dependencies.flat_map { |query, templates|
+            @view_paths.find_all_with_query(query).map do |template|
+              "#{File.dirname(query)}/#{File.basename(template).split('.').first}"
+            end
+          }.sort
+        end
+
+        def explicit_dependencies
+          dependencies = source.scan(EXPLICIT_DEPENDENCY).flatten.uniq
+
+          wildcards, explicits = dependencies.partition { |dependency| dependency[-1] == "*" }
+
+          (explicits + resolve_directories(wildcards)).uniq
+        end
+    end
+
+    register_tracker :erb, ERBTracker
+  end
+end

data/lib/action_view/digestor.rb

@@ -0,0 +1,134 @@
+# frozen_string_literal: true
+
+require "concurrent/map"
+require "action_view/dependency_tracker"
+require "monitor"
+
+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

data/lib/action_view/flows.rb

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+require "active_support/core_ext/string/output_safety"
+
+module ActionView
+  class OutputFlow #:nodoc:
+    attr_reader :content
+
+    def initialize
+      @content = Hash.new { |h, k| h[k] = ActiveSupport::SafeBuffer.new }
+    end
+
+    # Called by _layout_for to read stored values.
+    def get(key)
+      @content[key]
+    end
+
+    # Called by each renderer object to set the layout contents.
+    def set(key, value)
+      @content[key] = ActiveSupport::SafeBuffer.new(value)
+    end
+
+    # Called by content_for
+    def append(key, value)
+      @content[key] << value
+    end
+    alias_method :append!, :append
+  end
+
+  class StreamingFlow < OutputFlow #:nodoc:
+    def initialize(view, fiber)
+      @view    = view
+      @parent  = nil
+      @child   = view.output_buffer
+      @content = view.view_flow.content
+      @fiber   = fiber
+      @root    = Fiber.current.object_id
+    end
+
+    # Try to get stored content. If the content
+    # is not available and we're inside the layout fiber,
+    # then it will begin waiting for the given key and yield.
+    def get(key)
+      return super if @content.key?(key)
+
+      if inside_fiber?
+        view = @view
+
+        begin
+          @waiting_for = key
+          view.output_buffer, @parent = @child, view.output_buffer
+          Fiber.yield
+        ensure
+          @waiting_for = nil
+          view.output_buffer, @child = @parent, view.output_buffer
+        end
+      end
+
+      super
+    end
+
+    # Appends the contents for the given key. This is called
+    # by providing and resuming back to the fiber,
+    # if that's the key it's waiting for.
+    def append!(key, value)
+      super
+      @fiber.resume if @waiting_for == key
+    end
+
+    private
+
+      def inside_fiber?
+        Fiber.current.object_id != @root
+      end
+  end
+end