ultra-fast-box 0.0.1

data/shoulda-matchers-8.0.1/lib/shoulda/matchers/active_model/validate_confirmation_of_matcher.rb

@@ -0,0 +1,185 @@
+module Shoulda
+  module Matchers
+    module ActiveModel
+      # The `validate_confirmation_of` matcher tests usage of the
+      # `validates_confirmation_of` validation.
+      #
+      #     class User
+      #       include ActiveModel::Model
+      #       attr_accessor :email
+      #
+      #       validates_confirmation_of :email
+      #     end
+      #
+      #     # RSpec
+      #     RSpec.describe User, type: :model do
+      #       it { should validate_confirmation_of(:email) }
+      #     end
+      #
+      #     # Minitest (Shoulda)
+      #     class UserTest < ActiveSupport::TestCase
+      #       should validate_confirmation_of(:email)
+      #     end
+      #
+      # #### Qualifiers
+      #
+      # ##### on
+      #
+      # Use `on` if your validation applies only under a certain context.
+      #
+      #     class User
+      #       include ActiveModel::Model
+      #       attr_accessor :password
+      #
+      #       validates_confirmation_of :password, on: :create
+      #     end
+      #
+      #     # RSpec
+      #     RSpec.describe User, type: :model do
+      #       it { should validate_confirmation_of(:password).on(:create) }
+      #     end
+      #
+      #     # Minitest (Shoulda)
+      #     class UserTest < ActiveSupport::TestCase
+      #       should validate_confirmation_of(:password).on(:create)
+      #     end
+      #
+      # ##### with_message
+      #
+      # Use `with_message` if you are using a custom validation message.
+      #
+      #     class User
+      #       include ActiveModel::Model
+      #       attr_accessor :password
+      #
+      #       validates_confirmation_of :password,
+      #         message: 'Please re-enter your password'
+      #     end
+      #
+      #     # RSpec
+      #     RSpec.describe User, type: :model do
+      #       it do
+      #         should validate_confirmation_of(:password).
+      #           with_message('Please re-enter your password')
+      #       end
+      #     end
+      #
+      #     # Minitest (Shoulda)
+      #     class UserTest < ActiveSupport::TestCase
+      #       should validate_confirmation_of(:password).
+      #         with_message('Please re-enter your password')
+      #     end
+      #
+      # #### Multiple attributes
+      #
+      # You can pass multiple attributes to assert that each one has the
+      # validation. Any qualifier chained on the matcher is applied to
+      # every attribute uniformly.
+      #
+      #     class User
+      #       include ActiveModel::Model
+      #       attr_accessor :password, :password_confirmation, :email, :email_confirmation
+      #
+      #       validates_confirmation_of :password, :email
+      #     end
+      #
+      #     # RSpec
+      #     RSpec.describe User, type: :model do
+      #       it { should validate_confirmation_of(:password, :email) }
+      #     end
+      #
+      #     # Minitest (Shoulda)
+      #     class UserTest < ActiveSupport::TestCase
+      #       should validate_confirmation_of(:password, :email)
+      #     end
+      #
+      # @return [ValidateConfirmationOfMatcher]
+      #
+      def validate_confirmation_of(*attrs)
+        MatcherCollection.build(attrs) { |attr| ValidateConfirmationOfMatcher.new(attr) }
+      end
+
+      # @private
+      class ValidateConfirmationOfMatcher < ValidationMatcher
+        include Helpers
+
+        attr_reader :attribute, :confirmation_attribute
+
+        def initialize(attribute)
+          super
+          @expected_message = :confirmation
+          @confirmation_attribute = "#{attribute}_confirmation"
+        end
+
+        def simple_description
+          "validate that :#{@confirmation_attribute} matches :#{@attribute}"
+        end
+
+        def matches?(subject)
+          super(subject)
+
+          disallows_different_value &&
+            allows_same_value &&
+            allows_missing_confirmation
+        end
+
+        def does_not_match?(subject)
+          super(subject)
+
+          allows_different_value ||
+            disallows_same_value ||
+            disallows_missing_confirmation
+        end
+
+        private
+
+        def allows_different_value
+          allows_value_of('different value') do |matcher|
+            qualify_matcher(matcher, 'some value')
+          end
+        end
+
+        def disallows_different_value
+          disallows_value_of('different value') do |matcher|
+            qualify_matcher(matcher, 'some value')
+          end
+        end
+
+        def allows_same_value
+          allows_value_of('same value') do |matcher|
+            qualify_matcher(matcher, 'same value')
+          end
+        end
+
+        def disallows_same_value
+          disallows_value_of('same value') do |matcher|
+            qualify_matcher(matcher, 'same value')
+          end
+        end
+
+        def allows_missing_confirmation
+          allows_value_of('any value') do |matcher|
+            qualify_matcher(matcher, nil)
+          end
+        end
+
+        def disallows_missing_confirmation
+          disallows_value_of('any value') do |matcher|
+            qualify_matcher(matcher, nil)
+          end
+        end
+
+        def qualify_matcher(matcher, confirmation_attribute_value)
+          matcher.values_to_preset = {
+            confirmation_attribute => confirmation_attribute_value,
+          }
+          matcher.with_message(
+            @expected_message,
+            against: confirmation_attribute,
+            values: { attribute: },
+          )
+        end
+      end
+    end
+  end
+end

