actionview 5.0.7.2 → 5.1.7

data/lib/action_view/template/handlers/erb.rb

@@ -1,87 +1,20 @@
-require 'erubis'
-
 module ActionView
   class Template
     module Handlers
-      class Erubis < ::Erubis::Eruby
-        def add_preamble(src)
-          @newline_pending = 0
-          src << "@output_buffer = output_buffer || ActionView::OutputBuffer.new;"
-        end
-
-        def add_text(src, text)
-          return if text.empty?
-
-          if text == "\n"
-            @newline_pending += 1
-          else
-            src << "@output_buffer.safe_append='"
-            src << "\n" * @newline_pending if @newline_pending > 0
-            src << escape_text(text)
-            src << "'.freeze;"
-
-            @newline_pending = 0
-          end
-        end
-
-        # Erubis toggles <%= and <%== behavior when escaping is enabled.
-        # We override to always treat <%== as escaped.
-        def add_expr(src, code, indicator)
-          case indicator
-          when '=='
-            add_expr_escaped(src, code)
-          else
-            super
-          end
-        end
-
-        BLOCK_EXPR = /\s*((\s+|\))do|\{)(\s*\|[^|]*\|)?\s*\Z/
-
-        def add_expr_literal(src, code)
-          flush_newline_if_pending(src)
-          if code =~ BLOCK_EXPR
-            src << '@output_buffer.append= ' << code
-          else
-            src << '@output_buffer.append=(' << code << ');'
-          end
-        end
-
-        def add_expr_escaped(src, code)
-          flush_newline_if_pending(src)
-          if code =~ BLOCK_EXPR
-            src << "@output_buffer.safe_expr_append= " << code
-          else
-            src << "@output_buffer.safe_expr_append=(" << code << ");"
-          end
-        end
-
-        def add_stmt(src, code)
-          flush_newline_if_pending(src)
-          super
-        end
-
-        def add_postamble(src)
-          flush_newline_if_pending(src)
-          src << '@output_buffer.to_s'
-        end
-
-        def flush_newline_if_pending(src)
-          if @newline_pending > 0
-            src << "@output_buffer.safe_append='#{"\n" * @newline_pending}'.freeze;"
-            @newline_pending = 0
-          end
-        end
-      end
+      autoload :Erubis, "action_view/template/handlers/erb/deprecated_erubis"
 
       class ERB
+        autoload :Erubi, "action_view/template/handlers/erb/erubi"
+        autoload :Erubis, "action_view/template/handlers/erb/erubis"
+
         # Specify trim mode for the ERB compiler. Defaults to '-'.
         # See ERB documentation for suitable values.
         class_attribute :erb_trim_mode
-        self.erb_trim_mode = '-'
+        self.erb_trim_mode = "-"
 
         # Default implementation used.
         class_attribute :erb_implementation
-        self.erb_implementation = Erubis
+        self.erb_implementation = Erubi
 
         # Do not escape templates of these mime types.
         class_attribute :escape_whitelist
@@ -108,7 +41,7 @@ module ActionView
           # expression
           template_source = template.source.dup.force_encoding(Encoding::ASCII_8BIT)
 
-          erb = template_source.gsub(ENCODING_TAG, '')
+          erb = template_source.gsub(ENCODING_TAG, "")
           encoding = $2
 
           erb.force_encoding valid_encoding(template.source.dup, encoding)
@@ -118,8 +51,8 @@ module ActionView
 
           self.class.erb_implementation.new(
             erb,
-            :escape => (self.class.escape_whitelist.include? template.type),
-            :trim => (self.class.erb_trim_mode == "-")
+            escape: (self.class.escape_whitelist.include? template.type),
+            trim: (self.class.erb_trim_mode == "-")
           ).src
         end
 

data/lib/action_view/template/handlers.rb

@@ -2,10 +2,10 @@ module ActionView #:nodoc:
   # = Action View Template Handlers
   class Template
     module Handlers #:nodoc:
