actionview 5.2.7.1 → 6.1.4.6

data/lib/action_view/template.rb

@@ -1,8 +1,7 @@
 # frozen_string_literal: true
 
-require "active_support/core_ext/object/try"
-require "active_support/core_ext/kernel/singleton_class"
 require "thread"
+require "delegate"
 
 module ActionView
   # = Action View Template
@@ -103,41 +102,37 @@ module ActionView
 
     eager_autoload do
       autoload :Error
+      autoload :RawFile
+      autoload :Renderable
       autoload :Handlers
       autoload :HTML
+      autoload :Inline
+      autoload :Sources
       autoload :Text
       autoload :Types
     end
 
     extend Template::Handlers
 
-    attr_accessor :locals, :formats, :variants, :virtual_path
-
-    attr_reader :source, :identifier, :handler, :original_encoding, :updated_at
-
-    # This finalizer is needed (and exactly with a proc inside another proc)
-    # otherwise templates leak in development.
-    Finalizer = proc do |method_name, mod| # :nodoc:
-      proc do
-        mod.module_eval do
-          remove_possible_method method_name
-        end
-      end
-    end
-
-    def initialize(source, identifier, handler, details)
-      format = details[:format] || (handler.default_format if handler.respond_to?(:default_format))
+    attr_reader :identifier, :handler
+    attr_reader :variable, :format, :variant, :locals, :virtual_path
 
+    def initialize(source, identifier, handler, locals:, format: nil, variant: nil, virtual_path: nil)
       @source            = source
       @identifier        = identifier
       @handler           = handler
       @compiled          = false
-      @original_encoding = nil
-      @locals            = details[:locals] || []
-      @virtual_path      = details[:virtual_path]
-      @updated_at        = details[:updated_at] || Time.now
-      @formats           = Array(format).map { |f| f.respond_to?(:ref) ? f.ref : f  }
-      @variants          = [details[:variant]]
+      @locals            = locals
+      @virtual_path      = virtual_path
+
+      @variable = if @virtual_path
+        base = @virtual_path.end_with?("/") ? "" : ::File.basename(@virtual_path)
+        base =~ /\A_?(.*?)(?:\.\w+)*\z/
+        $1.to_sym
+      end
+
+      @format            = format
+      @variant           = variant
       @compile_mutex     = Mutex.new
     end
 
@@ -153,40 +148,29 @@ module ActionView
     # This method is instrumented as "!render_template.action_view". Notice that
     # we use a bang in this instrumentation because you don't want to
     # consume this in production. This is only slow if it's being listened to.
-    def render(view, locals, buffer = nil, &block)
+    def render(view, locals, buffer = ActionView::OutputBuffer.new, add_to_stack: true, &block)
       instrument_render_template do
         compile!(view)
-        view.send(method_name, locals, buffer, &block)
+        view._run(method_name, self, locals, buffer, add_to_stack: add_to_stack, &block)
       end
     rescue => e
       handle_render_error(view, e)
     end
 
     def type
-      @type ||= Types[@formats.first] if @formats.first
+      @type ||= Types[format]
     end
 
-    # Receives a view object and return a template similar to self by using @virtual_path.
-    #
-    # This method is useful if you have a template object but it does not contain its source
-    # anymore since it was already compiled. In such cases, all you need to do is to call
-    # refresh passing in the view object.
-    #
-    # Notice this method raises an error if the template to be refreshed does not have a
-    # virtual path set (true just for inline templates).
-    def refresh(view)
-      raise "A template needs to have a virtual path in order to be refreshed" unless @virtual_path
-      lookup  = view.lookup_context
-      pieces  = @virtual_path.split("/")
-      name    = pieces.pop
-      partial = !!name.sub!(/^_/, "")
-      lookup.disable_cache do
-        lookup.find_template(name, [ pieces.join("/") ], partial, @locals)
-      end
+    def short_identifier
+      @short_identifier ||= defined?(Rails.root) ? identifier.delete_prefix("#{Rails.root}/") : identifier
     end
 
     def inspect
-      @inspect ||= defined?(Rails.root) ? identifier.sub("#{Rails.root}/", "".freeze) : identifier
+      "#<#{self.class.name} #{short_identifier} locals=#{@locals.inspect}>"
+    end
+
+    def source
+      @source.to_s
     end
 
     # This method is responsible for properly setting the encoding of the
@@ -200,7 +184,9 @@ module ActionView
     # before passing the source on to the template engine, leaving a
     # blank line in its stead.
     def encode!
