omg-actionview 8.0.0.alpha1

data/lib/action_view/renderer/renderer.rb

@@ -0,0 +1,107 @@
+# frozen_string_literal: true
+
+module ActionView
+  # = Action View \Renderer
+  #
+  # This is the main entry point for rendering. It basically delegates
+  # to other objects like TemplateRenderer and PartialRenderer which
+  # actually renders the template.
+  #
+  # The Renderer will parse the options from the +render+ or +render_body+
+  # method and render a partial or a template based on the options. The
+  # +TemplateRenderer+ and +PartialRenderer+ objects are wrappers which do all
+  # the setup and logic necessary to render a view and a new object is created
+  # each time +render+ is called.
+  class Renderer
+    attr_accessor :lookup_context
+
+    def initialize(lookup_context)
+      @lookup_context = lookup_context
+    end
+
+    # Main render entry point shared by Action View and Action Controller.
+    def render(context, options)
+      render_to_object(context, options).body
+    end
+
+    def render_to_object(context, options) # :nodoc:
+      if options.key?(:partial)
+        render_partial_to_object(context, options)
+      else
+        render_template_to_object(context, options)
+      end
+    end
+
+    # Render but returns a valid Rack body. If fibers are defined, we return
+    # a streaming body that renders the template piece by piece.
+    #
+    # Note that partials are not supported to be rendered with streaming,
+    # so in such cases, we just wrap them in an array.
+    def render_body(context, options)
+      if options.key?(:partial)
+        [render_partial(context, options)]
+      else
+        StreamingTemplateRenderer.new(@lookup_context).render(context, options)
+      end
+    end
+
+    def render_partial(context, options, &block) # :nodoc:
+      render_partial_to_object(context, options, &block).body
+    end
+
+    def cache_hits # :nodoc:
+      @cache_hits ||= {}
+    end
+
+    private
+      def render_template_to_object(context, options)
+        TemplateRenderer.new(@lookup_context).render(context, options)
+      end
+
+      def render_partial_to_object(context, options, &block)
+        partial = options[:partial]
+        if String === partial
+          collection = collection_from_options(options)
+
+          if collection
+            # Collection + Partial
+            renderer = CollectionRenderer.new(@lookup_context, options)
+            renderer.render_collection_with_partial(collection, partial, context, block)
+          else
+            if options.key?(:object)
+              # Object + Partial
+              renderer = ObjectRenderer.new(@lookup_context, options)
+              renderer.render_object_with_partial(options[:object], partial, context, block)
+            else
+              # Partial
+              renderer = PartialRenderer.new(@lookup_context, options)
+              renderer.render(partial, context, block)
+            end
+          end
+        else
+          collection = collection_from_object(partial) || collection_from_options(options)
+
+          if collection
+            # Collection + Derived Partial
+            renderer = CollectionRenderer.new(@lookup_context, options)
+            renderer.render_collection_derive_partial(collection, context, block)
+          else
+            # Object + Derived Partial
+            renderer = ObjectRenderer.new(@lookup_context, options)
+            renderer.render_object_derive_partial(partial, context, block)
+          end
+        end
+      end
+
+      def collection_from_options(options)
+        if options.key?(:collection)
+          collection = options[:collection]
+          collection || []
+        end
+      end
+
+      def collection_from_object(object)
+        object if object.respond_to?(:to_ary)
+      end
+  end
+end

data/lib/action_view/renderer/streaming_template_renderer.rb

