ric 0.14.2 → 0.14.6

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

@@ -1,128 +0,0 @@
-# frozen_string_literal: true
-
-module ActiveModel
-  module SecurePassword
-    extend ActiveSupport::Concern
-
-    # BCrypt hash function can handle maximum 72 bytes, and if we pass
-    # password of length more than 72 bytes it ignores extra characters.
-    # Hence need to put a restriction on password length.
-    MAX_PASSWORD_LENGTH_ALLOWED = 72
-
-    class << self
-      attr_accessor :min_cost # :nodoc:
-    end
-    self.min_cost = false
-
-    module ClassMethods
-      # Adds methods to set and authenticate against a BCrypt password.
-      # This mechanism requires you to have a +XXX_digest+ attribute.
-      # Where +XXX+ is the attribute name of your desired password.
-      #
-      # The following validations are added automatically:
-      # * Password must be present on creation
-      # * Password length should be less than or equal to 72 bytes
-      # * Confirmation of password (using a +XXX_confirmation+ attribute)
-      #
-      # If confirmation validation is not needed, simply leave out the
-      # value for +XXX_confirmation+ (i.e. don't provide a form field for
-      # it). When this attribute has a +nil+ value, the validation will not be
-      # triggered.
-      #
-      # For further customizability, it is possible to suppress the default
-      # validations by passing <tt>validations: false</tt> as an argument.
-      #
-      # Add bcrypt (~> 3.1.7) to Gemfile to use #has_secure_password:
-      #
-      #   gem 'bcrypt', '~> 3.1.7'
-      #
-      # Example using Active Record (which automatically includes ActiveModel::SecurePassword):
-      #
-      #   # Schema: User(name:string, password_digest:string, recovery_password_digest:string)
-      #   class User < ActiveRecord::Base
-      #     has_secure_password
-      #     has_secure_password :recovery_password, validations: false
-      #   end
-      #
-      #   user = User.new(name: 'david', password: '', password_confirmation: 'nomatch')
-      #   user.save                                                  # => false, password required
-      #   user.password = 'mUc3m00RsqyRe'
-      #   user.save                                                  # => false, confirmation doesn't match
-      #   user.password_confirmation = 'mUc3m00RsqyRe'
-      #   user.save                                                  # => true
-      #   user.recovery_password = "42password"
-      #   user.recovery_password_digest                              # => "$2a$04$iOfhwahFymCs5weB3BNH/uXkTG65HR.qpW.bNhEjFP3ftli3o5DQC"
-      #   user.save                                                  # => true
-      #   user.authenticate('notright')                              # => false
-      #   user.authenticate('mUc3m00RsqyRe')                         # => user
-      #   user.authenticate_recovery_password('42password')          # => user
-      #   User.find_by(name: 'david')&.authenticate('notright')      # => false
-      #   User.find_by(name: 'david')&.authenticate('mUc3m00RsqyRe') # => user
-      def has_secure_password(attribute = :password, validations: true)
-        # Load bcrypt gem only when has_secure_password is used.
-        # This is to avoid ActiveModel (and by extension the entire framework)
-        # being dependent on a binary library.
-        begin
-          require "bcrypt"
-        rescue LoadError
-          $stderr.puts "You don't have bcrypt installed in your application. Please add it to your Gemfile and run bundle install"
-          raise
-        end
-
-        include InstanceMethodsOnActivation.new(attribute)
-
-        if validations
-          include ActiveModel::Validations
-
-          # This ensures the model has a password by checking whether the password_digest
-          # is present, so that this works with both new and existing records. However,
-          # when there is an error, the message is added to the password attribute instead
-          # so that the error message will make sense to the end-user.
-          validate do |record|
-            record.errors.add(attribute, :blank) unless record.public_send("#{attribute}_digest").present?
-          end
-
-          validates_length_of attribute, maximum: ActiveModel::SecurePassword::MAX_PASSWORD_LENGTH_ALLOWED
-          validates_confirmation_of attribute, allow_blank: true
-        end
-      end
-    end
-
-    class InstanceMethodsOnActivation < Module
-      def initialize(attribute)
-        attr_reader attribute
-
-        define_method("#{attribute}=") do |unencrypted_password|
-          if unencrypted_password.nil?
-            self.public_send("#{attribute}_digest=", nil)
-          elsif !unencrypted_password.empty?
-            instance_variable_set("@#{attribute}", unencrypted_password)
-            cost = ActiveModel::SecurePassword.min_cost ? BCrypt::Engine::MIN_COST : BCrypt::Engine.cost
-            self.public_send("#{attribute}_digest=", BCrypt::Password.create(unencrypted_password, cost: cost))
-          end
-        end
-
-        define_method("#{attribute}_confirmation=") do |unencrypted_password|
-          instance_variable_set("@#{attribute}_confirmation", unencrypted_password)
-        end
-
-        # Returns +self+ if the password is correct, otherwise +false+.
-        #
-        #   class User < ActiveRecord::Base
-        #     has_secure_password validations: false
-        #   end
-        #
-        #   user = User.new(name: 'david', password: 'mUc3m00RsqyRe')
-        #   user.save
-        #   user.authenticate_password('notright')      # => false
-        #   user.authenticate_password('mUc3m00RsqyRe') # => user
-        define_method("authenticate_#{attribute}") do |unencrypted_password|
-          attribute_digest = public_send("#{attribute}_digest")
-          BCrypt::Password.new(attribute_digest).is_password?(unencrypted_password) && self
-        end
-
-        alias_method :authenticate, :authenticate_password if attribute == :password
-      end
-    end
-  end
-end

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

