jets 1.4.11 → 1.5.0

data/vendor/rails/actionpack/lib/action_dispatch/testing/request_encoder.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+module ActionDispatch
+  class RequestEncoder # :nodoc:
+    class IdentityEncoder
+      def content_type; end
+      def accept_header; end
+      def encode_params(params); params; end
+      def response_parser; -> body { body }; end
+    end
+
+    @encoders = { identity: IdentityEncoder.new }
+
+    attr_reader :response_parser
+
+    def initialize(mime_name, param_encoder, response_parser)
+      @mime = Mime[mime_name]
+
+      unless @mime
+        raise ArgumentError, "Can't register a request encoder for " \
+          "unregistered MIME Type: #{mime_name}. See `Mime::Type.register`."
+      end
+
+      @response_parser = response_parser || -> body { body }
+      @param_encoder   = param_encoder   || :"to_#{@mime.symbol}".to_proc
+    end
+
+    def content_type
+      @mime.to_s
+    end
+
+    def accept_header
+      @mime.to_s
+    end
+
+    def encode_params(params)
+      @param_encoder.call(params) if params
+    end
+
+    def self.parser(content_type)
+      mime = Mime::Type.lookup(content_type)
+      encoder(mime ? mime.ref : nil).response_parser
+    end
+
+    def self.encoder(name)
+      @encoders[name] || @encoders[:identity]
+    end
+
+    def self.register_encoder(mime_name, param_encoder: nil, response_parser: nil)
+      @encoders[mime_name] = new(mime_name, param_encoder, response_parser)
+    end
+
+    register_encoder :json, response_parser: -> body { JSON.parse(body) }
+  end
+end

data/vendor/rails/actionpack/lib/action_dispatch/testing/test_process.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+require "action_dispatch/middleware/cookies"
+require "action_dispatch/middleware/flash"
+
+module ActionDispatch
+  module TestProcess
+    module FixtureFile
+      # Shortcut for <tt>Rack::Test::UploadedFile.new(File.join(ActionDispatch::IntegrationTest.fixture_path, path), type)</tt>:
+      #
+      #   post :change_avatar, avatar: fixture_file_upload('files/spongebob.png', 'image/png')
+      #
+      # To upload binary files on Windows, pass <tt>:binary</tt> as the last parameter.
+      # This will not affect other platforms:
+      #
+      #   post :change_avatar, avatar: fixture_file_upload('files/spongebob.png', 'image/png', :binary)
+      def fixture_file_upload(path, mime_type = nil, binary = false)
+        if self.class.respond_to?(:fixture_path) && self.class.fixture_path &&
+            !File.exist?(path)
+          path = File.join(self.class.fixture_path, path)
+        end
+        Rack::Test::UploadedFile.new(path, mime_type, binary)
+      end
+    end
+
+    include FixtureFile
+
+    def assigns(key = nil)
+      raise NoMethodError,
+        "assigns has been extracted to a gem. To continue using it,
+        add `gem 'rails-controller-testing'` to your Gemfile."
+    end
+
+    def session
+      @request.session
+    end
+
+    def flash
+      @request.flash
+    end
+
+    def cookies
+      @cookie_jar ||= Cookies::CookieJar.build(@request, @request.cookies)
+    end
+
+    def redirect_to_url
+      @response.redirect_url
+    end
+  end
+end

