actionview 4.1.13 → 6.1.3.1

data/lib/action_view/template/sources/file.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module ActionView
+  class Template
+    module Sources
+      class File
+        def initialize(filename)
+          @filename = filename
+        end
+
+        def to_s
+          ::File.binread @filename
+        end
+      end
+    end
+  end
+end

data/lib/action_view/template/sources.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module ActionView
+  class Template
+    module Sources
+      extend ActiveSupport::Autoload
+
+      eager_autoload do
+        autoload :File
+      end
+    end
+  end
+end

data/lib/action_view/template/text.rb

@@ -1,22 +1,20 @@
+# frozen_string_literal: true
+
 module ActionView #:nodoc:
   # = Action View Text Template
-  class Template
+  class Template #:nodoc:
     class Text #:nodoc:
       attr_accessor :type
 
-      def initialize(string, type = nil)
+      def initialize(string)
         @string = string.to_s
-        @type   = Types[type] || type if type
-        @type ||= Types[:text]
       end
 
       def identifier
-        'text template'
+        "text template"
       end
 
-      def inspect
-        'text template'
-      end
+      alias_method :inspect, :identifier
 
       def to_str
         @string
@@ -26,8 +24,8 @@ module ActionView #:nodoc:
         to_str
       end
 
-      def formats
-        [@type.respond_to?(:ref) ? @type.ref : @type.to_s]
+      def format
+        :text
       end
     end
   end

data/lib/action_view/template/types.rb

@@ -1,23 +1,17 @@
-require 'set'
-require 'active_support/core_ext/module/attribute_accessors'
+# frozen_string_literal: true
+
+require "active_support/core_ext/module/attribute_accessors"
 
 module ActionView
-  class Template
+  class Template #:nodoc:
     class Types
       class Type
-        cattr_accessor :types
-        self.types = Set.new
-
-        def self.register(*t)
-          types.merge(t.map { |type| type.to_s })
-        end
-
-        register :html, :text, :js, :css,  :xml, :json
+        SET = Struct.new(:symbols).new([ :html, :text, :js, :css, :xml, :json ])
 
         def self.[](type)
-          return type if type.is_a?(self)
-
-          if type.is_a?(Symbol) || types.member?(type.to_s)
+          if type.is_a?(self)
+            type
+          else
             new(type)
           end
         end
@@ -28,16 +22,18 @@ module ActionView
           @symbol = symbol.to_sym
         end
 
-        delegate :to_s, :to_sym, :to => :symbol
+        def to_s
+          @symbol.to_s
+        end
         alias to_str to_s
 
         def ref
-          to_sym || to_s
+          @symbol
         end
+        alias to_sym ref
 
         def ==(type)
-          return false if type.blank?
-          symbol.to_sym == type.to_sym
+          @symbol == type.to_sym unless type.blank?
         end
       end
 
@@ -52,6 +48,10 @@ module ActionView
       def self.[](type)
         type_klass[type]
       end
+
+      def self.symbols
+        type_klass::SET.symbols
+      end
     end
   end
 end

data/lib/action_view/template.rb

@@ -1,6 +1,7 @@
-require 'active_support/core_ext/object/try'
-require 'active_support/core_ext/kernel/singleton_class'
-require 'thread'
+# frozen_string_literal: true
+
+require "thread"
+require "delegate"
 
 module ActionView
   # = Action View Template
@@ -65,8 +66,7 @@ module ActionView
     # If you want to provide an alternate mechanism for
     # specifying encodings (like ERB does via <%# encoding: ... %>),
     # you may indicate that you will handle encodings yourself
-    # by implementing <tt>self.handles_encoding?</tt>
-    # on your handler.
+    # by implementing <tt>handles_encoding?</tt> on your handler.
     #
     # If you do, Rails will not try to encode the String
     # into the default_internal, passing you the unaltered
@@ -87,48 +87,57 @@ module ActionView
     #       expected_encoding
     #     )
 
+    ##
+    # :method: local_assigns
+    #
+    # Returns a hash with the defined local variables.
+    #
+    # Given this sub template rendering:
+    #
+    #   <%= render "shared/header", { headline: "Welcome", person: person } %>
+    #
+    # You can use +local_assigns+ in the sub templates to access the local variables:
+    #
+    #   local_assigns[:headline] # => "Welcome"
+
     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|
