jets 1.9.7 → 1.9.8

data/vendor/rails/actionpack/lib/action_dispatch/middleware/request_id.rb

@@ -1,43 +0,0 @@
-# frozen_string_literal: true
-
-require "securerandom"
-require "active_support/core_ext/string/access"
-
-module ActionDispatch
-  # Makes a unique request id available to the +action_dispatch.request_id+ env variable (which is then accessible
-  # through <tt>ActionDispatch::Request#request_id</tt> or the alias <tt>ActionDispatch::Request#uuid</tt>) and sends
-  # the same id to the client via the X-Request-Id header.
-  #
-  # The unique request id is either based on the X-Request-Id header in the request, which would typically be generated
-  # by a firewall, load balancer, or the web server, or, if this header is not available, a random uuid. If the
-  # header is accepted from the outside world, we sanitize it to a max of 255 chars and alphanumeric and dashes only.
-  #
-  # The unique request id can be used to trace a request end-to-end and would typically end up being part of log files
-  # from multiple pieces of the stack.
-  class RequestId
-    X_REQUEST_ID = "X-Request-Id".freeze #:nodoc:
-
-    def initialize(app)
-      @app = app
-    end
-
-    def call(env)
-      req = ActionDispatch::Request.new env
-      req.request_id = make_request_id(req.x_request_id)
-      @app.call(env).tap { |_status, headers, _body| headers[X_REQUEST_ID] = req.request_id }
-    end
-
-    private
-      def make_request_id(request_id)
-        if request_id.presence
-          request_id.gsub(/[^\w\-@]/, "".freeze).first(255)
-        else
-          internal_request_id
-        end
-      end
-
-      def internal_request_id
-        SecureRandom.uuid
-      end
-  end
-end

data/vendor/rails/actionpack/lib/action_dispatch/middleware/session/abstract_store.rb

@@ -1,92 +0,0 @@
-# frozen_string_literal: true
-
-require "rack/utils"
-require "rack/request"
-require "rack/session/abstract/id"
-require "action_dispatch/middleware/cookies"
-require "action_dispatch/request/session"
-
-module ActionDispatch
-  module Session
-    class SessionRestoreError < StandardError #:nodoc:
-      def initialize
-        super("Session contains objects whose class definition isn't available.\n" \
-          "Remember to require the classes for all objects kept in the session.\n" \
-          "(Original exception: #{$!.message} [#{$!.class}])\n")
-        set_backtrace $!.backtrace
-      end
-    end
-
-    module Compatibility
-      def initialize(app, options = {})
-        options[:key] ||= "_session_id"
-        super
-      end
-
-      def generate_sid
-        sid = SecureRandom.hex(16)
-        sid.encode!(Encoding::UTF_8)
-        sid
-      end
-
-    private
-
-      def initialize_sid # :doc:
-        @default_options.delete(:sidbits)
-        @default_options.delete(:secure_random)
-      end
-
-      def make_request(env)
-        ActionDispatch::Request.new env
-      end
-    end
-
-    module StaleSessionCheck
-      def load_session(env)
-        stale_session_check! { super }
-      end
-
-      def extract_session_id(env)
-        stale_session_check! { super }
-      end
-
-      def stale_session_check!
-        yield
-      rescue ArgumentError => argument_error
-        if argument_error.message =~ %r{undefined class/module ([\w:]*\w)}
-          begin
-            # Note that the regexp does not allow $1 to end with a ':'.
-            $1.constantize
-          rescue LoadError, NameError
-            raise ActionDispatch::Session::SessionRestoreError
-          end
-          retry
-        else
-          raise
-        end
-      end
-    end
-
-    module SessionObject # :nodoc:
-      def prepare_session(req)
-        Request::Session.create(self, req, @default_options)
-      end
-
-      def loaded_session?(session)
-        !session.is_a?(Request::Session) || session.loaded?
-      end
-    end
-
-    class AbstractStore < Rack::Session::Abstract::Persisted
-      include Compatibility
-      include StaleSessionCheck
-      include SessionObject
-
-      private
-
-        def set_cookie(request, session_id, cookie)
-          request.cookie_jar[key] = cookie
-        end
-    end
-  end
-end

