ultra-fast-box 0.0.1

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

@@ -0,0 +1,157 @@
+require 'active_support/core_ext/module/delegation'
+
+module Shoulda
+  module Matchers
+    module ActiveModel
+      # @private
+      class ComparisonMatcher < ValidationMatcher
+        ERROR_MESSAGES = {
+          :> => {
+            label: :greater_than,
+            assertions: [false, false, true],
+          },
+          :>= => {
+            label: :greater_than_or_equal_to,
+            assertions: [false, true, true],
+          },
+          :< => {
+            label: :less_than,
+            assertions: [true, false, false],
+          },
+          :<= => {
+            label: :less_than_or_equal_to,
+            assertions: [true, true, false],
+          },
+          :== => {
+            label: :equal_to,
+            assertions: [false, true, false],
+          },
+          :!= => {
+            label: :other_than,
+            assertions: [true, false, true],
+          },
+        }.freeze
+
+        delegate :failure_message, :failure_message_when_negated, to: :comparison_submatchers
+
+        def initialize(matcher, value, operator)
+          super(nil)
+          unless matcher.respond_to? :diff_to_compare
+            raise ArgumentError, 'matcher is invalid'
+          end
+
+          @matcher = matcher
+          @value = value
+          @operator = operator
+          @message = ERROR_MESSAGES[operator][:label]
+        end
+
+        def simple_description
+          description = ''
+
+          if expects_strict?
+            description = ' strictly'
+          end
+
+          description +
+            "disallow :#{attribute} from being a number that is not " +
+            "#{comparison_expectation} #{@value}"
+        end
+
+        def for(attribute)
+          @attribute = attribute
+          self
+        end
+
+        def with_message(message)
+          @expects_custom_validation_message = true
+          @message = message
+          self
+        end
+
+        def expects_custom_validation_message?
+          @expects_custom_validation_message
+        end
+
+        def matches?(subject)
+          @subject = subject
+          comparison_submatchers.matches?(subject)
+        end
+
+        def comparison_description
+          "#{comparison_expectation} #{@value}"
+        end
+
+        def comparison_submatchers
+          @_comparison_submatchers ||=
+            NumericalityMatchers::Submatchers.new(build_comparison_submatchers)
+        end
+
+        private
+
+        def build_comparison_submatchers
+          comparison_combos.map do |diff, submatcher_method_name|
+            matcher = __send__(submatcher_method_name, diff, nil)
+            matcher.with_message(@message, values: { count: option_value })
+            matcher
+          end
+        end
+
+        def comparison_combos
+          diffs_to_compare.zip(submatcher_method_names)
+        end
+
+        def submatcher_method_names
+          assertions.map do |value|
+            if value
+              :allow_value_matcher
+            else
+              :disallow_value_matcher
+            end
+          end
+        end
+
+        def assertions
+          ERROR_MESSAGES[@operator][:assertions]
+        end
+
+        def option_value
+          if defined?(@_option_value)
+            @_option_value
+          else
+            @_option_value =
+              case @value
+              when Proc then @value.call(@subject)
+              when Symbol then @subject.send(@value)
+              else @value
+              end
+          end
+        end
+
+        def diffs_to_compare
+          diff_to_compare = @matcher.diff_to_compare
+          values = case option_value
+                   when String then diffs_when_string(diff_to_compare)
+                   else [-1, 0, 1].map { |sign| option_value + (diff_to_compare * sign) }
+                   end
+
+          if @matcher.given_numeric_column?
+            values
+          else
+            values.map(&:to_s)
+          end
+        end
+
+        def diffs_when_string(diff_to_compare)
+          [-1, 0, 1].map do |sign|
+            option_value[0..-2] + (option_value[-1].ord + diff_to_compare * sign).chr
+          end
+        end
+
+        def comparison_expectation
+          ERROR_MESSAGES[@operator][:label].to_s.tr('_', ' ')
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,78 @@
+require 'forwardable'
+
+module Shoulda
+  module Matchers
+    module ActiveModel
+      # @private
+      class DisallowValueMatcher
+        extend Forwardable
+
+        def_delegators(
+          :allow_matcher,
+          :_after_setting_value,
+          :attribute_changed_value_message=,
+          :attribute_to_set,
+          :description,
+          :expects_strict?,
+          :failure_message_preface,
+          :failure_message_preface=,
+          :ignore_interference_by_writer,
+          :last_attribute_setter_used,
+          :last_value_set,
+          :model,
+          :simple_description,
+          :values_to_preset=,
+        )
+
+        def initialize(value)
+          @allow_matcher = AllowValueMatcher.new(value)
+        end
+
+        def matches?(subject)
+          allow_matcher.does_not_match?(subject)
+        end
+
+        def does_not_match?(subject)
+          allow_matcher.matches?(subject)
+        end
+
+        def for(attribute)
+          allow_matcher.for(attribute)
+          self
+        end
+
+        def on(context)
+          allow_matcher.on(context)
+          self
+        end
+
+        def with_message(message, options = {})
+          allow_matcher.with_message(message, options)
+          self
+        end
+
+        def strict(strict = true)
+          allow_matcher.strict(strict)
+          self
+        end
+
+        def ignoring_interference_by_writer(value = :always)
+          allow_matcher.ignoring_interference_by_writer(value)
+          self
+        end
+
+        def failure_message
+          allow_matcher.failure_message_when_negated
+        end
+
+        def failure_message_when_negated
+          allow_matcher.failure_message
+        end
+
+        protected
+
+        attr_reader :allow_matcher
+      end
+    end
+  end
+end

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

