ric 0.14.2 → 0.14.6

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

@@ -1,133 +0,0 @@
-# frozen_string_literal: true
-
-module ActiveModel
-  module Type
-    class Value
-      attr_reader :precision, :scale, :limit
-
-      def initialize(precision: nil, limit: nil, scale: nil)
-        @precision = precision
-        @scale = scale
-        @limit = limit
-      end
-
-      # Returns true if this type can convert +value+ to a type that is usable
-      # by the database.  For example a boolean type can return +true+ if the
-      # value parameter is a Ruby boolean, but may return +false+ if the value
-      # parameter is some other object.
-      def serializable?(value)
-        true
-      end
-
-      def type # :nodoc:
-      end
-
-      # Converts a value from database input to the appropriate ruby type. The
-      # return value of this method will be returned from
-      # ActiveRecord::AttributeMethods::Read#read_attribute. The default
-      # implementation just calls Value#cast.
-      #
-      # +value+ The raw input, as provided from the database.
-      def deserialize(value)
-        cast(value)
-      end
-
-      # Type casts a value from user input (e.g. from a setter). This value may
-      # be a string from the form builder, or a ruby object passed to a setter.
-      # There is currently no way to differentiate between which source it came
-      # from.
-      #
-      # The return value of this method will be returned from
-      # ActiveRecord::AttributeMethods::Read#read_attribute. See also:
-      # Value#cast_value.
-      #
-      # +value+ The raw input, as provided to the attribute setter.
-      def cast(value)
-        cast_value(value) unless value.nil?
-      end
-
-      # Casts a value from the ruby type to a type that the database knows how
-      # to understand. The returned value from this method should be a
-      # +String+, +Numeric+, +Date+, +Time+, +Symbol+, +true+, +false+, or
-      # +nil+.
-      def serialize(value)
-        value
-      end
-
-      # Type casts a value for schema dumping. This method is private, as we are
-      # hoping to remove it entirely.
-      def type_cast_for_schema(value) # :nodoc:
-        value.inspect
-      end
-
-      # These predicates are not documented, as I need to look further into
-      # their use, and see if they can be removed entirely.
-      def binary? # :nodoc:
-        false
-      end
-
-      # Determines whether a value has changed for dirty checking. +old_value+
-      # and +new_value+ will always be type-cast. Types should not need to
-      # override this method.
-      def changed?(old_value, new_value, _new_value_before_type_cast)
-        old_value != new_value
-      end
-
-      # Determines whether the mutable value has been modified since it was
-      # read. Returns +false+ by default. If your type returns an object
-      # which could be mutated, you should override this method. You will need
-      # to either:
-      #
-      # - pass +new_value+ to Value#serialize and compare it to
-      #   +raw_old_value+
-      #
-      # or
-      #
-      # - pass +raw_old_value+ to Value#deserialize and compare it to
-      #   +new_value+
-      #
-      # +raw_old_value+ The original value, before being passed to
-      # +deserialize+.
-      #
-      # +new_value+ The current value, after type casting.
-      def changed_in_place?(raw_old_value, new_value)
-        false
-      end
-
-      def value_constructed_by_mass_assignment?(_value) # :nodoc:
-        false
-      end
-
-      def force_equality?(_value) # :nodoc:
-        false
-      end
-
-      def map(value) # :nodoc:
-        yield value
-      end
-
-      def ==(other)
-        self.class == other.class &&
-          precision == other.precision &&
-          scale == other.scale &&
-          limit == other.limit
-      end
-      alias eql? ==
-
-      def hash
-        [self.class, precision, scale, limit].hash
-      end
-
-      def assert_valid_value(_)
-      end
-
-      private
-        # Convenience method for types which do not need separate type casting
-        # behavior for user and database inputs. Called by Value#cast for
-        # values except +nil+.
-        def cast_value(value) # :doc:
-          value
-        end
-    end
-  end
-end

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

@@ -1,53 +0,0 @@
-# frozen_string_literal: true
-
-require "active_model/type/helpers"
-require "active_model/type/value"
-
-require "active_model/type/big_integer"
-require "active_model/type/binary"
-require "active_model/type/boolean"
-require "active_model/type/date"
-require "active_model/type/date_time"
-require "active_model/type/decimal"
-require "active_model/type/float"
-require "active_model/type/immutable_string"
-require "active_model/type/integer"
-require "active_model/type/string"
-require "active_model/type/time"
-
-require "active_model/type/registry"
-
-module ActiveModel
-  module Type
-    @registry = Registry.new
-
-    class << self
-      attr_accessor :registry # :nodoc:
-
-      # Add a new type to the registry, allowing it to be gotten through ActiveModel::Type#lookup
-      def register(type_name, klass = nil, **options, &block)
-        registry.register(type_name, klass, **options, &block)
-      end
-
-      def lookup(*args, **kwargs) # :nodoc:
-        registry.lookup(*args, **kwargs)
-      end
-
-      def default_value # :nodoc:
-        @default_value ||= Value.new
-      end
-    end
-
-    register(:big_integer, Type::BigInteger)
-    register(:binary, Type::Binary)
-    register(:boolean, Type::Boolean)
-    register(:date, Type::Date)
-    register(:datetime, Type::DateTime)
-    register(:decimal, Type::Decimal)
-    register(:float, Type::Float)
-    register(:immutable_string, Type::ImmutableString)
-    register(:integer, Type::Integer)
-    register(:string, Type::String)
-    register(:time, Type::Time)
-  end
-end

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