@@ -0,0 +1,107 @@
+# frozen_string_literal: true
+
+
+module ActionView
+  # == TODO
+  #
+  # * Support streaming from child templates, partials and so on.
+  # * Rack::Cache needs to support streaming bodies
+  class StreamingTemplateRenderer < TemplateRenderer # :nodoc:
+    # A valid Rack::Body (i.e. it responds to each).
+    # It is initialized with a block that, when called, starts
+    # rendering the template.
+    class Body # :nodoc:
+      def initialize(&start)
+        @start = start
+      end
+
+      def each(&block)
+        begin
+          @start.call(block)
+        rescue Exception => exception
+          log_error(exception)
+          block.call ActionView::Base.streaming_completion_on_exception
+        end
+        self
+      end
+
+      private
+        # This is the same logging logic as in ShowExceptions middleware.
+        def log_error(exception)
+          logger = ActionView::Base.logger
+          return unless logger
+
+          message = +"\n#{exception.class} (#{exception.message}):\n"
+          message << exception.annotated_source_code.to_s if exception.respond_to?(:annotated_source_code)
+          message << "  " << exception.backtrace.join("\n  ")
+          logger.fatal("#{message}\n\n")
+        end
+    end
+
+    # For streaming, instead of rendering a given a template, we return a Body
+    # object that responds to each. This object is initialized with a block
+    # that knows how to render the template.
+    def render_template(view, template, layout_name = nil, locals = {}) # :nodoc:
+      return [super.body] unless layout_name && template.supports_streaming?
+
+      locals ||= {}
+      layout   = find_layout(layout_name, locals.keys, [formats.first])
+
+      Body.new do |buffer|
+        delayed_render(buffer, template, layout, view, locals)
+      end
+    end
+
+    private
+      def delayed_render(buffer, template, layout, view, locals)
+        # Wrap the given buffer in the StreamingBuffer and pass it to the
+        # underlying template handler. Now, every time something is concatenated
+        # to the buffer, it is not appended to an array, but streamed straight
+        # to the client.
+        output  = ActionView::StreamingBuffer.new(buffer)
+        yielder = lambda { |*name| view._layout_for(*name) }
+
+        ActiveSupport::Notifications.instrument(
+          "render_template.action_view",
+          identifier: template.identifier,
+          layout: layout && layout.virtual_path,
+          locals: locals
+        ) do
+          outer_config = I18n.config
+          fiber = Fiber.new do
+            I18n.config = outer_config
+            if layout
+              layout.render(view, locals, output, &yielder)
+            else
+              # If you don't have a layout, just render the thing
+              # and concatenate the final result. This is the same
+              # as a layout with just <%= yield %>
+              output.safe_concat view._layout_for
+            end
+          end
+
+          # Set the view flow to support streaming. It will be aware
+          # when to stop rendering the layout because it needs to search
+          # something in the template and vice-versa.
+          view.view_flow = StreamingFlow.new(view, fiber)
+
+          # Yo! Start the fiber!
+          fiber.resume
+
+          # If the fiber is still alive, it means we need something
+          # from the template, so start rendering it. If not, it means
+          # the layout exited without requiring anything from the template.
+          if fiber.alive?
+            content = template.render(view, locals, &yielder)
+
+            # Once rendering the template is done, sets its content in the :layout key.
+            view.view_flow.set(:layout, content)
+
+            # In case the layout continues yielding, we need to resume
+            # the fiber until all yields are handled.
+            fiber.resume while fiber.alive?
+          end
+        end
+      end
+  end
+end

data/lib/action_view/renderer/template_renderer.rb

