actionview 7.0.4 → 7.1.5.1

data/lib/action_view/rendering.rb

@@ -10,7 +10,8 @@ module ActionView
 
     def initialize(original_config, lookup_context)
       original_config = original_config.original_config if original_config.respond_to?(:original_config)
-      @original_config, @lookup_context = original_config, lookup_context
+      @original_config = original_config
+      @lookup_context = lookup_context
     end
 
     def locale
@@ -48,7 +49,18 @@ module ActionView
       def _helpers
       end
 
+      def inherit_view_context_class?
+        superclass.respond_to?(:view_context_class) &&
+          supports_path? == superclass.supports_path? &&
+          _routes.equal?(superclass._routes) &&
+          _helpers.equal?(superclass._helpers)
+      end
+
       def build_view_context_class(klass, supports_path, routes, helpers)
+        if inherit_view_context_class?
+          return superclass.view_context_class
+        end
+
         Class.new(klass) do
           if routes
             include routes.url_helpers(supports_path)
@@ -61,8 +73,14 @@ module ActionView
         end
       end
 
+      def eager_load!
+        super
+        view_context_class
+        nil
+      end
+
       def view_context_class
-        klass = ActionView::LookupContext::DetailsKey.view_context_class(ActionView::Base)
+        klass = ActionView::LookupContext::DetailsKey.view_context_class
 
         @view_context_class ||= build_view_context_class(klass, supports_path?, _routes, _helpers)
 
@@ -129,8 +147,8 @@ module ActionView
         lookup_context.formats = [format.to_sym] if format.to_sym
       end
 
-      # Normalize args by converting render "foo" to render :action => "foo" and
-      # render "foo/bar" to render :template => "foo/bar".
+      # Normalize args by converting render "foo" to render action: "foo" and
+      # render "foo/bar" to render template: "foo/bar".
       def _normalize_args(action = nil, options = {})
         options = super(action, options)
         case action

data/lib/action_view/ripper_ast_parser.rb

@@ -63,7 +63,7 @@ module ActionView
         end
 
         def call_method_name
-          self.last.first
+          self[2].first
         end
 
         def to_string
@@ -86,11 +86,11 @@ module ActionView
         end
 
         def hash_from_body(body)
-          body.map do |hash_node|
+          body.to_h do |hash_node|
             return nil if hash_node.type != :assoc_new
 
             [hash_node[0], hash_node[1]]
-          end.to_h
+          end
         end
 
         def symbol?
@@ -179,7 +179,7 @@ module ActionView
           end
 
           def on_paren(content)
-            content
+            content.size == 1 ? content.first : content
           end
       end
 
@@ -189,9 +189,9 @@ module ActionView
         parser = RenderCallExtractor.new(code)
         parser.parse
 
-        parser.render_calls.group_by(&:first).collect do |method, nodes|
+        parser.render_calls.group_by(&:first).to_h do |method, nodes|
           [ method.to_sym, nodes.collect { |v| v[1] } ]
-        end.to_h
+        end
       end
     end
   end

data/lib/action_view/routing_url_for.rb

@@ -6,14 +6,14 @@ module ActionView
   module RoutingUrlFor
     # Returns the URL for the set of +options+ provided. This takes the
     # same options as +url_for+ in Action Controller (see the
-    # documentation for <tt>ActionController::Base#url_for</tt>). Note that by default
-    # <tt>:only_path</tt> is <tt>true</tt> so you'll get the relative "/controller/action"
-    # instead of the fully qualified URL like "http://example.com/controller/action".
+    # documentation for ActionDispatch::Routing::UrlFor#url_for). Note that by default
+    # <tt>:only_path</tt> is <tt>true</tt> so you'll get the relative <tt>"/controller/action"</tt>
+    # instead of the fully qualified URL like <tt>"http://example.com/controller/action"</tt>.
     #
     # ==== Options
     # * <tt>:anchor</tt> - Specifies the anchor name to be appended to the path.
     # * <tt>:only_path</tt> - If true, returns the relative URL (omitting the protocol, host name, and port) (<tt>true</tt> by default unless <tt>:host</tt> is specified).
-    # * <tt>:trailing_slash</tt> - If true, adds a trailing slash, as in "/archive/2005/". Note that this
+    # * <tt>:trailing_slash</tt> - If true, adds a trailing slash, as in <tt>"/archive/2005/"</tt>. Note that this
     #   is currently not recommended since it breaks caching.
     # * <tt>:host</tt> - Overrides the default (current) host if provided.
     # * <tt>:protocol</tt> - Overrides the default (current) protocol if provided.