@@ -1,194 +0,0 @@
-# frozen_string_literal: true
-
-require "active_support/core_ext/enumerable"
-
-module ActiveModel
-  # == Active \Model \Serialization
-  #
-  # Provides a basic serialization to a serializable_hash for your objects.
-  #
-  # A minimal implementation could be:
-  #
-  #   class Person
-  #     include ActiveModel::Serialization
-  #
-  #     attr_accessor :name
-  #
-  #     def attributes
-  #       {'name' => nil}
-  #     end
-  #   end
-  #
-  # Which would provide you with:
-  #
-  #   person = Person.new
-  #   person.serializable_hash   # => {"name"=>nil}
-  #   person.name = "Bob"
-  #   person.serializable_hash   # => {"name"=>"Bob"}
-  #
-  # An +attributes+ hash must be defined and should contain any attributes you
-  # need to be serialized. Attributes must be strings, not symbols.
-  # When called, serializable hash will use instance methods that match the name
-  # of the attributes hash's keys. In order to override this behavior, take a look
-  # at the private method +read_attribute_for_serialization+.
-  #
-  # ActiveModel::Serializers::JSON module automatically includes
-  # the <tt>ActiveModel::Serialization</tt> module, so there is no need to
-  # explicitly include <tt>ActiveModel::Serialization</tt>.
-  #
-  # A minimal implementation including JSON would be:
-  #
-  #   class Person
-  #     include ActiveModel::Serializers::JSON
-  #
-  #     attr_accessor :name
-  #
-  #     def attributes
-  #       {'name' => nil}
-  #     end
-  #   end
-  #
-  # Which would provide you with:
-  #
-  #   person = Person.new
-  #   person.serializable_hash   # => {"name"=>nil}
-  #   person.as_json             # => {"name"=>nil}
-  #   person.to_json             # => "{\"name\":null}"
-  #
-  #   person.name = "Bob"
-  #   person.serializable_hash   # => {"name"=>"Bob"}
-  #   person.as_json             # => {"name"=>"Bob"}
-  #   person.to_json             # => "{\"name\":\"Bob\"}"
-  #
-  # Valid options are <tt>:only</tt>, <tt>:except</tt>, <tt>:methods</tt> and
-  # <tt>:include</tt>. The following are all valid examples:
-  #
-  #   person.serializable_hash(only: 'name')
-  #   person.serializable_hash(include: :address)
-  #   person.serializable_hash(include: { address: { only: 'city' }})
-  module Serialization
-    # Returns a serialized hash of your object.
-    #
-    #   class Person
-    #     include ActiveModel::Serialization
-    #
-    #     attr_accessor :name, :age
-    #
-    #     def attributes
-    #       {'name' => nil, 'age' => nil}
-    #     end
-    #
-    #     def capitalized_name
-    #       name.capitalize
-    #     end
-    #   end
-    #
-    #   person = Person.new
-    #   person.name = 'bob'
-    #   person.age  = 22
-    #   person.serializable_hash                # => {"name"=>"bob", "age"=>22}
-    #   person.serializable_hash(only: :name)   # => {"name"=>"bob"}
-    #   person.serializable_hash(except: :name) # => {"age"=>22}
-    #   person.serializable_hash(methods: :capitalized_name)
-    #   # => {"name"=>"bob", "age"=>22, "capitalized_name"=>"Bob"}
-    #
-    # Example with <tt>:include</tt> option
-    #
-    #   class User
-    #     include ActiveModel::Serializers::JSON
-    #     attr_accessor :name, :notes # Emulate has_many :notes
-    #     def attributes
-    #       {'name' => nil}
-    #     end
-    #   end
-    #
-    #   class Note
-    #     include ActiveModel::Serializers::JSON
-    #     attr_accessor :title, :text
-    #     def attributes
-    #       {'title' => nil, 'text' => nil}
-    #     end
-    #   end
-    #
-    #   note = Note.new
-    #   note.title = 'Battle of Austerlitz'
-    #   note.text = 'Some text here'
-    #
-    #   user = User.new
-    #   user.name = 'Napoleon'
-    #   user.notes = [note]
-    #
-    #   user.serializable_hash
-    #   # => {"name" => "Napoleon"}
-    #   user.serializable_hash(include: { notes: { only: 'title' }})
-    #   # => {"name" => "Napoleon", "notes" => [{"title"=>"Battle of Austerlitz"}]}
-    def serializable_hash(options = nil)
-      attribute_names = attributes.keys
-
-      return serializable_attributes(attribute_names) if options.blank?
-
-      if only = options[:only]
-        attribute_names &= Array(only).map(&:to_s)
-      elsif except = options[:except]
-        attribute_names -= Array(except).map(&:to_s)
-      end
-
-      hash = serializable_attributes(attribute_names)
-
-      Array(options[:methods]).each { |m| hash[m.to_s] = send(m) }
-
-      serializable_add_includes(options) do |association, records, opts|
-        hash[association.to_s] = if records.respond_to?(:to_ary)
-          records.to_ary.map { |a| a.serializable_hash(opts) }
-        else
-          records.serializable_hash(opts)
-        end
-      end
-
-      hash
-    end
-
-    private
-      # Hook method defining how an attribute value should be retrieved for
-      # serialization. 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::Serialization
-      #
-      #     def initialize(data = {})
-      #       @data = data
-      #     end
-      #
-      #     def read_attribute_for_serialization(key)
-      #       @data[key]
-      #     end
-      #   end
-      alias :read_attribute_for_serialization :send
-
-      def serializable_attributes(attribute_names)
-        attribute_names.index_with { |n| read_attribute_for_serialization(n) }
-      end
-
-      # Add associations specified via the <tt>:include</tt> option.
-      #
-      # Expects a block that takes as arguments:
-      #   +association+ - name of the association
-      #   +records+     - the association record(s) to be serialized
-      #   +opts+        - options for the association records
-      def serializable_add_includes(options = {}) #:nodoc:
-        return unless includes = options[:include]
-
-        unless includes.is_a?(Hash)
-          includes = Hash[Array(includes).flat_map { |n| n.is_a?(Hash) ? n.to_a : [[n, {}]] }]
-        end
-
-        includes.each do |association, opts|
-          if records = send(association)
-            yield association, records, opts
-          end
-        end
-      end
-  end
-end

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

