ric 0.13.0 → 0.14.0

data/vendor/bundle/ruby/2.7.0/gems/activemodel-6.1.4.4/lib/active_model/validations/length.rb

@@ -0,0 +1,129 @@
+# frozen_string_literal: true
+
+module ActiveModel
+  module Validations
+    class LengthValidator < EachValidator # :nodoc:
+      MESSAGES  = { is: :wrong_length, minimum: :too_short, maximum: :too_long }.freeze
+      CHECKS    = { is: :==, minimum: :>=, maximum: :<= }.freeze
+
+      RESERVED_OPTIONS = [:minimum, :maximum, :within, :is, :too_short, :too_long]
+
+      def initialize(options)
+        if range = (options.delete(:in) || options.delete(:within))
+          raise ArgumentError, ":in and :within must be a Range" unless range.is_a?(Range)
+          options[:minimum], options[:maximum] = range.min, range.max
+        end
+
+        if options[:allow_blank] == false && options[:minimum].nil? && options[:is].nil?
+          options[:minimum] = 1
+        end
+
+        super
+      end
+
+      def check_validity!
+        keys = CHECKS.keys & options.keys
+
+        if keys.empty?
+          raise ArgumentError, "Range unspecified. Specify the :in, :within, :maximum, :minimum, or :is option."
+        end
+
+        keys.each do |key|
+          value = options[key]
+
+          unless (value.is_a?(Integer) && value >= 0) || value == Float::INFINITY || value.is_a?(Symbol) || value.is_a?(Proc)
+            raise ArgumentError, ":#{key} must be a non-negative Integer, Infinity, Symbol, or Proc"
+          end
+        end
+      end
+
+      def validate_each(record, attribute, value)
+        value_length = value.respond_to?(:length) ? value.length : value.to_s.length
+        errors_options = options.except(*RESERVED_OPTIONS)
+
+        CHECKS.each do |key, validity_check|
+          next unless check_value = options[key]
+
+          if !value.nil? || skip_nil_check?(key)
+            case check_value
+            when Proc
+              check_value = check_value.call(record)
+            when Symbol
+              check_value = record.send(check_value)
+            end
+            next if value_length.public_send(validity_check, check_value)
+          end
+
+          errors_options[:count] = check_value
+
+          default_message = options[MESSAGES[key]]
+          errors_options[:message] ||= default_message if default_message
+
+          record.errors.add(attribute, MESSAGES[key], **errors_options)
+        end
+      end
+
+      private
+        def skip_nil_check?(key)
+          key == :maximum && options[:allow_nil].nil? && options[:allow_blank].nil?
+        end
+    end
+
+    module HelperMethods
+      # Validates that the specified attributes match the length restrictions
+      # supplied. Only one constraint option can be used at a time apart from
+      # +:minimum+ and +:maximum+ that can be combined together:
+      #
+      #   class Person < ActiveRecord::Base
+      #     validates_length_of :first_name, maximum: 30
+      #     validates_length_of :last_name, maximum: 30, message: "less than 30 if you don't mind"
+      #     validates_length_of :fax, in: 7..32, allow_nil: true
+      #     validates_length_of :phone, in: 7..32, allow_blank: true
+      #     validates_length_of :user_name, within: 6..20, too_long: 'pick a shorter name', too_short: 'pick a longer name'
+      #     validates_length_of :zip_code, minimum: 5, too_short: 'please enter at least 5 characters'
+      #     validates_length_of :smurf_leader, is: 4, message: "papa is spelled with 4 characters... don't play me."
+      #     validates_length_of :words_in_essay, minimum: 100, too_short: 'Your essay must be at least 100 words.'
+      #
+      #     private
+      #
+      #     def words_in_essay
+      #       essay.scan(/\w+/)
+      #     end
+      #   end
+      #
+      # Constraint options:
+      #
+      # * <tt>:minimum</tt> - The minimum size of the attribute.
+      # * <tt>:maximum</tt> - The maximum size of the attribute. Allows +nil+ by
+      #   default if not used with +:minimum+.
+      # * <tt>:is</tt> - The exact size of the attribute.
+      # * <tt>:within</tt> - A range specifying the minimum and maximum size of
+      #   the attribute.
+      # * <tt>:in</tt> - A synonym (or alias) for <tt>:within</tt>.
+      #
+      # Other options:
+      #
+      # * <tt>:allow_nil</tt> - Attribute may be +nil+; skip validation.
+      # * <tt>:allow_blank</tt> - Attribute may be blank; skip validation.
+      # * <tt>:too_long</tt> - The error message if the attribute goes over the
+      #   maximum (default is: "is too long (maximum is %{count} characters)").
+      # * <tt>:too_short</tt> - The error message if the attribute goes under the
+      #   minimum (default is: "is too short (minimum is %{count} characters)").
+      # * <tt>:wrong_length</tt> - The error message if using the <tt>:is</tt>
+      #   method and the attribute is the wrong size (default is: "is the wrong
+      #   length (should be %{count} characters)").
+      # * <tt>:message</tt> - The error message to use for a <tt>:minimum</tt>,
+      #   <tt>:maximum</tt>, or <tt>:is</tt> violation. An alias of the appropriate
+      #   <tt>too_long</tt>/<tt>too_short</tt>/<tt>wrong_length</tt> message.
+      #
+      # There is also a list of default options supported by every validator:
+      # +:if+, +:unless+, +:on+ and +:strict+.
+      # See <tt>ActiveModel::Validations#validates</tt> for more information
+      def validates_length_of(*attr_names)
+        validates_with LengthValidator, _merge_attributes(attr_names)
+      end
+
+      alias_method :validates_size_of, :validates_length_of
+    end
+  end
+end

