actionview 6.1.7.10 → 7.0.0.alpha1

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)