actionview 4.2.11.1 → 7.0.2.4

data/lib/action_view/record_identifier.rb

@@ -1,38 +1,66 @@
-require 'active_support/core_ext/module'
-require 'action_view/model_naming'
+# frozen_string_literal: true
+
+require "active_support/core_ext/module"
+require "action_view/model_naming"
 
 module ActionView
-  # The record identifier encapsulates a number of naming conventions for dealing with records, like Active Records or
-  # pretty much any other model type that has an id. These patterns are then used to try elevate the view actions to
-  # a higher logical level.
+  # RecordIdentifier encapsulates methods used by various ActionView helpers
+  # to associate records with DOM elements.
   #
-  #   # routes
-  #   resources :posts
+  # Consider for example the following code that form of post:
   #
-  #   # view
-  #   <%= div_for(post) do %>    <div id="post_45" class="post">
-  #     <%= post.body %>           What a wonderful world!
-  #   <% end %>                  </div>
+  #   <%= form_for(post) do |f| %>
+  #     <%= f.text_field :body %>
+  #   <% end %>
   #
-  #   # controller
-  #   def update
-  #     post = Post.find(params[:id])
-  #     post.update(params[:post])
+  # When +post+ is a new, unsaved ActiveRecord::Base instance, the resulting HTML
+  # is:
   #
-  #     redirect_to(post) # Calls polymorphic_url(post) which in turn calls post_url(post)
-  #   end
+  #    <form class="new_post" id="new_post" action="/posts" accept-charset="UTF-8" method="post">
+  #      <input type="text" name="post[body]" id="post_body" />
+  #    </form>
+  #
+  # When +post+ is a persisted ActiveRecord::Base instance, the resulting HTML
+  # is:
+  #
+  #   <form class="edit_post" id="edit_post_42" action="/posts/42" accept-charset="UTF-8" method="post">
+  #     <input type="text" value="What a wonderful world!" name="post[body]" id="post_body" />
+  #   </form>
+  #
+  # In both cases, the +id+ and +class+ of the wrapping DOM element are
+  # automatically generated, following naming conventions encapsulated by the
+  # RecordIdentifier methods #dom_id and #dom_class:
+  #
+  #   dom_id(Post.new)         # => "new_post"
+  #   dom_class(Post.new)      # => "post"
+  #   dom_id(Post.find 42)     # => "post_42"
+  #   dom_class(Post.find 42)  # => "post"
   #
-  # As the example above shows, you can stop caring to a large extent what the actual id of the post is.
-  # You just know that one is being assigned and that the subsequent calls in redirect_to expect that
-  # same naming convention and allows you to write less code if you follow it.
+  # Note that these methods do not strictly require +Post+ to be a subclass of
+  # ActiveRecord::Base.
+  # Any +Post+ class will work as long as its instances respond to +to_key+
+  # and +model_name+, given that +model_name+ responds to +param_key+.
+  # For instance:
+  #
+  #   class Post
+  #     attr_accessor :to_key
+  #
+  #     def model_name
+  #       OpenStruct.new param_key: 'post'
+  #     end
+  #
+  #     def self.find(id)
+  #       new.tap { |post| post.to_key = [id] }
+  #     end
+  #   end
   module RecordIdentifier
     extend self
     extend ModelNaming
 
     include ModelNaming
 
-    JOIN = '_'.freeze
-    NEW = 'new'.freeze
+    JOIN = "_"
+    NEW = "new"
 
     # The DOM class convention is to use the singular form of an object or class.
     #
@@ -66,8 +94,7 @@ module ActionView
       end
     end
 
-  protected
-
+  private
     # Returns a string representation of the key attribute(s) that is suitable for use in an HTML DOM id.
     # This can be overwritten to customize the default generated string representation if desired.
     # If you need to read back a key from a dom_id in order to query for the underlying database record,
@@ -76,9 +103,9 @@ module ActionView
     # overwritten version of the method. By default, this implementation passes the key string through a
     # method that replaces all characters that are invalid inside DOM ids, with valid ones. You need to
     # make sure yourself that your dom ids are valid, in case you overwrite this method.
-    def record_key_for_dom_id(record)
+    def record_key_for_dom_id(record) # :doc:
       key = convert_to_model(record).to_key
