jets 1.9.7 → 1.9.8

data/vendor/rails/actionpack/lib/action_controller/metal/implicit_render.rb

@@ -1,73 +0,0 @@
-# frozen_string_literal: true
-
-module ActionController
-  # Handles implicit rendering for a controller action that does not
-  # explicitly respond with +render+, +respond_to+, +redirect+, or +head+.
-  #
-  # For API controllers, the implicit response is always <tt>204 No Content</tt>.
-  #
-  # For all other controllers, we use these heuristics to decide whether to
-  # render a template, raise an error for a missing template, or respond with
-  # <tt>204 No Content</tt>:
-  #
-  # First, if we DO find a template, it's rendered. Template lookup accounts
-  # for the action name, locales, format, variant, template handlers, and more
-  # (see +render+ for details).
-  #
-  # Second, if we DON'T find a template but the controller action does have
-  # templates for other formats, variants, etc., then we trust that you meant
-  # to provide a template for this response, too, and we raise
-  # <tt>ActionController::UnknownFormat</tt> with an explanation.
-  #
-  # Third, if we DON'T find a template AND the request is a page load in a web
-  # browser (technically, a non-XHR GET request for an HTML response) where
-  # you reasonably expect to have rendered a template, then we raise
-  # <tt>ActionView::UnknownFormat</tt> with an explanation.
-  #
-  # Finally, if we DON'T find a template AND the request isn't a browser page
-  # load, then we implicitly respond with <tt>204 No Content</tt>.
-  module ImplicitRender
-    # :stopdoc:
-    include BasicImplicitRender
-
-    def default_render(*args)
-      if template_exists?(action_name.to_s, _prefixes, variants: request.variant)
-        render(*args)
-      elsif any_templates?(action_name.to_s, _prefixes)
-        message = "#{self.class.name}\##{action_name} is missing a template " \
-          "for this request format and variant.\n" \
-          "\nrequest.formats: #{request.formats.map(&:to_s).inspect}" \
-          "\nrequest.variant: #{request.variant.inspect}"
-
-        raise ActionController::UnknownFormat, message
-      elsif interactive_browser_request?
-        message = "#{self.class.name}\##{action_name} is missing a template " \
-          "for this request format and variant.\n\n" \
-          "request.formats: #{request.formats.map(&:to_s).inspect}\n" \
-          "request.variant: #{request.variant.inspect}\n\n" \
-          "NOTE! For XHR/Ajax or API requests, this action would normally " \
-          "respond with 204 No Content: an empty white screen. Since you're " \
-          "loading it in a web browser, we assume that you expected to " \
-          "actually render a template, not nothing, so we're showing an " \
-          "error to be extra-clear. If you expect 204 No Content, carry on. " \
-          "That's what you'll get from an XHR or API request. Give it a shot."
-
-        raise ActionController::UnknownFormat, message
-      else
-        logger.info "No template found for #{self.class.name}\##{action_name}, rendering head :no_content" if logger
-        super
-      end
-    end
-
-    def method_for_action(action_name)
-      super || if template_exists?(action_name.to_s, _prefixes)
-                 "default_render"
-               end
-    end
-
-    private
-      def interactive_browser_request?
-        request.get? && request.format == Mime[:html] && !request.xhr?
-      end
-  end
-end

data/vendor/rails/actionpack/lib/action_controller/metal/instrumentation.rb

@@ -1,107 +0,0 @@
-# frozen_string_literal: true
-
-require "benchmark"
-require "abstract_controller/logger"
-
-module ActionController
-  # Adds instrumentation to several ends in ActionController::Base. It also provides
-  # some hooks related with process_action. This allows an ORM like Active Record
-  # and/or DataMapper to plug in ActionController and show related information.
-  #
-  # Check ActiveRecord::Railties::ControllerRuntime for an example.
-  module Instrumentation
-    extend ActiveSupport::Concern
-
-    include AbstractController::Logger
-
-    attr_internal :view_runtime
-
-    def process_action(*args)
-      raw_payload = {
-        controller: self.class.name,
-        action: action_name,
-        params: request.filtered_parameters,
-        headers: request.headers,
-        format: request.format.ref,
-        method: request.request_method,
-        path: request.fullpath
-      }
-
-      ActiveSupport::Notifications.instrument("start_processing.action_controller", raw_payload.dup)
-
-      ActiveSupport::Notifications.instrument("process_action.action_controller", raw_payload) do |payload|
-        begin
-          result = super
-          payload[:status] = response.status
-          result
-        ensure
-          append_info_to_payload(payload)
-        end
-      end
-    end
-
-    def render(*args)
-      render_output = nil
-      self.view_runtime = cleanup_view_runtime do
-        Benchmark.ms { render_output = super }
-      end
-      render_output
-    end
-
-    def send_file(path, options = {})
-      ActiveSupport::Notifications.instrument("send_file.action_controller",
-        options.merge(path: path)) do
-        super
-      end
-    end
-
-    def send_data(data, options = {})
-      ActiveSupport::Notifications.instrument("send_data.action_controller", options) do
-        super
-      end
-    end
-
-    def redirect_to(*args)
-      ActiveSupport::Notifications.instrument("redirect_to.action_controller") do |payload|
-        result = super
-        payload[:status]   = response.status
-        payload[:location] = response.filtered_location
-        result
-      end
-    end
-
-  private
-
-    # A hook invoked every time a before callback is halted.
-    def halted_callback_hook(filter)
-      ActiveSupport::Notifications.instrument("halted_callback.action_controller", filter: filter)
-    end
-
-    # A hook which allows you to clean up any time, wrongly taken into account in
-    # views, like database querying time.
-    #
-    #   def cleanup_view_runtime
-    #     super - time_taken_in_something_expensive
-    #   end
-    def cleanup_view_runtime # :doc:
-      yield
-    end
-
-    # Every time after an action is processed, this method is invoked
-    # with the payload, so you can add more information.
-    def append_info_to_payload(payload) # :doc:
-      payload[:view_runtime] = view_runtime
-    end
-
-    module ClassMethods
-      # A hook which allows other frameworks to log what happened during
-      # controller process action. This method should return an array
-      # with the messages to be added.
-      def log_process_action(payload) #:nodoc:
-        messages, view_runtime = [], payload[:view_runtime]
-        messages << ("Views: %.1fms" % view_runtime.to_f) if view_runtime
-        messages
-      end
-    end
-  end
-end