data/lib/action_view/template/error.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require "active_support/core_ext/enumerable"
+require "active_support/syntax_error_proxy"
 
 module ActionView
   # = Action View Errors
@@ -156,13 +157,25 @@ module ActionView
       # Override to prevent #cause resetting during re-raise.
       attr_reader :cause
 
+      attr_reader :template
+
       def initialize(template)
         super($!.message)
-        set_backtrace($!.backtrace)
         @cause = $!
+        if @cause.is_a?(SyntaxError)
+          @cause = ActiveSupport::SyntaxErrorProxy.new(@cause)
+        end
         @template, @sub_templates = template, nil
       end
 
+      def backtrace
+        @cause.backtrace
+      end
+
+      def backtrace_locations
+        @cause.backtrace_locations
+      end
+
       def file_name
         @template.identifier
       end

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

@@ -7,10 +7,10 @@ module ActionView
 
       def call(template, source)
         require_engine
-        "xml = ::Builder::XmlMarkup.new(:indent => 2);" \
-          "self.output_buffer = xml.target!;" +
-          source +
-          ";xml.target!;"
+        # the double assignment is to silence "assigned but unused variable" warnings
+        "xml = xml = ::Builder::XmlMarkup.new(indent: 2, target: output_buffer.raw);" \
+          "#{source};" \
+          "output_buffer.to_s"
       end
 
       private

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

@@ -16,22 +16,16 @@ module ActionView
 
             properties[:bufvar]     ||= "@output_buffer"
             properties[:preamble]   ||= ""
-            properties[:postamble]  ||= "#{properties[:bufvar]}.to_s"
+            properties[:postamble]  ||= "#{properties[:bufvar]}"
+
+            # Tell Eruby that whether template will be compiled with `frozen_string_literal: true`
+            properties[:freeze_template_literals] = !Template.frozen_string_literal
 
             properties[:escapefunc] = ""
 
             super
           end
 
-          def evaluate(action_view_erb_handler_context)
-            src = @src
-            view = Class.new(ActionView::Base) {
-              include action_view_erb_handler_context._routes.url_helpers
-              class_eval("define_method(:_template) { |local_assigns, output_buffer| #{src} }", defined?(@filename) ? @filename : "(erubi)", 0)
-            }.empty
-            view._run(:_template, nil, {}, ActionView::OutputBuffer.new)
-          end
-
         private
           def add_text(text)
             return if text.empty?
@@ -39,30 +33,32 @@ module ActionView
             if text == "\n"
               @newline_pending += 1
             else