@@ -0,0 +1,115 @@
+# frozen_string_literal: true
+
+module ActionView
+  class TemplateRenderer < AbstractRenderer # :nodoc:
+    def render(context, options)
+      @details = extract_details(options)
+      template = determine_template(options)
+
+      prepend_formats(template.format)
+
+      render_template(context, template, options[:layout], options[:locals] || {})
+    end
+
+    private
+      # Determine the template to be rendered using the given options.
+      def determine_template(options)
+        keys = options.has_key?(:locals) ? options[:locals].keys : []
+
+        if options.key?(:body)
+          Template::Text.new(options[:body])
+        elsif options.key?(:plain)
+          Template::Text.new(options[:plain])
+        elsif options.key?(:html)
+          Template::HTML.new(options[:html], formats.first)
+        elsif options.key?(:file)
+          if File.exist?(options[:file])
+            Template::RawFile.new(options[:file])
+          else
+            if Pathname.new(options[:file]).absolute?
+              raise ArgumentError, "File #{options[:file]} does not exist"
+            else
+              raise ArgumentError, "`render file:` should be given the absolute path to a file. '#{options[:file]}' was given instead"
+            end
+          end
+        elsif options.key?(:inline)
+          handler = Template.handler_for_extension(options[:type] || "erb")
+          format = if handler.respond_to?(:default_format)
+            handler.default_format
+          else
+            @lookup_context.formats.first
+          end
+          Template::Inline.new(options[:inline], "inline template", handler, locals: keys, format: format)
+        elsif options.key?(:renderable)
+          Template::Renderable.new(options[:renderable])
+        elsif options.key?(:template)
+          if options[:template].respond_to?(:render)
+            options[:template]
+          else
+            @lookup_context.find_template(options[:template], options[:prefixes], false, keys, @details)
+          end
+        else
+          raise ArgumentError, "You invoked render but did not give any of :body, :file, :html, :inline, :partial, :plain, :renderable, or :template option."
+        end
+      end
+
+      # Renders the given template. A string representing the layout can be
+      # supplied as well.
+      def render_template(view, template, layout_name, locals)
+        render_with_layout(view, template, layout_name, locals) do |layout|
+          ActiveSupport::Notifications.instrument(
+            "render_template.action_view",
+            identifier: template.identifier,
+            layout: layout && layout.virtual_path,
+            locals: locals
+          ) do
+            template.render(view, locals) { |*name| view._layout_for(*name) }
+          end
+        end
+      end
+
+      def render_with_layout(view, template, path, locals)
+        layout  = path && find_layout(path, locals.keys, [formats.first])
+
+        body = if layout
+          ActiveSupport::Notifications.instrument("render_layout.action_view", identifier: layout.identifier) do
+            view.view_flow.set(:layout, yield(layout))
+            layout.render(view, locals) { |*name| view._layout_for(*name) }
+          end
+        else
+          yield
+        end
+        build_rendered_template(body, template)
+      end
+
+      # This is the method which actually finds the layout using details in the lookup
+      # context object. If no layout is found, it checks if at least a layout with
+      # the given name exists across all details before raising the error.
+      def find_layout(layout, keys, formats)
+        resolve_layout(layout, keys, formats)
+      end
+
+      def resolve_layout(layout, keys, formats)
+        details = @details.dup
+        details[:formats] = formats
+
+        case layout
+        when String
+          begin
+            if layout.start_with?("/")
+              raise ArgumentError, "Rendering layouts from an absolute path is not supported."
+            else
+              @lookup_context.find_template(layout, nil, false, [], details)
+            end
+          rescue ActionView::MissingTemplate
+            all_details = @details.merge(formats: @lookup_context.default_formats)
+            raise unless template_exists?(layout, nil, false, [], **all_details)
+          end
+        when Proc
+          resolve_layout(layout.call(@lookup_context, formats), keys, formats)
+        else
+          layout
+        end
+      end
+  end
+end

data/lib/action_view/rendering.rb