@@ -0,0 +1,52 @@
+module Shoulda
+  module Matchers
+    module ActiveModel
+      # @private
+      class CouldNotDetermineValueOutsideOfArray < RuntimeError; end
+
+      # @private
+      class NonNullableBooleanError < Shoulda::Matchers::Error
+        def self.create(attribute)
+          super(attribute:)
+        end
+
+        attr_accessor :attribute
+
+        def message
+          <<-EOT.strip
+You have specified that your model's #{attribute} should ensure inclusion of nil.
+However, #{attribute} is a boolean column which does not allow null values.
+Hence, this test will fail and there is no way to make it pass.
+          EOT
+        end
+      end
+
+      # @private
+      class CouldNotSetPasswordError < Shoulda::Matchers::Error
+        def self.create(model)
+          super(model:)
+        end
+
+        attr_accessor :model
+
+        def message
+          <<-EOT.strip
+The validation failed because your #{model_name} model declares `has_secure_password`, and
+`validate_presence_of` was called on a #{record_name} which has `password` already set to a value.
+Please use a #{record_name} with an empty `password` instead.
+          EOT
+        end
+
+        private
+
+        def model_name
+          model.name
+        end
+
+        def record_name
+          model_name.humanize.downcase
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,125 @@
+module Shoulda
+  module Matchers
+    module ActiveModel
+      # The `have_secure_password` matcher tests usage of the
+      # `has_secure_password` macro.
+      #
+      # #### Example
+      #
+      #     class User
+      #       include ActiveModel::Model
+      #       include ActiveModel::SecurePassword
+      #       attr_accessor :password
+      #       attr_accessor :reset_password
+      #
+      #       has_secure_password
+      #       has_secure_password :reset_password
+      #     end
+      #
+      #     # RSpec
+      #     RSpec.describe User, type: :model do
+      #       it { should have_secure_password }
+      #       it { should have_secure_password(:reset_password) }
+      #     end
+      #
+      #     # Minitest (Shoulda)
+      #     class UserTest < ActiveSupport::TestCase
+      #       should have_secure_password
+      #       should have_secure_password(:reset_password)
+      #     end
+      #
+      # @return [HaveSecurePasswordMatcher]
+      #
+      def have_secure_password(attr = :password)
+        HaveSecurePasswordMatcher.new(attr)
+      end
+
+      # @private
+      class HaveSecurePasswordMatcher
+        attr_reader :failure_message
+
+        CORRECT_PASSWORD = 'aBcDe12345'.freeze
+        INCORRECT_PASSWORD = 'password'.freeze
+
+        MESSAGES = {
+          authenticated_incorrect_password: 'expected %{subject} to not'\
+            ' authenticate an incorrect %{attribute}',
+          did_not_authenticate_correct_password: 'expected %{subject} to'\
+            ' authenticate the correct %{attribute}',
+          method_not_found: 'expected %{subject} to respond to %{methods}',
+          should_not_have_secure_password: 'expected %{subject} to'\
+            ' not %{description}!',
+        }.freeze
+
+        def initialize(attribute)
+          @attribute = attribute.to_sym
+        end
+
+        def description
+          "have a secure password, defined on #{@attribute} attribute"
+        end
+
+        def matches?(subject)
+          @subject = subject
+
+          if failure = validate
+            key, params = failure
+            @failure_message =
+              MESSAGES[key] % { subject: subject.class }.merge(params)
+          end
+
+          failure.nil?
+        end
+
+        def failure_message_when_negated
+          MESSAGES[:should_not_have_secure_password] %
+            { subject: @subject.class, description: }
+        end
+
+        protected
+
+        attr_reader :subject
+
+        def validate
+          missing_methods = expected_methods.reject do |m|
+            subject.respond_to?(m)
+          end
+
+          if missing_methods.present?
+            [:method_not_found, { methods: missing_methods.to_sentence }]
+          else
+            subject.send("#{@attribute}=", CORRECT_PASSWORD)
+            subject.send("#{@attribute}_confirmation=", CORRECT_PASSWORD)
+
+            if not subject.send(authenticate_method, CORRECT_PASSWORD)
+              [:did_not_authenticate_correct_password,
+               { attribute: @attribute },]
+            elsif subject.send(authenticate_method, INCORRECT_PASSWORD)
+              [:authenticated_incorrect_password, { attribute: @attribute }]
+            end
+          end
+        end
+
+        private
+
+        def expected_methods
+          @_expected_methods ||= %I[
+            #{authenticate_method}
+            #{@attribute}=
+            #{@attribute}_confirmation=
+            #{@attribute}_digest
+            #{@attribute}_digest=
+          ]
+        end
+
+        def authenticate_method
+          if @attribute == :password
+            :authenticate
+          else
+            "authenticate_#{@attribute}".to_sym
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,37 @@
+module Shoulda
+  module Matchers
+    module ActiveModel
+      # @private
+      module Helpers
+        def pretty_error_messages(object)
+          format_validation_errors(object.errors)
+        end
+
+        def format_validation_errors(errors, attr = nil)
+          list_items = errors.to_hash.keys.map do |attribute|
+            next if attr && attr.to_sym != attribute.to_sym
+
+            messages = errors[attribute]
+            "* #{attribute}: #{messages}"
+          end
+
+          list_items.join("\n")
+        end
+
+        def default_error_message(type, options = {})
+          model_name = options.delete(:model_name)
+          attribute = options.delete(:attribute)
+          instance = options.delete(:instance)
+
+          RailsShim.generate_validation_message(
+            instance,
+            attribute.to_sym,
+            type,
+            model_name,
+            options,
+          )
+        end
+      end
+    end
+  end
+end

