actionview 4.2.11.1 → 7.0.2.4

data/lib/action_view/dependency_tracker.rb

@@ -1,141 +1,40 @@
-require 'thread_safe'
+# frozen_string_literal: true
+
+require "concurrent/map"
+require "action_view/path_set"
+require "action_view/render_parser"
 
 module ActionView
   class DependencyTracker # :nodoc:
-    @trackers = ThreadSafe::Cache.new
+    extend ActiveSupport::Autoload
+
+    autoload :ERBTracker
+    autoload :RipperTracker
 
-    def self.find_dependencies(name, template)
+    @trackers = Concurrent::Map.new
+
+    def self.find_dependencies(name, template, view_paths = nil)
       tracker = @trackers[template.handler]
+      return [] unless tracker
 
-      if tracker.present?
-        tracker.call(name, template)
-      else
-        []
-      end
+      tracker.call(name, template, view_paths)
     end
 
     def self.register_tracker(extension, tracker)
       handler = Template.handler_for_extension(extension)
-      @trackers[handler] = tracker
+      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
-
-      def self.call(name, template)
-        new(name, template).dependencies
-      end
-
-      def initialize(name, template)
-        @name, @template = name, template
-      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|
-            arguments.scan(RENDER_ARGUMENTS) do
-              add_dynamic_dependency(render_dependencies, Regexp.last_match[:dynamic])
-              add_static_dependency(render_dependencies, Regexp.last_match[:static])
-            end
-          end
-
-          render_dependencies.uniq
-        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 explicit_dependencies
-          source.scan(EXPLICIT_DEPENDENCY).flatten.uniq
-        end
-    end
-
     register_tracker :erb, ERBTracker
   end
 end

data/lib/action_view/digestor.rb

@@ -1,123 +1,130 @@
-require 'thread_safe'
-require 'action_view/dependency_tracker'
-require 'monitor'
+# frozen_string_literal: true
+
+require "action_view/dependency_tracker"
 
 module ActionView
   class Digestor
-    cattr_reader(:cache)
-    @@cache          = ThreadSafe::Cache.new
-    @@digest_monitor = Monitor.new
+    @@digest_mutex = Mutex.new
 
     class << self
       # Supported options:
       #
-      # * <tt>name</tt>   - Template name
-      # * <tt>finder</tt>  - An instance of ActionView::LookupContext
-      # * <tt>dependencies</tt>  - An array of dependent views
-      # * <tt>partial</tt>  - Specifies whether the template is a partial
-      def digest(options)
-        options.assert_valid_keys(:name, :finder, :dependencies, :partial)
-
-        cache_key = ([ options[:name], options[:finder].details_key.hash ].compact + Array.wrap(options[:dependencies])).join('.')
+      # * <tt>name</tt>         - Template name
+      # * <tt>format</tt>       - Template format
+      # * <tt>finder</tt>       - An instance of <tt>ActionView::LookupContext</tt>
+      # * <tt>dependencies</tt> - An array of dependent views
+      def digest(name:, format: nil, finder:, dependencies: nil)
+        if dependencies.nil? || dependencies.empty?
+          cache_key = "#{name}.#{format}"
+        else
+          dependencies_suffix = dependencies.flatten.tap(&:compact!).join(".")
+          cache_key = "#{name}.#{format}.#{dependencies_suffix}"
+        end
 
         # this is a correctly done double-checked locking idiom
-        # (ThreadSafe::Cache's lookups have volatile semantics)
-        @@cache[cache_key] || @@digest_monitor.synchronize do
-          @@cache.fetch(cache_key) do # re-check under lock
-            compute_and_store_digest(cache_key, options)
+        # (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
+            path = TemplatePath.parse(name)
+            root = tree(path.to_s, finder, path.partial?)
+            dependencies.each do |injected_dep|
+              root.children << Injected.new(injected_dep, nil, nil)
+            end if dependencies
+            finder.digest_cache[cache_key] = root.digest(finder)
           end
         end
       end
 