-      key ? key.join('_') : key
+      key ? key.join(JOIN) : key
     end
   end
 end

data/lib/action_view/render_parser.rb

@@ -0,0 +1,188 @@
+# frozen_string_literal: true
+
+require "action_view/ripper_ast_parser"
+
+module ActionView
+  class RenderParser # :nodoc:
+    def initialize(name, code)
+      @name = name
+      @code = code
+      @parser = RipperASTParser
+    end
+
+    def render_calls
+      render_nodes = @parser.parse_render_nodes(@code)
+
+      render_nodes.map do |method, nodes|
+        nodes.map { |n| send(:parse_render, n) }
+      end.flatten.compact
+    end
+
+    private
+      def directory
+        File.dirname(@name)
+      end
+
+      def resolve_path_directory(path)
+        if path.include?("/")
+          path
+        else
+          "#{directory}/#{path}"
+        end
+      end
+
+      # Convert
+      #   render("foo", ...)
+      # into either
+      #   render(template: "foo", ...)
+      # or
+      #   render(partial: "foo", ...)
+      def normalize_args(string, options_hash)
+        if options_hash
+          { partial: string, locals: options_hash }
+        else
+          { partial: string }
+        end
+      end
+
+      def parse_render(node)
+        node = node.argument_nodes
+
+        if (node.length == 1 || node.length == 2) && !node[0].hash?
+          if node.length == 1
+            options = normalize_args(node[0], nil)
+          elsif node.length == 2
+            options = normalize_args(node[0], node[1])
+          end
+
+          return nil unless options
+
+          parse_render_from_options(options)
+        elsif node.length == 1 && node[0].hash?
+          options = parse_hash_to_symbols(node[0])
+
+          return nil unless options
+
+          parse_render_from_options(options)
+        else
+          nil
+        end
+      end
+
+      def parse_hash(node)
+        node.hash? && node.to_hash
+      end
+
+      def parse_hash_to_symbols(node)
+        hash = parse_hash(node)
+
+        return unless hash
+
+        hash.transform_keys do |key_node|
+          key = parse_sym(key_node)
+
+          return unless key
+
+          key
+        end
+      end
+
+      ALL_KNOWN_KEYS = [:partial, :template, :layout, :formats, :locals, :object, :collection, :as, :status, :content_type, :location, :spacer_template]
+
+      RENDER_TYPE_KEYS =
+        [:partial, :template, :layout]
+
+      def parse_render_from_options(options_hash)
+        renders = []
+        keys = options_hash.keys
+
+        if (keys & RENDER_TYPE_KEYS).size < 1
+          # Must have at least one of render keys
+          return nil
+        end
+
+        if (keys - ALL_KNOWN_KEYS).any?
+          # de-opt in case of unknown option
+          return nil
+        end
+
+        render_type = (keys & RENDER_TYPE_KEYS)[0]
+
+        node = options_hash[render_type]
+
+        if node.string?
+          template = resolve_path_directory(node.to_string)
+        else
+          if node.variable_reference?
+            dependency = node.variable_name.sub(/\A(?:\$|@{1,2})/, "")
+          elsif node.vcall?
+            dependency = node.variable_name
+          elsif node.call?
+            dependency = node.call_method_name
+          else
+            return
+          end
+
+          object_template = true
+          template = "#{dependency.pluralize}/#{dependency.singularize}"
+        end
+
+        return unless template
+
+        if spacer_template = render_template_with_spacer?(options_hash)
+          virtual_path = partial_to_virtual_path(:partial, spacer_template)
+          renders << virtual_path
+        end
+
+        if options_hash.key?(:object) || options_hash.key?(:collection) || object_template
+          return nil if options_hash.key?(:object) && options_hash.key?(:collection)
+          return nil unless options_hash.key?(:partial)
+        end
+
+        virtual_path = partial_to_virtual_path(render_type, template)
+        renders << virtual_path
+
+        # Support for rendering multiple templates (i.e. a partial with a layout)
+        if layout_template = render_template_with_layout?(render_type, options_hash)
+          virtual_path = partial_to_virtual_path(:layout, layout_template)
+
+          renders << virtual_path
+        end
+
+        renders
+      end
+
+      def parse_str(node)
+        node.string? && node.to_string
+      end
+
+      def parse_sym(node)
+        node.symbol? && node.to_symbol
+      end
+
+      private
+        def render_template_with_layout?(render_type, options_hash)
+          if render_type != :layout && options_hash.key?(:layout)
+            parse_str(options_hash[:layout])
+          end
+        end
+
+        def render_template_with_spacer?(options_hash)
+          if options_hash.key?(:spacer_template)
+            parse_str(options_hash[:spacer_template])
+          end
+        end
+
+        def partial_to_virtual_path(render_type, partial_path)
+          if render_type == :partial || render_type == :layout
+            partial_path.gsub(%r{(/|^)([^/]*)\z}, '\1_\2')
+          else
+            partial_path
+          end
+        end
+
+        def layout_to_virtual_path(layout_path)
+          "layouts/#{layout_path}"
+        end
+  end
+end