data/shoulda-matchers-8.0.1/lib/shoulda/matchers/active_model/numericality_matchers/even_number_matcher.rb

@@ -0,0 +1,45 @@
+module Shoulda
+  module Matchers
+    module ActiveModel
+      module NumericalityMatchers
+        # @private
+        class EvenNumberMatcher < NumericTypeMatcher
+          NON_EVEN_NUMBER_VALUE = 1
+
+          def simple_description
+            description = ''
+
+            if expects_strict?
+              description << 'strictly '
+            end
+
+            description +
+              "disallow :#{attribute} from being an odd number"
+          end
+
+          def allowed_type_adjective
+            'even'
+          end
+
+          def diff_to_compare
+            2
+          end
+
+          protected
+
+          def wrap_disallow_value_matcher(matcher)
+            matcher.with_message(:even)
+          end
+
+          def disallowed_value
+            if @numeric_type_matcher.given_numeric_column?
+              NON_EVEN_NUMBER_VALUE
+            else
+              NON_EVEN_NUMBER_VALUE.to_s
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/shoulda-matchers-8.0.1/lib/shoulda/matchers/active_model/numericality_matchers/numeric_type_matcher.rb

@@ -0,0 +1,67 @@
+require 'forwardable'
+
+module Shoulda
+  module Matchers
+    module ActiveModel
+      module NumericalityMatchers
+        # @private
+        class NumericTypeMatcher
+          extend Forwardable
+
+          def_delegators(
+            :disallow_value_matcher,
+            :expects_custom_validation_message?,
+            :expects_strict?,
+            :failure_message,
+            :failure_message_when_negated,
+            :ignore_interference_by_writer,
+            :ignoring_interference_by_writer,
+            :matches?,
+            :does_not_match?,
+            :on,
+            :strict,
+            :with_message,
+          )
+
+          def initialize(numeric_type_matcher, attribute)
+            @numeric_type_matcher = numeric_type_matcher
+            @attribute = attribute
+          end
+
+          def allowed_type_name
+            'number'
+          end
+
+          def allowed_type_adjective
+            ''
+          end
+
+          def diff_to_compare
+            raise NotImplementedError
+          end
+
+          protected
+
+          attr_reader :attribute
+
+          def wrap_disallow_value_matcher(_matcher)
+            raise NotImplementedError
+          end
+
+          def disallowed_value
+            raise NotImplementedError
+          end
+
+          private
+
+          def disallow_value_matcher
+            @_disallow_value_matcher ||= DisallowValueMatcher.new(disallowed_value).tap do |matcher|
+              matcher.for(attribute)
+              wrap_disallow_value_matcher(matcher)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/shoulda-matchers-8.0.1/lib/shoulda/matchers/active_model/numericality_matchers/odd_number_matcher.rb