data/vendor/bundle/ruby/2.7.0/gems/activemodel-6.1.4.4/lib/active_model/validations/numericality.rb

@@ -0,0 +1,203 @@
+# frozen_string_literal: true
+
+require "bigdecimal/util"
+
+module ActiveModel
+  module Validations
+    class NumericalityValidator < EachValidator # :nodoc:
+      CHECKS = { greater_than: :>, greater_than_or_equal_to: :>=,
+                 equal_to: :==, less_than: :<, less_than_or_equal_to: :<=,
+                 odd: :odd?, even: :even?, other_than: :!= }.freeze
+
+      RESERVED_OPTIONS = CHECKS.keys + [:only_integer]
+
+      INTEGER_REGEX = /\A[+-]?\d+\z/
+
+      HEXADECIMAL_REGEX = /\A[+-]?0[xX]/
+
+      def check_validity!
+        keys = CHECKS.keys - [:odd, :even]
+        options.slice(*keys).each do |option, value|
+          unless value.is_a?(Numeric) || value.is_a?(Proc) || value.is_a?(Symbol)
+            raise ArgumentError, ":#{option} must be a number, a symbol or a proc"
+          end
+        end
+      end
+
+      def validate_each(record, attr_name, value, precision: Float::DIG, scale: nil)
+        unless is_number?(value, precision, scale)
+          record.errors.add(attr_name, :not_a_number, **filtered_options(value))
+          return
+        end
+
+        if allow_only_integer?(record) && !is_integer?(value)
+          record.errors.add(attr_name, :not_an_integer, **filtered_options(value))
+          return
+        end
+
+        value = parse_as_number(value, precision, scale)
+
+        options.slice(*CHECKS.keys).each do |option, option_value|
+          case option
+          when :odd, :even
+            unless value.to_i.public_send(CHECKS[option])
+              record.errors.add(attr_name, option, **filtered_options(value))
+            end
+          else
+            case option_value
+            when Proc
+              option_value = option_value.call(record)
+            when Symbol
+              option_value = record.send(option_value)
+            end
+
+            option_value = parse_as_number(option_value, precision, scale)
+
+            unless value.public_send(CHECKS[option], option_value)
+              record.errors.add(attr_name, option, **filtered_options(value).merge!(count: option_value))
+            end
+          end
+        end
+      end
+
+    private
+      def parse_as_number(raw_value, precision, scale)
+        if raw_value.is_a?(Float)
+          parse_float(raw_value, precision, scale)
+        elsif raw_value.is_a?(BigDecimal)
+          round(raw_value, scale)
+        elsif raw_value.is_a?(Numeric)
+          raw_value
+        elsif is_integer?(raw_value)
+          raw_value.to_i
+        elsif !is_hexadecimal_literal?(raw_value)
+          parse_float(Kernel.Float(raw_value), precision, scale)
+        end
+      end
+
+      def parse_float(raw_value, precision, scale)
+        round(raw_value, scale).to_d(precision)
+      end
+
+      def round(raw_value, scale)
+        scale ? raw_value.round(scale) : raw_value
+      end
+
+      def is_number?(raw_value, precision, scale)
+        !parse_as_number(raw_value, precision, scale).nil?
+      rescue ArgumentError, TypeError
+        false
+      end
+
+      def is_integer?(raw_value)
+        INTEGER_REGEX.match?(raw_value.to_s)
+      end
+
+      def is_hexadecimal_literal?(raw_value)
+        HEXADECIMAL_REGEX.match?(raw_value.to_s)
+      end
+
+      def filtered_options(value)
+        filtered = options.except(*RESERVED_OPTIONS)
+        filtered[:value] = value
+        filtered
+      end
+
+      def allow_only_integer?(record)
+        case options[:only_integer]
+        when Symbol
+          record.send(options[:only_integer])
+        when Proc
+          options[:only_integer].call(record)
+        else
+          options[:only_integer]
+        end
+      end
+
+      def prepare_value_for_validation(value, record, attr_name)
+        return value if record_attribute_changed_in_place?(record, attr_name)
+
+        came_from_user = :"#{attr_name}_came_from_user?"
+
+        if record.respond_to?(came_from_user)
+          if record.public_send(came_from_user)
+            raw_value = record.public_send(:"#{attr_name}_before_type_cast")
+          elsif record.respond_to?(:read_attribute)
+            raw_value = record.read_attribute(attr_name)
+          end
+        else
+          before_type_cast = :"#{attr_name}_before_type_cast"
+          if record.respond_to?(before_type_cast)
+            raw_value = record.public_send(before_type_cast)
+          end
+        end
+
+        raw_value || value
+      end
+
+      def record_attribute_changed_in_place?(record, attr_name)
+        record.respond_to?(:attribute_changed_in_place?) &&
+          record.attribute_changed_in_place?(attr_name.to_s)
+      end
+    end
+
+    module HelperMethods
+      # Validates whether the value of the specified attribute is numeric by
+      # trying to convert it to a float with Kernel.Float (if <tt>only_integer</tt>
+      # is +false+) or applying it to the regular expression <tt>/\A[\+\-]?\d+\z/</tt>
+      # (if <tt>only_integer</tt> is set to +true+). Precision of Kernel.Float values
+      # are guaranteed up to 15 digits.
+      #
+      #   class Person < ActiveRecord::Base
+      #     validates_numericality_of :value, on: :create
+      #   end
+      #
+      # Configuration options:
+      # * <tt>:message</tt> - A custom error message (default is: "is not a number").
+      # * <tt>:only_integer</tt> - Specifies whether the value has to be an
+      #   integer, e.g. an integral value (default is +false+).
+      # * <tt>:allow_nil</tt> - Skip validation if attribute is +nil+ (default is
+      #   +false+). Notice that for Integer and Float columns empty strings are
+      #   converted to +nil+.
+      # * <tt>:greater_than</tt> - Specifies the value must be greater than the
+      #   supplied value.
+      # * <tt>:greater_than_or_equal_to</tt> - Specifies the value must be
+      #   greater than or equal the supplied value.
+      # * <tt>:equal_to</tt> - Specifies the value must be equal to the supplied
+      #   value.
+      # * <tt>:less_than</tt> - Specifies the value must be less than the
+      #   supplied value.
+      # * <tt>:less_than_or_equal_to</tt> - Specifies the value must be less
+      #   than or equal the supplied value.
+      # * <tt>:other_than</tt> - Specifies the value must be other than the
+      #   supplied value.
+      # * <tt>:odd</tt> - Specifies the value must be an odd number.
+      # * <tt>:even</tt> - Specifies the value must be an even number.
+      #
+      # There is also a list of default options supported by every validator:
+      # +:if+, +:unless+, +:on+, +:allow_nil+, +:allow_blank+, and +:strict+ .
+      # See <tt>ActiveModel::Validations#validates</tt> for more information
+      #
+      # The following checks can also be supplied with a proc or a symbol which
+      # corresponds to a method:
+      #
+      # * <tt>:greater_than</tt>
+      # * <tt>:greater_than_or_equal_to</tt>
+      # * <tt>:equal_to</tt>
+      # * <tt>:less_than</tt>
+      # * <tt>:less_than_or_equal_to</tt>
+      # * <tt>:only_integer</tt>
+      # * <tt>:other_than</tt>
+      #
+      # For example:
+      #
+      #   class Person < ActiveRecord::Base
+      #     validates_numericality_of :width, less_than: ->(person) { person.height }
+      #     validates_numericality_of :width, greater_than: :minimum_weight
+      #   end
+      def validates_numericality_of(*attr_names)
+        validates_with NumericalityValidator, _merge_attributes(attr_names)
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/2.7.0/gems/activemodel-6.1.4.4/lib/active_model/validations/presence.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module ActiveModel
+  module Validations
+    class PresenceValidator < EachValidator # :nodoc:
+      def validate_each(record, attr_name, value)
+        record.errors.add(attr_name, :blank, **options) if value.blank?
+      end
+    end
+
+    module HelperMethods
+      # Validates that the specified attributes are not blank (as defined by
+      # Object#blank?). Happens by default on save.
+      #
+      #   class Person < ActiveRecord::Base
+      #     validates_presence_of :first_name
+      #   end
+      #
+      # The first_name attribute must be in the object and it cannot be blank.
+      #
+      # If you want to validate the presence of a boolean field (where the real
+      # values are +true+ and +false+), you will want to use
+      # <tt>validates_inclusion_of :field_name, in: [true, false]</tt>.
+      #
+      # This is due to the way Object#blank? handles boolean values:
+      # <tt>false.blank? # => true</tt>.
+      #
+      # Configuration options:
+      # * <tt>:message</tt> - A custom error message (default is: "can't be blank").
+      #
+      # There is also a list of default options supported by every validator:
+      # +:if+, +:unless+, +:on+, +:allow_nil+, +:allow_blank+, and +:strict+.
+      # See <tt>ActiveModel::Validations#validates</tt> for more information
+      def validates_presence_of(*attr_names)
+        validates_with PresenceValidator, _merge_attributes(attr_names)
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/2.7.0/gems/activemodel-6.1.4.4/lib/active_model/validations/validates.rb