-      autoload :Raw, 'action_view/template/handlers/raw'
-      autoload :ERB, 'action_view/template/handlers/erb'
-      autoload :Html, 'action_view/template/handlers/html'
-      autoload :Builder, 'action_view/template/handlers/builder'
+      autoload :Raw, "action_view/template/handlers/raw"
+      autoload :ERB, "action_view/template/handlers/erb"
+      autoload :Html, "action_view/template/handlers/html"
+      autoload :Builder, "action_view/template/handlers/builder"
 
       def self.extended(base)
         base.register_default_template_handler :raw, Raw.new

data/lib/action_view/template/html.rb

@@ -11,12 +11,10 @@ module ActionView #:nodoc:
       end
 
       def identifier
-        'html template'
+        "html template"
       end
 
-      def inspect
-        'html template'
-      end
+      alias_method :inspect, :identifier
 
       def to_str
         ERB::Util.h(@string)

data/lib/action_view/template/resolver.rb

@@ -37,15 +37,15 @@ module ActionView
     class Cache #:nodoc:
       class SmallCache < Concurrent::Map
         def initialize(options = {})
-          super(options.merge(:initial_capacity => 2))
+          super(options.merge(initial_capacity: 2))
         end
       end
 
       # preallocate all the default blocks for performance/memory consumption reasons
-      PARTIAL_BLOCK = lambda {|cache, partial| cache[partial] = SmallCache.new}
-      PREFIX_BLOCK  = lambda {|cache, prefix|  cache[prefix]  = SmallCache.new(&PARTIAL_BLOCK)}
-      NAME_BLOCK    = lambda {|cache, name|    cache[name]    = SmallCache.new(&PREFIX_BLOCK)}
-      KEY_BLOCK     = lambda {|cache, key|     cache[key]     = SmallCache.new(&NAME_BLOCK)}
+      PARTIAL_BLOCK = lambda { |cache, partial| cache[partial] = SmallCache.new }
+      PREFIX_BLOCK  = lambda { |cache, prefix|  cache[prefix]  = SmallCache.new(&PARTIAL_BLOCK) }
+      NAME_BLOCK    = lambda { |cache, name|    cache[name]    = SmallCache.new(&PREFIX_BLOCK) }
+      KEY_BLOCK     = lambda { |cache, key|     cache[key]     = SmallCache.new(&NAME_BLOCK) }
 
       # usually a majority of template look ups return nothing, use this canonical preallocated array to save memory
       NO_TEMPLATES = [].freeze
@@ -88,24 +88,41 @@ module ActionView
         @query_cache.clear
       end
 
-      private
+      # Get the cache size.  Do not call this
+      # method. This method is not guaranteed to be here ever.
+      def size # :nodoc:
+        size = 0
+        @data.each_value do |v1|
+          v1.each_value do |v2|
+            v2.each_value do |v3|
+              v3.each_value do |v4|
+                size += v4.size
+              end
+            end
+          end
+        end
 
-      def canonical_no_templates(templates)
-        templates.empty? ? NO_TEMPLATES : templates
+        size + @query_cache.size
       end
 
-      def templates_have_changed?(cached_templates, fresh_templates)
-        # if either the old or new template list is empty, we don't need to (and can't)
-        # compare modification times, and instead just check whether the lists are different
-        if cached_templates.blank? || fresh_templates.blank?
-          return fresh_templates.blank? != cached_templates.blank?
+      private
+
+        def canonical_no_templates(templates)
+          templates.empty? ? NO_TEMPLATES : templates
         end
 
-        cached_templates_max_updated_at = cached_templates.map(&:updated_at).max
+        def templates_have_changed?(cached_templates, fresh_templates)
+          # if either the old or new template list is empty, we don't need to (and can't)
+          # compare modification times, and instead just check whether the lists are different
+          if cached_templates.blank? || fresh_templates.blank?
+            return fresh_templates.blank? != cached_templates.blank?
+          end
 
-        # if a template has changed, it will be now be newer than all the cached templates
-        fresh_templates.any? { |t| t.updated_at > cached_templates_max_updated_at }
-      end
+          cached_templates_max_updated_at = cached_templates.map(&:updated_at).max
+
+          # if a template has changed, it will be now be newer than all the cached templates
+          fresh_templates.any? { |t| t.updated_at > cached_templates_max_updated_at }
+        end
     end
 
     cattr_accessor :caching
@@ -124,13 +141,13 @@ module ActionView
     end
 
     # Normalizes the arguments and passes it on to find_templates.