data/vendor/rails/actionpack/lib/action_dispatch/testing/test_request.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+require "active_support/core_ext/hash/indifferent_access"
+require "rack/utils"
+
+module ActionDispatch
+  class TestRequest < Request
+    DEFAULT_ENV = Rack::MockRequest.env_for("/",
+      "HTTP_HOST"                => "test.host",
+      "REMOTE_ADDR"              => "0.0.0.0",
+      "HTTP_USER_AGENT"          => "Rails Testing",
+    )
+
+    # Create a new test request with default +env+ values.
+    def self.create(env = {})
+      env = Rails.application.env_config.merge(env) if defined?(Rails.application) && Rails.application
+      env["rack.request.cookie_hash"] ||= {}.with_indifferent_access
+      new(default_env.merge(env))
+    end
+
+    def self.default_env
+      DEFAULT_ENV
+    end
+    private_class_method :default_env
+
+    def request_method=(method)
+      super(method.to_s.upcase)
+    end
+
+    def host=(host)
+      set_header("HTTP_HOST", host)
+    end
+
+    def port=(number)
+      set_header("SERVER_PORT", number.to_i)
+    end
+
+    def request_uri=(uri)
+      set_header("REQUEST_URI", uri)
+    end
+
+    def path=(path)
+      set_header("PATH_INFO", path)
+    end
+
+    def action=(action_name)
+      path_parameters[:action] = action_name.to_s
+    end
+
+    def if_modified_since=(last_modified)
+      set_header("HTTP_IF_MODIFIED_SINCE", last_modified)
+    end
+
+    def if_none_match=(etag)
+      set_header("HTTP_IF_NONE_MATCH", etag)
+    end
+
+    def remote_addr=(addr)
+      set_header("REMOTE_ADDR", addr)
+    end
+
+    def user_agent=(user_agent)
+      set_header("HTTP_USER_AGENT", user_agent)
+    end
+
+    def accept=(mime_types)
+      delete_header("action_dispatch.request.accepts")
+      set_header("HTTP_ACCEPT", Array(mime_types).collect(&:to_s).join(","))
+    end
+  end
+end

data/vendor/rails/actionpack/lib/action_dispatch/testing/test_response.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+require "action_dispatch/testing/request_encoder"
+
+module ActionDispatch
+  # Integration test methods such as ActionDispatch::Integration::Session#get
+  # and ActionDispatch::Integration::Session#post return objects of class
+  # TestResponse, which represent the HTTP response results of the requested
+  # controller actions.
+  #
+  # See Response for more information on controller response objects.
+  class TestResponse < Response
+    def self.from_response(response)
+      new response.status, response.headers, response.body
+    end
+
+    def initialize(*) # :nodoc:
+      super
+      @response_parser = RequestEncoder.parser(content_type)
+    end
+
+    # Was the response successful?
+    def success?
+      ActiveSupport::Deprecation.warn(<<-MSG.squish)
+       The success? predicate is deprecated and will be removed in Rails 6.0.
+       Please use successful? as provided by Rack::Response::Helpers.
+      MSG
+      successful?
+    end
+
+    # Was the URL not found?
+    def missing?
+      ActiveSupport::Deprecation.warn(<<-MSG.squish)
+       The missing? predicate is deprecated and will be removed in Rails 6.0.
+       Please use not_found? as provided by Rack::Response::Helpers.
+      MSG
+      not_found?
+    end
+
+    # Was there a server-side error?
+    def error?
+      ActiveSupport::Deprecation.warn(<<-MSG.squish)
+       The error? predicate is deprecated and will be removed in Rails 6.0.
+       Please use server_error? as provided by Rack::Response::Helpers.
+      MSG
+      server_error?
+    end
+
+    def parsed_body
+      @parsed_body ||= @response_parser.call(body)
+    end
+  end
+end

data/vendor/rails/actionpack/lib/action_pack.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+#--
+# Copyright (c) 2004-2018 David Heinemeier Hansson
+#
+# Permission is hereby granted, free of charge, to any person obtaining
+# a copy of this software and associated documentation files (the
+# "Software"), to deal in the Software without restriction, including
+# without limitation the rights to use, copy, modify, merge, publish,
+# distribute, sublicense, and/or sell copies of the Software, and to
+# permit persons to whom the Software is furnished to do so, subject to
+# the following conditions:
+#
+# The above copyright notice and this permission notice shall be
+# included in all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+#++
+
+require "action_pack/version"