-      private
-        def compute_and_store_digest(cache_key, options) # called under @@digest_monitor lock
-          klass = if options[:partial] || options[:name].include?("/_")
-            # Prevent re-entry or else recursive templates will blow the stack.
-            # There is no need to worry about other threads seeing the +false+ value,
-            # as they will then have to wait for this thread to let go of the @@digest_monitor lock.
-            pre_stored = @@cache.put_if_absent(cache_key, false).nil? # put_if_absent returns nil on insertion
-            PartialDigestor
-          else
-            Digestor
-          end
+      def logger
+        ActionView::Base.logger || NullLogger
+      end
 
-          digest = klass.new(options).digest
-          # Store the actual digest if config.cache_template_loading is true
-          @@cache[cache_key] = stored_digest = digest if ActionView::Resolver.caching?
-          digest
-        ensure
-          # something went wrong or ActionView::Resolver.caching? is false, make sure not to corrupt the @@cache
-          @@cache.delete_pair(cache_key, false) if pre_stored && !stored_digest
-        end
-    end
+      # Create a dependency tree for template named +name+.
+      def tree(name, finder, partial = false, seen = {})
+        logical_name = name.gsub(%r|/_|, "/")
+        interpolated = name.include?("#")
 
-    attr_reader :name, :finder, :options
+        path = TemplatePath.parse(name)
 
-    def initialize(options)
-      @name, @finder = options.values_at(:name, :finder)
-      @options = options.except(:name, :finder)
-    end
+        if !interpolated && (template = find_template(finder, path.name, [path.prefix], partial, []))
+          if node = seen[template.identifier] # handle cycles in the tree
+            node
+          else
+            node = seen[template.identifier] = Node.create(name, logical_name, template, partial)
 
-    def digest
-      Digest::MD5.hexdigest("#{source}-#{dependency_digest}").tap do |digest|
-        logger.try :debug, "  Cache digest for #{template.inspect}: #{digest}"
+            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 interpolated # 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
-    rescue ActionView::MissingTemplate
-      logger.try :error, "  Couldn't find template for digesting: #{name}"
-      ''
-    end
 
-    def dependencies
-      DependencyTracker.find_dependencies(name, template)
-    rescue ActionView::MissingTemplate
-      logger.try :error, "  '#{name}' file doesn't exist, so no dependencies"
-      []
+      private
+        def find_template(finder, name, prefixes, partial, keys)
+          finder.disable_cache do
+            finder.find_all(name, prefixes, partial, keys).first
+          end
+        end
     end
 
-    def nested_dependencies
-      dependencies.collect do |dependency|
-        dependencies = PartialDigestor.new(name: dependency, finder: finder).nested_dependencies
-        dependencies.any? ? { dependency => dependencies } : dependency
-      end
-    end
+    class Node
+      attr_reader :name, :logical_name, :template, :children
 
-    private
-      def logger
-        ActionView::Base.logger
+      def self.create(name, logical_name, template, partial)
+        klass = partial ? Partial : Node
+        klass.new(name, logical_name, template, [])
       end
 
-      def logical_name
-        name.gsub(%r|/_|, "/")
+      def initialize(name, logical_name, template, children = [])
+        @name         = name
+        @logical_name = logical_name
+        @template     = template
+        @children     = children
       end
 
-      def partial?
-        false
+      def digest(finder, stack = [])
+        ActiveSupport::Digest.hexdigest("#{template.source}-#{dependency_digest(finder, stack)}")
       end
 
-      def template
-        @template ||= finder.disable_cache { finder.find(logical_name, [], partial?) }
+      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 source
-        template.source
+      def to_dep_map
+        children.any? ? { name => children.map(&:to_dep_map) } : name
       end
+    end
 
-      def dependency_digest
-        template_digests = dependencies.collect do |template_name|
-          Digestor.digest(name: template_name, finder: finder, partial: true)
-        end
+    class Partial < Node; end
 
-        (template_digests + injected_dependencies).join("-")
-      end
+    class Missing < Node
+      def digest(finder, _ = []) "" end
+    end
 
-      def injected_dependencies
-        Array.wrap(options[:dependencies])
-      end
-  end
+    class Injected < Node
+      def digest(finder, _ = []) name end
+    end
 
-  class PartialDigestor < Digestor # :nodoc:
-    def partial?
-      true
+    class NullLogger
+      def self.debug(_); end
+      def self.error(_); end
     end
   end
 end

