giga-safe-box 0.0.1

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

@@ -0,0 +1,71 @@
+require 'active_support/core_ext/module/delegation'
+
+module Shoulda
+  module Matchers
+    module ActiveModel
+      module NumericalityMatchers
+        # @private
+        class RangeMatcher < ValidationMatcher
+          OPERATORS = [:>=, :<=].freeze
+
+          delegate :failure_message, to: :submatchers
+
+          def initialize(numericality_matcher, attribute, range)
+            super(attribute)
+            unless numericality_matcher.respond_to? :diff_to_compare
+              raise ArgumentError, 'numericality_matcher is invalid'
+            end
+
+            @numericality_matcher = numericality_matcher
+            @range = range
+            @attribute = attribute
+          end
+
+          def matches?(subject)
+            @subject = subject
+            submatchers.matches?(subject)
+          end
+
+          def simple_description
+            description = ''
+
+            if expects_strict?
+              description << ' strictly'
+            end
+
+            description +
+              "disallow :#{attribute} from being a number that is not " +
+              range_description
+          end
+
+          def range_description
+            "from #{Shoulda::Matchers::Util.inspect_range(@range)}"
+          end
+
+          def submatchers
+            @_submatchers ||= NumericalityMatchers::Submatchers.new(build_submatchers)
+          end
+
+          private
+
+          def build_submatchers
+            submatcher_combos.map do |value, operator|
+              build_comparison_submatcher(value, operator)
+            end
+          end
+
+          def submatcher_combos
+            @range.minmax.zip(OPERATORS)
+          end
+
+          def build_comparison_submatcher(value, operator)
+            ComparisonMatcher.new(@numericality_matcher, value, operator).
+              for(@attribute).
+              with_message(@message).
+              on(@context)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,53 @@
+module Shoulda
+  module Matchers
+    module ActiveModel
+      module NumericalityMatchers
+        # @private
+        class Submatchers
+          def initialize(submatchers)
+            @submatchers = submatchers
+          end
+
+          def matches?(subject)
+            @subject = subject
+            failing_submatchers.empty?
+          end
+
+          def failure_message
+            failing_submatcher.failure_message
+          end
+
+          def failure_message_when_negated
+            non_failing_submatcher.failure_message_when_negated
+          end
+
+          def add(submatcher)
+            @submatchers << submatcher
+          end
+
+          private
+
+          def failing_submatchers
+            @_failing_submatchers ||= @submatchers.reject do |submatcher|
+              submatcher.matches?(@subject)
+            end
+          end
+
+          def non_failing_submatchers
+            @_non_failing_submatchers ||= @submatchers.reject do |submatcher|
+              submatcher.does_not_match?(@subject)
+            end
+          end
+
+          def failing_submatcher
+            failing_submatchers.last
+          end
+
+          def non_failing_submatcher
+            non_failing_submatchers.last
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,9 @@
+module Shoulda
+  module Matchers
+    module ActiveModel
+      # @private
+      module NumericalityMatchers
+      end
+    end
+  end
+end

data/shoulda-matchers-8.0.1/lib/shoulda/matchers/active_model/qualifiers/allow_blank.rb

@@ -0,0 +1,26 @@
+module Shoulda
+  module Matchers
+    module ActiveModel
+      module Qualifiers
+        # @private
+        module AllowBlank
+          def initialize(*args)
+            super
+            @expects_to_allow_blank = false
+          end
+
+          def allow_blank
+            @expects_to_allow_blank = true
+            self
+          end
+
+          protected
+
+          def expects_to_allow_blank?
+            @expects_to_allow_blank
+          end
+        end
+      end
+    end
+  end
+end

data/shoulda-matchers-8.0.1/lib/shoulda/matchers/active_model/qualifiers/allow_nil.rb

@@ -0,0 +1,26 @@
+module Shoulda
+  module Matchers
+    module ActiveModel
+      module Qualifiers
+        # @private
+        module AllowNil
+          def initialize(*args)
+            super
+            @expects_to_allow_nil = false
+          end
+
+          def allow_nil
+            @expects_to_allow_nil = true
+            self
+          end
+
+          protected
+
+          def expects_to_allow_nil?
+            @expects_to_allow_nil
+          end
+        end
+      end
+    end
+  end
+end