data/lib/action_view/renderer/abstract_renderer.rb

@@ -1,3 +1,7 @@
+# frozen_string_literal: true
+
+require "concurrent/map"
+
 module ActionView
   # This class defines the interface for a renderer. Each class that
   # subclasses +AbstractRenderer+ is used by the base +Renderer+ class to
@@ -12,10 +16,10 @@ module ActionView
   #
   # Whenever the +render+ method is called on the base +Renderer+ class, a new
   # renderer object of the correct type is created, and the +render+ method on
-  # that new object is called in turn. This abstracts the setup and rendering
+  # that new object is called in turn. This abstracts the set up and rendering
   # into a separate classes for partials and templates.
-  class AbstractRenderer #:nodoc:
-    delegate :find_template, :find_file, :template_exists?, :with_fallbacks, :with_layout_format, :formats, :to => :@lookup_context
+  class AbstractRenderer # :nodoc:
+    delegate :template_exists?, :any_templates?, :formats, to: :@lookup_context
 
     def initialize(lookup_context)
       @lookup_context = lookup_context
@@ -25,25 +29,158 @@ module ActionView
       raise NotImplementedError
     end
 
-    protected
-
-    def extract_details(options)
-      @lookup_context.registered_details.each_with_object({}) do |key, details|
-        value = options[key]
+    module ObjectRendering # :nodoc:
+      PREFIXED_PARTIAL_NAMES = Concurrent::Map.new do |h, k|
+        h[k] = Concurrent::Map.new
+      end
 
-        details[key] = Array(value) if value
+      def initialize(lookup_context, options)
+        super
+        @context_prefix = lookup_context.prefixes.first
       end
+
+      private
+        def local_variable(path)
+          if as = @options[:as]
+            raise_invalid_option_as(as) unless /\A[a-z_]\w*\z/.match?(as.to_s)
+            as.to_sym
+          else
+            base = path.end_with?("/") ? "" : File.basename(path)
+            raise_invalid_identifier(path) unless base =~ /\A_?(.*?)(?:\.\w+)*\z/
+            $1.to_sym
+          end
+        end
+
+        IDENTIFIER_ERROR_MESSAGE = "The partial name (%s) is not a valid Ruby identifier; " \
+                                   "make sure your partial name starts with underscore."
+
+        OPTION_AS_ERROR_MESSAGE  = "The value (%s) of the option `as` is not a valid Ruby identifier; " \
+                                   "make sure it starts with lowercase letter, " \
+                                   "and is followed by any combination of letters, numbers and underscores."
+
+        def raise_invalid_identifier(path)
+          raise ArgumentError, IDENTIFIER_ERROR_MESSAGE % path
+        end
+
+        def raise_invalid_option_as(as)
+          raise ArgumentError, OPTION_AS_ERROR_MESSAGE % as
+        end
+
+        # Obtains the path to where the object's partial is located. If the object
+        # responds to +to_partial_path+, then +to_partial_path+ will be called and
+        # will provide the path. If the object does not respond to +to_partial_path+,
+        # then an +ArgumentError+ is raised.
+        #
+        # If +prefix_partial_path_with_controller_namespace+ is true, then this
+        # method will prefix the partial paths with a namespace.
+        def partial_path(object, view)
+          object = object.to_model if object.respond_to?(:to_model)
+
+          path = if object.respond_to?(:to_partial_path)
+            object.to_partial_path
+          else
+            raise ArgumentError.new("'#{object.inspect}' is not an ActiveModel-compatible object. It must implement :to_partial_path.")
+          end
+
+          if view.prefix_partial_path_with_controller_namespace
+            PREFIXED_PARTIAL_NAMES[@context_prefix][path] ||= merge_prefix_into_object_path(@context_prefix, path.dup)
+          else
+            path
+          end
+        end
+
+        def merge_prefix_into_object_path(prefix, object_path)
+          if prefix.include?(?/) && object_path.include?(?/)
+            prefixes = []
+            prefix_array = File.dirname(prefix).split("/")
+            object_path_array = object_path.split("/")[0..-3] # skip model dir & partial
+
+            prefix_array.each_with_index do |dir, index|
+              break if dir == object_path_array[index]
+              prefixes << dir
+            end
+
+            (prefixes << object_path).join("/")
+          else
+            object_path
+          end
+        end
     end
 