-      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
 
-    # Returns if the underlying handler supports streaming. If so,
-    # a streaming buffer *may* be passed when it start rendering.
+    # Returns whether the underlying handler supports streaming. If so,
+    # a streaming buffer *may* be passed when it starts rendering.
     def supports_streaming?
       handler.respond_to?(:supports_streaming?) && handler.supports_streaming?
     end
@@ -139,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)
-      instrument("!render_template") do
+    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}/", '') : 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
@@ -186,12 +184,14 @@ 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
       # default external encoding.
-      if source.sub!(/\A#{ENCODING_FLAG}/, '')
+      if source.sub!(/\A#{ENCODING_FLAG}/, "")
         encoding = magic_encoding = $1
       else
         encoding = Encoding.default_external
@@ -219,11 +219,23 @@ module ActionView
       end
     end
 
-    protected
 
+    # 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) #:nodoc:
+      def compile!(view)
         return if @compiled
 
         # Templates can be used concurrently in threaded environments
@@ -235,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(view, mod)
+            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
@@ -264,18 +269,16 @@ module ActionView
       # encode the source into <tt>Encoding.default_internal</tt>.
       # In general, this means that templates will be UTF-8 inside of Rails,
       # regardless of the original source encoding.
-      def compile(view, mod) #:nodoc:
-        encode!
-        method_name = self.method_name
-        code = @handler.call(self)
+      def compile(mod)
+        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
+        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
 
@@ -290,53 +293,60 @@ 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
 
         begin
           mod.module_eval(source, identifier, 0)
-          ObjectSpace.define_finalizer(self, Finalizer[method_name, mod])
-        rescue => e # errors from template code
-          if logger = (view && view.logger)
-            logger.debug "ERROR: compiling #{method_name} RAISED #{e}"
-            logger.debug "Function body: #{source}"
-            logger.debug "Backtrace: #{e.backtrace.join("\n")}"
-          end
-
-          raise ActionView::Template::Error.new(self, e)
+        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) #:nodoc:
+      def handle_render_error(view, e)
         if e.is_a?(Template::Error)
           e.sub_template_of(self)
           raise e
         else
-          template = self
-          unless template.source
-            template = refresh(view)
-            template.encode!
-          end
-          raise Template::Error.new(template, e)
+          raise Template::Error.new(self)
+        end
+      end
+
+      def locals_code
+        # Only locals with valid variable names get set directly. Others will
+        # still be available in local_assigns.
+        locals = @locals - Module::RUBY_RESERVED_KEYWORDS
+        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(+"") { |key, code| code << "#{key} = local_assigns[:#{key}]; #{key} = #{key};" }
+      end
+
+      def method_name
+        @method_name ||= begin
+          m = +"_#{identifier_method_name}__#{@identifier.hash}_#{__id__}"
+          m.tr!("-", "_")
+          m
         end
       end
 
-      def locals_code #:nodoc:
-        # Double assign to suppress the dreaded 'assigned but unused variable' warning
-        @locals.map { |key| "#{key} = #{key} = local_assigns[:#{key}];" }.join
+      def identifier_method_name
+        short_identifier.tr("^a-z_", "_")
       end
 
-      def method_name #:nodoc:
-        @method_name ||= "_#{identifier_method_name}__#{@identifier.hash}_#{__id__}".gsub('-', "_")
+      def instrument(action, &block) # :doc:
+        ActiveSupport::Notifications.instrument("#{action}.action_view", instrument_payload, &block)
       end
 
-      def identifier_method_name #:nodoc:
-        inspect.gsub(/[^a-z_]/, '_')
+      def instrument_render_template(&block)
+        ActiveSupport::Notifications.instrument("!render_template.action_view", instrument_payload, &block)
       end
 
-      def instrument(action, &block)
-        payload = { virtual_path: @virtual_path, identifier: @identifier }
-        ActiveSupport::Notifications.instrument("#{action}.action_view", payload, &block)
+      def instrument_payload
+        { virtual_path: @virtual_path, identifier: @identifier }
       end
   end
 end