ric 0.12.0 → 0.14.1

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

@@ -0,0 +1,436 @@
+# frozen_string_literal: true
+
+require "active_support/core_ext/array/extract_options"
+
+module ActiveModel
+  # == Active \Model \Validations
+  #
+  # Provides a full validation framework to your objects.
+  #
+  # A minimal implementation could be:
+  #
+  #   class Person
+  #     include ActiveModel::Validations
+  #
+  #     attr_accessor :first_name, :last_name
+  #
+  #     validates_each :first_name, :last_name do |record, attr, value|
+  #       record.errors.add attr, "starts with z." if value.start_with?("z")
+  #     end
+  #   end
+  #
+  # Which provides you with the full standard validation stack that you
+  # know from Active Record:
+  #
+  #   person = Person.new
+  #   person.valid?                   # => true
+  #   person.invalid?                 # => false
+  #
+  #   person.first_name = 'zoolander'
+  #   person.valid?                   # => false
+  #   person.invalid?                 # => true
+  #   person.errors.messages          # => {first_name:["starts with z."]}
+  #
+  # Note that <tt>ActiveModel::Validations</tt> automatically adds an +errors+
+  # method to your instances initialized with a new <tt>ActiveModel::Errors</tt>
+  # object, so there is no need for you to do this manually.
+  module Validations
+    extend ActiveSupport::Concern
+
+    included do
+      extend ActiveModel::Naming
+      extend ActiveModel::Callbacks
+      extend ActiveModel::Translation
+
+      extend  HelperMethods
+      include HelperMethods
+
+      attr_accessor :validation_context
+      private :validation_context=
+      define_callbacks :validate, scope: :name
+
+      class_attribute :_validators, instance_writer: false, default: Hash.new { |h, k| h[k] = [] }
+    end
+
+    module ClassMethods
+      # Validates each attribute against a block.
+      #
+      #   class Person
+      #     include ActiveModel::Validations
+      #
+      #     attr_accessor :first_name, :last_name
+      #
+      #     validates_each :first_name, :last_name, allow_blank: true do |record, attr, value|
+      #       record.errors.add attr, "starts with z." if value.start_with?("z")
+      #     end
+      #   end
+      #
+      # 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>:allow_nil</tt> - Skip validation if attribute is +nil+.
+      # * <tt>:allow_blank</tt> - Skip validation if attribute is blank.
+      # * <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.
+      def validates_each(*attr_names, &block)
+        validates_with BlockValidator, _merge_attributes(attr_names), &block
+      end
+
+      VALID_OPTIONS_FOR_VALIDATE = [:on, :if, :unless, :prepend].freeze # :nodoc:
+
+      # Adds a validation method or block to the class. This is useful when
+      # overriding the +validate+ instance method becomes too unwieldy and
+      # you're looking for more descriptive declaration of your validations.
+      #
+      # This can be done with a symbol pointing to a method:
+      #
+      #   class Comment
+      #     include ActiveModel::Validations
+      #
+      #     validate :must_be_friends
+      #
+      #     def must_be_friends
+      #       errors.add(:base, 'Must be friends to leave a comment') unless commenter.friend_of?(commentee)
+      #     end
+      #   end
+      #
+      # With a block which is passed with the current record to be validated:
+      #
+      #   class Comment
+      #     include ActiveModel::Validations
+      #
+      #     validate do |comment|
+      #       comment.must_be_friends
+      #     end
+      #
+      #     def must_be_friends
+      #       errors.add(:base, 'Must be friends to leave a comment') unless commenter.friend_of?(commentee)
+      #     end
+      #   end
+      #
+      # Or with a block where self points to the current record to be validated:
+      #
+      #   class Comment
+      #     include ActiveModel::Validations
+      #
+      #     validate do
+      #       errors.add(:base, 'Must be friends to leave a comment') unless commenter.friend_of?(commentee)
+      #     end
+      #   end
+      #
+      # Note that the return value of validation methods is not relevant.
+      # It's not possible to halt the validate callback chain.
+      #
+      # 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.
+      #
+      # NOTE: Calling +validate+ multiple times on the same method will overwrite previous definitions.
+      #
+      def validate(*args, &block)
+        options = args.extract_options!
+
+        if args.all? { |arg| arg.is_a?(Symbol) }
+          options.each_key do |k|
+            unless VALID_OPTIONS_FOR_VALIDATE.include?(k)
+              raise ArgumentError.new("Unknown key: #{k.inspect}. Valid keys are: #{VALID_OPTIONS_FOR_VALIDATE.map(&:inspect).join(', ')}. Perhaps you meant to call `validates` instead of `validate`?")
+            end
+          end
+        end
+
+        if options.key?(:on)
+          options = options.dup
+          options[:on] = Array(options[:on])
+          options[:if] = [
+            ->(o) { !(options[:on] & Array(o.validation_context)).empty? },
+            *options[:if]
+          ]
+        end
+
+        set_callback(:validate, *args, options, &block)
+      end
+
+      # List all validators that are being used to validate the model using
+      # +validates_with+ method.
+      #
+      #   class Person
+      #     include ActiveModel::Validations
+      #
+      #     validates_with MyValidator
+      #     validates_with OtherValidator, on: :create
+      #     validates_with StrictValidator, strict: true
+      #   end
+      #
+      #   Person.validators
+      #   # => [
+      #   #      #<MyValidator:0x007fbff403e808 @options={}>,
+      #   #      #<OtherValidator:0x007fbff403d930 @options={on: :create}>,
+      #   #      #<StrictValidator:0x007fbff3204a30 @options={strict:true}>
+      #   #    ]
+      def validators
+        _validators.values.flatten.uniq
+      end
+
+      # Clears all of the validators and validations.
+      #
+      # Note that this will clear anything that is being used to validate
+      # the model for both the +validates_with+ and +validate+ methods.
+      # It clears the validators that are created with an invocation of
+      # +validates_with+ and the callbacks that are set by an invocation
+      # of +validate+.
+      #
+      #   class Person
+      #     include ActiveModel::Validations
+      #
+      #     validates_with MyValidator
+      #     validates_with OtherValidator, on: :create
+      #     validates_with StrictValidator, strict: true
+      #     validate :cannot_be_robot
+      #
+      #     def cannot_be_robot
+      #       errors.add(:base, 'A person cannot be a robot') if person_is_robot
+      #     end
+      #   end
+      #
+      #   Person.validators
+      #   # => [
+      #   #      #<MyValidator:0x007fbff403e808 @options={}>,
+      #   #      #<OtherValidator:0x007fbff403d930 @options={on: :create}>,
+      #   #      #<StrictValidator:0x007fbff3204a30 @options={strict:true}>
+      #   #    ]
+      #
+      # If one runs <tt>Person.clear_validators!</tt> and then checks to see what
+      # validators this class has, you would obtain:
+      #
+      #   Person.validators # => []
+      #
+      # Also, the callback set by <tt>validate :cannot_be_robot</tt> will be erased
+      # so that:
+      #
+      #   Person._validate_callbacks.empty?  # => true
+      #
+      def clear_validators!
+        reset_callbacks(:validate)
+        _validators.clear
+      end
+
+      # List all validators that are being used to validate a specific attribute.
+      #
+      #   class Person
+      #     include ActiveModel::Validations
+      #
+      #     attr_accessor :name , :age
+      #
+      #     validates_presence_of :name
+      #     validates_inclusion_of :age, in: 0..99
+      #   end
+      #
+      #   Person.validators_on(:name)
+      #   # => [
+      #   #       #<ActiveModel::Validations::PresenceValidator:0x007fe604914e60 @attributes=[:name], @options={}>,
+      #   #    ]
+      def validators_on(*attributes)
+        attributes.flat_map do |attribute|
+          _validators[attribute.to_sym]
+        end
+      end
+
+      # Returns +true+ if +attribute+ is an attribute method, +false+ otherwise.
+      #
+      #  class Person
+      #    include ActiveModel::Validations
+      #
+      #    attr_accessor :name
+      #  end
+      #
+      #  User.attribute_method?(:name) # => true
+      #  User.attribute_method?(:age)  # => false
+      def attribute_method?(attribute)
+        method_defined?(attribute)
+      end
+
+      # Copy validators on inheritance.
+      def inherited(base) #:nodoc:
+        dup = _validators.dup
+        base._validators = dup.each { |k, v| dup[k] = v.dup }
+        super
+      end
+    end
+
+    # Clean the +Errors+ object if instance is duped.
+    def initialize_dup(other) #:nodoc:
+      @errors = nil
+      super
+    end
+
+    # Returns the +Errors+ object that holds all information about attribute
+    # error messages.
+    #
+    #   class Person
+    #     include ActiveModel::Validations
+    #
+    #     attr_accessor :name
+    #     validates_presence_of :name
+    #   end
+    #
+    #   person = Person.new
+    #   person.valid? # => false
+    #   person.errors # => #<ActiveModel::Errors:0x007fe603816640 @messages={name:["can't be blank"]}>
+    def errors
+      @errors ||= Errors.new(self)
+    end
+
+    # Runs all the specified validations and returns +true+ if no errors were
+    # added otherwise +false+.
+    #
+    #   class Person
+    #     include ActiveModel::Validations
+    #
+    #     attr_accessor :name
+    #     validates_presence_of :name
+    #   end
+    #
+    #   person = Person.new
+    #   person.name = ''
+    #   person.valid? # => false
+    #   person.name = 'david'
+    #   person.valid? # => true
+    #
+    # Context can optionally be supplied to define which callbacks to test
+    # against (the context is defined on the validations using <tt>:on</tt>).
+    #
+    #   class Person
+    #     include ActiveModel::Validations
+    #
+    #     attr_accessor :name
+    #     validates_presence_of :name, on: :new
+    #   end
+    #
+    #   person = Person.new
+    #   person.valid?       # => true
+    #   person.valid?(:new) # => false
+    def valid?(context = nil)
+      current_context, self.validation_context = validation_context, context
+      errors.clear
+      run_validations!
+    ensure
+      self.validation_context = current_context
+    end
+
+    alias_method :validate, :valid?
+
+    # Performs the opposite of <tt>valid?</tt>. Returns +true+ if errors were
+    # added, +false+ otherwise.
+    #
+    #   class Person
+    #     include ActiveModel::Validations
+    #
+    #     attr_accessor :name
+    #     validates_presence_of :name
+    #   end
+    #
+    #   person = Person.new
+    #   person.name = ''
+    #   person.invalid? # => true
+    #   person.name = 'david'
+    #   person.invalid? # => false
+    #
+    # Context can optionally be supplied to define which callbacks to test
+    # against (the context is defined on the validations using <tt>:on</tt>).
+    #
+    #   class Person
+    #     include ActiveModel::Validations
+    #
+    #     attr_accessor :name
+    #     validates_presence_of :name, on: :new
+    #   end
+    #
+    #   person = Person.new
+    #   person.invalid?       # => false
+    #   person.invalid?(:new) # => true
+    def invalid?(context = nil)
+      !valid?(context)
+    end
+
+    # Runs all the validations within the specified context. Returns +true+ if
+    # no errors are found, raises +ValidationError+ otherwise.
+    #
+    # Validations with no <tt>:on</tt> option will run no matter the context. Validations with
+    # some <tt>:on</tt> option will only run in the specified context.
+    def validate!(context = nil)
+      valid?(context) || raise_validation_error
+    end
+
+    # Hook method defining how an attribute value should be retrieved. By default
+    # this is assumed to be an instance named after the attribute. Override this
+    # method in subclasses should you need to retrieve the value for a given
+    # attribute differently:
+    #
+    #   class MyClass
+    #     include ActiveModel::Validations
+    #
+    #     def initialize(data = {})
+    #       @data = data
+    #     end
+    #
+    #     def read_attribute_for_validation(key)
+    #       @data[key]
+    #     end
+    #   end
+    alias :read_attribute_for_validation :send
+
+  private
+    def run_validations!
+      _run_validate_callbacks
+      errors.empty?
+    end
+
+    def raise_validation_error # :doc:
+      raise(ValidationError.new(self))
+    end
+  end
+
+  # = Active Model ValidationError
+  #
+  # Raised by <tt>validate!</tt> when the model is invalid. Use the
+  # +model+ method to retrieve the record which did not validate.
+  #
+  #   begin
+  #     complex_operation_that_internally_calls_validate!
+  #   rescue ActiveModel::ValidationError => invalid
+  #     puts invalid.model.errors
+  #   end
+  class ValidationError < StandardError
+    attr_reader :model
+
+    def initialize(model)
+      @model = model
+      errors = @model.errors.full_messages.join(", ")
+      super(I18n.t(:"#{@model.class.i18n_scope}.errors.messages.model_invalid", errors: errors, default: :"errors.messages.model_invalid"))
+    end
+  end
+end
+
+Dir[File.expand_path("validations/*.rb", __dir__)].each { |file| require file }

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

@@ -0,0 +1,188 @@
+# 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 set up your validator override the constructor.
+  #
+  #   class MyValidator < ActiveModel::Validator
+  #     def initialize(options={})
+  #       super
+  #       options[:class].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])
+        value = prepare_value_for_validation(value, record, attribute)
+        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
+
+    private
+      def prepare_value_for_validation(value, record, attr_name)
+        value
+      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

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

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+require_relative "gem_version"
+
+module ActiveModel
+  # Returns the version of the currently loaded \Active \Model as a <tt>Gem::Version</tt>
+  def self.version
+    gem_version
+  end
+end