@@ -0,0 +1,175 @@
+# frozen_string_literal: true
+
+require "active_support/core_ext/hash/slice"
+
+module ActiveModel
+  module Validations
+    module ClassMethods
+      # This method is a shortcut to all default validators and any custom
+      # validator classes ending in 'Validator'. Note that Rails default
+      # validators can be overridden inside specific classes by creating
+      # custom validator classes in their place such as PresenceValidator.
+      #
+      # Examples of using the default rails validators:
+      #
+      #   validates :username, absence: true
+      #   validates :terms, acceptance: true
+      #   validates :password, confirmation: true
+      #   validates :username, exclusion: { in: %w(admin superuser) }
+      #   validates :email, format: { with: /\A([^@\s]+)@((?:[-a-z0-9]+\.)+[a-z]{2,})\z/i, on: :create }
+      #   validates :age, inclusion: { in: 0..9 }
+      #   validates :first_name, length: { maximum: 30 }
+      #   validates :age, numericality: true
+      #   validates :username, presence: true
+      #
+      # The power of the +validates+ method comes when using custom validators
+      # and default validators in one call for a given attribute.
+      #
+      #   class EmailValidator < ActiveModel::EachValidator
+      #     def validate_each(record, attribute, value)
+      #       record.errors.add attribute, (options[:message] || "is not an email") unless
+      #         /\A([^@\s]+)@((?:[-a-z0-9]+\.)+[a-z]{2,})\z/i.match?(value)
+      #     end
+      #   end
+      #
+      #   class Person
+      #     include ActiveModel::Validations
+      #     attr_accessor :name, :email
+      #
+      #     validates :name, presence: true, length: { maximum: 100 }
+      #     validates :email, presence: true, email: true
+      #   end
+      #
+      # Validator classes may also exist within the class being validated
+      # allowing custom modules of validators to be included as needed.
+      #
+      #   class Film
+      #     include ActiveModel::Validations
+      #
+      #     class TitleValidator < ActiveModel::EachValidator
+      #       def validate_each(record, attribute, value)
+      #         record.errors.add attribute, "must start with 'the'" unless /\Athe/i.match?(value)
+      #       end
+      #     end
+      #
+      #     validates :name, title: true
+      #   end
+      #
+      # Additionally validator classes may be in another namespace and still
+      # used within any class.
+      #
+      #   validates :name, :'film/title' => true
+      #
+      # The validators hash can also handle regular expressions, ranges, arrays
+      # and strings in shortcut form.
+      #
+      #   validates :email, format: /@/
+      #   validates :role, inclusion: %w(admin contributor)
+      #   validates :password, length: 6..20
+      #
+      # When using shortcut form, ranges and arrays are passed to your
+      # validator's initializer as <tt>options[:in]</tt> while other types
+      # including regular expressions and strings are passed as <tt>options[:with]</tt>.
+      #
+      # There is also a list of options that could be used along with validators:
+      #
+      # * <tt>:on</tt> - Specifies the contexts where this validation is active.
+      #   Runs in all validation contexts by default +nil+. You can pass a symbol
+      #   or an array of symbols. (e.g. <tt>on: :create</tt> or
+      #   <tt>on: :custom_validation_context</tt> or
+      #   <tt>on: [:create, :custom_validation_context]</tt>)
+      # * <tt>:if</tt> - Specifies a method, proc or string to call to determine
+      #   if the validation should occur (e.g. <tt>if: :allow_validation</tt>,
+      #   or <tt>if: Proc.new { |user| user.signup_step > 2 }</tt>). The method,
+      #   proc or string should return or evaluate to a +true+ or +false+ value.
+      # * <tt>:unless</tt> - Specifies a method, proc or string to call to determine
+      #   if the validation should not occur (e.g. <tt>unless: :skip_validation</tt>,
+      #   or <tt>unless: Proc.new { |user| user.signup_step <= 2 }</tt>). The
+      #   method, proc or string should return or evaluate to a +true+ or
+      #   +false+ value.
+      # * <tt>:allow_nil</tt> - Skip validation if the attribute is +nil+.
+      # * <tt>:allow_blank</tt> - Skip validation if the attribute is blank.
+      # * <tt>:strict</tt> - If the <tt>:strict</tt> option is set to true
+      #   will raise ActiveModel::StrictValidationFailed instead of adding the error.
+      #   <tt>:strict</tt> option can also be set to any other exception.
+      #
+      # Example:
+      #
+      #   validates :password, presence: true, confirmation: true, if: :password_required?
+      #   validates :token, length: 24, strict: TokenLengthException
+      #
+      #
+      # Finally, the options +:if+, +:unless+, +:on+, +:allow_blank+, +:allow_nil+, +:strict+
+      # and +:message+ can be given to one specific validator, as a hash:
+      #
+      #   validates :password, presence: { if: :password_required?, message: 'is forgotten.' }, confirmation: true
+      def validates(*attributes)
+        defaults = attributes.extract_options!.dup
+        validations = defaults.slice!(*_validates_default_keys)
+
+        raise ArgumentError, "You need to supply at least one attribute" if attributes.empty?
+        raise ArgumentError, "You need to supply at least one validation" if validations.empty?
+
+        defaults[:attributes] = attributes
+
+        validations.each do |key, options|
+          key = "#{key.to_s.camelize}Validator"
+
+          begin
+            validator = key.include?("::") ? key.constantize : const_get(key)
+          rescue NameError
+            raise ArgumentError, "Unknown validator: '#{key}'"
+          end
+
+          next unless options
+
+          validates_with(validator, defaults.merge(_parse_validates_options(options)))
+        end
+      end
+
+      # This method is used to define validations that cannot be corrected by end
+      # users and are considered exceptional. So each validator defined with bang
+      # or <tt>:strict</tt> option set to <tt>true</tt> will always raise
+      # <tt>ActiveModel::StrictValidationFailed</tt> instead of adding error
+      # when validation fails. See <tt>validates</tt> for more information about
+      # the validation itself.
+      #
+      #   class Person
+      #     include ActiveModel::Validations
+      #
+      #     attr_accessor :name
+      #     validates! :name, presence: true
+      #   end
+      #
+      #   person = Person.new
+      #   person.name = ''
+      #   person.valid?
+      #   # => ActiveModel::StrictValidationFailed: Name can't be blank
+      def validates!(*attributes)
+        options = attributes.extract_options!
+        options[:strict] = true
+        validates(*(attributes << options))
+      end
+
+    private
+      # When creating custom validators, it might be useful to be able to specify
+      # additional default keys. This can be done by overwriting this method.
+      def _validates_default_keys
+        [:if, :unless, :on, :allow_blank, :allow_nil, :strict]
+      end
+
+      def _parse_validates_options(options)
+        case options
+        when TrueClass
+          {}
+        when Hash
+          options
+        when Range, Array
+          { in: options }
+        else
+          { with: options }
+        end
+      end
+    end
+  end
+end