-    def instrument(name, options={})
-      ActiveSupport::Notifications.instrument("render_#{name}.action_view", options){ yield }
+    class RenderedCollection # :nodoc:
+      def self.empty(format)
+        EmptyCollection.new format
+      end
+
+      attr_reader :rendered_templates
+
+      def initialize(rendered_templates, spacer)
+        @rendered_templates = rendered_templates
+        @spacer = spacer
+      end
+
+      def body
+        @rendered_templates.map(&:body).join(@spacer.body).html_safe
+      end
+
+      def format
+        rendered_templates.first.format
+      end
+
+      class EmptyCollection
+        attr_reader :format
+
+        def initialize(format)
+          @format = format
+        end
+
+        def body; nil; end
+      end
     end
 
-    def prepend_formats(formats)
-      formats = Array(formats)
-      return if formats.empty? || @lookup_context.html_fallback_for_js
+    class RenderedTemplate # :nodoc:
+      attr_reader :body, :template
 
-      @lookup_context.formats = formats | @lookup_context.formats
+      def initialize(body, template)
+        @body = body
+        @template = template
+      end
+
+      def format
+        template.format
+      end
+
+      EMPTY_SPACER = Struct.new(:body).new
     end
+
+    private
+      NO_DETAILS = {}.freeze
+
+      def extract_details(options) # :doc:
+        details = nil
+        LookupContext.registered_details.each do |key|
+          value = options[key]
+
+          if value
+            (details ||= {})[key] = Array(value)
+          end
+        end
+        details || NO_DETAILS
+      end
+
+      def prepend_formats(formats) # :doc:
+        formats = Array(formats)
+        return if formats.empty? || @lookup_context.html_fallback_for_js
+
+        @lookup_context.formats = formats | @lookup_context.formats
+      end
+
+      def build_rendered_template(content, template)
+        RenderedTemplate.new content, template
+      end
+
+      def build_rendered_collection(templates, spacer)
+        RenderedCollection.new templates, spacer
+      end
   end
 end

data/lib/action_view/renderer/collection_renderer.rb

