actionview 6.1.7.2 → 7.0.6

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

@@ -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.
@@ -47,6 +47,9 @@ module ActionView
     #   <%= url_for(action: 'jump', anchor: 'tax&ship') %>
     #   # => /testing/jump/#tax&ship
     #
+    #   <%= url_for(Workshop) %>
+    #   # => /workshops
+    #
     #   <%= url_for(Workshop.new) %>
     #   # relies on Workshop answering a persisted? call (and in this case returning false)
     #   # => /workshops
@@ -118,7 +121,7 @@ module ActionView
       end
     end
 
-    def url_options #:nodoc:
+    def url_options # :nodoc:
       return super unless controller.respond_to?(:url_options)
       controller.url_options
     end

data/lib/action_view/template/error.rb

@@ -4,13 +4,13 @@ require "active_support/core_ext/enumerable"
 
 module ActionView
   # = Action View Errors
-  class ActionViewError < StandardError #:nodoc:
+  class ActionViewError < StandardError # :nodoc:
   end
 
-  class EncodingError < StandardError #:nodoc:
+  class EncodingError < StandardError # :nodoc:
   end
 
-  class WrongEncodingError < EncodingError #:nodoc:
+  class WrongEncodingError < EncodingError # :nodoc:
     def initialize(string, encoding)
       @string, @encoding = string, encoding
     end
@@ -26,12 +26,18 @@ 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 /layouts/i.match?(path)
@@ -40,22 +46,111 @@ module ActionView
         "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
 
       # Override to prevent #cause resetting during re-raise.
@@ -134,7 +229,7 @@ module ActionView
 
   TemplateError = Template::Error
 
-  class SyntaxErrorInTemplate < TemplateError #:nodoc
+  class SyntaxErrorInTemplate < TemplateError # :nodoc:
     def initialize(template, offending_code_string)
       @offending_code_string = offending_code_string
       super(template)

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

@@ -16,6 +16,9 @@ module ActionView
         # Do not escape templates of these mime types.
         class_attribute :escape_ignore_list, default: ["text/plain"]
 
+        # Strip trailing newlines from rendered output
+        class_attribute :strip_trailing_newlines, default: false
+
         ENCODING_TAG = Regexp.new("\\A(<%#{ENCODING_FLAG}-?%>)[ \\t]*")
 
         def self.call(template, source)
@@ -45,6 +48,9 @@ module ActionView
           # Always make sure we return a String in the default_internal
           erb.encode!
 
+          # Strip trailing newlines from the template if enabled
+          erb.chomp! if strip_trailing_newlines
+
           options = {
             escape: (self.class.escape_ignore_list.include? template.type),
             trim: (self.class.erb_trim_mode == "-")

data/lib/action_view/template/handlers.rb

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

data/lib/action_view/template/html.rb

@@ -1,9 +1,9 @@
 # frozen_string_literal: true
 
-module ActionView #:nodoc:
+module ActionView # :nodoc:
   # = Action View HTML Template
-  class Template #:nodoc:
-    class HTML #:nodoc:
+  class Template # :nodoc:
+    class HTML # :nodoc:
       attr_reader :type
 
       def initialize(string, type)

data/lib/action_view/template/inline.rb

@@ -1,8 +1,8 @@
 # frozen_string_literal: true
 
-module ActionView #:nodoc:
-  class Template #:nodoc:
-    class Inline < Template #:nodoc:
+module ActionView # :nodoc:
+  class Template # :nodoc:
+    class Inline < Template # :nodoc:
       # This finalizer is needed (and exactly with a proc inside another proc)
       # otherwise templates leak in development.
       Finalizer = proc do |method_name, mod| # :nodoc:

data/lib/action_view/template/raw_file.rb

@@ -1,9 +1,9 @@
 # frozen_string_literal: true
 
-module ActionView #:nodoc:
+module ActionView # :nodoc:
   # = Action View RawFile Template
-  class Template #:nodoc:
-    class RawFile #:nodoc:
+  class Template # :nodoc:
+    class RawFile # :nodoc:
       attr_accessor :type, :format
 
       def initialize(filename)