actionview 7.0.8.1 → 7.2.2.1

data/lib/action_view/base.rb

@@ -10,7 +10,7 @@ require "action_view/template"
 require "action_view/lookup_context"
 
 module ActionView # :nodoc:
-  # = Action View Base
+  # = Action View \Base
   #
   # Action View templates can be written in several ways.
   # If the template file has a <tt>.erb</tt> extension, then it uses the erubi[https://rubygems.org/gems/erubi]
@@ -44,9 +44,9 @@ module ActionView # :nodoc:
   # Using sub templates allows you to sidestep tedious replication and extract common display structures in shared templates. The
   # classic example is the use of a header and footer (even though the Action Pack-way would be to use Layouts):
   #
-  #   <%= render "shared/header" %>
+  #   <%= render "application/header" %>
   #   Something really specific and terrific
-  #   <%= render "shared/footer" %>
+  #   <%= render "application/footer" %>
   #
   # As you see, we use the output embeddings for the render methods. The render call itself will just return a string holding the
   # result of the rendering. The output embedding writes it to the current template.
@@ -55,7 +55,7 @@ module ActionView # :nodoc:
   # variables defined using the regular embedding tags. Like this:
   #
   #   <% @page_title = "A Wonderful Hello" %>
-  #   <%= render "shared/header" %>
+  #   <%= render "application/header" %>
   #
   # Now the header can pick up on the <tt>@page_title</tt> variable and use it for outputting a title tag:
   #
@@ -65,9 +65,9 @@ module ActionView # :nodoc:
   #
   # You can pass local variables to sub templates by using a hash with the variable names as keys and the objects as values:
   #
-  #   <%= render "shared/header", { headline: "Welcome", person: person } %>
+  #   <%= render "application/header", { headline: "Welcome", person: person } %>
   #
-  # These can now be accessed in <tt>shared/header</tt> with:
+  # These can now be accessed in <tt>application/header</tt> with:
   #
   #   Headline: <%= headline %>
   #   First name: <%= person.first_name %>
@@ -80,10 +80,27 @@ module ActionView # :nodoc:
   # This is useful in cases where you aren't sure if the local variable has been assigned. Alternatively, you could also use
   # <tt>defined? headline</tt> to first check if the variable has been assigned before using it.
   #
+  # By default, templates will accept any <tt>locals</tt> as keyword arguments. To restrict what <tt>locals</tt> a template accepts, add a <tt>locals:</tt> magic comment:
+  #
+  #   <%# locals: (headline:) %>
+  #
+  #   Headline: <%= headline %>
+  #
+  # In cases where the local variables are optional, declare the keyword argument with a default value:
+  #
+  #   <%# locals: (headline: nil) %>
+  #
+  #   <% unless headline.nil? %>
+  #   Headline: <%= headline %>
+  #   <% end %>
+  #
+  # Read more about strict locals in {Action View Overview}[https://guides.rubyonrails.org/action_view_overview.html#strict-locals]
+  # in the guides.
+  #
   # === Template caching
   #
-  # By default, Rails will compile each template to a method in order to render it. When you alter a template,
-  # Rails will check the file's modification time and recompile it in development mode.
+  # By default, \Rails will compile each template to a method in order to render it. When you alter a template,
+  # \Rails will check the file's modification time and recompile it in development mode.
   #
   # == Builder
   #
@@ -136,8 +153,7 @@ module ActionView # :nodoc:
   #     end
   #   end
   #
-  # For more information on Builder please consult the {source
-  # code}[https://github.com/jimweirich/builder].
+  # For more information on Builder please consult the {source code}[https://github.com/rails/builder].
   class Base
     include Helpers, ::ERB::Util, Context
 
@@ -205,7 +221,8 @@ module ActionView # :nodoc:
     delegate :formats, :formats=, :locale, :locale=, :view_paths, :view_paths=, to: :lookup_context
 
     def assign(new_assigns) # :nodoc:
