ric 0.11.19 → 0.14.0

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

@@ -0,0 +1,113 @@
+# frozen_string_literal: true
+
+module ActiveModel
+  module Validations
+    class FormatValidator < EachValidator # :nodoc:
+      def validate_each(record, attribute, value)
+        if options[:with]
+          regexp = option_call(record, :with)
+          record_error(record, attribute, :with, value) unless regexp.match?(value.to_s)
+        elsif options[:without]
+          regexp = option_call(record, :without)
+          record_error(record, attribute, :without, value) if regexp.match?(value.to_s)
+        end
+      end
+
+      def check_validity!
+        unless options.include?(:with) ^ options.include?(:without)  # ^ == xor, or "exclusive or"
+          raise ArgumentError, "Either :with or :without must be supplied (but not both)"
+        end
+
+        check_options_validity :with
+        check_options_validity :without
+      end
+
+      private
+        def option_call(record, name)
+          option = options[name]
+          option.respond_to?(:call) ? option.call(record) : option
+        end
+
+        def record_error(record, attribute, name, value)
+          record.errors.add(attribute, :invalid, **options.except(name).merge!(value: value))
+        end
+
+        def check_options_validity(name)
+          if option = options[name]
+            if option.is_a?(Regexp)
+              if options[:multiline] != true && regexp_using_multiline_anchors?(option)
+                raise ArgumentError, "The provided regular expression is using multiline anchors (^ or $), " \
+                "which may present a security risk. Did you mean to use \\A and \\z, or forgot to add the " \
+                ":multiline => true option?"
+              end
+            elsif !option.respond_to?(:call)
+              raise ArgumentError, "A regular expression or a proc or lambda must be supplied as :#{name}"
+            end
+          end
+        end
+
+        def regexp_using_multiline_anchors?(regexp)
+          source = regexp.source
+          source.start_with?("^") || (source.end_with?("$") && !source.end_with?("\\$"))
+        end
+    end
+
+    module HelperMethods
+      # Validates whether the value of the specified attribute is of the correct
+      # form, going by the regular expression provided. You can require that the
+      # attribute matches the regular expression:
+      #
+      #   class Person < ActiveRecord::Base
+      #     validates_format_of :email, with: /\A([^@\s]+)@((?:[-a-z0-9]+\.)+[a-z]{2,})\z/i, on: :create
+      #   end
+      #
+      # Alternatively, you can require that the specified attribute does _not_
+      # match the regular expression:
+      #
+      #   class Person < ActiveRecord::Base
+      #     validates_format_of :email, without: /NOSPAM/
+      #   end
+      #
+      # You can also provide a proc or lambda which will determine the regular
+      # expression that will be used to validate the attribute.
+      #
+      #   class Person < ActiveRecord::Base
+      #     # Admin can have number as a first letter in their screen name
+      #     validates_format_of :screen_name,
+      #                         with: ->(person) { person.admin? ? /\A[a-z0-9][a-z0-9_\-]*\z/i : /\A[a-z][a-z0-9_\-]*\z/i }
+      #   end
+      #
+      # Note: use <tt>\A</tt> and <tt>\z</tt> to match the start and end of the
+      # string, <tt>^</tt> and <tt>$</tt> match the start/end of a line.
+      #
+      # Due to frequent misuse of <tt>^</tt> and <tt>$</tt>, you need to pass
+      # the <tt>multiline: true</tt> option in case you use any of these two
+      # anchors in the provided regular expression. In most cases, you should be
+      # using <tt>\A</tt> and <tt>\z</tt>.
+      #
+      # You must pass either <tt>:with</tt> or <tt>:without</tt> as an option.
+      # In addition, both must be a regular expression or a proc or lambda, or
+      # else an exception will be raised.
+      #
+      # Configuration options:
+      # * <tt>:message</tt> - A custom error message (default is: "is invalid").
+      # * <tt>:with</tt> - Regular expression that if the attribute matches will
+      #   result in a successful validation. This can be provided as a proc or
+      #   lambda returning regular expression which will be called at runtime.
+      # * <tt>:without</tt> - Regular expression that if the attribute does not
+      #   match will result in a successful validation. This can be provided as
+      #   a proc or lambda returning regular expression which will be called at
+      #   runtime.
+      # * <tt>:multiline</tt> - Set to true if your regular expression contains
+      #   anchors that match the beginning or end of lines as opposed to the
+      #   beginning or end of the string. These anchors are <tt>^</tt> and <tt>$</tt>.
+      #
+      # 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_format_of(*attr_names)
+        validates_with FormatValidator, _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/helper_methods.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module ActiveModel
+  module Validations
+    module HelperMethods # :nodoc:
+      private
+        def _merge_attributes(attr_names)
+          options = attr_names.extract_options!.symbolize_keys
+          attr_names.flatten!
+          options[:attributes] = attr_names
+          options
+        end
+    end
+  end
+end

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

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+require "active_model/validations/clusivity"
+
+module ActiveModel
+  module Validations
+    class InclusionValidator < EachValidator # :nodoc:
+      include Clusivity
+
+      def validate_each(record, attribute, value)
+        unless include?(record, value)
+          record.errors.add(attribute, :inclusion, **options.except(:in, :within).merge!(value: value))
+        end
+      end
+    end
+
+    module HelperMethods
+      # Validates whether the value of the specified attribute is available in a
+      # particular enumerable object.
+      #
+      #   class Person < ActiveRecord::Base
+      #     validates_inclusion_of :role, in: %w( admin contributor )
+      #     validates_inclusion_of :age, in: 0..99
+      #     validates_inclusion_of :format, in: %w( jpg gif png ), message: "extension %{value} is not included in the list"
+      #     validates_inclusion_of :states, in: ->(person) { STATES[person.country] }
+      #     validates_inclusion_of :karma, in: :available_karmas
+      #   end
+      #
+      # Configuration options:
+      # * <tt>:in</tt> - An enumerable object of available items. This can be
+      #   supplied as a proc, lambda or symbol which returns an enumerable. If the
+      #   enumerable is a numerical, time or datetime range the test is performed
+      #   with <tt>Range#cover?</tt>, otherwise with <tt>include?</tt>. When using
+      #   a proc or lambda the instance under validation is passed as an argument.
+      # * <tt>:within</tt> - A synonym(or alias) for <tt>:in</tt>
+      # * <tt>:message</tt> - Specifies a custom error message (default is: "is
+      #   not included in the list").
+      #
+      # 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_inclusion_of(*attr_names)
+        validates_with InclusionValidator, _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/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