data/shoulda-matchers-8.0.1/lib/shoulda/matchers/active_model/validate_exclusion_of_matcher.rb

@@ -0,0 +1,272 @@
+module Shoulda
+  module Matchers
+    module ActiveModel
+      # The `validate_exclusion_of` matcher tests usage of the
+      # `validates_exclusion_of` validation, asserting that an attribute cannot
+      # take a blocklist of values, and inversely, can take values outside of
+      # this list.
+      #
+      # If your blocklist an array of values, use `in_array`:
+      #
+      #     class Game
+      #       include ActiveModel::Model
+      #       attr_accessor :supported_os
+      #
+      #       validates_exclusion_of :supported_os, in: ['Mac', 'Linux']
+      #     end
+      #
+      #     # RSpec
+      #     RSpec.describe Game, type: :model do
+      #       it do
+      #         should validate_exclusion_of(:supported_os).
+      #           in_array(['Mac', 'Linux'])
+      #       end
+      #     end
+      #
+      #     # Minitest (Shoulda)
+      #     class GameTest < ActiveSupport::TestCase
+      #       should validate_exclusion_of(:supported_os).
+      #         in_array(['Mac', 'Linux'])
+      #     end
+      #
+      # If your blocklist is a range of values, use `in_range`:
+      #
+      #     class Game
+      #       include ActiveModel::Model
+      #       attr_accessor :floors_with_enemies
+      #
+      #       validates_exclusion_of :floors_with_enemies, in: 5..8
+      #     end
+      #
+      #     # RSpec
+      #     RSpec.describe Game, type: :model do
+      #       it do
+      #         should validate_exclusion_of(:floors_with_enemies).
+      #           in_range(5..8)
+      #       end
+      #     end
+      #
+      #     # Minitest (Shoulda)
+      #     class GameTest < ActiveSupport::TestCase
+      #       should validate_exclusion_of(:floors_with_enemies).
+      #         in_range(5..8)
+      #     end
+      #
+      # #### Qualifiers
+      #
+      # ##### on
+      #
+      # Use `on` if your validation applies only under a certain context.
+      #
+      #     class Game
+      #       include ActiveModel::Model
+      #       attr_accessor :weapon
+      #
+      #       validates_exclusion_of :weapon,
+      #         in: ['pistol', 'paintball gun', 'stick'],
+      #         on: :create
+      #     end
+      #
+      #     # RSpec
+      #     RSpec.describe Game, type: :model do
+      #       it do
+      #         should validate_exclusion_of(:weapon).
+      #           in_array(['pistol', 'paintball gun', 'stick']).
+      #           on(:create)
+      #       end
+      #     end
+      #
+      #     # Minitest (Shoulda)
+      #     class GameTest < ActiveSupport::TestCase
+      #       should validate_exclusion_of(:weapon).
+      #         in_array(['pistol', 'paintball gun', 'stick']).
+      #         on(:create)
+      #     end
+      #
+      # ##### with_message
+      #
+      # Use `with_message` if you are using a custom validation message.
+      #
+      #     class Game
+      #       include ActiveModel::Model
+      #       attr_accessor :weapon
+      #
+      #       validates_exclusion_of :weapon,
+      #         in: ['pistol', 'paintball gun', 'stick'],
+      #         message: 'You chose a puny weapon'
+      #     end
+      #
+      #     # RSpec
+      #     RSpec.describe Game, type: :model do
+      #       it do
+      #         should validate_exclusion_of(:weapon).
+      #           in_array(['pistol', 'paintball gun', 'stick']).
+      #           with_message('You chose a puny weapon')
+      #       end
+      #     end
+      #
+      #     # Minitest (Shoulda)
+      #     class GameTest < ActiveSupport::TestCase
+      #       should validate_exclusion_of(:weapon).
+      #         in_array(['pistol', 'paintball gun', 'stick']).
+      #         with_message('You chose a puny weapon')
+      #     end
+      #
+      # #### Multiple attributes
+      #
+      # You can pass multiple attributes to assert that each one has the
+      # validation. Any qualifier chained on the matcher is applied to
+      # every attribute uniformly.
+      #
+      #     class Article
+      #       include ActiveModel::Model
+      #       attr_accessor :slug, :handle
+      #
+      #       validates_exclusion_of :slug, :handle, in: %w[admin root]
+      #     end
+      #
+      #     # RSpec
+      #     RSpec.describe Article, type: :model do
+      #       it { should validate_exclusion_of(:slug, :handle).in_array(%w[admin root]) }
+      #     end
+      #
+      #     # Minitest (Shoulda)
+      #     class ArticleTest < ActiveSupport::TestCase
+      #       should validate_exclusion_of(:slug, :handle).in_array(%w[admin root])
+      #     end
+      #
+      # @return [ValidateExclusionOfMatcher]
+      #
+      def validate_exclusion_of(*attrs)
+        MatcherCollection.build(attrs) { |attr| ValidateExclusionOfMatcher.new(attr) }
+      end
+
+      # @private
+      class ValidateExclusionOfMatcher < ValidationMatcher
+        def initialize(attribute)
+          super(attribute)
+          @expected_message = :exclusion
+          @array = nil
+          @range = nil
+        end
+
+        def in_array(array)
+          @array = array
+          self
+        end
+
+        def in_range(range)
+          @range = range
+          @minimum = range.first
+          @maximum = range.max
+          self
+        end
+
+        def simple_description
+          if @range
+            "validate that :#{@attribute} lies outside the range " +
+              Shoulda::Matchers::Util.inspect_range(@range)
+          else
+            description = "validate that :#{@attribute}"
+
+            description <<
+              if @array.many?
+                " is neither #{inspected_array}"
+              else
+                " is not #{inspected_array}"
+              end
+
+            description
+          end
+        end
+
+        def matches?(subject)
+          super(subject)
+
+          if @range
+            allows_lower_value &&
+              disallows_minimum_value &&
+              disallows_maximum_value &&
+              allows_higher_value
+          elsif @array
+            disallows_all_values_in_array?
+          end
+        end
+
+        def does_not_match?(subject)
+          super(subject)
+
+          if @range
+            disallows_lower_value ||
+              allows_minimum_value ||
+              allows_maximum_value ||
+              disallows_higher_value
+          elsif @array
+            allows_any_values_in_array?
+          end
+        end
+
+        private
+
+        def allows_any_values_in_array?
+          @array.any? do |value|
+            allows_value_of(value, @expected_message)
+          end
+        end
+
+        def disallows_all_values_in_array?
+          @array.all? do |value|
+            disallows_value_of(value, @expected_message)
+          end
+        end
+
+        def allows_lower_value
+          @minimum == 0 || allows_value_of(@minimum - 1, @expected_message)
+        end
+
+        def disallows_lower_value
+          @minimum != 0 && disallows_value_of(@minimum - 1, @expected_message)
+        end
+
+        def allows_minimum_value
+          allows_value_of(@minimum, @expected_message)
+        end
+
+        def disallows_minimum_value
+          disallows_value_of(@minimum, @expected_message)
+        end
+
+        def allows_maximum_value
+          allows_value_of(@maximum, @expected_message)
+        end
+
+        def disallows_maximum_value
+          disallows_value_of(@maximum, @expected_message)
+        end
+
+        def allows_higher_value
+          allows_value_of(@maximum + 1, @expected_message)
+        end
+
+        def disallows_higher_value
+          disallows_value_of(@maximum + 1, @expected_message)
+        end
+
+        def inspect_message
+          if @range
+            @range.inspect
+          else
+            @array.inspect
+          end
+        end
+
+        def inspected_array
+          Shoulda::Matchers::Util.inspect_values(@array).to_sentence(
+            two_words_connector: ' nor ',
+            last_word_connector: ', nor ',
+          )
+        end
+      end
+    end
+  end
+end