@@ -1,154 +0,0 @@
-# frozen_string_literal: true
-
-require "active_support/json"
-
-module ActiveModel
-  module Serializers
-    # == Active \Model \JSON \Serializer
-    module JSON
-      extend ActiveSupport::Concern
-      include ActiveModel::Serialization
-
-      included do
-        extend ActiveModel::Naming
-
-        class_attribute :include_root_in_json, instance_writer: false, default: false
-      end
-
-      # Returns a hash representing the model. Some configuration can be
-      # passed through +options+.
-      #
-      # The option <tt>include_root_in_json</tt> controls the top-level behavior
-      # of +as_json+. If +true+, +as_json+ will emit a single root node named
-      # after the object's type. The default value for <tt>include_root_in_json</tt>
-      # option is +false+.
-      #
-      #   user = User.find(1)
-      #   user.as_json
-      #   # => { "id" => 1, "name" => "Konata Izumi", "age" => 16,
-      #   #     "created_at" => "2006-08-01T17:27:133.000Z", "awesome" => true}
-      #
-      #   ActiveRecord::Base.include_root_in_json = true
-      #
-      #   user.as_json
-      #   # => { "user" => { "id" => 1, "name" => "Konata Izumi", "age" => 16,
-      #   #                  "created_at" => "2006-08-01T17:27:13.000Z", "awesome" => true } }
-      #
-      # This behavior can also be achieved by setting the <tt>:root</tt> option
-      # to +true+ as in:
-      #
-      #   user = User.find(1)
-      #   user.as_json(root: true)
-      #   # => { "user" => { "id" => 1, "name" => "Konata Izumi", "age" => 16,
-      #   #                  "created_at" => "2006-08-01T17:27:13.000Z", "awesome" => true } }
-      #
-      # If you prefer, <tt>:root</tt> may also be set to a custom string key instead as in:
-      #
-      #   user = User.find(1)
-      #   user.as_json(root: "author")
-      #   # => { "author" => { "id" => 1, "name" => "Konata Izumi", "age" => 16,
-      #   #                  "created_at" => "2006-08-01T17:27:13.000Z", "awesome" => true } }
-      #
-      # Without any +options+, the returned Hash will include all the model's
-      # attributes.
-      #
-      #   user = User.find(1)
-      #   user.as_json
-      #   # => { "id" => 1, "name" => "Konata Izumi", "age" => 16,
-      #   #      "created_at" => "2006-08-01T17:27:13.000Z", "awesome" => true}
-      #
-      # The <tt>:only</tt> and <tt>:except</tt> options can be used to limit
-      # the attributes included, and work similar to the +attributes+ method.
-      #
-      #   user.as_json(only: [:id, :name])
-      #   # => { "id" => 1, "name" => "Konata Izumi" }
-      #
-      #   user.as_json(except: [:id, :created_at, :age])
-      #   # => { "name" => "Konata Izumi", "awesome" => true }
-      #
-      # To include the result of some method calls on the model use <tt>:methods</tt>:
-      #
-      #   user.as_json(methods: :permalink)
-      #   # => { "id" => 1, "name" => "Konata Izumi", "age" => 16,
-      #   #      "created_at" => "2006-08-01T17:27:13.000Z", "awesome" => true,
-      #   #      "permalink" => "1-konata-izumi" }
-      #
-      # To include associations use <tt>:include</tt>:
-      #
-      #   user.as_json(include: :posts)
-      #   # => { "id" => 1, "name" => "Konata Izumi", "age" => 16,
-      #   #      "created_at" => "2006-08-01T17:27:13.000Z", "awesome" => true,
-      #   #      "posts" => [ { "id" => 1, "author_id" => 1, "title" => "Welcome to the weblog" },
-      #   #                   { "id" => 2, "author_id" => 1, "title" => "So I was thinking" } ] }
-      #
-      # Second level and higher order associations work as well:
-      #
-      #   user.as_json(include: { posts: {
-      #                              include: { comments: {
-      #                                             only: :body } },
-      #                              only: :title } })
-      #   # => { "id" => 1, "name" => "Konata Izumi", "age" => 16,
-      #   #      "created_at" => "2006-08-01T17:27:13.000Z", "awesome" => true,
-      #   #      "posts" => [ { "comments" => [ { "body" => "1st post!" }, { "body" => "Second!" } ],
-      #   #                     "title" => "Welcome to the weblog" },
-      #   #                   { "comments" => [ { "body" => "Don't think too hard" } ],
-      #   #                     "title" => "So I was thinking" } ] }
-      def as_json(options = nil)
-        root = if options && options.key?(:root)
-          options[:root]
-        else
-          include_root_in_json
-        end
-
-        hash = serializable_hash(options).as_json
-        if root
-          root = model_name.element if root == true
-          { root => hash }
-        else
-          hash
-        end
-      end
-
-      # Sets the model +attributes+ from a JSON string. Returns +self+.
-      #
-      #   class Person
-      #     include ActiveModel::Serializers::JSON
-      #
-      #     attr_accessor :name, :age, :awesome
-      #
-      #     def attributes=(hash)
-      #       hash.each do |key, value|
-      #         send("#{key}=", value)
-      #       end
-      #     end
-      #
-      #     def attributes
-      #       instance_values
-      #     end
-      #   end
-      #
-      #   json = { name: 'bob', age: 22, awesome:true }.to_json
-      #   person = Person.new
-      #   person.from_json(json) # => #<Person:0x007fec5e7a0088 @age=22, @awesome=true, @name="bob">
-      #   person.name            # => "bob"
-      #   person.age             # => 22
-      #   person.awesome         # => true
-      #
-      # The default value for +include_root+ is +false+. You can change it to
-      # +true+ if the given JSON string includes a single root node.
-      #
-      #   json = { person: { name: 'bob', age: 22, awesome:true } }.to_json
-      #   person = Person.new
-      #   person.from_json(json, true) # => #<Person:0x007fec5e7a0088 @age=22, @awesome=true, @name="bob">
-      #   person.name                  # => "bob"
-      #   person.age                   # => 22
-      #   person.awesome               # => true
-      def from_json(json, include_root = include_root_in_json)
-        hash = ActiveSupport::JSON.decode(json)
-        hash = hash.values.first if include_root
-        self.attributes = hash
-        self
-      end
-    end
-  end
-end

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