@@ -0,0 +1,196 @@
+# frozen_string_literal: true
+
+require "action_view/renderer/partial_renderer"
+
+module ActionView
+  class PartialIteration
+    # The number of iterations that will be done by the partial.
+    attr_reader :size
+
+    # The current iteration of the partial.
+    attr_reader :index
+
+    def initialize(size)
+      @size  = size
+      @index = 0
+    end
+
+    # Check if this is the first iteration of the partial.
+    def first?
+      index == 0
+    end
+
+    # Check if this is the last iteration of the partial.
+    def last?
+      index == size - 1
+    end
+
+    def iterate! # :nodoc:
+      @index += 1
+    end
+  end
+
+  class CollectionRenderer < PartialRenderer # :nodoc:
+    include ObjectRendering
+
+    class CollectionIterator # :nodoc:
+      include Enumerable
+
+      def initialize(collection)
+        @collection = collection
+      end
+
+      def each(&blk)
+        @collection.each(&blk)
+      end
+
+      def size
+        @collection.size
+      end
+
+      def length
+        @collection.respond_to?(:length) ? @collection.length : size
+      end
+    end
+
+    class SameCollectionIterator < CollectionIterator # :nodoc:
+      def initialize(collection, path, variables)
+        super(collection)
+        @path      = path
+        @variables = variables
+      end
+
+      def from_collection(collection)
+        self.class.new(collection, @path, @variables)
+      end
+
+      def each_with_info
+        return enum_for(:each_with_info) unless block_given?
+        variables = [@path] + @variables
+        @collection.each { |o| yield(o, variables) }
+      end
+    end
+
+    class PreloadCollectionIterator < SameCollectionIterator # :nodoc:
+      def initialize(collection, path, variables, relation)
+        super(collection, path, variables)
+        relation.skip_preloading! unless relation.loaded?
+        @relation = relation
+      end
+
+      def from_collection(collection)
+        self.class.new(collection, @path, @variables, @relation)
+      end
+
+      def each_with_info
+        return super unless block_given?
+        @relation.preload_associations(@collection)
+        super
+      end
+    end
+
+    class MixedCollectionIterator < CollectionIterator # :nodoc:
+      def initialize(collection, paths)
+        super(collection)
+        @paths = paths
+      end
+
+      def each_with_info
+        return enum_for(:each_with_info) unless block_given?
+        @collection.each_with_index { |o, i| yield(o, @paths[i]) }
+      end
+    end
+
+    def render_collection_with_partial(collection, partial, context, block)
+      iter_vars  = retrieve_variable(partial)
+
+      collection = if collection.respond_to?(:preload_associations)
+        PreloadCollectionIterator.new(collection, partial, iter_vars, collection)
+      else
+        SameCollectionIterator.new(collection, partial, iter_vars)
+      end
+
+      template = find_template(partial, @locals.keys + iter_vars)
+
+      layout = if !block && (layout = @options[:layout])
+        find_template(layout.to_s, @locals.keys + iter_vars)
+      end
+
+      render_collection(collection, context, partial, template, layout, block)
+    end
+
+    def render_collection_derive_partial(collection, context, block)
+      paths = collection.map { |o| partial_path(o, context) }
+
+      if paths.uniq.length == 1
+        # Homogeneous
+        render_collection_with_partial(collection, paths.first, context, block)
+      else
+        if @options[:cached]
+          raise NotImplementedError, "render caching requires a template. Please specify a partial when rendering"
+        end
+
+        paths.map! { |path| retrieve_variable(path).unshift(path) }
+        collection = MixedCollectionIterator.new(collection, paths)
+        render_collection(collection, context, nil, nil, nil, block)
+      end
+    end
+
+    private
+      def retrieve_variable(path)
+        variable = local_variable(path)
+        [variable, :"#{variable}_counter", :"#{variable}_iteration"]
+      end
+
+      def render_collection(collection, view, path, template, layout, block)
+        identifier = (template && template.identifier) || path
+        ActiveSupport::Notifications.instrument(
+          "render_collection.action_view",
+          identifier: identifier,
+          layout: layout && layout.virtual_path,
+          count: collection.length
+        ) do |payload|
+          spacer = if @options.key?(:spacer_template)
+            spacer_template = find_template(@options[:spacer_template], @locals.keys)
+            build_rendered_template(spacer_template.render(view, @locals), spacer_template)
+          else
+            RenderedTemplate::EMPTY_SPACER
+          end
+
+          collection_body = if template
+            cache_collection_render(payload, view, template, collection) do |filtered_collection|
+              collection_with_template(view, template, layout, filtered_collection)
+            end
+          else
+            collection_with_template(view, nil, layout, collection)
+          end
+
+          return RenderedCollection.empty(@lookup_context.formats.first) if collection_body.empty?
+
+          build_rendered_collection(collection_body, spacer)
+        end
+      end
+
+      def collection_with_template(view, template, layout, collection)
+        locals = @locals
+        cache = {}
+
+        partial_iteration = PartialIteration.new(collection.size)
+
+        collection.each_with_info.map do |object, (path, as, counter, iteration)|
+          index = partial_iteration.index
+
+          locals[as]        = object
+          locals[counter]   = index
+          locals[iteration] = partial_iteration
+
+          _template = (cache[path] ||= (template || find_template(path, @locals.keys + [as, counter, iteration])))
+
+          content = _template.render(view, locals)
+          content = layout.render(view, locals) { content } if layout
+          partial_iteration.iterate!
+          build_rendered_template(content, _template)
+        end
+      end
+  end
+end