@@ -1,33 +0,0 @@
-# frozen_string_literal: true
-
-module ActiveModel
-  module Validations
-    # == \Active \Model Absence Validator
-    class AbsenceValidator < EachValidator #:nodoc:
-      def validate_each(record, attr_name, value)
-        record.errors.add(attr_name, :present, **options) if value.present?
-      end
-    end
-
-    module HelperMethods
-      # Validates that the specified attributes are blank (as defined by
-      # Object#present?). Happens by default on save.
-      #
-      #   class Person < ActiveRecord::Base
-      #     validates_absence_of :first_name
-      #   end
-      #
-      # The first_name attribute must be in the object and it must be blank.
-      #
-      # Configuration options:
-      # * <tt>:message</tt> - A custom error message (default is: "must 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_absence_of(*attr_names)
-        validates_with AbsenceValidator, _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/acceptance.rb

@@ -1,113 +0,0 @@
-# frozen_string_literal: true
-
-module ActiveModel
-  module Validations
-    class AcceptanceValidator < EachValidator # :nodoc:
-      def initialize(options)
-        super({ allow_nil: true, accept: ["1", true] }.merge!(options))
-        setup!(options[:class])
-      end
-
-      def validate_each(record, attribute, value)
-        unless acceptable_option?(value)
-          record.errors.add(attribute, :accepted, **options.except(:accept, :allow_nil))
-        end
-      end
-
-      private
-        def setup!(klass)
-          define_attributes = LazilyDefineAttributes.new(attributes)
-          klass.include(define_attributes) unless klass.included_modules.include?(define_attributes)
-        end
-
-        def acceptable_option?(value)
-          Array(options[:accept]).include?(value)
-        end
-
-        class LazilyDefineAttributes < Module
-          def initialize(attributes)
-            @attributes = attributes.map(&:to_s)
-          end
-
-          def included(klass)
-            @lock = Mutex.new
-            mod = self
-
-            define_method(:respond_to_missing?) do |method_name, include_private = false|
-              mod.define_on(klass)
-              super(method_name, include_private) || mod.matches?(method_name)
-            end
-
-            define_method(:method_missing) do |method_name, *args, &block|
-              mod.define_on(klass)
-              if mod.matches?(method_name)
-                send(method_name, *args, &block)
-              else
-                super(method_name, *args, &block)
-              end
-            end
-          end
-
-          def matches?(method_name)
-            attr_name = method_name.to_s.chomp("=")
-            attributes.any? { |name| name == attr_name }
-          end
-
-          def define_on(klass)
-            @lock&.synchronize do
-              return unless @lock
-
-              attr_readers = attributes.reject { |name| klass.attribute_method?(name) }
-              attr_writers = attributes.reject { |name| klass.attribute_method?("#{name}=") }
-
-              attr_reader(*attr_readers)
-              attr_writer(*attr_writers)
-
-              remove_method :respond_to_missing?
-              remove_method :method_missing
-
-              @lock = nil
-            end
-          end
-
-          def ==(other)
-            self.class == other.class && attributes == other.attributes
-          end
-
-          protected
-            attr_reader :attributes
-        end
-    end
-
-    module HelperMethods
-      # Encapsulates the pattern of wanting to validate the acceptance of a
-      # terms of service check box (or similar agreement).
-      #
-      #   class Person < ActiveRecord::Base
-      #     validates_acceptance_of :terms_of_service
-      #     validates_acceptance_of :eula, message: 'must be abided'
-      #   end
-      #
-      # If the database column does not exist, the +terms_of_service+ attribute
-      # is entirely virtual. This check is performed only if +terms_of_service+
-      # is not +nil+ and by default on save.
-      #
-      # Configuration options:
-      # * <tt>:message</tt> - A custom error message (default is: "must be
-      #   accepted").
-      # * <tt>:accept</tt> - Specifies a value that is considered accepted.
-      #   Also accepts an array of possible values. The default value is
-      #   an array ["1", true], which makes it easy to relate to an HTML
-      #   checkbox. This should be set to, or include, +true+ if you are validating
-      #   a database column, since the attribute is typecast from "1" to +true+
-      #   before validation.
-      #
-      # 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_acceptance_of(*attr_names)
-        validates_with AcceptanceValidator, _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/callbacks.rb