data/vendor/rails/actionpack/lib/action_dispatch/middleware/session/cache_store.rb

@@ -1,54 +0,0 @@
-# frozen_string_literal: true
-
-require "action_dispatch/middleware/session/abstract_store"
-
-module ActionDispatch
-  module Session
-    # A session store that uses an ActiveSupport::Cache::Store to store the sessions. This store is most useful
-    # if you don't store critical data in your sessions and you don't need them to live for extended periods
-    # of time.
-    #
-    # ==== Options
-    # * <tt>cache</tt>         - The cache to use. If it is not specified, <tt>Rails.cache</tt> will be used.
-    # * <tt>expire_after</tt>  - The length of time a session will be stored before automatically expiring.
-    #   By default, the <tt>:expires_in</tt> option of the cache is used.
-    class CacheStore < AbstractStore
-      def initialize(app, options = {})
-        @cache = options[:cache] || Rails.cache
-        options[:expire_after] ||= @cache.options[:expires_in]
-        super
-      end
-
-      # Get a session from the cache.
-      def find_session(env, sid)
-        unless sid && (session = @cache.read(cache_key(sid)))
-          sid, session = generate_sid, {}
-        end
-        [sid, session]
-      end
-
-      # Set a session in the cache.
-      def write_session(env, sid, session, options)
-        key = cache_key(sid)
-        if session
-          @cache.write(key, session, expires_in: options[:expire_after])
-        else
-          @cache.delete(key)
-        end
-        sid
-      end
-
-      # Remove a session from the cache.
-      def delete_session(env, sid, options)
-        @cache.delete(cache_key(sid))
-        generate_sid
-      end
-
-      private
-        # Turn the session id into a cache key.
-        def cache_key(sid)
-          "_session_id:#{sid}"
-        end
-    end
-  end
-end

data/vendor/rails/actionpack/lib/action_dispatch/middleware/session/cookie_store.rb