@@ -0,0 +1,190 @@
+# frozen_string_literal: true
+
+require "action_view/view_paths"
+
+module ActionView
+  # This is a class to fix I18n global state. Whenever you provide I18n.locale during a request,
+  # it will trigger the lookup_context and consequently expire the cache.
+  class I18nProxy < ::I18n::Config # :nodoc:
+    attr_reader :original_config, :lookup_context
+
+    def initialize(original_config, lookup_context)
+      original_config = original_config.original_config if original_config.respond_to?(:original_config)
+      @original_config = original_config
+      @lookup_context = lookup_context
+    end
+
+    def locale
+      @original_config.locale
+    end
+
+    def locale=(value)
+      @lookup_context.locale = value
+    end
+  end
+
+  module Rendering
+    extend ActiveSupport::Concern
+    include ActionView::ViewPaths
+
+    attr_internal_reader :rendered_format
+
+    def initialize
+      @_rendered_format = nil
+      super
+    end
+
+    # Override process to set up I18n proxy.
+    def process(...) # :nodoc:
+      old_config, I18n.config = I18n.config, I18nProxy.new(I18n.config, lookup_context)
+      super
+    ensure
+      I18n.config = old_config
+    end
+
+    module ClassMethods
+      def _routes
+      end
+
+      def _helpers
+      end
+
+      def inherit_view_context_class?
+        superclass.respond_to?(:view_context_class) &&
+          supports_path? == superclass.supports_path? &&
+          _routes.equal?(superclass._routes) &&
+          _helpers.equal?(superclass._helpers)
+      end
+
+      def build_view_context_class(klass, supports_path, routes, helpers)
+        if inherit_view_context_class?
+          return superclass.view_context_class
+        end
+
+        Class.new(klass) do
+          if routes
+            include routes.url_helpers(supports_path)
+            include routes.mounted_helpers
+          end
+
+          if helpers
+            include helpers
+          end
+        end
+      end
+
+      def eager_load!
+        super
+        view_context_class
+        nil
+      end
+
+      def view_context_class
+        klass = ActionView::LookupContext::DetailsKey.view_context_class
+
+        @view_context_class ||= build_view_context_class(klass, supports_path?, _routes, _helpers)
+
+        if klass.changed?(@view_context_class)
+          @view_context_class = build_view_context_class(klass, supports_path?, _routes, _helpers)
+        end
+
+        @view_context_class
+      end
+    end
+
+    def view_context_class
+      self.class.view_context_class
+    end
+
+    # An instance of a view class. The default view class is ActionView::Base.
+    #
+    # The view class must have the following methods:
+    #
+    # * <tt>View.new(lookup_context, assigns, controller)</tt> — Create a new
+    #   ActionView instance for a controller and we can also pass the arguments.
+    #
+    # * <tt>View#render(option)</tt> — Returns String with the rendered template.
+    #
+    # Override this method in a module to change the default behavior.
+    def view_context
+      view_context_class.new(lookup_context, view_assigns, self)
+    end
+
+    # Returns an object that is able to render templates.
+    def view_renderer # :nodoc:
+      # Lifespan: Per controller
+      @_view_renderer ||= ActionView::Renderer.new(lookup_context)
+    end
+
+    def render_to_body(options = {})
+      _process_options(options)
+      _render_template(options)
+    end
+
+    private
+      # Find and render a template based on the options given.
+      def _render_template(options)
+        variant = options.delete(:variant)
+        assigns = options.delete(:assigns)
+        context = view_context
+
+        context.assign assigns if assigns
+        lookup_context.variants = variant if variant
+
+        rendered_template = context.in_rendering_context(options) do |renderer|
+          renderer.render_to_object(context, options)
+        end
+
+        rendered_format = rendered_template.format || lookup_context.formats.first
+        @_rendered_format = Template::Types[rendered_format]
+
+        rendered_template.body
+      end
+
+      # Assign the rendered format to look up context.
+      def _process_format(format)
+        super
+        lookup_context.formats = [format.to_sym] if format.to_sym
+      end
+
+      # Normalize args by converting render "foo" to render action: "foo" and
+      # render "foo/bar" to render template: "foo/bar".
+      def _normalize_args(action = nil, options = {})
+        options = super(action, options)
+        case action
+        when NilClass
+        when Hash
+          options = action
+        when String, Symbol
+          action = action.to_s
+          key = action.include?(?/) ? :template : :action
+          options[key] = action
+        else
+          if action.respond_to?(:permitted?) && action.permitted?
+            options = action
+          elsif action.respond_to?(:render_in)
+            options[:renderable] = action
+          else
+            options[:partial] = action
+          end
+        end
+
+        options
+      end
+
+      # Normalize options.
+      def _normalize_options(options)
+        options = super(options)
+        if options[:partial] == true
+          options[:partial] = action_name
+        end
+
+        if !options.keys.intersect?([:partial, :file, :template])
+          options[:prefixes] ||= _prefixes
+        end
+
+        options[:template] ||= (options[:action] || action_name).to_s
+        options
+      end
+  end
+end