@@ -1,121 +0,0 @@
-# frozen_string_literal: true
-
-module ActiveModel
-  module Validations
-    # == Active \Model \Validation \Callbacks
-    #
-    # Provides an interface for any class to have +before_validation+ and
-    # +after_validation+ callbacks.
-    #
-    # First, include ActiveModel::Validations::Callbacks from the class you are
-    # creating:
-    #
-    #   class MyModel
-    #     include ActiveModel::Validations::Callbacks
-    #
-    #     before_validation :do_stuff_before_validation
-    #     after_validation  :do_stuff_after_validation
-    #   end
-    #
-    # Like other <tt>before_*</tt> callbacks if +before_validation+ throws
-    # +:abort+ then <tt>valid?</tt> will not be called.
-    module Callbacks
-      extend ActiveSupport::Concern
-
-      included do
-        include ActiveSupport::Callbacks
-        define_callbacks :validation,
-                         skip_after_callbacks_if_terminated: true,
-                         scope: [:kind, :name]
-      end
-
-      module ClassMethods
-        # Defines a callback that will get called right before validation.
-        #
-        #   class Person
-        #     include ActiveModel::Validations
-        #     include ActiveModel::Validations::Callbacks
-        #
-        #     attr_accessor :name
-        #
-        #     validates_length_of :name, maximum: 6
-        #
-        #     before_validation :remove_whitespaces
-        #
-        #     private
-        #
-        #     def remove_whitespaces
-        #       name.strip!
-        #     end
-        #   end
-        #
-        #   person = Person.new
-        #   person.name = '  bob  '
-        #   person.valid? # => true
-        #   person.name   # => "bob"
-        def before_validation(*args, &block)
-          options = args.extract_options!
-
-          set_options_for_callback(options)
-
-          set_callback(:validation, :before, *args, options, &block)
-        end
-
-        # Defines a callback that will get called right after validation.
-        #
-        #   class Person
-        #     include ActiveModel::Validations
-        #     include ActiveModel::Validations::Callbacks
-        #
-        #     attr_accessor :name, :status
-        #
-        #     validates_presence_of :name
-        #
-        #     after_validation :set_status
-        #
-        #     private
-        #
-        #     def set_status
-        #       self.status = errors.empty?
-        #     end
-        #   end
-        #
-        #   person = Person.new
-        #   person.name = ''
-        #   person.valid? # => false
-        #   person.status # => false
-        #   person.name = 'bob'
-        #   person.valid? # => true
-        #   person.status # => true
-        def after_validation(*args, &block)
-          options = args.extract_options!
-          options = options.dup
-          options[:prepend] = true
-
-          set_options_for_callback(options)
-
-          set_callback(:validation, :after, *args, options, &block)
-        end
-
-        private
-          def set_options_for_callback(options)
-            if options.key?(:on)
-              options[:on] = Array(options[:on])
-              options[:if] = [
-                ->(o) {
-                  !(options[:on] & Array(o.validation_context)).empty?
-                },
-                *options[:if]
-              ]
-            end
-          end
-      end
-
-    private
-      # Overwrite run validations to include callbacks.
-      def run_validations!
-        _run_validation_callbacks { super }
-      end
-    end
-  end
-end

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

@@ -1,57 +0,0 @@
-# frozen_string_literal: true
-
-require "active_support/core_ext/range"
-
-module ActiveModel
-  module Validations
-    module Clusivity #:nodoc:
-      ERROR_MESSAGE = "An object with the method #include? or a proc, lambda or symbol is required, " \
-                      "and must be supplied as the :in (or :within) option of the configuration hash"
-
-      def check_validity!
-        unless delimiter.respond_to?(:include?) || delimiter.respond_to?(:call) || delimiter.respond_to?(:to_sym)
-          raise ArgumentError, ERROR_MESSAGE
-        end
-      end
-
-    private
-      def include?(record, value)
-        members = if delimiter.respond_to?(:call)
-          delimiter.call(record)
-        elsif delimiter.respond_to?(:to_sym)
-          record.send(delimiter)
-        else
-          delimiter
-        end
-
-        if value.is_a?(Array)
-          value.all? { |v| members.public_send(inclusion_method(members), v) }
-        else
-          members.public_send(inclusion_method(members), value)
-        end
-      end
-
-      def delimiter
-        @delimiter ||= options[:in] || options[:within]
-      end
-
-      # After Ruby 2.2, <tt>Range#include?</tt> on non-number-or-time-ish ranges checks all
-      # possible values in the range for equality, which is slower but more accurate.
-      # <tt>Range#cover?</tt> uses the previous logic of comparing a value with the range
-      # endpoints, which is fast but is only accurate on Numeric, Time, Date,
-      # or DateTime ranges.
-      def inclusion_method(enumerable)
-        if enumerable.is_a? Range
-          case enumerable.first
-          when Numeric, Time, DateTime, Date
-            :cover?
-          else
-            :include?
-          end
-        else
-          :include?
-        end
-      end
-    end
-  end
-end

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

