ultra-fast-box 0.0.1

data/shoulda-matchers-8.0.1/docs/errors/NonCaseSwappableValueError.md

@@ -0,0 +1,111 @@
+# @title NonCaseSwappableValueError
+
+# NonCaseSwappableValueError
+
+This error is raised when using `validate_uniqueness_of`. This matcher, of
+course, tests that an attribute disallows a non-unique value -- and what
+constitutes as "unique" depends on whether the case-sensitivity of that value
+matters. If it does matter -- meaning that the uniqueness validation in your
+model isn't using `case_sensitive: false` and you haven't qualified the matcher
+with `case_insensitive` -- then the matcher will run the following test:
+
+> Creating first a record with a value of "A":
+>
+> * A new record with a value of "A" should not be valid (failing the uniqueness
+>   validation)
+> * A new record with a value of "a" should be valid
+
+The test value we're using is in this case "A", and this is what the matcher
+will use if an existing record is not already present in the database. But if
+a record already exists, then the matcher will use it as comparison -- it will
+read the attribute under test off of the record and use its value. So a better
+example might be:
+
+> Given an existing record with a value:
+>
+> * A new record with the same value should not be valid (failing the uniqueness
+>   validation)
+> * A new record with the same value, but where the case is swapped (using
+>   String#swapcase), should be valid
+
+Now, what happens if an existing record is there, but the value being used is
+not one whose case can be swapped, such as `"123"` or `"{-#%}"`? Then the second
+assertion cannot be made effectively.
+
+So this is why you're getting this exception. What can you do about it? As the
+error message explains, you have two options:
+
+1. If you want the uniqueness validation in the model to operate
+   case-sensitively and you didn't mean to use a non-case-swappable value,
+   then you need to provide an existing record with a different value, one that
+   contains alpha characters. Here's an example:
+
+        # Model
+        class User < ActiveRecord::Base
+          validates_uniqueness_of :username
+        end
+
+        # RSpec
+        RSpec.describe User, type: :model do
+          context "validations" do
+            subject do
+              # Note that "123" == "123".swapcase. This is a problem!
+              User.new(username: "123")
+            end
+
+            it do
+              # So you can either override it like this, or just fix the subject.
+              user = User.create!(username: "john123")
+              expect(user).to validate_uniqueness_of(:username)
+            end
+          end
+        end
+
+        # Minitest (Shoulda)
+        class UserTest < ActiveSupport::TestCase
+          context "validations" do
+            subject do
+              # Note that "123" == "123".swapcase. This is a problem!
+              User.new(username: "123")
+            end
+
+            should "validate uniqueness of :username" do
+              # So you can either override it like this, or just fix the subject.
+              user = User.create!(username: "john123")
+              assert_accepts validate_uniqueness_of(:username), record
+            end
+          end
+        end
+
+2. If you don't want the uniqueness validation to operate case-sensitively,
+   then you need to add `case_sensitive: false` to the validation and add
+   `case_insensitive` to the matcher:
+
+        # Model
+        class User < ActiveRecord::Base
+          validates_uniqueness_of :username, case_sensitive: false
+        end
+        
+        # RSpec
+        RSpec.describe User, type: :model do
+          context "validations" do
+            subject do
+              # Note that "123" == "123".swapcase, but it's okay
+              User.new(username: "123")
+            end
+
+            it { should validate_uniqueness_of(:username).case_insensitive }
+          end
+        end
+        
+        # Minitest (Shoulda)
+        class UserTest < ActiveSupport::TestCase
+          context "validations" do
+            subject do
+              # Note that "123" == "123".swapcase, but it's okay
+              User.new(username: "123")
+            end
+
+            should validate_uniqueness_of(:username).case_insensitive
+          end
+        end

data/shoulda-matchers-8.0.1/lib/shoulda/matchers/action_controller/callback_matcher.rb

@@ -0,0 +1,121 @@
+module Shoulda
+  module Matchers
+    module ActionController
+      # The `use_before_action` matcher is used to test that a before_action
+      # callback is defined within your controller.
+      #
+      #     class UsersController < ApplicationController
+      #       before_action :authenticate_user!
+      #     end
+      #
+      #     # RSpec
+      #     RSpec.describe UsersController, type: :controller do
+      #       it { should use_before_action(:authenticate_user!) }
+      #       it { should_not use_before_action(:prevent_ssl) }
+      #     end
+      #
+      #     # Minitest (Shoulda)
+      #     class UsersControllerTest < ActionController::TestCase
+      #       should use_before_action(:authenticate_user!)
+      #       should_not use_before_action(:prevent_ssl)
+      #     end
+      #
+      # @return [CallbackMatcher]
+      #
+      def use_before_action(callback)
+        CallbackMatcher.new(callback, :before, :action)
+      end
+
+      # The `use_after_action` matcher is used to test that an after_action
+      # callback is defined within your controller.
+      #
+      #     class IssuesController < ApplicationController
+      #       after_action :log_activity
+      #     end
+      #
+      #     # RSpec
+      #     RSpec.describe IssuesController, type: :controller do
+      #       it { should use_after_action(:log_activity) }
+      #       it { should_not use_after_action(:destroy_user) }
+      #     end
+      #
+      #     # Minitest (Shoulda)
+      #     class IssuesControllerTest < ActionController::TestCase
+      #       should use_after_action(:log_activity)
+      #       should_not use_after_action(:destroy_user)
+      #     end
+      #
+      # @return [CallbackMatcher]
+      #
+      def use_after_action(callback)
+        CallbackMatcher.new(callback, :after, :action)
+      end
+
+      # The `use_around_action` matcher is used to test that an around_action
+      # callback is defined within your controller.
+      #
+      #     class ChangesController < ApplicationController
+      #       around_action :wrap_in_transaction
+      #     end
+      #
+      #     # RSpec
+      #     RSpec.describe ChangesController, type: :controller do
+      #       it { should use_around_action(:wrap_in_transaction) }
+      #       it { should_not use_around_action(:save_view_context) }
+      #     end
+      #
+      #     # Minitest (Shoulda)
+      #     class ChangesControllerTest < ActionController::TestCase
+      #       should use_around_action(:wrap_in_transaction)
+      #       should_not use_around_action(:save_view_context)
+      #     end
+      #
+      # @return [CallbackMatcher]
+      #
+      def use_around_action(callback)
+        CallbackMatcher.new(callback, :around, :action)
+      end
+
+      # @private
+      class CallbackMatcher
+        def initialize(method_name, kind, callback_type)
+          @method_name = method_name
+          @kind = kind
+          @callback_type = callback_type
+        end
+
+        def matches?(controller)
+          @controller = controller
+          @controller_class = controller.class
+
+          callbacks.map(&:filter).include?(method_name)
+        end
+
+        def failure_message
+          "Expected that #{controller_class.name} would have :#{method_name}"\
+            " as a #{kind}_#{callback_type}"
+        end
+
+        def failure_message_when_negated
+          "Expected that #{controller_class.name} would not have"\
+            " :#{method_name} as a #{kind}_#{callback_type}"
+        end
+
+        def description
+          "have :#{method_name} as a #{kind}_#{callback_type}"
+        end
+
+        protected
+
+        def callbacks
+          controller_class._process_action_callbacks.select do |callback|
+            callback.kind == kind
+          end
+        end
+
+        attr_reader :method_name, :controller, :controller_class, :kind,
+          :callback_type
+      end
+    end
+  end
+end

data/shoulda-matchers-8.0.1/lib/shoulda/matchers/action_controller/filter_param_matcher.rb

@@ -0,0 +1,70 @@
+module Shoulda
+  module Matchers
+    module ActionController
+      # The `filter_param` matcher is used to test parameter filtering
+      # configuration. Specifically, it asserts that the given parameter is
+      # present in `config.filter_parameters`.
+      #
+      #     class MyApplication < Rails::Application
+      #       config.filter_parameters << :secret_key
+      #     end
+      #
+      #     # RSpec
+      #     RSpec.describe ApplicationController, type: :controller do
+      #       it { should filter_param(:secret_key) }
+      #     end
+      #
+      #     # Minitest (Shoulda)
+      #     class ApplicationControllerTest < ActionController::TestCase
+      #       should filter_param(:secret_key)
+      #     end
+      #
+      # @return [FilterParamMatcher]
+      #
+      def filter_param(key)
+        FilterParamMatcher.new(key)
+      end
+
+      # @private
+      class FilterParamMatcher
+        def initialize(key)
+          @key = key
+        end
+
+        def matches?(_controller)
+          filters_key?
+        end
+
+        def failure_message
+          "Expected #{@key} to be filtered; filtered keys:"\
+            " #{filtered_keys.join(', ')}"
+        end
+
+        def failure_message_when_negated
+          "Did not expect #{@key} to be filtered"
+        end
+
+        def description
+          "filter #{@key}"
+        end
+
+        private
+
+        def filters_key?
+          filtered_keys.any? do |filter|
+            case filter
+            when Regexp
+              filter =~ @key
+            else
+              filter == @key
+            end
+          end
+        end
+
+        def filtered_keys
+          Rails.application.config.filter_parameters
+        end
+      end
+    end
+  end
+end

data/shoulda-matchers-8.0.1/lib/shoulda/matchers/action_controller/flash_store.rb

@@ -0,0 +1,86 @@
+require 'active_support/core_ext/module/delegation'
+module Shoulda
+  module Matchers
+    module ActionController
+      # @private
+      class FlashStore
+        def self.future
+          new
+        end
+
+        def self.now
+          new.use_now!
+        end
+
+        attr_accessor :controller
+
+        def initialize
+          @use_now = false
+        end
+
+        def name
+          if @use_now
+            'flash.now'
+          else
+            'flash'
+          end
+        end
+
+        def has_key?(key)
+          values_to_check.include?(key.to_s)
+        end
+
+        def has_value?(expected_value)
+          values_to_check.values.any? do |actual_value|
+            expected_value === actual_value
+          end
+        end
+        delegate :empty?, to: :flash
+
+        def use_now!
+          @use_now = true
+          self
+        end
+
+        private
+
+        def flash
+          @_flash ||= copy_of_flash_from_controller
+        end
+
+        def copy_of_flash_from_controller
+          controller.flash.dup.tap do |flash|
+            copy_flashes(controller.flash, flash)
+            copy_discard_if_necessary(controller.flash, flash)
+          end
+        end
+
+        def copy_flashes(original_flash, new_flash)
+          flashes = original_flash.instance_variable_get('@flashes').dup
+          new_flash.instance_variable_set('@flashes', flashes)
+        end
+
+        def copy_discard_if_necessary(original_flash, new_flash)
+          discard = original_flash.instance_variable_get('@discard').dup
+          new_flash.instance_variable_set('@discard', discard)
+        end
+
+        def set_values
+          flash.instance_variable_get('@flashes')
+        end
+
+        def keys_to_discard
+          flash.instance_variable_get('@discard')
+        end
+
+        def values_to_check
+          if @use_now
+            set_values.slice(*keys_to_discard.to_a)
+          else
+            set_values.except(*keys_to_discard.to_a)
+          end
+        end
+      end
+    end
+  end
+end