@@ -0,0 +1,45 @@
+module Shoulda
+  module Matchers
+    module ActiveModel
+      module NumericalityMatchers
+        # @private
+        class OddNumberMatcher < NumericTypeMatcher
+          NON_ODD_NUMBER_VALUE = 2
+
+          def simple_description
+            description = ''
+
+            if expects_strict?
+              description << 'strictly '
+            end
+
+            description +
+              "disallow :#{attribute} from being an even number"
+          end
+
+          def allowed_type_adjective
+            'odd'
+          end
+
+          def diff_to_compare
+            2
+          end
+
+          protected
+
+          def wrap_disallow_value_matcher(matcher)
+            matcher.with_message(:odd)
+          end
+
+          def disallowed_value
+            if @numeric_type_matcher.given_numeric_column?
+              NON_ODD_NUMBER_VALUE
+            else
+              NON_ODD_NUMBER_VALUE.to_s
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/shoulda-matchers-8.0.1/lib/shoulda/matchers/active_model/numericality_matchers/only_integer_matcher.rb

@@ -0,0 +1,44 @@
+module Shoulda
+  module Matchers
+    module ActiveModel
+      module NumericalityMatchers
+        # @private
+        class OnlyIntegerMatcher < NumericTypeMatcher
+          NON_INTEGER_VALUE = 0.1
+
+          def simple_description
+            description = ''
+
+            if expects_strict?
+              description << ' strictly'
+            end
+
+            description + "disallow :#{attribute} from being a decimal number"
+          end
+
+          def allowed_type_name
+            'integer'
+          end
+
+          def diff_to_compare
+            1
+          end
+
+          protected
+
+          def wrap_disallow_value_matcher(matcher)
+            matcher.with_message(:not_an_integer)
+          end
+
+          def disallowed_value
+            if @numeric_type_matcher.given_numeric_column?
+              NON_INTEGER_VALUE
+            else
+              NON_INTEGER_VALUE.to_s
+            end
+          end
+        end
+      end
+    end
+  end
+end