@@ -1,80 +0,0 @@
-# frozen_string_literal: true
-
-module ActiveModel
-  module Validations
-    class ConfirmationValidator < EachValidator # :nodoc:
-      def initialize(options)
-        super({ case_sensitive: true }.merge!(options))
-        setup!(options[:class])
-      end
-
-      def validate_each(record, attribute, value)
-        unless (confirmed = record.public_send("#{attribute}_confirmation")).nil?
-          unless confirmation_value_equal?(record, attribute, value, confirmed)
-            human_attribute_name = record.class.human_attribute_name(attribute)
-            record.errors.add(:"#{attribute}_confirmation", :confirmation, **options.except(:case_sensitive).merge!(attribute: human_attribute_name))
-          end
-        end
-      end
-
-      private
-        def setup!(klass)
-          klass.attr_reader(*attributes.map do |attribute|
-            :"#{attribute}_confirmation" unless klass.method_defined?(:"#{attribute}_confirmation")
-          end.compact)
-
-          klass.attr_writer(*attributes.map do |attribute|
-            :"#{attribute}_confirmation" unless klass.method_defined?(:"#{attribute}_confirmation=")
-          end.compact)
-        end
-
-        def confirmation_value_equal?(record, attribute, value, confirmed)
-          if !options[:case_sensitive] && value.is_a?(String)
-            value.casecmp(confirmed) == 0
-          else
-            value == confirmed
-          end
-        end
-    end
-
-    module HelperMethods
-      # Encapsulates the pattern of wanting to validate a password or email
-      # address field with a confirmation.
-      #
-      #   Model:
-      #     class Person < ActiveRecord::Base
-      #       validates_confirmation_of :user_name, :password
-      #       validates_confirmation_of :email_address,
-      #                                 message: 'should match confirmation'
-      #     end
-      #
-      #   View:
-      #     <%= password_field "person", "password" %>
-      #     <%= password_field "person", "password_confirmation" %>
-      #
-      # The added +password_confirmation+ attribute is virtual; it exists only
-      # as an in-memory attribute for validating the password. To achieve this,
-      # the validation adds accessors to the model for the confirmation
-      # attribute.
-      #
-      # NOTE: This check is performed only if +password_confirmation+ is not
-      # +nil+. To require confirmation, make sure to add a presence check for
-      # the confirmation attribute:
-      #
-      #   validates_presence_of :password_confirmation, if: :password_changed?
-      #
-      # Configuration options:
-      # * <tt>:message</tt> - A custom error message (default is: "doesn't match
-      #   <tt>%{translated_attribute_name}</tt>").
-      # * <tt>:case_sensitive</tt> - Looks for an exact match. Ignored by
-      #   non-text columns (+true+ by default).
-      #
-      # 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_confirmation_of(*attr_names)
-        validates_with ConfirmationValidator, _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/exclusion.rb

@@ -1,49 +0,0 @@
-# frozen_string_literal: true
-
-require "active_model/validations/clusivity"
-
-module ActiveModel
-  module Validations
-    class ExclusionValidator < EachValidator # :nodoc:
-      include Clusivity
-
-      def validate_each(record, attribute, value)
-        if include?(record, value)
-          record.errors.add(attribute, :exclusion, **options.except(:in, :within).merge!(value: value))
-        end
-      end
-    end
-
-    module HelperMethods
-      # Validates that the value of the specified attribute is not in a
-      # particular enumerable object.
-      #
-      #   class Person < ActiveRecord::Base
-      #     validates_exclusion_of :username, in: %w( admin superuser ), message: "You don't belong here"
-      #     validates_exclusion_of :age, in: 30..60, message: 'This site is only for under 30 and over 60'
-      #     validates_exclusion_of :format, in: %w( mov avi ), message: "extension %{value} is not allowed"
-      #     validates_exclusion_of :password, in: ->(person) { [person.username, person.first_name] },
-      #                            message: 'should not be the same as your username or first name'
-      #     validates_exclusion_of :karma, in: :reserved_karmas
-      #   end
-      #
-      # Configuration options:
-      # * <tt>:in</tt> - An enumerable object of items that the value shouldn't
-      #   be part of. 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>Range#cover?</tt>, otherwise with <tt>include?</tt>.
-      # * <tt>:message</tt> - Specifies a custom error message (default is: "is
-      #   reserved").
-      #
-      # 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_exclusion_of(*attr_names)
-        validates_with ExclusionValidator, _merge_attributes(attr_names)
-      end
-    end
-  end
-end