-      return unless source.encoding == Encoding::BINARY
+      source = self.source
+
+      return source unless source.encoding == Encoding::BINARY
 
       # Look for # encoding: *. If we find one, we'll encode the
       # String in that encoding, otherwise, we'll use the
@@ -233,8 +219,20 @@ module ActionView
       end
     end
 
-    private
 
+    # Exceptions are marshalled when using the parallel test runner with DRb, so we need
+    # to ensure that references to the template object can be marshalled as well. This means forgoing
+    # the marshalling of the compiler mutex and instantiating that again on unmarshalling.
+    def marshal_dump # :nodoc:
+      [ @source, @identifier, @handler, @compiled, @locals, @virtual_path, @format, @variant ]
+    end
+
+    def marshal_load(array) # :nodoc:
+      @source, @identifier, @handler, @compiled, @locals, @virtual_path, @format, @variant = *array
+      @compile_mutex = Mutex.new
+    end
+
+    private
       # Compile a template. This method ensures a template is compiled
       # just once and removes the source after it is compiled.
       def compile!(view)
@@ -249,19 +247,12 @@ module ActionView
           # re-compilation
           return if @compiled
 
-          if view.is_a?(ActionView::CompiledTemplates)
-            mod = ActionView::CompiledTemplates
-          else
-            mod = view.singleton_class
-          end
+          mod = view.compiled_method_container
 
           instrument("!compile_template") do
             compile(mod)
           end
 
-          # Just discard the source if we have a virtual path. This
-          # means we can get the template back.
-          @source = nil if @virtual_path
           @compiled = true
         end
       end
@@ -279,16 +270,15 @@ module ActionView
       # In general, this means that templates will be UTF-8 inside of Rails,
       # regardless of the original source encoding.
       def compile(mod)
-        encode!
-        code = @handler.call(self)
+        source = encode!
+        code = @handler.call(self, source)
 
         # Make sure that the resulting String to be eval'd is in the
         # encoding of the code
-        source = <<-end_src.dup
+        original_source = source
+        source = +<<-end_src
           def #{method_name}(local_assigns, output_buffer)
-            _old_virtual_path, @virtual_path = @virtual_path, #{@virtual_path.inspect};_old_output_buffer = @output_buffer;#{locals_code};#{code}
-          ensure
-            @virtual_path, @output_buffer = _old_virtual_path, _old_output_buffer
+            @virtual_path = #{@virtual_path.inspect};#{locals_code};#{code}
           end
         end_src
 
@@ -303,11 +293,17 @@ module ActionView
         # handler is valid in the default_internal. This is for handlers
         # that handle encoding but screw up
         unless source.valid_encoding?
-          raise WrongEncodingError.new(@source, Encoding.default_internal)
+          raise WrongEncodingError.new(source, Encoding.default_internal)
         end
 
-        mod.module_eval(source, identifier, 0)
-        ObjectSpace.define_finalizer(self, Finalizer[method_name, mod])
+        begin
+          mod.module_eval(source, identifier, 0)
+        rescue SyntaxError
+          # Account for when code in the template is not syntactically valid; e.g. if we're using
+          # ERB and the user writes <%= foo( %>, attempting to call a helper `foo` and interpolate
+          # the result into the template, but missing an end parenthesis.
+          raise SyntaxErrorInTemplate.new(self, original_source)
+        end
       end
 
       def handle_render_error(view, e)
@@ -315,12 +311,7 @@ module ActionView
           e.sub_template_of(self)
           raise e
         else
-          template = self
-          unless template.source
-            template = refresh(view)
-            template.encode!
-          end
-          raise Template::Error.new(template)
+          raise Template::Error.new(self)
         end
       end
 
@@ -331,19 +322,19 @@ module ActionView
         locals = locals.grep(/\A@?(?![A-Z0-9])(?:[[:alnum:]_]|[^\0-\177])+\z/)
 
         # Assign for the same variable is to suppress unused variable warning
-        locals.each_with_object("".dup) { |key, code| code << "#{key} = local_assigns[:#{key}]; #{key} = #{key};" }
+        locals.each_with_object(+"") { |key, code| code << "#{key} = local_assigns[:#{key}]; #{key} = #{key};" }
       end
 
       def method_name
         @method_name ||= begin