-    def find_all(name, prefix=nil, partial=false, details={}, key=nil, locals=[])
+    def find_all(name, prefix = nil, partial = false, details = {}, key = nil, locals = [])
       cached(key, [name, prefix, partial], details, locals) do
         find_templates(name, prefix, partial, details)
       end
     end
 
-    def find_all_anywhere(name, prefix, partial=false, details={}, key=nil, locals=[])
+    def find_all_anywhere(name, prefix, partial = false, details = {}, key = nil, locals = [])
       cached(key, [name, prefix, partial], details, locals) do
         find_templates(name, prefix, partial, details, true)
       end
@@ -160,7 +177,7 @@ module ActionView
     # always check the cache before hitting the resolver. Otherwise,
     # it always hits the resolver but if the key is present, check if the
     # resolver is fresher before returning it.
-    def cached(key, path_info, details, locals) #:nodoc:
+    def cached(key, path_info, details, locals)
       name, prefix, partial = path_info
       locals = locals.map(&:to_s).sort!
 
@@ -174,7 +191,7 @@ module ActionView
     end
 
     # Ensures all the resolver information is set in the template.
-    def decorate(templates, path_info, details, locals) #:nodoc:
+    def decorate(templates, path_info, details, locals)
       cached = nil
       templates.each do |t|
         t.locals         = locals
@@ -187,103 +204,103 @@ module ActionView
 
   # An abstract class that implements a Resolver with path semantics.
   class PathResolver < Resolver #:nodoc:
-    EXTENSIONS = { :locale => ".", :formats => ".", :variants => "+", :handlers => "." }
+    EXTENSIONS = { locale: ".", formats: ".", variants: "+", handlers: "." }
     DEFAULT_PATTERN = ":prefix/:action{.:locale,}{.:formats,}{+:variants,}{.:handlers,}"
 
-    def initialize(pattern=nil)
+    def initialize(pattern = nil)
       @pattern = pattern || DEFAULT_PATTERN
       super()
     end
 
     private
 
-    def find_templates(name, prefix, partial, details, outside_app_allowed = false)
-      path = Path.build(name, prefix, partial)
-      query(path, details, details[:formats], outside_app_allowed)
-    end
+      def find_templates(name, prefix, partial, details, outside_app_allowed = false)
+        path = Path.build(name, prefix, partial)
+        query(path, details, details[:formats], outside_app_allowed)
+      end
 
-    def query(path, details, formats, outside_app_allowed)
-      query = build_query(path, details)
+      def query(path, details, formats, outside_app_allowed)
+        query = build_query(path, details)
 
-      template_paths = find_template_paths(query)
-      template_paths = reject_files_external_to_app(template_paths) unless outside_app_allowed
+        template_paths = find_template_paths(query)
+        template_paths = reject_files_external_to_app(template_paths) unless outside_app_allowed
 
-      template_paths.map do |template|
-        handler, format, variant = extract_handler_and_format_and_variant(template, formats)
-        contents = File.binread(template)
+        template_paths.map do |template|
+          handler, format, variant = extract_handler_and_format_and_variant(template)
+          contents = File.binread(template)
 
-        Template.new(contents, File.expand_path(template), handler,
-          :virtual_path => path.virtual,
-          :format       => format,
-          :variant      => variant,
-          :updated_at   => mtime(template)
-        )
+          Template.new(contents, File.expand_path(template), handler,
+            virtual_path: path.virtual,
+            format: format,
+            variant: variant,
+            updated_at: mtime(template)
+          )
+        end
       end
-    end
 
-    def reject_files_external_to_app(files)
-      files.reject { |filename| !inside_path?(@path, filename) }
-    end
+      def reject_files_external_to_app(files)
+        files.reject { |filename| !inside_path?(@path, filename) }
+      end
 
-    def find_template_paths(query)
-      Dir[query].uniq.reject do |filename|
-        File.directory?(filename) ||
-          # deals with case-insensitive file systems.
-          !File.fnmatch(query, filename, File::FNM_EXTGLOB)
+      def find_template_paths(query)
+        Dir[query].uniq.reject do |filename|
+          File.directory?(filename) ||
+            # deals with case-insensitive file systems.
+            !File.fnmatch(query, filename, File::FNM_EXTGLOB)
+        end
       end