data/vendor/rails/actionpack/lib/action_controller/metal/live.rb

@@ -1,312 +0,0 @@
-# frozen_string_literal: true
-
-require "action_dispatch/http/response"
-require "delegate"
-require "active_support/json"
-
-module ActionController
-  # Mix this module into your controller, and all actions in that controller
-  # will be able to stream data to the client as it's written.
-  #
-  #   class MyController < ActionController::Base
-  #     include ActionController::Live
-  #
-  #     def stream
-  #       response.headers['Content-Type'] = 'text/event-stream'
-  #       100.times {
-  #         response.stream.write "hello world\n"
-  #         sleep 1
-  #       }
-  #     ensure
-  #       response.stream.close
-  #     end
-  #   end
-  #
-  # There are a few caveats with this module. You *cannot* write headers after the
-  # response has been committed (Response#committed? will return truthy).
-  # Calling +write+ or +close+ on the response stream will cause the response
-  # object to be committed. Make sure all headers are set before calling write
-  # or close on your stream.
-  #
-  # You *must* call close on your stream when you're finished, otherwise the
-  # socket may be left open forever.
-  #
-  # The final caveat is that your actions are executed in a separate thread than
-  # the main thread. Make sure your actions are thread safe, and this shouldn't
-  # be a problem (don't share state across threads, etc).
-  module Live
-    extend ActiveSupport::Concern
-
-    module ClassMethods
-      def make_response!(request)
-        if request.get_header("HTTP_VERSION") == "HTTP/1.0"
-          super
-        else
-          Live::Response.new.tap do |res|
-            res.request = request
-          end
-        end
-      end
-    end
-
-    # This class provides the ability to write an SSE (Server Sent Event)
-    # to an IO stream. The class is initialized with a stream and can be used
-    # to either write a JSON string or an object which can be converted to JSON.
-    #
-    # Writing an object will convert it into standard SSE format with whatever
-    # options you have configured. You may choose to set the following options:
-    #
-    #   1) Event. If specified, an event with this name will be dispatched on
-    #   the browser.
-    #   2) Retry. The reconnection time in milliseconds used when attempting
-    #   to send the event.
-    #   3) Id. If the connection dies while sending an SSE to the browser, then
-    #   the server will receive a +Last-Event-ID+ header with value equal to +id+.
-    #
-    # After setting an option in the constructor of the SSE object, all future
-    # SSEs sent across the stream will use those options unless overridden.
-    #
-    # Example Usage:
-    #
-    #   class MyController < ActionController::Base
-    #     include ActionController::Live
-    #
-    #     def index
-    #       response.headers['Content-Type'] = 'text/event-stream'
-    #       sse = SSE.new(response.stream, retry: 300, event: "event-name")
-    #       sse.write({ name: 'John'})
-    #       sse.write({ name: 'John'}, id: 10)
-    #       sse.write({ name: 'John'}, id: 10, event: "other-event")
-    #       sse.write({ name: 'John'}, id: 10, event: "other-event", retry: 500)
-    #     ensure
-    #       sse.close
-    #     end
-    #   end
-    #
-    # Note: SSEs are not currently supported by IE. However, they are supported
-    # by Chrome, Firefox, Opera, and Safari.
-    class SSE
-      WHITELISTED_OPTIONS = %w( retry event id )
-
-      def initialize(stream, options = {})
-        @stream = stream
-        @options = options
-      end
-
-      def close
-        @stream.close
-      end
-
-      def write(object, options = {})
-        case object
-        when String
-          perform_write(object, options)
-        else
-          perform_write(ActiveSupport::JSON.encode(object), options)
-        end
-      end
-
-      private
-
-        def perform_write(json, options)
-          current_options = @options.merge(options).stringify_keys
-
-          WHITELISTED_OPTIONS.each do |option_name|
-            if (option_value = current_options[option_name])
-              @stream.write "#{option_name}: #{option_value}\n"
-            end
-          end
-
-          message = json.gsub("\n".freeze, "\ndata: ".freeze)
-          @stream.write "data: #{message}\n\n"
-        end
-    end
-
-    class ClientDisconnected < RuntimeError
-    end
-
-    class Buffer < ActionDispatch::Response::Buffer #:nodoc:
-      include MonitorMixin
-
-      # Ignore that the client has disconnected.
-      #
-      # If this value is `true`, calling `write` after the client
-      # disconnects will result in the written content being silently
-      # discarded. If this value is `false` (the default), a
-      # ClientDisconnected exception will be raised.
-      attr_accessor :ignore_disconnect
-
-      def initialize(response)
-        @error_callback = lambda { true }
-        @cv = new_cond
-        @aborted = false
-        @ignore_disconnect = false
-        super(response, SizedQueue.new(10))
-      end
-
-      def write(string)
-        unless @response.committed?
-          @response.set_header "Cache-Control", "no-cache"
-          @response.delete_header "Content-Length"
-        end
-
-        super
-
-        unless connected?
-          @buf.clear
-
-          unless @ignore_disconnect
-            # Raise ClientDisconnected, which is a RuntimeError (not an
-            # IOError), because that's more appropriate for something beyond
-            # the developer's control.
-            raise ClientDisconnected, "client disconnected"
-          end
-        end
-      end
-
-      # Write a 'close' event to the buffer; the producer/writing thread
-      # uses this to notify us that it's finished supplying content.
-      #
-      # See also #abort.
-      def close
-        synchronize do
-          super
-          @buf.push nil
-          @cv.broadcast
-        end
-      end
-
-      # Inform the producer/writing thread that the client has
-      # disconnected; the reading thread is no longer interested in
-      # anything that's being written.
-      #
-      # See also #close.
-      def abort
-        synchronize do
-          @aborted = true
-          @buf.clear
-        end
-      end
-
-      # Is the client still connected and waiting for content?
-      #
-      # The result of calling `write` when this is `false` is determined
-      # by `ignore_disconnect`.
-      def connected?
-        !@aborted
-      end
-
-      def on_error(&block)
-        @error_callback = block
-      end
-
-      def call_on_error
-        @error_callback.call
-      end
-
-      private
-
-        def each_chunk(&block)
-          loop do
-            str = nil
-            ActiveSupport::Dependencies.interlock.permit_concurrent_loads do
-              str = @buf.pop
-            end
-            break unless str
-            yield str
-          end
-        end
-    end
-
-    class Response < ActionDispatch::Response #:nodoc: all
-      private
-
-        def before_committed
-          super
-          jar = request.cookie_jar
-          # The response can be committed multiple times
-          jar.write self unless committed?
-        end
-
-        def build_buffer(response, body)
-          buf = Live::Buffer.new response
-          body.each { |part| buf.write part }
-          buf
-        end
-    end
-
-    def process(name)
-      t1 = Thread.current
-      locals = t1.keys.map { |key| [key, t1[key]] }
-
-      error = nil
-      # This processes the action in a child thread. It lets us return the
-      # response code and headers back up the Rack stack, and still process
-      # the body in parallel with sending data to the client.
-      new_controller_thread {
-        ActiveSupport::Dependencies.interlock.running do
-          t2 = Thread.current
-
-          # Since we're processing the view in a different thread, copy the
-          # thread locals from the main thread to the child thread. :'(
-          locals.each { |k, v| t2[k] = v }
-
-          begin
-            super(name)
-          rescue => e
-            if @_response.committed?
-              begin
-                @_response.stream.write(ActionView::Base.streaming_completion_on_exception) if request.format == :html
-                @_response.stream.call_on_error
-              rescue => exception
-                log_error(exception)
-              ensure
-                log_error(e)
-                @_response.stream.close
-              end
-            else
-              error = e
-            end
-          ensure
-            @_response.commit!
-          end
-        end
-      }
-
-      ActiveSupport::Dependencies.interlock.permit_concurrent_loads do
-        @_response.await_commit
-      end
-
-      raise error if error
-    end
-
-    # Spawn a new thread to serve up the controller in. This is to get
-    # around the fact that Rack isn't based around IOs and we need to use
-    # a thread to stream data from the response bodies. Nobody should call
-    # this method except in Rails internals. Seriously!
-    def new_controller_thread # :nodoc:
-      Thread.new {
-        t2 = Thread.current
-        t2.abort_on_exception = true
-        yield
-      }
-    end
-
-    def log_error(exception)
-      logger = ActionController::Base.logger
-      return unless logger
-
-      logger.fatal do
-        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  ")
-        "#{message}\n\n"
-      end
-    end
-
-    def response_body=(body)
-      super
-      response.close if response
-    end
-  end
-end