-          m = "_#{identifier_method_name}__#{@identifier.hash}_#{__id__}".dup
-          m.tr!("-".freeze, "_".freeze)
+          m = +"_#{identifier_method_name}__#{@identifier.hash}_#{__id__}"
+          m.tr!("-", "_")
           m
         end
       end
 
       def identifier_method_name
-        inspect.tr("^a-z_".freeze, "_".freeze)
+        short_identifier.tr("^a-z_", "_")
       end
 
       def instrument(action, &block) # :doc:
@@ -351,7 +342,7 @@ module ActionView
       end
 
       def instrument_render_template(&block)
-        ActiveSupport::Notifications.instrument("!render_template.action_view".freeze, instrument_payload, &block)
+        ActiveSupport::Notifications.instrument("!render_template.action_view", instrument_payload, &block)
       end
 
       def instrument_payload

data/lib/action_view/test_case.rb

@@ -16,11 +16,12 @@ module ActionView
       attr_accessor :request, :response, :params
 
       class << self
-        attr_writer :controller_path
+        # Overrides AbstractController::Base#controller_path
+        attr_accessor :controller_path
       end
 
       def controller_path=(path)
-        self.class.controller_path = (path)
+        self.class.controller_path = path
       end
 
       def initialize
@@ -73,10 +74,11 @@ module ActionView
         def helper_method(*methods)
           # Almost a duplicate from ActionController::Helpers
           methods.flatten.each do |method|
-            _helpers.module_eval <<-end_eval, __FILE__, __LINE__ + 1
+            _helpers_for_modification.module_eval <<-end_eval, __FILE__, __LINE__ + 1
               def #{method}(*args, &block)                    # def current_user(*args, &block)