data/lib/action_view/flows.rb

@@ -1,11 +1,13 @@
-require 'active_support/core_ext/string/output_safety'
+# frozen_string_literal: true
+
+require "active_support/core_ext/string/output_safety"
 
 module ActionView
-  class OutputFlow #:nodoc:
+  class OutputFlow # :nodoc:
     attr_reader :content
 
     def initialize
-      @content = Hash.new { |h,k| h[k] = ActiveSupport::SafeBuffer.new }
+      @content = Hash.new { |h, k| h[k] = ActiveSupport::SafeBuffer.new }
     end
 
     # Called by _layout_for to read stored values.
@@ -15,18 +17,17 @@ module ActionView
 
     # Called by each renderer object to set the layout contents.
     def set(key, value)
-      @content[key] = ActiveSupport::SafeBuffer.new(value)
+      @content[key] = ActiveSupport::SafeBuffer.new(value.to_s)
     end
 
     # Called by content_for
     def append(key, value)
-      @content[key] << value
+      @content[key] << value.to_s
     end
     alias_method :append!, :append
-
   end
 
-  class StreamingFlow < OutputFlow #:nodoc:
+  class StreamingFlow < OutputFlow # :nodoc:
     def initialize(view, fiber)
       @view    = view
       @parent  = nil
@@ -37,9 +38,8 @@ module ActionView
     end
 
     # Try to get stored content. If the content
-    # is not available and we are inside the layout
-    # fiber, we set that we are waiting for the given
-    # key and yield.
+    # 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)
 
@@ -60,17 +60,16 @@ module ActionView
     end
 
     # Appends the contents for the given key. This is called
-    # by provides and resumes back to the fiber if it is
-    # the key it is waiting for.
+    # 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
+      def inside_fiber?
+        Fiber.current.object_id != @root
+      end
   end
 end

data/lib/action_view/gem_version.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module ActionView
   # Returns the version of the currently loaded Action View as a <tt>Gem::Version</tt>
   def self.gem_version
@@ -5,10 +7,10 @@ module ActionView
   end
 
   module VERSION
-    MAJOR = 4
-    MINOR = 2
-    TINY  = 11
-    PRE   = "1"
+    MAJOR = 7
+    MINOR = 0
+    TINY  = 2
+    PRE   = "4"
 
     STRING = [MAJOR, MINOR, TINY, PRE].compact.join(".")
   end

data/lib/action_view/helpers/active_model_helper.rb

@@ -1,9 +1,11 @@
-require 'active_support/core_ext/module/attribute_accessors'
-require 'active_support/core_ext/enumerable'
+# frozen_string_literal: true
+
+require "active_support/core_ext/module/attribute_accessors"
+require "active_support/core_ext/enumerable"
 
 module ActionView
   # = Active Model Helpers
-  module Helpers
+  module Helpers # :nodoc:
     module ActiveModelHelper
     end
 
@@ -15,8 +17,8 @@ module ActionView
         end
       end
 
-      def content_tag(*)
-        error_wrapping(super)
+      def content_tag(type, options, *)
+        select_markup_helper?(type) ? super : error_wrapping(super)
       end
 
       def tag(type, options, *)
@@ -25,7 +27,7 @@ module ActionView
 
       def error_wrapping(html_tag)
         if object_has_errors?
-          Base.field_error_proc.call(html_tag, self)
+          @template_object.instance_exec(html_tag, self, &Base.field_error_proc)
         else
           html_tag
         end
@@ -36,14 +38,17 @@ module ActionView
       end
 
       private
+        def object_has_errors?
+          object.respond_to?(:errors) && object.errors.respond_to?(:[]) && error_message.present?
+        end
 
-      def object_has_errors?
-        object.respond_to?(:errors) && object.errors.respond_to?(:[]) && error_message.present?
-      end
+        def select_markup_helper?(type)
+          ["optgroup", "option"].include?(type)
+        end
 
-      def tag_generate_errors?(options)
-        options['type'] != 'hidden'
-      end
+        def tag_generate_errors?(options)
+          options["type"] != "hidden"
+        end
     end
   end
 end