-      @_assigns = new_assigns.each { |key, value| instance_variable_set("@#{key}", value) }
+      @_assigns = new_assigns
+      new_assigns.each { |key, value| instance_variable_set("@#{key}", value) }
     end
 
     # :stopdoc:
@@ -232,16 +249,37 @@ module ActionView # :nodoc:
       @view_renderer = ActionView::Renderer.new @lookup_context
       @current_template = nil
 
-      assign(assigns)
       assign_controller(controller)
       _prepare_context
+
+      super()
+
+      # Assigns must be called last to minimize the number of shapes
+      assign(assigns)
     end
 
-    def _run(method, template, locals, buffer, add_to_stack: true, &block)
+    def _run(method, template, locals, buffer, add_to_stack: true, has_strict_locals: false, &block)
       _old_output_buffer, _old_virtual_path, _old_template = @output_buffer, @virtual_path, @current_template
       @current_template = template if add_to_stack
       @output_buffer = buffer
-      public_send(method, locals, buffer, &block)
+
+      if has_strict_locals
+        begin
+          public_send(method, locals, buffer, **locals, &block)
+        rescue ArgumentError => argument_error
+          raise(
+            ArgumentError,
+            argument_error.
+              message.
+                gsub("unknown keyword:", "unknown local:").
+                gsub("missing keyword:", "missing local:").
+                gsub("no keywords accepted", "no locals accepted").
+                concat(" for #{@current_template.short_identifier}")
+          )
+        end
+      else
+        public_send(method, locals, buffer, &block)
+      end
     ensure
       @output_buffer, @virtual_path, @current_template = _old_output_buffer, _old_virtual_path, _old_template
     end

data/lib/action_view/buffers.rb

@@ -18,24 +18,91 @@ module ActionView
   #   sbuf << 5
   #   puts sbuf # => "hello\u0005"
   #
-  class OutputBuffer < ActiveSupport::SafeBuffer # :nodoc:
-    def initialize(*)
-      super
-      encode!
+  class OutputBuffer # :nodoc:
+    def initialize(buffer = "")
+      @raw_buffer = String.new(buffer)
+      @raw_buffer.encode!
+    end
+
+    delegate :length, :empty?, :blank?, :encoding, :encode!, :force_encoding, to: :@raw_buffer
+
+    def to_s
+      @raw_buffer.html_safe
+    end
+    alias_method :html_safe, :to_s
+
+    def to_str
+      @raw_buffer.dup
+    end
+
+    def html_safe?
+      true
     end
 
     def <<(value)
-      return self if value.nil?
-      super(value.to_s)
+      unless value.nil?
+        value = value.to_s
+        @raw_buffer << if value.html_safe?
+          value
+        else
+          CGI.escapeHTML(value)
+        end
+      end
+      self
     end
+    alias :concat :<<
     alias :append= :<<
 
+    def safe_concat(value)
+      @raw_buffer << value
+      self
+    end
+    alias :safe_append= :safe_concat
+
     def safe_expr_append=(val)
       return self if val.nil?
-      safe_concat val.to_s
+      @raw_buffer << val.to_s
+      self
     end
 
-    alias :safe_append= :safe_concat
+    def initialize_copy(other)
+      @raw_buffer = other.to_str
+    end
+
+    def capture(*args)
+      new_buffer = +""
+      old_buffer, @raw_buffer = @raw_buffer, new_buffer
+      yield(*args)
+      new_buffer.html_safe
+    ensure
+      @raw_buffer = old_buffer
+    end
+
+    def ==(other)
+      other.class == self.class && @raw_buffer == other.to_str
+    end
+
+    def raw
+      RawOutputBuffer.new(self)
+    end
+
+    attr_reader :raw_buffer
+  end
+
+  class RawOutputBuffer # :nodoc:
+    def initialize(buffer)
+      @buffer = buffer
+    end
+
+    def <<(value)
+      unless value.nil?
+        @buffer.raw_buffer << value.to_s
+      end
+    end
+
+    def raw
+      self
+    end
   end
 
   class StreamingBuffer # :nodoc:
@@ -56,6 +123,15 @@ module ActionView
     end
     alias :safe_append= :safe_concat
 
+    def capture
+      buffer = +""
+      old_block, @block = @block, ->(value) { buffer << value }
+      yield
+      buffer.html_safe
+    ensure
+      @block = old_block
+    end
+
     def html_safe?
       true
     end
@@ -63,5 +139,27 @@ module ActionView
     def html_safe
       self
     end
+
+    def raw
+      RawStreamingBuffer.new(self)
+    end
+
+    attr_reader :block
+  end
+
+  class RawStreamingBuffer # :nodoc:
+    def initialize(buffer)
+      @buffer = buffer
+    end
+
+    def <<(value)
+      unless value.nil?
+        @buffer.block.call(value.to_s)
+      end
+    end
+
+    def raw
+      self
+    end
   end
 end

data/lib/action_view/cache_expiry.rb

@@ -1,65 +1,68 @@
 # frozen_string_literal: true
 
 module ActionView
-  class CacheExpiry
-    class Executor
-      def initialize(watcher:)
-        @execution_lock = Concurrent::ReentrantReadWriteLock.new
-        @cache_expiry = ViewModificationWatcher.new(watcher: watcher) do
-          clear_cache
-        end
+  module CacheExpiry # :nodoc: all
+    class ViewReloader
+      def initialize(watcher:, &block)
+        @mutex = Mutex.new
+        @watcher_class = watcher
+        @watched_dirs = nil
+        @watcher = nil
+        @previous_change = false
+
+        ActionView::PathRegistry.file_system_resolver_hooks << method(:rebuild_watcher)
       end
 
-      def run
-        ActiveSupport::Dependencies.interlock.permit_concurrent_loads do
-          @cache_expiry.execute_if_updated
-          @execution_lock.acquire_read_lock
-        end
+      def updated?
+        build_watcher unless @watcher
+        @previous_change || @watcher.updated?
       end
 
-      def complete(_)
-        @execution_lock.release_read_lock
+      def execute
+        return unless @watcher
+
+        watcher = nil
+        @mutex.synchronize do
+          @previous_change = false
+          watcher = @watcher
+        end
+        watcher.execute
       end
 
       private
-        def clear_cache
-          @execution_lock.with_write_lock do
-            ActionView::LookupContext::DetailsKey.clear
-          end
+        def reload!
+          ActionView::LookupContext::DetailsKey.clear
         end
-    end
 
-    class ViewModificationWatcher
-      def initialize(watcher:, &block)
-        @watched_dirs = nil
-        @watcher_class = watcher
-        @watcher = nil
-        @mutex = Mutex.new
-        @block = block
-      end
+        def build_watcher
+          @mutex.synchronize do
+            old_watcher = @watcher
 
-      def execute_if_updated
-        @mutex.synchronize do
-          watched_dirs = dirs_to_watch
-          return if watched_dirs.empty?
+            if @watched_dirs != dirs_to_watch
+              @watched_dirs = dirs_to_watch
+              new_watcher = @watcher_class.new([], @watched_dirs) do
+                reload!
+              end
+              @watcher = new_watcher
 
-          if watched_dirs != @watched_dirs
-            @watched_dirs = watched_dirs
-            @watcher = @watcher_class.new([], watched_dirs, &@block)
-            @watcher.execute
-          else
-            @watcher.execute_if_updated
+              # We must check the old watcher after initializing the new one to
+              # ensure we don't miss any events
+              @previous_change ||= old_watcher&.updated?
+            end
           end
         end
-      end
 
-      private
+        def rebuild_watcher
+          return unless @watcher
+          build_watcher
+        end
+
         def dirs_to_watch