-                _test_case.send(%(#{method}), *args, &block)  #   _test_case.send(%(current_user), *args, &block)
+                _test_case.send(:'#{method}', *args, &block)  #   _test_case.send(:'current_user', *args, &block)
               end                                             # end
+              ruby2_keywords(:'#{method}') if respond_to?(:ruby2_keywords, true)
             end_eval
           end
         end
@@ -93,7 +95,6 @@ module ActionView
         end
 
       private
-
         def include_helper_modules!
           helper(helper_class) if helper_class
           include _helpers
@@ -101,16 +102,17 @@ module ActionView
       end
 
       def setup_with_controller
-        @controller = ActionView::TestCase::TestController.new
+        controller_class = Class.new(ActionView::TestCase::TestController)
+        @controller = controller_class.new
         @request = @controller.request
         @view_flow = ActionView::OutputFlow.new
         # empty string ensures buffer has UTF-8 encoding as
         # new without arguments returns ASCII-8BIT encoded buffer like String#new
         @output_buffer = ActiveSupport::SafeBuffer.new ""
-        @rendered = "".dup
+        @rendered = +""
 
-        make_test_case_available_to_view!
-        say_no_to_protect_against_forgery!
+        test_case_instance = self
+        controller_class.define_method(:_test_case) { test_case_instance }
       end
 
       def config
@@ -160,34 +162,24 @@ module ActionView
       included do
         setup :setup_with_controller
         ActiveSupport.run_load_hooks(:action_view_test_case, self)
-      end
-
-    private
-
-      # Need to experiment if this priority is the best one: rendered => output_buffer
-      def document_root_element
-        Nokogiri::HTML::Document.parse(@rendered.blank? ? @output_buffer : @rendered).root
-      end
 
-      def say_no_to_protect_against_forgery!
-        _helpers.module_eval do
-          silence_redefinition_of_method :protect_against_forgery?
+        helper do
           def protect_against_forgery?
             false
           end
-        end
-      end
 
-      def make_test_case_available_to_view!
-        test_case_instance = self
-        _helpers.module_eval do
-          unless private_method_defined?(:_test_case)
-            define_method(:_test_case) { test_case_instance }
-            private :_test_case
+          def _test_case
+            controller._test_case
           end
         end
       end
 
+    private
+      # Need to experiment if this priority is the best one: rendered => output_buffer
+      def document_root_element
+        Nokogiri::HTML::Document.parse(@rendered.blank? ? @output_buffer : @rendered).root
+      end
+
       module Locals
         attr_accessor :rendered_views
 
@@ -284,7 +276,7 @@ module ActionView
 
       def respond_to_missing?(name, include_private = false)
         begin
-          routes = @controller.respond_to?(:_routes) && @controller._routes
+          routes = defined?(@controller) && @controller.respond_to?(:_routes) && @controller._routes
         rescue
           # Don't call routes, if there is an error on _routes call
         end

data/lib/action_view/testing/resolvers.rb

@@ -7,12 +7,15 @@ module ActionView #:nodoc:
   # file system. This is used internally by Rails' own test suite, and is
   # useful for testing extensions that have no way of knowing what the file
   # system will look like at runtime.
-  class FixtureResolver < PathResolver
-    attr_reader :hash
-
-    def initialize(hash = {}, pattern = nil)
-      super(pattern)
+  class FixtureResolver < OptimizedFileSystemResolver
+    def initialize(hash = {})
+      super("")
       @hash = hash
+      @path = ""
+    end
+
+    def data
+      @hash
     end
 
     def to_s
@@ -20,35 +23,23 @@ module ActionView #:nodoc:
     end
 
     private
-
-      def query(path, exts, _, _)
-        query = "".dup
-        EXTENSIONS.each_key do |ext|
-          query << "(" << exts[ext].map { |e| e && Regexp.escape(".#{e}") }.join("|") << "|)"
-        end
-        query = /^(#{Regexp.escape(path)})#{query}$/
-
-        templates = []
-        @hash.each do |_path, array|
-          source, updated_at = array
-          next unless query.match?(_path)
-          handler, format, variant = extract_handler_and_format_and_variant(_path)
-          templates << Template.new(source, _path, handler,
-            virtual_path: path.virtual,
-            format: format,
-            variant: variant,
-            updated_at: updated_at
-          )
+      def find_candidate_template_paths(path)
+        @hash.keys.select do |fixture|
+          fixture.start_with?(path.virtual)
+        end.map do |fixture|
+          "/#{fixture}"
         end
+      end
 
-        templates.sort_by { |t| -t.identifier.match(/^#{query}$/).captures.reject(&:blank?).size }
+      def source_for_template(template)
+        @hash[template[1..template.size]]
       end
   end
 
   class NullResolver < PathResolver
-    def query(path, exts, _, _)
+    def query(path, exts, _, locals, cache:)
       handler, format, variant = extract_handler_and_format_and_variant(path)
-      [ActionView::Template.new("Template generated by Null Resolver", path.virtual, handler, virtual_path: path.virtual, format: format, variant: variant)]
+      [ActionView::Template.new("Template generated by Null Resolver", path.virtual, handler, virtual_path: path.virtual, format: format, variant: variant, locals: locals)]
     end
   end
 end

data/lib/action_view/unbound_template.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+require "concurrent/map"
+
+module ActionView
+  class UnboundTemplate
+    def initialize(source, identifier, handler, options)
+      @source = source
+      @identifier = identifier
+      @handler = handler
+      @options = options
+
+      @templates = Concurrent::Map.new(initial_capacity: 2)
+    end
+
+    def bind_locals(locals)
+      @templates[locals] ||= build_template(locals)
+    end
+
+    private
+      def build_template(locals)
+        options = @options.merge(locals: locals)
+        Template.new(
+          @source,
+          @identifier,
+          @handler,
+          **options
+        )
+      end
+  end
+end

data/lib/action_view/view_paths.rb

@@ -5,13 +5,21 @@ module ActionView
     extend ActiveSupport::Concern
 
     included do
-      class_attribute :_view_paths, default: ActionView::PathSet.new.freeze
+      ViewPaths.set_view_paths(self, ActionView::PathSet.new.freeze)
     end
 
     delegate :template_exists?, :any_templates?, :view_paths, :formats, :formats=,
              :locale, :locale=, to: :lookup_context
 
     module ClassMethods
+      def _view_paths
+        ViewPaths.get_view_paths(self)
+      end
+
+      def _view_paths=(paths)
+        ViewPaths.set_view_paths(self, paths)
+      end
+
       def _prefixes # :nodoc:
         @_prefixes ||= begin
           return local_prefixes if superclass.abstract?
@@ -20,8 +28,41 @@ module ActionView
         end
       end
 
-      private
+      # Append a path to the list of view paths for this controller.
+      #
+      # ==== Parameters
+      # * <tt>path</tt> - If a String is provided, it gets converted into
+      #   the default view path. You may also provide a custom view path
+      #   (see ActionView::PathSet for more information)
+      def append_view_path(path)
+        self._view_paths = view_paths + Array(path)
+      end
 
+      # Prepend a path to the list of view paths for this controller.
+      #
+      # ==== Parameters
+      # * <tt>path</tt> - If a String is provided, it gets converted into
+      #   the default view path. You may also provide a custom view path
+      #   (see ActionView::PathSet for more information)
+      def prepend_view_path(path)
+        self._view_paths = ActionView::PathSet.new(Array(path) + view_paths)
+      end
+
+      # A list of all of the default view paths for this controller.
+      def view_paths
+        _view_paths
+      end
+
+      # Set the view paths.
+      #
+      # ==== Parameters
+      # * <tt>paths</tt> - If a PathSet is provided, use that;
+      #   otherwise, process the parameter into a PathSet.
+      def view_paths=(paths)
+        self._view_paths = ActionView::PathSet.new(Array(paths))
+      end
+
+      private
         # Override this method in your controller if you want to change paths prefixes for finding views.
         # Prefixes defined here will still be added to parents' <tt>._prefixes</tt>.
         def local_prefixes
@@ -29,6 +70,22 @@ module ActionView
         end
     end
 
+    # :stopdoc:
+    @all_view_paths = {}
+
+    def self.get_view_paths(klass)
+      @all_view_paths[klass] || get_view_paths(klass.superclass)
+    end
+
+    def self.set_view_paths(klass, paths)
+      @all_view_paths[klass] = paths
+    end
+
+    def self.all_view_paths
+      @all_view_paths.values.uniq
+    end
+    # :startdoc:
+
     # The prefixes used in render "foo" shortcuts.
     def _prefixes # :nodoc:
       self.class._prefixes
@@ -65,41 +122,5 @@ module ActionView
     def prepend_view_path(path)
       lookup_context.view_paths.unshift(*path)
     end
-
-    module ClassMethods
-      # Append a path to the list of view paths for this controller.
-      #
-      # ==== Parameters
-      # * <tt>path</tt> - If a String is provided, it gets converted into
-      #   the default view path. You may also provide a custom view path
-      #   (see ActionView::PathSet for more information)
-      def append_view_path(path)
-        self._view_paths = view_paths + Array(path)
-      end
-
-      # Prepend a path to the list of view paths for this controller.
-      #
-      # ==== Parameters
-      # * <tt>path</tt> - If a String is provided, it gets converted into
-      #   the default view path. You may also provide a custom view path
-      #   (see ActionView::PathSet for more information)
-      def prepend_view_path(path)
-        self._view_paths = ActionView::PathSet.new(Array(path) + view_paths)
-      end
-
-      # A list of all of the default view paths for this controller.
-      def view_paths
-        _view_paths
-      end
-
-      # Set the view paths.
-      #
-      # ==== Parameters
-      # * <tt>paths</tt> - If a PathSet is provided, use that;
-      #   otherwise, process the parameter into a PathSet.
-      def view_paths=(paths)
-        self._view_paths = ActionView::PathSet.new(Array(paths))
-      end
-    end
   end
 end

data/lib/action_view.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 #--
-# Copyright (c) 2004-2018 David Heinemeier Hansson
+# Copyright (c) 2004-2020 David Heinemeier Hansson
 #
 # Permission is hereby granted, free of charge, to any person obtaining
 # a copy of this software and associated documentation files (the
@@ -35,7 +35,6 @@ module ActionView
   eager_autoload do
     autoload :Base
     autoload :Context
-    autoload :CompiledTemplates, "action_view/context"
     autoload :Digestor
     autoload :Helpers
     autoload :LookupContext
@@ -45,12 +44,15 @@ module ActionView
     autoload :Rendering
     autoload :RoutingUrlFor
     autoload :Template
+    autoload :UnboundTemplate
     autoload :ViewPaths
 
     autoload_under "renderer" do
       autoload :Renderer
       autoload :AbstractRenderer
       autoload :PartialRenderer
+      autoload :CollectionRenderer
+      autoload :ObjectRenderer
       autoload :TemplateRenderer
       autoload :StreamingTemplateRenderer
     end
@@ -58,6 +60,7 @@ module ActionView
     autoload_at "action_view/template/resolver" do
       autoload :Resolver
       autoload :PathResolver
+      autoload :FileSystemResolver
       autoload :OptimizedFileSystemResolver
       autoload :FallbackFileSystemResolver
     end
@@ -77,10 +80,12 @@ module ActionView
       autoload :ActionViewError
       autoload :EncodingError
       autoload :TemplateError
+      autoload :SyntaxErrorInTemplate
       autoload :WrongEncodingError
     end
   end
 
+  autoload :CacheExpiry
   autoload :TestCase
 
   def self.eager_load!