jets 1.9.7 → 1.9.8

data/vendor/rails/actionview/lib/action_view/renderer/partial_renderer/collection_caching.rb

@@ -1,57 +0,0 @@
-# frozen_string_literal: true
-
-module ActionView
-  module CollectionCaching # :nodoc:
-    extend ActiveSupport::Concern
-
-    included do
-      # Fallback cache store if Action View is used without Rails.
-      # Otherwise overridden in Railtie to use Rails.cache.
-      mattr_accessor :collection_cache, default: ActiveSupport::Cache::MemoryStore.new
-    end
-
-    private
-      def cache_collection_render(instrumentation_payload)
-        return yield unless @options[:cached]
-
-        keyed_collection = collection_by_cache_keys
-        cached_partials  = collection_cache.read_multi(*keyed_collection.keys)
-        instrumentation_payload[:cache_hits] = cached_partials.size
-
-        @collection = keyed_collection.reject { |key, _| cached_partials.key?(key) }.values
-        rendered_partials = @collection.empty? ? [] : yield
-
-        index = 0
-        fetch_or_cache_partial(cached_partials, order_by: keyed_collection.each_key) do
-          rendered_partials[index].tap { index += 1 }
-        end
-      end
-
-      def callable_cache_key?
-        @options[:cached].respond_to?(:call)
-      end
-
-      def collection_by_cache_keys
-        seed = callable_cache_key? ? @options[:cached] : ->(i) { i }
-
-        @collection.each_with_object({}) do |item, hash|
-          hash[expanded_cache_key(seed.call(item))] = item
-        end
-      end
-
-      def expanded_cache_key(key)
-        key = @view.combined_fragment_cache_key(@view.cache_fragment_name(key, virtual_path: @template.virtual_path))
-        key.frozen? ? key.dup : key # #read_multi & #write may require mutability, Dalli 2.6.0.
-      end
-
-      def fetch_or_cache_partial(cached_partials, order_by:)
-        order_by.map do |cache_key|
-          cached_partials.fetch(cache_key) do
-            yield.tap do |rendered_partial|
-              collection_cache.write(cache_key, rendered_partial)
-            end
-          end
-        end
-      end
-  end
-end

data/vendor/rails/actionview/lib/action_view/renderer/renderer.rb

@@ -1,56 +0,0 @@
-# frozen_string_literal: true
-
-module ActionView
-  # 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)
-      if options.key?(:partial)
-        render_partial(context, options)
-      else
-        render_template(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
-
-    # Direct access to template rendering.
-    def render_template(context, options) #:nodoc:
-      TemplateRenderer.new(@lookup_context).render(context, options)
-    end
-
-    # Direct access to partial rendering.
-    def render_partial(context, options, &block) #:nodoc:
-      PartialRenderer.new(@lookup_context).render(context, options, block)
-    end
-
-    def cache_hits # :nodoc:
-      @cache_hits ||= {}
-    end
-  end
-end

data/vendor/rails/actionview/lib/action_view/renderer/streaming_template_renderer.rb

@@ -1,105 +0,0 @@
-# frozen_string_literal: true
-
-require "fiber"
-
-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".dup
-          message << exception.annoted_source_code.to_s if exception.respond_to?(:annoted_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(template, layout_name = nil, locals = {}) #:nodoc:
-      return [super] unless layout_name && template.supports_streaming?
-
-      locals ||= {}
-      layout   = layout_name && 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) }
-
-        instrument(:template, identifier: template.identifier, layout: layout.try(:virtual_path)) 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/vendor/rails/actionview/lib/action_view/renderer/template_renderer.rb

@@ -1,102 +0,0 @@
-# frozen_string_literal: true
-
-require "active_support/core_ext/object/try"
-
-module ActionView
-  class TemplateRenderer < AbstractRenderer #:nodoc:
-    def render(context, options)
-      @view    = context
-      @details = extract_details(options)
-      template = determine_template(options)
-
-      prepend_formats(template.formats)
-
-      @lookup_context.rendered_format ||= (template.formats.first || formats.first)
-
-      render_template(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)
-          with_fallbacks { find_file(options[:file], nil, false, keys, @details) }
-        elsif options.key?(:inline)
-          handler = Template.handler_for_extension(options[:type] || "erb")
-          Template.new(options[:inline], "inline template", handler, locals: keys)
-        elsif options.key?(:template)
-          if options[:template].respond_to?(:render)
-            options[:template]
-          else
-            find_template(options[:template], options[:prefixes], false, keys, @details)
-          end
-        else
-          raise ArgumentError, "You invoked render but did not give any of :partial, :template, :inline, :file, :plain, :html or :body option."
-        end
-      end
-
-      # Renders the given template. A string representing the layout can be
-      # supplied as well.
-      def render_template(template, layout_name = nil, locals = nil)
-        view, locals = @view, locals || {}
-
-        render_with_layout(layout_name, locals) do |layout|
-          instrument(:template, identifier: template.identifier, layout: layout.try(:virtual_path)) do
-            template.render(view, locals) { |*name| view._layout_for(*name) }
-          end
-        end
-      end
-
-      def render_with_layout(path, locals)
-        layout  = path && find_layout(path, locals.keys, [formats.first])
-        content = yield(layout)
-
-        if layout
-          view = @view
-          view.view_flow.set(:layout, content)
-          layout.render(view, locals) { |*name| view._layout_for(*name) }
-        else
-          content
-        end
-      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?("/")
-              with_fallbacks { find_template(layout, nil, false, [], details) }
-            else
-              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(formats), keys, formats)
-        else
-          layout
-        end
-      end
-  end
-end

data/vendor/rails/actionview/lib/action_view/rendering.rb

@@ -1,151 +0,0 @@
-# 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, @lookup_context = original_config, 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
-
-    # Overwrite process to setup 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 view_context_class
-        @view_context_class ||= begin
-          supports_path = supports_path?
-          routes  = respond_to?(:_routes)  && _routes
-          helpers = respond_to?(:_helpers) && _helpers
-
-          Class.new(ActionView::Base) do
-            if routes
-              include routes.url_helpers(supports_path)
-              include routes.mounted_helpers
-            end
-
-            if helpers
-              include helpers
-            end
-          end
-        end
-      end
-    end
-
-    attr_internal_writer :view_context_class
-
-    def view_context_class
-      @_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:
-    # View.new[lookup_context, assigns, controller]
-    #   Create a new ActionView instance for a controller and we can also pass the arguments.
-    # View#render(option)
-    #   Returns String with the rendered template
-    #
-    # Override this method in a module to change the default behavior.
-    def view_context
-      view_context_class.new(view_renderer, view_assigns, self)
-    end
-
-    # Returns an object that is able to render templates.
-    def view_renderer # :nodoc:
-      @_view_renderer ||= ActionView::Renderer.new(lookup_context)
-    end
-
-    def render_to_body(options = {})
-      _process_options(options)
-      _render_template(options)
-    end
-
-    def rendered_format
-      Template::Types[lookup_context.rendered_format]
-    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.rendered_format = nil if options[:formats]
-        lookup_context.variants = variant if variant
-
-        view_renderer.render(context, options)
-      end
-
-      # Assign the rendered format to look up context.
-      def _process_format(format)
-        super
-        lookup_context.formats = [format.to_sym]
-        lookup_context.rendered_format = lookup_context.formats.first
-      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
-          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 & [:partial, :file, :template]).empty?
-          options[:prefixes] ||= _prefixes
-        end
-
-        options[:template] ||= (options[:action] || action_name).to_s
-        options
-      end
-  end
-end