-              src << bufvar << ".safe_append='"
-              src << "\n" * @newline_pending if @newline_pending > 0
-              src << text.gsub(/['\\]/, '\\\\\&')
-              src << "'.freeze;"
-
+              with_buffer do
+                src << ".safe_append='"
+                src << "\n" * @newline_pending if @newline_pending > 0
+                src << text.gsub(/['\\]/, '\\\\\&') << @text_end
+              end
               @newline_pending = 0
             end
           end
 
-          BLOCK_EXPR = /\s*((\s+|\))do|\{)(\s*\|[^|]*\|)?\s*\Z/
+          BLOCK_EXPR = /((\s|\))do|\{)(\s*\|[^|]*\|)?\s*\Z/
 
           def add_expression(indicator, code)
             flush_newline_if_pending(src)
 
-            if (indicator == "==") || @escape
-              src << bufvar << ".safe_expr_append="
-            else
-              src << bufvar << ".append="
-            end
-
-            if BLOCK_EXPR.match?(code)
-              src << " " << code
-            else
-              src << "(" << code << ");"
+            with_buffer do
+              if (indicator == "==") || @escape
+                src << ".safe_expr_append="
+              else
+                src << ".append="
+              end
+
+              if BLOCK_EXPR.match?(code)
+                src << " " << code
+              else
+                src << "(" << code << ")"
+              end
             end
           end
 
@@ -78,7 +74,7 @@ module ActionView
 
           def flush_newline_if_pending(src)
             if @newline_pending > 0
-              src << bufvar << ".safe_append='#{"\n" * @newline_pending}'.freeze;"
+              with_buffer { src << ".safe_append='#{"\n" * @newline_pending}" << @text_end }
               @newline_pending = 0
             end
           end

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

@@ -1,5 +1,8 @@
 # frozen_string_literal: true
 
+require "strscan"
+require "active_support/core_ext/erb/util"
+
 module ActionView
   class Template
     module Handlers
@@ -21,6 +24,8 @@ module ActionView
 
         ENCODING_TAG = Regexp.new("\\A(<%#{ENCODING_FLAG}-?%>)[ \\t]*")
 
+        LocationParsingError = Class.new(StandardError) # :nodoc:
+
         def self.call(template, source)
           new.call(template, source)
         end
@@ -33,6 +38,26 @@ module ActionView
           true
         end
 
+        # Translate an error location returned by ErrorHighlight to the correct
+        # source location inside the template.
+        def translate_location(spot, backtrace_location, source)
+          # Tokenize the source line
+          tokens = ::ERB::Util.tokenize(source.lines[backtrace_location.lineno - 1])
+          new_first_column = find_offset(spot[:snippet], tokens, spot[:first_column])
+          lineno_delta = spot[:first_lineno] - backtrace_location.lineno
+          spot[:first_lineno] -= lineno_delta
+          spot[:last_lineno] -= lineno_delta
+
+          column_delta = spot[:first_column] - new_first_column
+          spot[:first_column] -= column_delta
+          spot[:last_column] -= column_delta
+          spot[:script_lines] = source.lines
+
+          spot
+        rescue NotImplementedError, LocationParsingError
+          nil
+        end
+
         def call(template, source)
           # First, convert to BINARY, so in case the encoding is
           # wrong, we can still find an encoding tag
@@ -58,7 +83,7 @@ module ActionView
 
           if ActionView::Base.annotate_rendered_view_with_filenames && template.format == :html
             options[:preamble] = "@output_buffer.safe_append='<!-- BEGIN #{template.short_identifier} -->';"
-            options[:postamble] = "@output_buffer.safe_append='<!-- END #{template.short_identifier} -->';@output_buffer.to_s"
+            options[:postamble] = "@output_buffer.safe_append='<!-- END #{template.short_identifier} -->';@output_buffer"
           end
 
           self.class.erb_implementation.new(erb, options).src
@@ -79,6 +104,53 @@ module ActionView
           # Otherwise, raise an exception
           raise WrongEncodingError.new(string, string.encoding)
         end
+
+        def find_offset(compiled, source_tokens, error_column)
+          compiled = StringScanner.new(compiled)
+
+          passed_tokens = []
+
+          while tok = source_tokens.shift
+            tok_name, str = *tok
+            case tok_name
+            when :TEXT
+              loop do
+                break if compiled.match?(str)
+                compiled.getch
+              end
+              raise LocationParsingError unless compiled.scan(str)
+            when :CODE
+              if compiled.pos > error_column
+                raise LocationParsingError, "We went too far"
+              end
+
+              if compiled.pos + str.bytesize >= error_column
+                offset = error_column - compiled.pos
+                return passed_tokens.map(&:last).join.bytesize + offset
+              else
+                unless compiled.scan(str)
+                  raise LocationParsingError, "Couldn't find code snippet"
+                end
+              end
+            when :OPEN
+              next_tok = source_tokens.first.last
+              loop do
+                break if compiled.match?(next_tok)
+                compiled.getch
+              end
+            when :CLOSE
+              next_tok = source_tokens.first.last
+              loop do
+                break if compiled.match?(next_tok)
+                compiled.getch
+              end
+            else
+              raise LocationParsingError, "Not implemented: #{tok.first}"
+            end
+
+            passed_tokens << tok
+          end
+        end
       end
     end
   end

data/lib/action_view/template/handlers.rb

@@ -1,8 +1,8 @@
 # frozen_string_literal: true
 
 module ActionView # :nodoc:
-  # = Action View Template Handlers
   class Template # :nodoc:
+    # = Action View Template Handlers
     module Handlers # :nodoc:
       autoload :Raw, "action_view/template/handlers/raw"
       autoload :ERB, "action_view/template/handlers/erb"

data/lib/action_view/template/html.rb

@@ -1,8 +1,8 @@
 # frozen_string_literal: true
 
 module ActionView # :nodoc:
-  # = Action View HTML Template
   class Template # :nodoc:
+    # = Action View HTML Template
     class HTML # :nodoc:
       attr_reader :type
 

data/lib/action_view/template/raw_file.rb

@@ -1,8 +1,8 @@
 # frozen_string_literal: true
 
 module ActionView # :nodoc:
-  # = Action View RawFile Template
   class Template # :nodoc:
+    # = Action View RawFile Template
     class RawFile # :nodoc:
       attr_accessor :type, :format
 

data/lib/action_view/template/renderable.rb

@@ -1,8 +1,8 @@
 # frozen_string_literal: true
 
 module ActionView
-  # = Action View Renderable Template for objects that respond to #render_in
   class Template
+    # = Action View Renderable Template for objects that respond to #render_in
     class Renderable # :nodoc:
       def initialize(renderable)
         @renderable = renderable

data/lib/action_view/template/resolver.rb

@@ -10,16 +10,17 @@ require "concurrent/map"
 module ActionView
   # = Action View Resolver
   class Resolver
-    Path = ActionView::TemplatePath
-    deprecate_constant :Path
+    include ActiveSupport::Deprecation::DeprecatedConstantAccessor
 
     class PathParser # :nodoc:
       ParsedPath = Struct.new(:path, :details)
 
       def build_path_regex
-        handlers = Template::Handlers.extensions.map { |x| Regexp.escape(x) }.join("|")
-        formats = Template::Types.symbols.map { |x| Regexp.escape(x) }.join("|")
-        locales = "[a-z]{2}(?:[-_][A-Z]{2})?"
+        handlers = Regexp.union(Template::Handlers.extensions.map(&:to_s))
+        formats = Regexp.union(Template::Types.symbols.map(&:to_s))
+        available_locales = I18n.available_locales.map(&:to_s)
+        regular_locales = [/[a-z]{2}(?:[-_][A-Z]{2})?/]
+        locales = Regexp.union(available_locales + regular_locales)
         variants = "[^.]*"
 
         %r{
@@ -63,6 +64,11 @@ module ActionView
       _find_all(name, prefix, partial, details, key, locals)
     end
 
+    def built_templates # :nodoc:
+      # Used for error pages
+      []
+    end
+
     def all_template_paths # :nodoc:
       # Not implemented by default
       []
@@ -120,6 +126,10 @@ module ActionView
       end
     end
 
+    def built_templates # :nodoc:
+      @unbound_templates.values.flatten.flat_map(&:built_templates)
+    end
+
     private
       def _find_all(name, prefix, partial, details, key, locals)
         requested_details = key || TemplateDetails::Requested.new(**details)

data/lib/action_view/template/text.rb

@@ -1,8 +1,8 @@
 # frozen_string_literal: true
 
 module ActionView # :nodoc:
-  # = Action View Text Template
   class Template # :nodoc:
+    # = Action View Text Template
     class Text # :nodoc:
       attr_accessor :type
 

data/lib/action_view/template/types.rb

@@ -4,11 +4,14 @@ require "active_support/core_ext/module/attribute_accessors"
 
 module ActionView
   class Template # :nodoc:
-    module Types
-      class Type
-        SET = Struct.new(:symbols).new([ :html, :text, :js, :css, :xml, :json ])
+    # SimpleType is mostly just a stub implementation for when Action View
+    # is used without Action Dispatch.
+    class SimpleType # :nodoc:
+      @symbols = [ :html, :text, :js, :css, :xml, :json ]
+      class << self
+        attr_reader :symbols
 
-        def self.[](type)
+        def [](type)
           if type.is_a?(self)
             type
           else
@@ -16,44 +19,32 @@ module ActionView
           end
         end
 
-        attr_reader :symbol
-
-        def initialize(symbol)
-          @symbol = symbol.to_sym
-        end
-
-        def to_s
-          @symbol.to_s
-        end
-        alias to_str to_s
-
-        def ref
-          @symbol
-        end
-        alias to_sym ref
-
-        def ==(type)
-          @symbol == type.to_sym unless type.blank?
+        def valid_symbols?(symbols) # :nodoc
+          symbols.all? { |s| @symbols.include?(s) }
         end
       end
 
-      class << self
-        attr_accessor :type_klass
+      attr_reader :symbol
 
-        def delegate_to(klass)
-          self.type_klass = klass
-        end
+      def initialize(symbol)
+        @symbol = symbol.to_sym
+      end
 
-        def [](type)
-          type_klass[type]
-        end
+      def to_s
+        @symbol.to_s
+      end
+      alias to_str to_s
 
-        def symbols
-          type_klass::SET.symbols
-        end
+      def ref
+        @symbol
       end
+      alias to_sym ref
 
-      delegate_to Type
+      def ==(type)
+        @symbol == type.to_sym unless type.blank?
+      end
     end
+
+    Types = SimpleType # :nodoc:
   end
 end