@@ -1,117 +0,0 @@
-# frozen_string_literal: true
-
-require "active_support/core_ext/hash/keys"
-require "action_dispatch/middleware/session/abstract_store"
-require "rack/session/cookie"
-
-module ActionDispatch
-  module Session
-    # This cookie-based session store is the Rails default. It is
-    # dramatically faster than the alternatives.
-    #
-    # Sessions typically contain at most a user_id and flash message; both fit
-    # within the 4K cookie size limit. A CookieOverflow exception is raised if
-    # you attempt to store more than 4K of data.
-    #
-    # The cookie jar used for storage is automatically configured to be the
-    # best possible option given your application's configuration.
-    #
-    # If you only have secret_token set, your cookies will be signed, but
-    # not encrypted. This means a user cannot alter their +user_id+ without
-    # knowing your app's secret key, but can easily read their +user_id+. This
-    # was the default for Rails 3 apps.
-    #
-    # Your cookies will be encrypted using your apps secret_key_base. This
-    # goes a step further than signed cookies in that encrypted cookies cannot
-    # be altered or read by users. This is the default starting in Rails 4.
-    #
-    # Configure your session store in <tt>config/initializers/session_store.rb</tt>:
-    #
-    #   Rails.application.config.session_store :cookie_store, key: '_your_app_session'
-    #
-    # By default, your secret key base is derived from your application name in
-    # the test and development environments. In all other environments, it is stored
-    # encrypted in the <tt>config/credentials.yml.enc</tt> file.
-    #
-    # If your application was not updated to Rails 5.2 defaults, the secret_key_base
-    # will be found in the old <tt>config/secrets.yml</tt> file.
-    #
-    # Note that changing your secret_key_base will invalidate all existing session.
-    # Additionally, you should take care to make sure you are not relying on the
-    # ability to decode signed cookies generated by your app in external
-    # applications or JavaScript before changing it.
-    #
-    # Because CookieStore extends Rack::Session::Abstract::Persisted, many of the
-    # options described there can be used to customize the session cookie that
-    # is generated. For example:
-    #
-    #   Rails.application.config.session_store :cookie_store, expire_after: 14.days
-    #
-    # would set the session cookie to expire automatically 14 days after creation.
-    # Other useful options include <tt>:key</tt>, <tt>:secure</tt> and
-    # <tt>:httponly</tt>.
-    class CookieStore < AbstractStore
-      def initialize(app, options = {})
-        super(app, options.merge!(cookie_only: true))
-      end
-
-      def delete_session(req, session_id, options)
-        new_sid = generate_sid unless options[:drop]
-        # Reset hash and Assign the new session id
-        req.set_header("action_dispatch.request.unsigned_session_cookie", new_sid ? { "session_id" => new_sid } : {})
-        new_sid
-      end
-
-      def load_session(req)
-        stale_session_check! do
-          data = unpacked_cookie_data(req)
-          data = persistent_session_id!(data)
-          [data["session_id"], data]
-        end
-      end
-
-      private
-
-        def extract_session_id(req)
-          stale_session_check! do
-            unpacked_cookie_data(req)["session_id"]
-          end
-        end
-
-        def unpacked_cookie_data(req)
-          req.fetch_header("action_dispatch.request.unsigned_session_cookie") do |k|
-            v = stale_session_check! do
-              if data = get_cookie(req)
-                data.stringify_keys!
-              end
-              data || {}
-            end
-            req.set_header k, v
-          end
-        end
-
-        def persistent_session_id!(data, sid = nil)
-          data ||= {}
-          data["session_id"] ||= sid || generate_sid
-          data
-        end
-
-        def write_session(req, sid, session_data, options)
-          session_data["session_id"] = sid
-          session_data
-        end
-
-        def set_cookie(request, session_id, cookie)
-          cookie_jar(request)[@key] = cookie
-        end
-
-        def get_cookie(req)
-          cookie_jar(req)[@key]
-        end
-
-        def cookie_jar(request)
-          request.cookie_jar.signed_or_encrypted
-        end
-    end
-  end
-end

data/vendor/rails/actionpack/lib/action_dispatch/middleware/session/mem_cache_store.rb

@@ -1,28 +0,0 @@
-# frozen_string_literal: true
-
-require "action_dispatch/middleware/session/abstract_store"
-begin
-  require "rack/session/dalli"
-rescue LoadError => e
-  $stderr.puts "You don't have dalli installed in your application. Please add it to your Gemfile and run bundle install"
-  raise e
-end
-
-module ActionDispatch
-  module Session
-    # A session store that uses MemCache to implement storage.
-    #
-    # ==== Options
-    # * <tt>expire_after</tt>  - The length of time a session will be stored before automatically expiring.
-    class MemCacheStore < Rack::Session::Dalli
-      include Compatibility
-      include StaleSessionCheck
-      include SessionObject
-
-      def initialize(app, options = {})
-        options[:expire_after] ||= options[:expires]
-        super
-      end
-    end
-  end
-end

data/vendor/rails/actionpack/lib/action_dispatch/middleware/show_exceptions.rb