@@ -1,70 +0,0 @@
-# frozen_string_literal: true
-
-module ActiveModel
-  # == Active \Model \Translation
-  #
-  # Provides integration between your object and the Rails internationalization
-  # (i18n) framework.
-  #
-  # A minimal implementation could be:
-  #
-  #   class TranslatedPerson
-  #     extend ActiveModel::Translation
-  #   end
-  #
-  #   TranslatedPerson.human_attribute_name('my_attribute')
-  #   # => "My attribute"
-  #
-  # This also provides the required class methods for hooking into the
-  # Rails internationalization API, including being able to define a
-  # class based +i18n_scope+ and +lookup_ancestors+ to find translations in
-  # parent classes.
-  module Translation
-    include ActiveModel::Naming
-
-    # Returns the +i18n_scope+ for the class. Overwrite if you want custom lookup.
-    def i18n_scope
-      :activemodel
-    end
-
-    # When localizing a string, it goes through the lookup returned by this
-    # method, which is used in ActiveModel::Name#human,
-    # ActiveModel::Errors#full_messages and
-    # ActiveModel::Translation#human_attribute_name.
-    def lookup_ancestors
-      ancestors.select { |x| x.respond_to?(:model_name) }
-    end
-
-    # Transforms attribute names into a more human format, such as "First name"
-    # instead of "first_name".
-    #
-    #   Person.human_attribute_name("first_name") # => "First name"
-    #
-    # Specify +options+ with additional translating options.
-    def human_attribute_name(attribute, options = {})
-      options   = { count: 1 }.merge!(options)
-      parts     = attribute.to_s.split(".")
-      attribute = parts.pop
-      namespace = parts.join("/") unless parts.empty?
-      attributes_scope = "#{i18n_scope}.attributes"
-
-      if namespace
-        defaults = lookup_ancestors.map do |klass|
-          :"#{attributes_scope}.#{klass.model_name.i18n_key}/#{namespace}.#{attribute}"
-        end
-        defaults << :"#{attributes_scope}.#{namespace}.#{attribute}"
-      else
-        defaults = lookup_ancestors.map do |klass|
-          :"#{attributes_scope}.#{klass.model_name.i18n_key}.#{attribute}"
-        end
-      end
-
-      defaults << :"attributes.#{attribute}"
-      defaults << options.delete(:default) if options[:default]
-      defaults << attribute.humanize
-
-      options[:default] = defaults
-      I18n.translate(defaults.shift, **options)
-    end
-  end
-end

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

