ric 0.12.0 → 0.12.2

data/vendor/bundle/ruby/2.5.0/gems/activemodel-5.2.3/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.5.0/gems/activemodel-5.2.3/lib/active_model/validations/validates.rb

@@ -0,0 +1,174 @@
+# 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 :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
+      #         value =~ /\A([^@\s]+)@((?:[-a-z0-9]+\.)+[a-z]{2,})\z/i
+      #     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 value =~ /\Athe/i
+      #       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 :gender, inclusion: %w(male female)
+      #   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|
+          next unless options
+          key = "#{key.to_s.camelize}Validator"
+
+          begin
+            validator = key.include?("::".freeze) ? key.constantize : const_get(key)
+          rescue NameError
+            raise ArgumentError, "Unknown validator: '#{key}'"
+          end
+
+          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

data/vendor/bundle/ruby/2.5.0/gems/activemodel-5.2.3/lib/active_model/validations/with.rb

@@ -0,0 +1,147 @@
+# frozen_string_literal: true
+
+require "active_support/core_ext/array/extract_options"
+
+module ActiveModel
+  module Validations
+    class WithValidator < EachValidator # :nodoc:
+      def validate_each(record, attr, val)
+        method_name = options[:with]
+
+        if record.method(method_name).arity == 0
+          record.send method_name
+        else
+          record.send method_name, attr
+        end
+      end
+    end
+
+    module ClassMethods
+      # Passes the record off to the class or classes specified and allows them
+      # to add errors based on more complex conditions.
+      #
+      #   class Person
+      #     include ActiveModel::Validations
+      #     validates_with MyValidator
+      #   end
+      #
+      #   class MyValidator < ActiveModel::Validator
+      #     def validate(record)
+      #       if some_complex_logic
+      #         record.errors.add :base, 'This record is invalid'
+      #       end
+      #     end
+      #
+      #     private
+      #       def some_complex_logic
+      #         # ...
+      #       end
+      #   end
+      #
+      # You may also pass it multiple classes, like so:
+      #
+      #   class Person
+      #     include ActiveModel::Validations
+      #     validates_with MyValidator, MyOtherValidator, on: :create
+      #   end
+      #
+      # Configuration options:
+      # * <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>:strict</tt> - Specifies whether validation should be strict.
+      #   See <tt>ActiveModel::Validations#validates!</tt> for more information.
+      #
+      # If you pass any additional configuration options, they will be passed
+      # to the class and available as +options+:
+      #
+      #   class Person
+      #     include ActiveModel::Validations
+      #     validates_with MyValidator, my_custom_key: 'my custom value'
+      #   end
+      #
+      #   class MyValidator < ActiveModel::Validator
+      #     def validate(record)
+      #       options[:my_custom_key] # => "my custom value"
+      #     end
+      #   end
+      def validates_with(*args, &block)
+        options = args.extract_options!
+        options[:class] = self
+
+        args.each do |klass|
+          validator = klass.new(options, &block)
+
+          if validator.respond_to?(:attributes) && !validator.attributes.empty?
+            validator.attributes.each do |attribute|
+              _validators[attribute.to_sym] << validator
+            end
+          else
+            _validators[nil] << validator
+          end
+
+          validate(validator, options)
+        end
+      end
+    end
+
+    # Passes the record off to the class or classes specified and allows them
+    # to add errors based on more complex conditions.
+    #
+    #   class Person
+    #     include ActiveModel::Validations
+    #
+    #     validate :instance_validations
+    #
+    #     def instance_validations
+    #       validates_with MyValidator
+    #     end
+    #   end
+    #
+    # Please consult the class method documentation for more information on
+    # creating your own validator.
+    #
+    # You may also pass it multiple classes, like so:
+    #
+    #   class Person
+    #     include ActiveModel::Validations
+    #
+    #     validate :instance_validations, on: :create
+    #
+    #     def instance_validations
+    #       validates_with MyValidator, MyOtherValidator
+    #     end
+    #   end
+    #
+    # Standard configuration options (<tt>:on</tt>, <tt>:if</tt> and
+    # <tt>:unless</tt>), which are available on the class version of
+    # +validates_with+, should instead be placed on the +validates+ method
+    # as these are applied and tested in the callback.
+    #
+    # If you pass any additional configuration options, they will be passed
+    # to the class and available as +options+, please refer to the
+    # class version of this method for more information.
+    def validates_with(*args, &block)
+      options = args.extract_options!
+      options[:class] = self.class
+
+      args.each do |klass|
+        validator = klass.new(options, &block)
+        validator.validate(self)
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/2.5.0/gems/activemodel-5.2.3/lib/active_model/validator.rb