@@ -1,62 +0,0 @@
-# frozen_string_literal: true
-
-require "action_dispatch/http/request"
-require "action_dispatch/middleware/exception_wrapper"
-
-module ActionDispatch
-  # This middleware rescues any exception returned by the application
-  # and calls an exceptions app that will wrap it in a format for the end user.
-  #
-  # The exceptions app should be passed as parameter on initialization
-  # of ShowExceptions. Every time there is an exception, ShowExceptions will
-  # store the exception in env["action_dispatch.exception"], rewrite the
-  # PATH_INFO to the exception status code and call the Rack app.
-  #
-  # If the application returns a "X-Cascade" pass response, this middleware
-  # will send an empty response as result with the correct status code.
-  # If any exception happens inside the exceptions app, this middleware
-  # catches the exceptions and returns a FAILSAFE_RESPONSE.
-  class ShowExceptions
-    FAILSAFE_RESPONSE = [500, { "Content-Type" => "text/plain" },
-      ["500 Internal Server Error\n" \
-       "If you are the administrator of this website, then please read this web " \
-       "application's log file and/or the web server's log file to find out what " \
-       "went wrong."]]
-
-    def initialize(app, exceptions_app)
-      @app = app
-      @exceptions_app = exceptions_app
-    end
-
-    def call(env)
-      request = ActionDispatch::Request.new env
-      @app.call(env)
-    rescue Exception => exception
-      if request.show_exceptions?
-        render_exception(request, exception)
-      else
-        raise exception
-      end
-    end
-
-    private
-
-      def render_exception(request, exception)
-        backtrace_cleaner = request.get_header "action_dispatch.backtrace_cleaner"
-        wrapper = ExceptionWrapper.new(backtrace_cleaner, exception)
-        status  = wrapper.status_code
-        request.set_header "action_dispatch.exception", wrapper.exception
-        request.set_header "action_dispatch.original_path", request.path_info
-        request.path_info = "/#{status}"
-        response = @exceptions_app.call(request.env)
-        response[1]["X-Cascade"] == "pass" ? pass_response(status) : response
-      rescue Exception => failsafe_error
-        $stderr.puts "Error during failsafe response: #{failsafe_error}\n  #{failsafe_error.backtrace * "\n  "}"
-        FAILSAFE_RESPONSE
-      end
-
-      def pass_response(status)
-        [status, { "Content-Type" => "text/html; charset=#{Response.default_charset}", "Content-Length" => "0" }, []]
-      end
-  end
-end

data/vendor/rails/actionpack/lib/action_dispatch/middleware/ssl.rb

