omg-actionview 8.0.0.alpha1

data/lib/action_view/dependency_tracker/erb_tracker.rb

@@ -0,0 +1,159 @@
+# frozen_string_literal: true
+
+module ActionView
+  class DependencyTracker # :nodoc:
+    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
+        WildcardResolver.new(@view_paths, render_dependencies + explicit_dependencies).resolve
+      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
+          dependencies = []
+          render_calls = source.split(/\brender\b/).drop(1)
+
+          render_calls.each do |arguments|
+            add_dependencies(dependencies, arguments, LAYOUT_DEPENDENCY)
+            add_dependencies(dependencies, arguments, RENDER_ARGUMENTS)
+          end
+
+          dependencies
+        end
+
+        def add_dependencies(render_dependencies, arguments, pattern)
+          arguments.scan(pattern) do
+            match = Regexp.last_match
+            add_dynamic_dependency(render_dependencies, match[:dynamic])
+            add_static_dependency(render_dependencies, match[:static], match[:quote])
+          end
+        end
+
+        def add_dynamic_dependency(dependencies, dependency)
+          if dependency
+            dependencies << "#{dependency.pluralize}/#{dependency.singularize}"
+          end
+        end
+
+        def add_static_dependency(dependencies, dependency, quote_type)
+          if quote_type == '"' && dependency.include?('#{')
+            scanner = StringScanner.new(dependency)
+
+            wildcard_dependency = +""
+
+            while !scanner.eos?
+              next unless scanner.scan_until(/\#{/)
+
+              unmatched_brackets = 1
+              wildcard_dependency << scanner.pre_match
+
+              while unmatched_brackets > 0 && !scanner.eos?
+                scanner.scan_until(/[{}]/)
+
+                case scanner.matched
+                when "{"
+                  unmatched_brackets += 1
+                when "}"
+                  unmatched_brackets -= 1
+                end
+              end
+
+              wildcard_dependency << "*"
+            end
+
+            dependencies << wildcard_dependency
+          elsif dependency
+            if dependency.include?("/")
+              dependencies << dependency
+            else
+              dependencies << "#{directory}/#{dependency}"
+            end
+          end
+        end
+
+        def explicit_dependencies
+          source.scan(EXPLICIT_DEPENDENCY).flatten.uniq
+        end
+    end
+  end
+end

data/lib/action_view/dependency_tracker/ruby_tracker.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module ActionView
+  class DependencyTracker # :nodoc:
+    class RubyTracker # :nodoc:
+      EXPLICIT_DEPENDENCY = /# Template Dependency: (\S+)/
+
+      def self.call(name, template, view_paths = nil)
+        new(name, template, view_paths).dependencies
+      end
+
+      def dependencies
+        WildcardResolver.new(view_paths, render_dependencies + explicit_dependencies).resolve
+      end
+
+      def self.supports_view_paths? # :nodoc:
+        true
+      end
+
+      def initialize(name, template, view_paths = nil, parser_class: RenderParser::Default)
+        @name, @template, @view_paths = name, template, view_paths
+        @parser_class = parser_class
+      end
+
+      private
+        attr_reader :template, :name, :view_paths
+
+        def render_dependencies
+          return [] unless template.source.include?("render")
+
+          compiled_source = template.handler.call(template, template.source)
+
+          @parser_class.new(@name, compiled_source).render_calls.filter_map do |render_call|
+            render_call.gsub(%r|/_|, "/")
+          end
+        end
+
+        def explicit_dependencies
+          template.source.scan(EXPLICIT_DEPENDENCY).flatten.uniq
+        end
+    end
+  end
+end

data/lib/action_view/dependency_tracker/wildcard_resolver.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module ActionView
+  class DependencyTracker # :nodoc:
+    class WildcardResolver # :nodoc:
+      def initialize(view_paths, dependencies)
+        @view_paths = view_paths
+
+        @wildcard_dependencies, @explicit_dependencies =
+          dependencies.partition { |dependency| dependency.end_with?("/*") }
+      end
+
+      def resolve
+        return explicit_dependencies.uniq if !view_paths || wildcard_dependencies.empty?
+
+        (explicit_dependencies + resolved_wildcard_dependencies).uniq
+      end
+
+      private
+        attr_reader :explicit_dependencies, :wildcard_dependencies, :view_paths
+
+        def resolved_wildcard_dependencies
+          # Remove trailing "/*"
+          prefixes = wildcard_dependencies.map { |query| query[0..-3] }
+
+          view_paths.flat_map(&:all_template_paths).uniq.filter_map { |path|
+            path.to_s if prefixes.include?(path.prefix)
+          }.sort
+        end
+    end
+  end
+end

data/lib/action_view/dependency_tracker.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+require "concurrent/map"
+require "action_view/path_set"
+require "action_view/render_parser"
+
+module ActionView
+  class DependencyTracker # :nodoc:
+    extend ActiveSupport::Autoload
+
+    autoload :ERBTracker
+    autoload :RubyTracker
+    autoload :WildcardResolver
+
+    @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
+
+    register_tracker :erb, ERBTracker
+  end
+end

data/lib/action_view/deprecator.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module ActionView
+  def self.deprecator # :nodoc:
+    @deprecator ||= ActiveSupport::Deprecation.new
+  end
+end

data/lib/action_view/digestor.rb

@@ -0,0 +1,130 @@
+# frozen_string_literal: true
+
+require "action_view/dependency_tracker"
+
+module ActionView
+  class Digestor
+    @@digest_mutex = Mutex.new
+
+    class << self
+      # Supported options:
+      #
+      # * <tt>name</tt>         - Template name
+      # * <tt>format</tt>       - Template format
+      # * +finder+              - An instance of ActionView::LookupContext
+      # * <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
+        # (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
+
+      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|/_|, "/")
+        interpolated = name.include?("#")
+
+        path = TemplatePath.parse(name)
+
+        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)
+
+            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
+
+      private
+        def find_template(finder, name, prefixes, partial, keys)
+          finder.disable_cache do
+            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,75 @@
+# 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.to_s)
+    end
+
+    # Called by content_for
+    def append(key, value)
+      @content[key] << value.to_s
+    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

data/lib/action_view/gem_version.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module ActionView
+  # Returns the currently loaded version of Action View as a +Gem::Version+.
+  def self.gem_version
+    Gem::Version.new VERSION::STRING
+  end
+
+  module VERSION
+    MAJOR = 8
+    MINOR = 0
+    TINY  = 0
+    PRE   = "alpha1"
+
+    STRING = [MAJOR, MINOR, TINY, PRE].compact.join(".")
+  end
+end

data/lib/action_view/helpers/active_model_helper.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+require "active_support/core_ext/module/attribute_accessors"
+require "active_support/core_ext/enumerable"
+
+module ActionView
+  module Helpers # :nodoc:
+    module ActiveModelHelper
+    end
+
+    # = Active \Model Instance Tag \Helpers
+    module ActiveModelInstanceTag
+      def object
+        @active_model_object ||= begin
+          object = super
+          object.respond_to?(:to_model) ? object.to_model : object
+        end
+      end
+
+      def content_tag(type, options, *)
+        select_markup_helper?(type) ? super : error_wrapping(super)
+      end
+
+      def tag(type, options, *)
+        tag_generate_errors?(options) ? error_wrapping(super) : super
+      end
+
+      def error_wrapping(html_tag)
+        if object_has_errors?
+          @template_object.instance_exec(html_tag, self, &Base.field_error_proc)
+        else
+          html_tag
+        end
+      end
+
+      def error_message
+        object.errors[@method_name]
+      end
+
+      private
+        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
+    end
+  end
+end