data/shoulda-matchers-8.0.1/lib/shoulda/matchers/active_model/qualifiers/ignore_interference_by_writer.rb

@@ -0,0 +1,101 @@
+module Shoulda
+  module Matchers
+    module ActiveModel
+      module Qualifiers
+        # @private
+        class IgnoreInterferenceByWriter
+          attr_reader :setting, :condition
+
+          def initialize(argument = :always)
+            set(argument)
+            @changed = false
+          end
+
+          def set(argument)
+            if argument.is_a?(self.class)
+              @setting = argument.setting
+              @condition = argument.condition
+            else
+              case argument
+              when true, :always
+                @setting = :always
+              when false, :never
+                @setting = :never
+              else
+                @setting = :sometimes
+
+                if argument.is_a?(Hash)
+                  @condition = argument.fetch(:when)
+                else
+                  raise invalid_argument_error(argument)
+                end
+              end
+            end
+
+            @changed = true
+
+            self
+          rescue KeyError
+            raise invalid_argument_error(argument)
+          end
+
+          def default_to(argument)
+            temporary_ignore_interference_by_writer =
+              IgnoreInterferenceByWriter.new(argument)
+
+            unless changed?
+              @setting = temporary_ignore_interference_by_writer.setting
+              @condition = temporary_ignore_interference_by_writer.condition
+            end
+
+            self
+          end
+
+          def considering?(value)
+            case setting
+            when :always then true
+            when :never then false
+            else condition_matches?(value)
+            end
+          end
+
+          def always?
+            setting == :always
+          end
+
+          def never?
+            setting == :never
+          end
+
+          def changed?
+            @changed
+          end
+
+          private
+
+          def invalid_argument_error(invalid_argument)
+            ArgumentError.new(<<-ERROR)
+Unknown argument: #{invalid_argument.inspect}.
+
+ignoring_interference_by_writer takes one of three arguments:
+
+* A symbol, either :never or :always.
+* A boolean, either true (which means always) or false (which means
+  never).
+* A hash with a single key, :when, and a single value, which is either
+  the name of a method or a Proc.
+            ERROR
+          end
+
+          def condition_matches?(value)
+            if condition.respond_to?(:call)
+              condition.call(value)
+            else
+              value.public_send(condition)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/shoulda-matchers-8.0.1/lib/shoulda/matchers/active_model/qualifiers/ignoring_interference_by_writer.rb

@@ -0,0 +1,21 @@
+module Shoulda
+  module Matchers
+    module ActiveModel
+      module Qualifiers
+        # @private
+        module IgnoringInterferenceByWriter
+          attr_reader :ignore_interference_by_writer
+
+          def initialize(*)
+            @ignore_interference_by_writer = IgnoreInterferenceByWriter.new
+          end
+
+          def ignoring_interference_by_writer(value = :always)
+            @ignore_interference_by_writer.set(value)
+            self
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,14 @@
+module Shoulda
+  module Matchers
+    module ActiveModel
+      # @private
+      module Qualifiers
+      end
+    end
+  end
+end
+
+require_relative 'qualifiers/allow_nil'
+require_relative 'qualifiers/allow_blank'
+require_relative 'qualifiers/ignore_interference_by_writer'
+require_relative 'qualifiers/ignoring_interference_by_writer'

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