@@ -1,150 +0,0 @@
-# frozen_string_literal: true
-
-module ActionDispatch
-  # This middleware is added to the stack when <tt>config.force_ssl = true</tt>, and is passed
-  # the options set in +config.ssl_options+. It does three jobs to enforce secure HTTP
-  # requests:
-  #
-  # 1. <b>TLS redirect</b>: Permanently redirects +http://+ requests to +https://+
-  #    with the same URL host, path, etc. Enabled by default. Set +config.ssl_options+
-  #    to modify the destination URL
-  #    (e.g. <tt>redirect: { host: "secure.widgets.com", port: 8080 }</tt>), or set
-  #    <tt>redirect: false</tt> to disable this feature.
-  #
-  #    Requests can opt-out of redirection with +exclude+:
-  #
-  #      config.ssl_options = { redirect: { exclude: -> request { request.path =~ /healthcheck/ } } }
-  #
-  #    Cookies will not be flagged as secure for excluded requests.
-  #
-  # 2. <b>Secure cookies</b>: Sets the +secure+ flag on cookies to tell browsers they
-  #    must not be sent along with +http://+ requests. Enabled by default. Set
-  #    +config.ssl_options+ with <tt>secure_cookies: false</tt> to disable this feature.
-  #
-  # 3. <b>HTTP Strict Transport Security (HSTS)</b>: Tells the browser to remember
-  #    this site as TLS-only and automatically redirect non-TLS requests.
-  #    Enabled by default. Configure +config.ssl_options+ with <tt>hsts: false</tt> to disable.
-  #
-  #    Set +config.ssl_options+ with <tt>hsts: { ... }</tt> to configure HSTS:
-  #
-  #    * +expires+: How long, in seconds, these settings will stick. The minimum
-  #      required to qualify for browser preload lists is 1 year. Defaults to
-  #      1 year (recommended).
-  #
-  #    * +subdomains+: Set to +true+ to tell the browser to apply these settings
-  #      to all subdomains. This protects your cookies from interception by a
-  #      vulnerable site on a subdomain. Defaults to +true+.
-  #
-  #    * +preload+: Advertise that this site may be included in browsers'
-  #      preloaded HSTS lists. HSTS protects your site on every visit <i>except the
-  #      first visit</i> since it hasn't seen your HSTS header yet. To close this
-  #      gap, browser vendors include a baked-in list of HSTS-enabled sites.
-  #      Go to https://hstspreload.org to submit your site for inclusion.
-  #      Defaults to +false+.
-  #
-  #    To turn off HSTS, omitting the header is not enough. Browsers will remember the
-  #    original HSTS directive until it expires. Instead, use the header to tell browsers to
-  #    expire HSTS immediately. Setting <tt>hsts: false</tt> is a shortcut for
-  #    <tt>hsts: { expires: 0 }</tt>.
-  class SSL
-    # :stopdoc:
-
-    # Default to 1 year, the minimum for browser preload lists.
-    HSTS_EXPIRES_IN = 31536000
-
-    def self.default_hsts_options
-      { expires: HSTS_EXPIRES_IN, subdomains: true, preload: false }
-    end
-
-    def initialize(app, redirect: {}, hsts: {}, secure_cookies: true)
-      @app = app
-
-      @redirect = redirect
-
-      @exclude = @redirect && @redirect[:exclude] || proc { !@redirect }
-      @secure_cookies = secure_cookies
-
-      @hsts_header = build_hsts_header(normalize_hsts_options(hsts))
-    end
-
-    def call(env)
-      request = Request.new env
-
-      if request.ssl?
-        @app.call(env).tap do |status, headers, body|
-          set_hsts_header! headers
-          flag_cookies_as_secure! headers if @secure_cookies && !@exclude.call(request)
-        end
-      else
-        return redirect_to_https request unless @exclude.call(request)
-        @app.call(env)
-      end
-    end
-
-    private
-      def set_hsts_header!(headers)
-        headers["Strict-Transport-Security".freeze] ||= @hsts_header
-      end
-
-      def normalize_hsts_options(options)
-        case options
-        # Explicitly disabling HSTS clears the existing setting from browsers
-        # by setting expiry to 0.
-        when false
-          self.class.default_hsts_options.merge(expires: 0)
-        # Default to enabled, with default options.
-        when nil, true
-          self.class.default_hsts_options
-        else
-          self.class.default_hsts_options.merge(options)
-        end
-      end
-
-      # https://tools.ietf.org/html/rfc6797#section-6.1
-      def build_hsts_header(hsts)
-        value = "max-age=#{hsts[:expires].to_i}".dup
-        value << "; includeSubDomains" if hsts[:subdomains]
-        value << "; preload" if hsts[:preload]
-        value
-      end
-
-      def flag_cookies_as_secure!(headers)
-        if cookies = headers["Set-Cookie".freeze]
-          cookies = cookies.split("\n".freeze)
-
-          headers["Set-Cookie".freeze] = cookies.map { |cookie|
-            if cookie !~ /;\s*secure\s*(;|$)/i
-              "#{cookie}; secure"
-            else
-              cookie
-            end
-          }.join("\n".freeze)
-        end
-      end
-
-      def redirect_to_https(request)
-        [ @redirect.fetch(:status, redirection_status(request)),
-          { "Content-Type" => "text/html",
-            "Location" => https_location_for(request) },
-          @redirect.fetch(:body, []) ]
-      end
-
-      def redirection_status(request)
-        if request.get? || request.head?
-          301 # Issue a permanent redirect via a GET request.
-        else
-          307 # Issue a fresh request redirect to preserve the HTTP method.
-        end
-      end
-
-      def https_location_for(request)
-        host = @redirect[:host] || request.host
-        port = @redirect[:port] || request.port
-
-        location = "https://#{host}".dup
-        location << ":#{port}" if port != 80 && port != 443
-        location << request.fullpath
-        location
-      end
-  end
-end