@@ -1,14 +0,0 @@
-# frozen_string_literal: true
-
-require "active_model/type/integer"
-
-module ActiveModel
-  module Type
-    class BigInteger < Integer # :nodoc:
-      private
-        def max_value
-          ::Float::INFINITY
-        end
-    end
-  end
-end

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

@@ -1,52 +0,0 @@
-# frozen_string_literal: true
-
-module ActiveModel
-  module Type
-    class Binary < Value # :nodoc:
-      def type
-        :binary
-      end
-
-      def binary?
-        true
-      end
-
-      def cast(value)
-        if value.is_a?(Data)
-          value.to_s
-        else
-          super
-        end
-      end
-
-      def serialize(value)
-        return if value.nil?
-        Data.new(super)
-      end
-
-      def changed_in_place?(raw_old_value, value)
-        old_value = deserialize(raw_old_value)
-        old_value != value
-      end
-
-      class Data # :nodoc:
-        def initialize(value)
-          @value = value.to_s
-        end
-
-        def to_s
-          @value
-        end
-        alias_method :to_str, :to_s
-
-        def hex
-          @value.unpack1("H*")
-        end
-
-        def ==(other)
-          other == to_s || super
-        end
-      end
-    end
-  end
-end

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

@@ -1,46 +0,0 @@
-# frozen_string_literal: true
-
-module ActiveModel
-  module Type
-    # == Active \Model \Type \Boolean
-    #
-    # A class that behaves like a boolean type, including rules for coercion of user input.
-    #
-    # === Coercion
-    # Values set from user input will first be coerced into the appropriate ruby type.
-    # Coercion behavior is roughly mapped to Ruby's boolean semantics.
-    #
-    # - "false", "f" , "0", +0+ or any other value in +FALSE_VALUES+ will be coerced to +false+
-    # - Empty strings are coerced to +nil+
-    # - All other values will be coerced to +true+
-    class Boolean < Value
-      FALSE_VALUES = [
-        false, 0,
-        "0", :"0",
-        "f", :f,
-        "F", :F,
-        "false", :false,
-        "FALSE", :FALSE,
-        "off", :off,
-        "OFF", :OFF,
-      ].to_set.freeze
-
-      def type # :nodoc:
-        :boolean
-      end
-
-      def serialize(value) # :nodoc:
-        cast(value)
-      end
-
-      private
-        def cast_value(value)
-          if value == ""
-            nil
-          else
-            !FALSE_VALUES.include?(value)
-          end
-        end
-    end
-  end
-end