@@ -0,0 +1,180 @@
+module Shoulda
+  module Matchers
+    module ActiveModel
+      # The `validate_absence_of` matcher tests the usage of the
+      # `validates_absence_of` validation.
+      #
+      #     class PowerHungryCountry
+      #       include ActiveModel::Model
+      #       attr_accessor :nuclear_weapons
+      #
+      #       validates_absence_of :nuclear_weapons
+      #     end
+      #
+      #     # RSpec
+      #     RSpec.describe PowerHungryCountry, type: :model do
+      #       it { should validate_absence_of(:nuclear_weapons) }
+      #     end
+      #
+      #     # Minitest (Shoulda)
+      #     class PowerHungryCountryTest < ActiveSupport::TestCase
+      #       should validate_absence_of(:nuclear_weapons)
+      #     end
+      #
+      # #### Qualifiers
+      #
+      # ##### on
+      #
+      # Use `on` if your validation applies only under a certain context.
+      #
+      #     class PowerHungryCountry
+      #       include ActiveModel::Model
+      #       attr_accessor :nuclear_weapons
+      #
+      #       validates_absence_of :nuclear_weapons, on: :create
+      #     end
+      #
+      #     # RSpec
+      #     RSpec.describe PowerHungryCountry, type: :model do
+      #       it { should validate_absence_of(:nuclear_weapons).on(:create) }
+      #     end
+      #
+      #     # Minitest (Shoulda)
+      #     class PowerHungryCountryTest < ActiveSupport::TestCase
+      #       should validate_absence_of(:nuclear_weapons).on(:create)
+      #     end
+      #
+      # ##### with_message
+      #
+      # Use `with_message` if you are using a custom validation message.
+      #
+      #     class PowerHungryCountry
+      #       include ActiveModel::Model
+      #       attr_accessor :nuclear_weapons
+      #
+      #       validates_absence_of :nuclear_weapons,
+      #         message: "there shall be peace on Earth"
+      #     end
+      #
+      #     # RSpec
+      #     RSpec.describe PowerHungryCountry, type: :model do
+      #       it do
+      #         should validate_absence_of(:nuclear_weapons).
+      #           with_message("there shall be peace on Earth")
+      #       end
+      #     end
+      #
+      #     # Minitest (Shoulda)
+      #     class PowerHungryCountryTest < ActiveSupport::TestCase
+      #       should validate_absence_of(:nuclear_weapons).
+      #         with_message("there shall be peace on Earth")
+      #     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 Robot
+      #       include ActiveModel::Model
+      #       attr_accessor :arms, :legs
+      #
+      #       validates_absence_of :arms, :legs
+      #     end
+      #
+      #     # RSpec
+      #     RSpec.describe Robot, type: :model do
+      #       it { should validate_absence_of(:arms, :legs) }
+      #     end
+      #
+      #     # Minitest (Shoulda)
+      #     class RobotTest < ActiveSupport::TestCase
+      #       should validate_absence_of(:arms, :legs)
+      #     end
+      #
+      # @return [ValidateAbsenceOfMatcher}
+      #
+      def validate_absence_of(*attrs)
+        MatcherCollection.build(attrs) { |attr| ValidateAbsenceOfMatcher.new(attr) }
+      end
+
+      # @private
+      class ValidateAbsenceOfMatcher < ValidationMatcher
+        def initialize(attribute)
+          super
+          @expected_message = :present
+        end
+
+        def matches?(subject)
+          super(subject)
+          disallows_value_of(value, @expected_message)
+        end
+
+        def does_not_match?(subject)
+          super(subject)
+          allows_value_of(value, @expected_message)
+        end
+
+        def simple_description
+          "validate that :#{@attribute} is empty/falsy"
+        end
+
+        private
+
+        def value
+          if reflection
+            obj = reflection.klass.new
+            if collection?
+              [obj]
+            else
+              obj
+            end
+          elsif array_column?
+            ['an arbitrary value']
+          elsif enum_column?
+            enum_values.first
+          else
+            case column_type
+            when :integer, :float then 1
+            when :decimal then BigDecimal(1, 0)
+            when :datetime, :time, :timestamp then Time.current
+            when :date then Date.new
+            when :binary then '0'
+            when :uuid then SecureRandom.uuid
+            else 'an arbitrary value'
+            end
+          end
+        end
+
+        def column_type
+          @subject.class.respond_to?(:columns_hash) &&
+            @subject.class.columns_hash[@attribute.to_s].respond_to?(:type) &&
+            @subject.class.columns_hash[@attribute.to_s].type
+        end
+
+        def collection?
+          if reflection
+            [:has_many, :has_and_belongs_to_many].include?(reflection.macro)
+          else
+            false
+          end
+        end
+
+        def reflection
+          @subject.class.respond_to?(:reflect_on_association) &&
+            @subject.class.reflect_on_association(@attribute)
+        end
+
+        def enum_column?
+          @subject.class.respond_to?(:defined_enums) &&
+            @subject.class.defined_enums.key?(@attribute.to_s)
+        end
+
+        def enum_values
+          @subject.class.defined_enums[@attribute.to_s].values
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,128 @@
+module Shoulda
+  module Matchers
+    module ActiveModel
+      # The `validate_acceptance_of` matcher tests usage of the
+      # `validates_acceptance_of` validation.
+      #
+      #     class Registration
+      #       include ActiveModel::Model
+      #       attr_accessor :eula
+      #
+      #       validates_acceptance_of :eula
+      #     end
+      #
+      #     # RSpec
+      #     RSpec.describe Registration, type: :model do
+      #       it { should validate_acceptance_of(:eula) }
+      #     end
+      #
+      #     # Minitest (Shoulda)
+      #     class RegistrationTest < ActiveSupport::TestCase
+      #       should validate_acceptance_of(:eula)
+      #     end
+      #
+      # #### Qualifiers
+      #
+      # ##### on
+      #
+      # Use `on` if your validation applies only under a certain context.
+      #
+      #     class Registration
+      #       include ActiveModel::Model
+      #       attr_accessor :terms_of_service
+      #
+      #       validates_acceptance_of :terms_of_service, on: :create
+      #     end
+      #
+      #     # RSpec
+      #     RSpec.describe Registration, type: :model do
+      #       it do
+      #         should validate_acceptance_of(:terms_of_service).
+      #           on(:create)
+      #       end
+      #     end
+      #
+      #     # Minitest (Shoulda)
+      #     class RegistrationTest < ActiveSupport::TestCase
+      #       should validate_acceptance_of(:terms_of_service).on(:create)
+      #     end
+      #
+      # ##### with_message
+      #
+      # Use `with_message` if you are using a custom validation message.
+      #
+      #     class Registration
+      #       include ActiveModel::Model
+      #       attr_accessor :terms_of_service
+      #
+      #       validates_acceptance_of :terms_of_service,
+      #         message: 'You must accept the terms of service'
+      #     end
+      #
+      #     # RSpec
+      #     RSpec.describe Registration, type: :model do
+      #       it do
+      #         should validate_acceptance_of(:terms_of_service).
+      #           with_message('You must accept the terms of service')
+      #       end
+      #     end
+      #
+      #     # Minitest (Shoulda)
+      #     class RegistrationTest < ActiveSupport::TestCase
+      #       should validate_acceptance_of(:terms_of_service).
+      #         with_message('You must accept the terms of service')
+      #     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 :terms, :privacy_policy
+      #
+      #       validates_acceptance_of :terms, :privacy_policy
+      #     end
+      #
+      #     # RSpec
+      #     RSpec.describe User, type: :model do
+      #       it { should validate_acceptance_of(:terms, :privacy_policy) }
+      #     end
+      #
+      #     # Minitest (Shoulda)
+      #     class UserTest < ActiveSupport::TestCase
+      #       should validate_acceptance_of(:terms, :privacy_policy)
+      #     end
+      #
+      # @return [ValidateAcceptanceOfMatcher]
+      #
+      def validate_acceptance_of(*attrs)
+        MatcherCollection.build(attrs) { |attr| ValidateAcceptanceOfMatcher.new(attr) }
+      end
+
+      # @private
+      class ValidateAcceptanceOfMatcher < ValidationMatcher
+        def initialize(attribute)
+          super
+          @expected_message = :accepted
+        end
+
+        def matches?(subject)
+          super(subject)
+          disallows_value_of(false, @expected_message)
+        end
+
+        def does_not_match?(subject)
+          super(subject)
+          allows_value_of(false, @expected_message)
+        end
+
+        def simple_description
+          %(validate that :#{@attribute} has been set to "1")
+        end
+      end
+    end
+  end
+end