-    end
 
-    def inside_path?(path, filename)
-      filename = File.expand_path(filename)
-      path = File.join(path, '')
-      filename.start_with?(path)
-    end
+      def inside_path?(path, filename)
+        filename = File.expand_path(filename)
+        path = File.join(path, "")
+        filename.start_with?(path)
+      end
 
-    # Helper for building query glob string based on resolver's pattern.
-    def build_query(path, details)
-      query = @pattern.dup
+      # Helper for building query glob string based on resolver's pattern.
+      def build_query(path, details)
+        query = @pattern.dup
 
-      prefix = path.prefix.empty? ? '' : "#{escape_entry(path.prefix)}\\1"
-      query.gsub!(/:prefix(\/)?/, prefix)
+        prefix = path.prefix.empty? ? "" : "#{escape_entry(path.prefix)}\\1"
+        query.gsub!(/:prefix(\/)?/, prefix)
 
-      partial = escape_entry(path.partial? ? "_#{path.name}" : path.name)
-      query.gsub!(/:action/, partial)
+        partial = escape_entry(path.partial? ? "_#{path.name}" : path.name)
+        query.gsub!(/:action/, partial)
 
-      details.each do |ext, candidates|
-        if ext == :variants && candidates == :any
-          query.gsub!(/:#{ext}/, "*")
-        else
-          query.gsub!(/:#{ext}/, "{#{candidates.compact.uniq.join(',')}}")
+        details.each do |ext, candidates|
+          if ext == :variants && candidates == :any
+            query.gsub!(/:#{ext}/, "*")
+          else
+            query.gsub!(/:#{ext}/, "{#{candidates.compact.uniq.join(',')}}")
+          end
         end
-      end
 
-      File.expand_path(query, @path)
-    end
+        File.expand_path(query, @path)
+      end
 
-    def escape_entry(entry)
-      entry.gsub(/[*?{}\[\]]/, '\\\\\\&'.freeze)
-    end
+      def escape_entry(entry)
+        entry.gsub(/[*?{}\[\]]/, '\\\\\\&'.freeze)
+      end
 
-    # Returns the file mtime from the filesystem.
-    def mtime(p)
-      File.mtime(p)
-    end
+      # Returns the file mtime from the filesystem.
+      def mtime(p)
+        File.mtime(p)
+      end
 
-    # Extract handler, formats and variant from path. If a format cannot be found neither
-    # from the path, or the handler, we should return the array of formats given
-    # to the resolver.
-    def extract_handler_and_format_and_variant(path, default_formats)
-      pieces = File.basename(path).split('.'.freeze)
-      pieces.shift
+      # Extract handler, formats and variant from path. If a format cannot be found neither
+      # from the path, or the handler, we should return the array of formats given
+      # to the resolver.
+      def extract_handler_and_format_and_variant(path)
+        pieces = File.basename(path).split(".".freeze)
+        pieces.shift
 
-      extension = pieces.pop
+        extension = pieces.pop
 
-      handler = Template.handler_for_extension(extension)
-      format, variant = pieces.last.split(EXTENSIONS[:variants], 2) if pieces.last
-      format  &&= Template::Types[format]
+        handler = Template.handler_for_extension(extension)
+        format, variant = pieces.last.split(EXTENSIONS[:variants], 2) if pieces.last
+        format &&= Template::Types[format]
 
-      [handler, format, variant]
-    end
+        [handler, format, variant]
+      end
   end
 
   # A resolver that loads files from the filesystem. It allows setting your own
@@ -325,7 +342,7 @@ module ActionView
   # * <tt>:handlers</tt> - possible handlers (for example erb, haml, builder...)
   #
   class FileSystemResolver < PathResolver
-    def initialize(path, pattern=nil)
+    def initialize(path, pattern = nil)
       raise ArgumentError, "path already is a Resolver class" if path.is_a?(Resolver)
       super(pattern)
       @path = File.expand_path(path)

data/lib/action_view/template/text.rb

@@ -4,19 +4,16 @@ module ActionView #: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]
+        @type = Types[:text]
       end
 
       def identifier
-        'text template'
+        "text template"
       end
 
-      def inspect
-        'text template'
-      end
+      alias_method :inspect, :identifier
 
       def to_str
         @string
@@ -27,7 +24,7 @@ module ActionView #:nodoc:
       end
 
       def formats
-        [@type.respond_to?(:ref) ? @type.ref : @type.to_s]
+        [@type.ref]
       end
     end
   end

data/lib/action_view/template/types.rb

@@ -1,4 +1,4 @@
-require 'active_support/core_ext/module/attribute_accessors'
+require "active_support/core_ext/module/attribute_accessors"
 
 module ActionView
   class Template

data/lib/action_view/template.rb

@@ -1,6 +1,5 @@
 require "active_support/core_ext/object/try"
 require "active_support/core_ext/kernel/singleton_class"
-require "active_support/core_ext/module/delegation"
 require "thread"
 
 module ActionView
@@ -66,8 +65,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
@@ -142,7 +140,7 @@ module ActionView
     end
 
     # Returns whether the underlying handler supports streaming. If so,
-    # a streaming buffer *may* be passed when it start rendering.
+    # a streaming buffer *may* be passed when it starts rendering.
     def supports_streaming?
       handler.respond_to?(:supports_streaming?) && handler.supports_streaming?
     end
@@ -153,8 +151,8 @@ 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".freeze) do
+    def render(view, locals, buffer = nil, &block)
+      instrument_render_template do
         compile!(view)
         view.send(method_name, locals, buffer, &block)
       end
@@ -181,12 +179,12 @@ module ActionView
       name    = pieces.pop
       partial = !!name.sub!(/^_/, "")
       lookup.disable_cache do
-        lookup.find_template(name, [ pieces.join('/') ], partial, @locals)
+        lookup.find_template(name, [ pieces.join("/") ], partial, @locals)
       end
     end
 
     def inspect
-      @inspect ||= defined?(Rails.root) ? identifier.sub("#{Rails.root}/", ''.freeze) : identifier
+      @inspect ||= defined?(Rails.root) ? identifier.sub("#{Rails.root}/", "".freeze) : identifier
     end
 
     # This method is responsible for properly setting the encoding of the
@@ -205,7 +203,7 @@ module ActionView
       # 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
@@ -233,11 +231,11 @@ module ActionView
       end
     end
 
-    protected
+    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
@@ -278,9 +276,8 @@ 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(mod) #:nodoc:
+      def compile(mod)
         encode!
-        method_name = self.method_name
         code = @handler.call(self)
 
         # Make sure that the resulting String to be eval'd is in the
@@ -311,7 +308,7 @@ module ActionView
         ObjectSpace.define_finalizer(self, Finalizer[method_name, mod])
       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
@@ -325,7 +322,7 @@ module ActionView
         end
       end
 
-      def locals_code #:nodoc:
+      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
@@ -335,26 +332,28 @@ module ActionView
         locals.each_with_object("") { |key, code| code << "#{key} = #{key} = local_assigns[:#{key}];" }
       end
 
-      def method_name #:nodoc:
+      def method_name
         @method_name ||= begin
           m = "_#{identifier_method_name}__#{@identifier.hash}_#{__id__}"
-          m.tr!('-'.freeze, '_'.freeze)
+          m.tr!("-".freeze, "_".freeze)
           m
         end
       end
 
-      def identifier_method_name #:nodoc:
-        inspect.tr('^a-z_'.freeze, '_'.freeze)
+      def identifier_method_name
+        inspect.tr("^a-z_".freeze, "_".freeze)
       end
 
-      def instrument(action, &block)
-        payload = { virtual_path: @virtual_path, identifier: @identifier }
-        case action
-        when "!render_template".freeze
-          ActiveSupport::Notifications.instrument("!render_template.action_view".freeze, payload, &block)
-        else
-          ActiveSupport::Notifications.instrument("#{action}.action_view".freeze, payload, &block)
-        end
+      def instrument(action, &block) # :doc:
+        ActiveSupport::Notifications.instrument("#{action}.action_view", instrument_payload, &block)
+      end
+
+      def instrument_render_template(&block)
+        ActiveSupport::Notifications.instrument("!render_template.action_view".freeze, instrument_payload, &block)
+      end
+
+      def instrument_payload
+        { virtual_path: @virtual_path, identifier: @identifier }
       end
   end
 end