-          all_view_paths.grep(FileSystemResolver).map!(&:path).tap(&:uniq!).sort!
+          all_view_paths.uniq.sort
         end
 
         def all_view_paths
-          ActionView::ViewPaths.all_view_paths.flat_map(&:paths)
+          ActionView::PathRegistry.all_file_system_resolvers.map(&:path)
         end
     end
   end

data/lib/action_view/context.rb

@@ -17,7 +17,7 @@ module ActionView
     # Prepares the context by setting the appropriate instance variables.
     def _prepare_context
       @view_flow     = OutputFlow.new
-      @output_buffer = nil
+      @output_buffer = ActionView::OutputBuffer.new
       @virtual_path  = nil
     end
 

data/lib/action_view/dependency_tracker/{ripper_tracker.rb → ruby_tracker.rb}

@@ -2,7 +2,7 @@
 
 module ActionView
   class DependencyTracker # :nodoc:
-    class RipperTracker # :nodoc:
+    class RubyTracker # :nodoc:
       EXPLICIT_DEPENDENCY = /# Template Dependency: (\S+)/
 
       def self.call(name, template, view_paths = nil)
@@ -17,8 +17,9 @@ module ActionView
         true
       end
 
-      def initialize(name, template, view_paths = nil)
+      def initialize(name, template, view_paths = nil, parser_class: RenderParser::Default)
         @name, @template, @view_paths = name, template, view_paths
+        @parser_class = parser_class
       end
 
       private
@@ -29,7 +30,7 @@ module ActionView
 
           compiled_source = template.handler.call(template, template.source)
 
-          RenderParser.new(@name, compiled_source).render_calls.filter_map do |render_call|
+          @parser_class.new(@name, compiled_source).render_calls.filter_map do |render_call|
             next if render_call.end_with?("/_")
             render_call.gsub(%r|/_|, "/")
           end

data/lib/action_view/dependency_tracker.rb

@@ -9,7 +9,7 @@ module ActionView
     extend ActiveSupport::Autoload
 
     autoload :ERBTracker
-    autoload :RipperTracker
+    autoload :RubyTracker
 
     @trackers = Concurrent::Map.new
 

data/lib/action_view/deprecator.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module ActionView
+  def self.deprecator # :nodoc:
+    @deprecator ||= ActiveSupport::Deprecation.new
+  end
+end

data/lib/action_view/digestor.rb

@@ -11,7 +11,7 @@ module ActionView
       #
       # * <tt>name</tt>         - Template name
       # * <tt>format</tt>       - Template format
-      # * <tt>finder</tt>       - An instance of <tt>ActionView::LookupContext</tt>
+      # * +finder+              - An instance of ActionView::LookupContext
       # * <tt>dependencies</tt> - An array of dependent views
       def digest(name:, format: nil, finder:, dependencies: nil)
         if dependencies.nil? || dependencies.empty?

data/lib/action_view/gem_version.rb

@@ -1,15 +1,15 @@
 # frozen_string_literal: true
 
 module ActionView
-  # Returns the currently loaded version of Action View as a <tt>Gem::Version</tt>.
+  # Returns the currently loaded version of Action View as a +Gem::Version+.
   def self.gem_version
     Gem::Version.new VERSION::STRING
   end
 
   module VERSION
     MAJOR = 7
-    MINOR = 0
-    TINY  = 8
+    MINOR = 2
+    TINY  = 2
     PRE   = "1"
 
     STRING = [MAJOR, MINOR, TINY, PRE].compact.join(".")

data/lib/action_view/helpers/active_model_helper.rb

@@ -4,11 +4,11 @@ require "active_support/core_ext/module/attribute_accessors"
 require "active_support/core_ext/enumerable"
 
 module ActionView
-  # = Active Model Helpers
   module Helpers # :nodoc:
     module ActiveModelHelper
     end
 
+    # = Active \Model Instance Tag \Helpers
     module ActiveModelInstanceTag
       def object
         @active_model_object ||= begin