data/lib/action_view/routing_url_for.rb

@@ -0,0 +1,149 @@
+# 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 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 <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.
+    # * <tt>:user</tt> - Inline HTTP authentication (only plucked out if <tt>:password</tt> is also present).
+    # * <tt>:password</tt> - Inline HTTP authentication (only plucked out if <tt>:user</tt> is also present).
+    #
+    # ==== Relying on named routes
+    #
+    # Passing a record (like an Active Record) instead of a hash as the options parameter will
+    # trigger the named route for that record. The lookup will happen on the name of the class. So passing a
+    # Workshop object will attempt to use the +workshop_path+ route. If you have a nested route, such as
+    # +admin_workshop_path+ you'll have to call that explicitly (it's impossible for +url_for+ to guess that route).
+    #
+    # ==== Implicit Controller Namespacing
+    #
+    # Controllers passed in using the +:controller+ option will retain their namespace unless it is an absolute one.
+    #
+    # ==== Examples
+    #   <%= url_for(action: 'index') %>
+    #   # => /blogs/
+    #
+    #   <%= url_for(action: 'find', controller: 'books') %>
+    #   # => /books/find
+    #
+    #   <%= url_for(action: 'login', controller: 'members', only_path: false, protocol: 'https') %>
+    #   # => https://www.example.com/members/login/
+    #
+    #   <%= url_for(action: 'play', anchor: 'player') %>
+    #   # => /messages/play/#player
+    #
+    #   <%= 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
+    #
+    #   <%= url_for(@workshop) %>
+    #   # calls @workshop.to_param which by default returns the id
+    #   # => /workshops/5
+    #
+    #   # to_param can be re-defined in a model to provide different URL names:
+    #   # => /workshops/1-workshop-name
+    #
+    #   <%= url_for("http://www.example.com") %>
+    #   # => http://www.example.com
+    #
+    #   <%= url_for(:back) %>
+    #   # if request.env["HTTP_REFERER"] is set to "http://www.example.com"
+    #   # => http://www.example.com
+    #
+    #   <%= url_for(:back) %>
+    #   # if request.env["HTTP_REFERER"] is not set or is blank
+    #   # => javascript:history.back()
+    #
+    #   <%= url_for(action: 'index', controller: 'users') %>
+    #   # Assuming an "admin" namespace
+    #   # => /admin/users
+    #
+    #   <%= url_for(action: 'index', controller: '/users') %>
+    #   # Specify absolute path with beginning slash
+    #   # => /users
+    def url_for(options = nil)
+      case options
+      when String
+        options
+      when nil
+        super(only_path: _generate_paths_by_default)
+      when Hash
+        options = options.symbolize_keys
+        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
+        options = components.extract_options!
+        ensure_only_path_option(options)
+
+        if options[:only_path]
+          polymorphic_path(components, options)
+        else
+          polymorphic_url(components, options)
+        end
+      else
+        method = _generate_paths_by_default ? :path : :url
+        builder = ActionDispatch::Routing::PolymorphicRoutes::HelperMethodBuilder.public_send(method)
+
+        case options
+        when Symbol
+          builder.handle_string_call(self, options)
+        when Class
+          builder.handle_class_call(self, options)
+        else
+          builder.handle_model_call(self, options)
+        end
+      end
+    end
+
+    def url_options # :nodoc:
+      return super unless controller.respond_to?(:url_options)
+      controller.url_options
+    end
+
+    private
+      def _routes_context
+        controller
+      end
+
+      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