@@ -0,0 +1,183 @@
+# frozen_string_literal: true
+
+require "active_support/core_ext/module/anonymous"
+
+module ActiveModel
+  # == Active \Model \Validator
+  #
+  # A simple base class that can be used along with
+  # ActiveModel::Validations::ClassMethods.validates_with
+  #
+  #   class Person
+  #     include ActiveModel::Validations
+  #     validates_with MyValidator
+  #   end
+  #
+  #   class MyValidator < ActiveModel::Validator
+  #     def validate(record)
+  #       if some_complex_logic
+  #         record.errors.add(:base, "This record is invalid")
+  #       end
+  #     end
+  #
+  #     private
+  #       def some_complex_logic
+  #         # ...
+  #       end
+  #   end
+  #
+  # Any class that inherits from ActiveModel::Validator must implement a method
+  # called +validate+ which accepts a +record+.
+  #
+  #   class Person
+  #     include ActiveModel::Validations
+  #     validates_with MyValidator
+  #   end
+  #
+  #   class MyValidator < ActiveModel::Validator
+  #     def validate(record)
+  #       record # => The person instance being validated
+  #       options # => Any non-standard options passed to validates_with
+  #     end
+  #   end
+  #
+  # To cause a validation error, you must add to the +record+'s errors directly
+  # from within the validators message.
+  #
+  #   class MyValidator < ActiveModel::Validator
+  #     def validate(record)
+  #       record.errors.add :base, "This is some custom error message"
+  #       record.errors.add :first_name, "This is some complex validation"
+  #       # etc...
+  #     end
+  #   end
+  #
+  # To add behavior to the initialize method, use the following signature:
+  #
+  #   class MyValidator < ActiveModel::Validator
+  #     def initialize(options)
+  #       super
+  #       @my_custom_field = options[:field_name] || :first_name
+  #     end
+  #   end
+  #
+  # Note that the validator is initialized only once for the whole application
+  # life cycle, and not on each validation run.
+  #
+  # The easiest way to add custom validators for validating individual attributes
+  # is with the convenient <tt>ActiveModel::EachValidator</tt>.
+  #
+  #   class TitleValidator < ActiveModel::EachValidator
+  #     def validate_each(record, attribute, value)
+  #       record.errors.add attribute, 'must be Mr., Mrs., or Dr.' unless %w(Mr. Mrs. Dr.).include?(value)
+  #     end
+  #   end
+  #
+  # This can now be used in combination with the +validates+ method
+  # (see <tt>ActiveModel::Validations::ClassMethods.validates</tt> for more on this).
+  #
+  #   class Person
+  #     include ActiveModel::Validations
+  #     attr_accessor :title
+  #
+  #     validates :title, presence: true, title: true
+  #   end
+  #
+  # It can be useful to access the class that is using that validator when there are prerequisites such
+  # as an +attr_accessor+ being present. This class is accessible via <tt>options[:class]</tt> in the constructor.
+  # To setup your validator override the constructor.
+  #
+  #   class MyValidator < ActiveModel::Validator
+  #     def initialize(options={})
+  #       super
+  #       options[:class].send :attr_accessor, :custom_attribute
+  #     end
+  #   end
+  class Validator
+    attr_reader :options
+
+    # Returns the kind of the validator.
+    #
+    #   PresenceValidator.kind   # => :presence
+    #   AcceptanceValidator.kind # => :acceptance
+    def self.kind
+      @kind ||= name.split("::").last.underscore.chomp("_validator").to_sym unless anonymous?
+    end
+
+    # Accepts options that will be made available through the +options+ reader.
+    def initialize(options = {})
+      @options = options.except(:class).freeze
+    end
+
+    # Returns the kind for this validator.
+    #
+    #   PresenceValidator.new(attributes: [:username]).kind # => :presence
+    #   AcceptanceValidator.new(attributes: [:terms]).kind  # => :acceptance
+    def kind
+      self.class.kind
+    end
+
+    # Override this method in subclasses with validation logic, adding errors
+    # to the records +errors+ array where necessary.
+    def validate(record)
+      raise NotImplementedError, "Subclasses must implement a validate(record) method."
+    end
+  end
+
+  # +EachValidator+ is a validator which iterates through the attributes given
+  # in the options hash invoking the <tt>validate_each</tt> method passing in the
+  # record, attribute and value.
+  #
+  # All \Active \Model validations are built on top of this validator.
+  class EachValidator < Validator #:nodoc:
+    attr_reader :attributes
+
+    # Returns a new validator instance. All options will be available via the
+    # +options+ reader, however the <tt>:attributes</tt> option will be removed
+    # and instead be made available through the +attributes+ reader.
+    def initialize(options)
+      @attributes = Array(options.delete(:attributes))
+      raise ArgumentError, ":attributes cannot be blank" if @attributes.empty?
+      super
+      check_validity!
+    end
+
+    # Performs validation on the supplied record. By default this will call
+    # +validate_each+ to determine validity therefore subclasses should
+    # override +validate_each+ with validation logic.
+    def validate(record)
+      attributes.each do |attribute|
+        value = record.read_attribute_for_validation(attribute)
+        next if (value.nil? && options[:allow_nil]) || (value.blank? && options[:allow_blank])
+        validate_each(record, attribute, value)
+      end
+    end
+
+    # Override this method in subclasses with the validation logic, adding
+    # errors to the records +errors+ array where necessary.
+    def validate_each(record, attribute, value)
+      raise NotImplementedError, "Subclasses must implement a validate_each(record, attribute, value) method"
+    end
+
+    # Hook method that gets called by the initializer allowing verification
+    # that the arguments supplied are valid. You could for example raise an
+    # +ArgumentError+ when invalid options are supplied.
+    def check_validity!
+    end
+  end
+
+  # +BlockValidator+ is a special +EachValidator+ which receives a block on initialization
+  # and call this block for each attribute being validated. +validates_each+ uses this validator.
+  class BlockValidator < EachValidator #:nodoc:
+    def initialize(options, &block)
+      @block = block
+      super
+    end
+
+    private
+
+      def validate_each(record, attribute, value)
+        @block.call(record, attribute, value)
+      end
+  end
+end