data/vendor/rails/actionpack/lib/action_pack/gem_version.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module ActionPack
+  # Returns the version of the currently loaded Action Pack as a <tt>Gem::Version</tt>
+  def self.gem_version
+    Gem::Version.new VERSION::STRING
+  end
+
+  module VERSION
+    MAJOR = 5
+    MINOR = 2
+    TINY  = 2
+    PRE   = nil
+
+    STRING = [MAJOR, MINOR, TINY, PRE].compact.join(".")
+  end
+end

data/vendor/rails/actionpack/lib/action_pack/version.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+require_relative "gem_version"
+
+module ActionPack
+  # Returns the version of the currently loaded ActionPack as a <tt>Gem::Version</tt>
+  def self.version
+    gem_version
+  end
+end

data/vendor/rails/actionpack/test/abstract/callbacks_test.rb

@@ -0,0 +1,270 @@
+# frozen_string_literal: true
+
+require "abstract_unit"
+
+module AbstractController
+  module Testing
+    class ControllerWithCallbacks < AbstractController::Base
+      include AbstractController::Callbacks
+    end
+
+    class Callback1 < ControllerWithCallbacks
+      set_callback :process_action, :before, :first
+
+      def first
+        @text = "Hello world"
+      end
+
+      def index
+        self.response_body = @text
+      end
+    end
+
+    class TestCallbacks1 < ActiveSupport::TestCase
+      test "basic callbacks work" do
+        controller = Callback1.new
+        controller.process(:index)
+        assert_equal "Hello world", controller.response_body
+      end
+    end
+
+    class Callback2 < ControllerWithCallbacks
+      before_action :first
+      after_action :second
+      around_action :aroundz
+
+      def first
+        @text = "Hello world"
+      end
+
+      def second
+        @second = "Goodbye"
+      end
+
+      def aroundz
+        @aroundz = "FIRST"
+        yield
+        @aroundz += "SECOND"
+      end
+
+      def index
+        @text ||= nil
+        self.response_body = @text.to_s
+      end
+    end
+
+    class Callback2Overwrite < Callback2
+      before_action :first, except: :index
+    end
+
+    class TestCallbacks2 < ActiveSupport::TestCase
+      def setup
+        @controller = Callback2.new
+      end
+
+      test "before_action works" do
+        @controller.process(:index)
+        assert_equal "Hello world", @controller.response_body
+      end
+
+      test "after_action works" do
+        @controller.process(:index)
+        assert_equal "Goodbye", @controller.instance_variable_get("@second")
+      end
+
+      test "around_action works" do
+        @controller.process(:index)
+        assert_equal "FIRSTSECOND", @controller.instance_variable_get("@aroundz")
+      end
+
+      test "before_action with overwritten condition" do
+        @controller = Callback2Overwrite.new
+        @controller.process(:index)
+        assert_equal "", @controller.response_body
+      end
+    end
+
+    class Callback3 < ControllerWithCallbacks
+      before_action do |c|
+        c.instance_variable_set("@text", "Hello world")
+      end
+
+      after_action do |c|
+        c.instance_variable_set("@second", "Goodbye")
+      end
+
+      def index
+        self.response_body = @text
+      end
+    end
+
+    class TestCallbacks3 < ActiveSupport::TestCase
+      def setup
+        @controller = Callback3.new
+      end
+
+      test "before_action works with procs" do
+        @controller.process(:index)
+        assert_equal "Hello world", @controller.response_body
+      end
+
+      test "after_action works with procs" do
+        @controller.process(:index)
+        assert_equal "Goodbye", @controller.instance_variable_get("@second")
+      end
+    end
+
+    class CallbacksWithConditions < ControllerWithCallbacks
+      before_action :list, only: :index
+      before_action :authenticate, except: :index
+
+      def index
+        self.response_body = @list.join(", ")
+      end
+
+      def sekrit_data
+        self.response_body = (@list + [@authenticated]).join(", ")
+      end
+
+      private
+        def list
+          @list = ["Hello", "World"]
+        end
+
+        def authenticate
+          @list ||= []
+          @authenticated = "true"
+        end
+    end
+
+    class TestCallbacksWithConditions < ActiveSupport::TestCase
+      def setup
+        @controller = CallbacksWithConditions.new
+      end
+
+      test "when :only is specified, a before action is triggered on that action" do
+        @controller.process(:index)
+        assert_equal "Hello, World", @controller.response_body
+      end
+
+      test "when :only is specified, a before action is not triggered on other actions" do
+        @controller.process(:sekrit_data)
+        assert_equal "true", @controller.response_body
+      end
+
+      test "when :except is specified, an after action is not triggered on that action" do
+        @controller.process(:index)
+        assert !@controller.instance_variable_defined?("@authenticated")
+      end
+    end
+
+    class CallbacksWithArrayConditions < ControllerWithCallbacks
+      before_action :list, only: [:index, :listy]
+      before_action :authenticate, except: [:index, :listy]
+
+      def index
+        self.response_body = @list.join(", ")
+      end
+
+      def sekrit_data
+        self.response_body = (@list + [@authenticated]).join(", ")
+      end
+
+      private
+        def list
+          @list = ["Hello", "World"]
+        end
+
+        def authenticate
+          @list = []
+          @authenticated = "true"
+        end
+    end
+
+    class TestCallbacksWithArrayConditions < ActiveSupport::TestCase
+      def setup
+        @controller = CallbacksWithArrayConditions.new
+      end
+
+      test "when :only is specified with an array, a before action is triggered on that action" do
+        @controller.process(:index)
+        assert_equal "Hello, World", @controller.response_body
+      end
+
+      test "when :only is specified with an array, a before action is not triggered on other actions" do
+        @controller.process(:sekrit_data)
+        assert_equal "true", @controller.response_body
+      end
+
+      test "when :except is specified with an array, an after action is not triggered on that action" do
+        @controller.process(:index)
+        assert !@controller.instance_variable_defined?("@authenticated")
+      end
+    end
+
+    class ChangedConditions < Callback2
+      before_action :first, only: :index
+
+      def not_index
+        @text ||= nil
+        self.response_body = @text.to_s
+      end
+    end
+
+    class TestCallbacksWithChangedConditions < ActiveSupport::TestCase
+      def setup
+        @controller = ChangedConditions.new
+      end
+
+      test "when a callback is modified in a child with :only, it works for the :only action" do
+        @controller.process(:index)
+        assert_equal "Hello world", @controller.response_body
+      end
+
+      test "when a callback is modified in a child with :only, it does not work for other actions" do
+        @controller.process(:not_index)
+        assert_equal "", @controller.response_body
+      end
+    end
+
+    class SetsResponseBody < ControllerWithCallbacks
+      before_action :set_body
+
+      def index
+        self.response_body = "Fail"
+      end
+
+      def set_body
+        self.response_body = "Success"
+      end
+    end
+
+    class TestHalting < ActiveSupport::TestCase
+      test "when a callback sets the response body, the action should not be invoked" do
+        controller = SetsResponseBody.new
+        controller.process(:index)
+        assert_equal "Success", controller.response_body
+      end
+    end
+
+    class CallbacksWithArgs < ControllerWithCallbacks
+      set_callback :process_action, :before, :first
+
+      def first
+        @text = "Hello world"
+      end
+
+      def index(text)
+        self.response_body = @text + text
+      end
+    end
+
+    class TestCallbacksWithArgs < ActiveSupport::TestCase
+      test "callbacks still work when invoking process with multiple arguments" do
+        controller = CallbacksWithArgs.new
+        controller.process(:index, " Howdy!")
+        assert_equal "Hello world Howdy!", controller.response_body
+      end
+    end
+  end
+end