actionview 4.2.11.1 → 7.0.2.4

data/lib/action_view/ripper_ast_parser.rb

@@ -0,0 +1,198 @@
+# frozen_string_literal: true
+
+require "ripper"
+
+module ActionView
+  class RenderParser
+    module RipperASTParser # :nodoc:
+      class Node < ::Array # :nodoc:
+        attr_reader :type
+
+        def initialize(type, arr, opts = {})
+          @type = type
+          super(arr)
+        end
+
+        def children
+          to_a
+        end
+
+        def inspect
+          typeinfo = type && type != :list ? ":" + type.to_s + ", " : ""
+          "s(" + typeinfo + map(&:inspect).join(", ") + ")"
+        end
+
+        def fcall?
+          type == :command || type == :fcall
+        end
+
+        def fcall_named?(name)
+          fcall? &&
+            self[0].type == :@ident &&
+            self[0][0] == name
+        end
+
+        def argument_nodes
+          raise unless fcall?
+          return [] if self[1].nil?
+          if self[1].last == false || self[1].last.type == :vcall
+            self[1][0...-1]
+          else
+            self[1][0..-1]
+          end
+        end
+
+        def string?
+          type == :string_literal
+        end
+
+        def variable_reference?
+          type == :var_ref
+        end
+
+        def vcall?
+          type == :vcall
+        end
+
+        def call?
+          type == :call
+        end
+
+        def variable_name
+          self[0][0]
+        end
+
+        def call_method_name
+          self.last.first
+        end
+
+        def to_string
+          raise unless string?
+          self[0][0][0]
+        end
+
+        def hash?
+          type == :bare_assoc_hash || type == :hash
+        end
+
+        def to_hash
+          if type == :bare_assoc_hash
+            hash_from_body(self[0])
+          elsif type == :hash && self[0] == nil
+            {}
+          elsif type == :hash && self[0].type == :assoclist_from_args
+            hash_from_body(self[0][0])
+          end
+        end
+
+        def hash_from_body(body)
+          body.map do |hash_node|
+            return nil if hash_node.type != :assoc_new
+
+            [hash_node[0], hash_node[1]]
+          end.to_h
+        end
+
+        def symbol?
+          type == :@label || type == :symbol_literal
+        end
+
+        def to_symbol
+          if type == :@label && self[0] =~ /\A(.+):\z/
+            $1.to_sym
+          elsif type == :symbol_literal && self[0].type == :symbol && self[0][0].type == :@ident
+            self[0][0][0].to_sym
+          else
+            raise "not a symbol?: #{self.inspect}"
+          end
+        end
+      end
+
+      class NodeParser < ::Ripper # :nodoc:
+        PARSER_EVENTS.each do |event|
+          arity = PARSER_EVENT_TABLE[event]
+          if arity == 0 && event.to_s.end_with?("_new")
+            module_eval(<<-eof, __FILE__, __LINE__ + 1)
+            def on_#{event}(*args)
+              Node.new(:list, args, lineno: lineno(), column: column())
+            end
+            eof
+          elsif event.to_s.match?(/_add(_.+)?\z/)
+            module_eval(<<-eof, __FILE__, __LINE__ + 1)
+            begin; undef on_#{event}; rescue NameError; end
+            def on_#{event}(list, item)
+              list.push(item)
+              list
+            end
+            eof
+          else
+            module_eval(<<-eof, __FILE__, __LINE__ + 1)
+            begin; undef on_#{event}; rescue NameError; end
+            def on_#{event}(*args)
+              Node.new(:#{event}, args, lineno: lineno(), column: column())
+            end
+            eof
+          end
+        end
+
+        SCANNER_EVENTS.each do |event|
+          module_eval(<<-End, __FILE__, __LINE__ + 1)
+          def on_#{event}(tok)
+            Node.new(:@#{event}, [tok], lineno: lineno(), column: column())
+          end
+          End
+        end
+      end
+
+      class RenderCallExtractor < NodeParser # :nodoc:
+        attr_reader :render_calls
+
+        METHODS_TO_PARSE = %w(render render_to_string)
+
+        def initialize(*args)
+          super
+
+          @render_calls = []
+        end
+
+        private
+          def on_fcall(name, *args)
+            on_render_call(super)
+          end
+
+          def on_command(name, *args)
+            on_render_call(super)
+          end
+
+          def on_render_call(node)
+            METHODS_TO_PARSE.each do |method|
+              if node.fcall_named?(method)
+                @render_calls << [method, node]
+                return node
+              end
+            end
+            node
+          end
+
+          def on_arg_paren(content)
+            content
+          end
+
+          def on_paren(content)
+            content
+          end
+      end
+
+      extend self
+
+      def parse_render_nodes(code)
+        parser = RenderCallExtractor.new(code)
+        parser.parse
+
+        parser.render_calls.group_by(&:first).collect 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

@@ -1,8 +1,9 @@
-require 'action_dispatch/routing/polymorphic_routes'
+# frozen_string_literal: true
+
+require "action_dispatch/routing/polymorphic_routes"
 
 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
@@ -32,7 +33,7 @@ module ActionView
     #
     # ==== Examples
     #   <%= url_for(action: 'index') %>
-    #   # => /blog/
+    #   # => /blogs/
     #
     #   <%= url_for(action: 'find', controller: 'books') %>
     #   # => /books/find
@@ -83,27 +84,28 @@ module ActionView
         super(only_path: _generate_paths_by_default)
       when Hash
         options = options.symbolize_keys
-        unless options.key?(:only_path)
-          if options[:host].nil?
-            options[:only_path] = _generate_paths_by_default
-          else
-            options[:only_path] = false
-          end
-        end
+        ensure_only_path_option(options)
+
+        super(options)
+      when ActionController::Parameters
+        ensure_only_path_option(options)
 
         super(options)
       when :back
         _back_url
       when Array
         components = options.dup
-        if _generate_paths_by_default
-          polymorphic_path(components, components.extract_options!)
+        options = components.extract_options!
+        ensure_only_path_option(options)
+
+        if options[:only_path]
+          polymorphic_path(components, options)
         else
-          polymorphic_url(components, components.extract_options!)
+          polymorphic_url(components, options)
         end
       else
         method = _generate_paths_by_default ? :path : :url
-        builder = ActionDispatch::Routing::PolymorphicRoutes::HelperMethodBuilder.send(method)
+        builder = ActionDispatch::Routing::PolymorphicRoutes::HelperMethodBuilder.public_send(method)
 
         case options
         when Symbol
@@ -116,20 +118,29 @@ module ActionView
       end
     end
 
-    def url_options #:nodoc:
+    def url_options # :nodoc:
       return super unless controller.respond_to?(:url_options)
       controller.url_options
     end
 
-    def _routes_context #:nodoc:
-      controller
-    end
-    protected :_routes_context
+    private
+      def _routes_context
+        controller
+      end
 
-    def optimize_routes_generation? #:nodoc:
-      controller.respond_to?(:optimize_routes_generation?, true) ?
-        controller.optimize_routes_generation? : super
-    end
-    protected :optimize_routes_generation?
+      def optimize_routes_generation?
+        controller.respond_to?(:optimize_routes_generation?, true) ?
+          controller.optimize_routes_generation? : super
+      end
+
+      def _generate_paths_by_default
+        true
+      end
+
+      def ensure_only_path_option(options)
+        unless options.key?(:only_path)
+          options[:only_path] = _generate_paths_by_default unless options[:host]
+        end
+      end
   end
 end

data/lib/action_view/tasks/cache_digests.rake

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+namespace :cache_digests do
+  desc "Lookup nested dependencies for TEMPLATE (like messages/show or comments/_comment.html)"
+  task nested_dependencies: :environment do
+    abort "You must provide TEMPLATE for the task to run" unless ENV["TEMPLATE"].present?
+    puts JSON.pretty_generate ActionView::Digestor.tree(CacheDigests.template_name, CacheDigests.finder).children.map(&:to_dep_map)
+  end
+
+  desc "Lookup first-level dependencies for TEMPLATE (like messages/show or comments/_comment.html)"
+  task dependencies: :environment do
+    abort "You must provide TEMPLATE for the task to run" unless ENV["TEMPLATE"].present?
+    puts JSON.pretty_generate ActionView::Digestor.tree(CacheDigests.template_name, CacheDigests.finder).children.map(&:name)
+  end
+
+  class CacheDigests
+    def self.template_name
+      ENV["TEMPLATE"].split(".", 2).first
+    end
+
+    def self.finder
+      ApplicationController.new.lookup_context
+    end
+  end
+end

data/lib/action_view/template/error.rb

@@ -1,17 +1,16 @@
+# frozen_string_literal: true
+
 require "active_support/core_ext/enumerable"
 
 module ActionView
   # = Action View Errors
-  class ActionViewError < StandardError #:nodoc:
-  end
-
-  class EncodingError < StandardError #:nodoc:
+  class ActionViewError < StandardError # :nodoc:
   end
 
-  class MissingRequestError < StandardError #:nodoc:
+  class EncodingError < StandardError # :nodoc:
   end
 
-  class WrongEncodingError < EncodingError #:nodoc:
+  class WrongEncodingError < EncodingError # :nodoc:
     def initialize(string, encoding)
       @string, @encoding = string, encoding
     end
@@ -27,45 +26,141 @@ module ActionView
     end
   end
 
-  class MissingTemplate < ActionViewError #:nodoc:
-    attr_reader :path
+  class MissingTemplate < ActionViewError # :nodoc:
+    attr_reader :path, :paths, :prefixes, :partial
 
     def initialize(paths, path, prefixes, partial, details, *)
+      if partial && path.present?
+        path = path.sub(%r{([^/]+)$}, "_\\1")
+      end
+
       @path = path
-      prefixes = Array(prefixes)
+      @paths = paths
+      @prefixes = Array(prefixes)
+      @partial = partial
       template_type = if partial
         "partial"
-      elsif path =~ /layouts/i
-        'layout'
+      elsif /layouts/i.match?(path)
+        "layout"
       else
-        'template'
+        "template"
       end
 
-      if partial && path.present?
-        path = path.sub(%r{([^/]+)$}, "_\\1")
-      end
-      searched_paths = prefixes.map { |prefix| [prefix, path].join("/") }
+      searched_paths = @prefixes.map { |prefix| [prefix, path].join("/") }
 
-      out  = "Missing #{template_type} #{searched_paths.join(", ")} with #{details.inspect}. Searched in:\n"
+      out  = "Missing #{template_type} #{searched_paths.join(", ")} with #{details.inspect}.\n\nSearched in:\n"
       out += paths.compact.map { |p| "  * #{p.to_s.inspect}\n" }.join
       super out
     end
+
+    if defined?(DidYouMean::Correctable) && defined?(DidYouMean::Jaro)
+      include DidYouMean::Correctable
+
+      class Results # :nodoc:
+        Result = Struct.new(:path, :score)
+
+        def initialize(size)
+          @size = size
+          @results = []
+        end
+
+        def to_a
+          @results.map(&:path)
+        end
+
+        def should_record?(score)
+          if @results.size < @size
+            true
+          else
+            score < @results.last.score
+          end
+        end
+
+        def add(path, score)
+          if should_record?(score)
+            @results << Result.new(path, score)
+            @results.sort_by!(&:score)
+            @results.pop if @results.size > @size
+          end
+        end
+      end
+
+      # Apps may have thousands of candidate templates so we attempt to
+      # generate the suggestions as efficiently as possible.
+      # First we split templates into prefixes and basenames, so that those can
+      # be matched separately.
+      def corrections
+        candidates = paths.flat_map(&:all_template_paths).uniq
+
+        if partial
+          candidates.select!(&:partial?)
+        else
+          candidates.reject!(&:partial?)
+        end
+
+        # Group by possible prefixes
+        files_by_dir = candidates.group_by(&:prefix)
+        files_by_dir.transform_values! do |files|
+          files.map do |file|
+            # Remove prefix
+            File.basename(file.to_s)
+          end
+        end
+
+        # No suggestions if there's an exact match, but wrong details
+        if prefixes.any? { |prefix| files_by_dir[prefix]&.include?(path) }
+          return []
+        end
+
+        cached_distance = Hash.new do |h, args|
+          h[args] = -DidYouMean::Jaro.distance(*args)
+        end
+
+        results = Results.new(6)
+
+        files_by_dir.keys.index_with do |dirname|
+          prefixes.map do |prefix|
+            cached_distance[[prefix, dirname]]
+          end.min
+        end.sort_by(&:last).each do |dirname, dirweight|
+          # If our directory's score makes it impossible to find a better match
+          # we can prune this search branch.
+          next unless results.should_record?(dirweight - 1.0)
+
+          files = files_by_dir[dirname]
+
+          files.each do |file|
+            fileweight = cached_distance[[path, file]]
+            score = dirweight + fileweight
+
+            results.add(File.join(dirname, file), score)
+          end
+        end
+
+        if partial
+          results.to_a.map { |res| res.sub(%r{_([^/]+)\z}, "\\1") }
+        else
+          results.to_a
+        end
+      end
+    end
   end
 
   class Template
     # The Template::Error exception is raised when the compilation or rendering of the template
     # fails. This exception then gathers a bunch of intimate details and uses it to report a
     # precise exception message.
-    class Error < ActionViewError #:nodoc:
+    class Error < ActionViewError # :nodoc:
       SOURCE_CODE_RADIUS = 3
 
-      attr_reader :original_exception
+      # Override to prevent #cause resetting during re-raise.
+      attr_reader :cause
 
-      def initialize(template, original_exception)
-        super(original_exception.message)
-        @template, @original_exception = template, original_exception
-        @sub_templates = nil
-        set_backtrace(original_exception.backtrace)
+      def initialize(template)
+        super($!.message)
+        set_backtrace($!.backtrace)
+        @cause = $!
+        @template, @sub_templates = template, nil
       end
 
       def file_name
@@ -75,25 +170,25 @@ module ActionView
       def sub_template_message
         if @sub_templates
           "Trace of template inclusion: " +
-          @sub_templates.collect { |template| template.inspect }.join(", ")
+          @sub_templates.collect(&:inspect).join(", ")
         else
           ""
         end
       end
 
-      def source_extract(indentation = 0, output = :console)
-        return unless num = line_number
+      def source_extract(indentation = 0)
+        return [] unless num = line_number
         num = num.to_i
 
-        source_code = @template.source.split("\n")
+        source_code = @template.encode!.split("\n")
 
         start_on_line = [ num - SOURCE_CODE_RADIUS - 1, 0 ].max
         end_on_line   = [ num + SOURCE_CODE_RADIUS - 1, source_code.length].min
 
         indent = end_on_line.to_s.size + indentation
-        return unless source_code = source_code[start_on_line..end_on_line]
+        return [] unless source_code = source_code[start_on_line..end_on_line]
 
-        formatted_code_for(source_code, start_on_line, indent, output)
+        formatted_code_for(source_code, start_on_line, indent)
       end
 
       def sub_template_of(template_path)
@@ -109,33 +204,48 @@ module ActionView
           end
       end
 
-      def annoted_source_code
+      def annotated_source_code
         source_extract(4)
       end
 
       private
-
         def source_location
           if line_number
             "on line ##{line_number} of "
           else
-            'in '
+            "in "
           end + file_name
         end
 
-        def formatted_code_for(source_code, line_counter, indent, output)
-          start_value = (output == :html) ? {} : ""
-          source_code.inject(start_value) do |result, line|
+        def formatted_code_for(source_code, line_counter, indent)
+          indent_template = "%#{indent}s: %s"
+          source_code.map do |line|
             line_counter += 1
-            if output == :html
-              result.update(line_counter.to_s => "%#{indent}s %s\n" % ["", line])
-            else
-              result << "%#{indent}s: %s\n" % [line_counter, line]
-            end
+            indent_template % [line_counter, line]
           end
         end
     end
   end
 
   TemplateError = Template::Error
+
+  class SyntaxErrorInTemplate < TemplateError # :nodoc:
+    def initialize(template, offending_code_string)
+      @offending_code_string = offending_code_string
+      super(template)
+    end
+
+    def message
+      <<~MESSAGE
+        Encountered a syntax error while rendering template: check #{@offending_code_string}
+      MESSAGE
+    end
+
+    def annotated_source_code
+      @offending_code_string.split("\n").map.with_index(1) { |line, index|
+        indentation = " " * 4
+        "#{index}:#{indentation}#{line}"
+      }
+    end
+  end
 end

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

@@ -1,26 +1,25 @@
+# frozen_string_literal: true
+
 module ActionView
   module Template::Handlers
     class Builder
-      # Default format used by Builder.
-      class_attribute :default_format
-      self.default_format = :xml
+      class_attribute :default_format, default: :xml
 
-      def call(template)
+      def call(template, source)
         require_engine
-        "xml = ::Builder::XmlMarkup.new(:indent => 2);" +
+        "xml = ::Builder::XmlMarkup.new(:indent => 2);" \
           "self.output_buffer = xml.target!;" +
-          template.source +
+          source +
           ";xml.target!;"
       end
 
-      protected
-
-      def require_engine
-        @required ||= begin
-          require "builder"
-          true
+      private
+        def require_engine # :doc:
+          @required ||= begin
+            require "builder"
+            true
+          end
         end
-      end
     end
   end
 end