ric 0.14.2 → 0.14.6

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

@@ -1,31 +0,0 @@
-# frozen_string_literal: true
-
-module ActiveModel
-  # Raised when forbidden attributes are used for mass assignment.
-  #
-  #   class Person < ActiveRecord::Base
-  #   end
-  #
-  #   params = ActionController::Parameters.new(name: 'Bob')
-  #   Person.new(params)
-  #   # => ActiveModel::ForbiddenAttributesError
-  #
-  #   params.permit!
-  #   Person.new(params)
-  #   # => #<Person id: nil, name: "Bob">
-  class ForbiddenAttributesError < StandardError
-  end
-
-  module ForbiddenAttributesProtection # :nodoc:
-    private
-      def sanitize_for_mass_assignment(attributes)
-        if attributes.respond_to?(:permitted?)
-          raise ActiveModel::ForbiddenAttributesError if !attributes.permitted?
-          attributes.to_h
-        else
-          attributes
-        end
-      end
-      alias :sanitize_forbidden_attributes :sanitize_for_mass_assignment
-  end
-end

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

@@ -1,17 +0,0 @@
-# frozen_string_literal: true
-
-module ActiveModel
-  # Returns the version of the currently loaded \Active \Model as a <tt>Gem::Version</tt>
-  def self.gem_version
-    Gem::Version.new VERSION::STRING
-  end
-
-  module VERSION
-    MAJOR = 6
-    MINOR = 1
-    TINY  = 4
-    PRE   = "4"
-
-    STRING = [MAJOR, MINOR, TINY, PRE].compact.join(".")
-  end
-end

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

@@ -1,118 +0,0 @@
-# frozen_string_literal: true
-
-module ActiveModel
-  module Lint
-    # == Active \Model \Lint \Tests
-    #
-    # You can test whether an object is compliant with the Active \Model API by
-    # including <tt>ActiveModel::Lint::Tests</tt> in your TestCase. It will
-    # include tests that tell you whether your object is fully compliant,
-    # or if not, which aspects of the API are not implemented.
-    #
-    # Note an object is not required to implement all APIs in order to work
-    # with Action Pack. This module only intends to provide guidance in case
-    # you want all features out of the box.
-    #
-    # These tests do not attempt to determine the semantic correctness of the
-    # returned values. For instance, you could implement <tt>valid?</tt> to
-    # always return +true+, and the tests would pass. It is up to you to ensure
-    # that the values are semantically meaningful.
-    #
-    # Objects you pass in are expected to return a compliant object from a call
-    # to <tt>to_model</tt>. It is perfectly fine for <tt>to_model</tt> to return
-    # +self+.
-    module Tests
-      # Passes if the object's model responds to <tt>to_key</tt> and if calling
-      # this method returns +nil+ when the object is not persisted.
-      # Fails otherwise.
-      #
-      # <tt>to_key</tt> returns an Enumerable of all (primary) key attributes
-      # of the model, and is used to a generate unique DOM id for the object.
-      def test_to_key
-        assert_respond_to model, :to_key
-        def model.persisted?() false end
-        assert model.to_key.nil?, "to_key should return nil when `persisted?` returns false"
-      end
-
-      # Passes if the object's model responds to <tt>to_param</tt> and if
-      # calling this method returns +nil+ when the object is not persisted.
-      # Fails otherwise.
-      #
-      # <tt>to_param</tt> is used to represent the object's key in URLs.
-      # Implementers can decide to either raise an exception or provide a
-      # default in case the record uses a composite primary key. There are no
-      # tests for this behavior in lint because it doesn't make sense to force
-      # any of the possible implementation strategies on the implementer.
-      def test_to_param
-        assert_respond_to model, :to_param
-        def model.to_key() [1] end
-        def model.persisted?() false end
-        assert model.to_param.nil?, "to_param should return nil when `persisted?` returns false"
-      end
-
-      # Passes if the object's model responds to <tt>to_partial_path</tt> and if
-      # calling this method returns a string. Fails otherwise.
-      #
-      # <tt>to_partial_path</tt> is used for looking up partials. For example,
-      # a BlogPost model might return "blog_posts/blog_post".
-      def test_to_partial_path
-        assert_respond_to model, :to_partial_path
-        assert_kind_of String, model.to_partial_path
-      end
-
-      # Passes if the object's model responds to <tt>persisted?</tt> and if
-      # calling this method returns either +true+ or +false+. Fails otherwise.
-      #
-      # <tt>persisted?</tt> is used when calculating the URL for an object.
-      # If the object is not persisted, a form for that object, for instance,
-      # will route to the create action. If it is persisted, a form for the
-      # object will route to the update action.
-      def test_persisted?
-        assert_respond_to model, :persisted?
-        assert_boolean model.persisted?, "persisted?"
-      end
-
-      # Passes if the object's model responds to <tt>model_name</tt> both as
-      # an instance method and as a class method, and if calling this method
-      # returns a string with some convenience methods: <tt>:human</tt>,
-      # <tt>:singular</tt> and <tt>:plural</tt>.
-      #
-      # Check ActiveModel::Naming for more information.
-      def test_model_naming
-        assert_respond_to model.class, :model_name
-        model_name = model.class.model_name
-        assert_respond_to model_name, :to_str
-        assert_respond_to model_name.human, :to_str
-        assert_respond_to model_name.singular, :to_str
-        assert_respond_to model_name.plural, :to_str
-
-        assert_respond_to model, :model_name
-        assert_equal model.model_name, model.class.model_name
-      end
-
-      # Passes if the object's model responds to <tt>errors</tt> and if calling
-      # <tt>[](attribute)</tt> on the result of this method returns an array.
-      # Fails otherwise.
-      #
-      # <tt>errors[attribute]</tt> is used to retrieve the errors of a model
-      # for a given attribute. If errors are present, the method should return
-      # an array of strings that are the errors for the attribute in question.
-      # If localization is used, the strings should be localized for the current
-      # locale. If no error is present, the method should return an empty array.
-      def test_errors_aref
-        assert_respond_to model, :errors
-        assert_equal [], model.errors[:hello], "errors#[] should return an empty Array"
-      end
-
-      private
-        def model
-          assert_respond_to @model, :to_model
-          @model.to_model
-        end
-
-        def assert_boolean(result, name)
-          assert result == true || result == false, "#{name} should be a boolean"
-        end
-    end
-  end
-end

data/vendor/bundle/ruby/2.7.0/gems/activemodel-6.1.4.4/lib/active_model/locale/en.yml

@@ -1,36 +0,0 @@
-en:
-  errors:
-    # The default format to use in full error messages.
-    format: "%{attribute} %{message}"
-
-    # The values :model, :attribute and :value are always available for interpolation
-    # The value :count is available when applicable. Can be used for pluralization.
-    messages:
-      model_invalid: "Validation failed: %{errors}"
-      inclusion: "is not included in the list"
-      exclusion: "is reserved"
-      invalid: "is invalid"
-      confirmation: "doesn't match %{attribute}"
-      accepted: "must be accepted"
-      empty: "can't be empty"
-      blank: "can't be blank"
-      present: "must be blank"
-      too_long:
-        one: "is too long (maximum is 1 character)"
-        other: "is too long (maximum is %{count} characters)"
-      too_short:
-        one: "is too short (minimum is 1 character)"
-        other: "is too short (minimum is %{count} characters)"
-      wrong_length:
-        one: "is the wrong length (should be 1 character)"
-        other: "is the wrong length (should be %{count} characters)"
-      not_a_number: "is not a number"
-      not_an_integer: "must be an integer"
-      greater_than: "must be greater than %{count}"
-      greater_than_or_equal_to: "must be greater than or equal to %{count}"
-      equal_to: "must be equal to %{count}"
-      less_than: "must be less than %{count}"
-      less_than_or_equal_to: "must be less than or equal to %{count}"
-      other_than: "must be other than %{count}"
-      odd: "must be odd"
-      even: "must be even"

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

@@ -1,99 +0,0 @@
-# frozen_string_literal: true
-
-module ActiveModel
-  # == Active \Model \Basic \Model
-  #
-  # Includes the required interface for an object to interact with
-  # Action Pack and Action View, using different Active Model modules.
-  # It includes model name introspections, conversions, translations and
-  # validations. Besides that, it allows you to initialize the object with a
-  # hash of attributes, pretty much like Active Record does.
-  #
-  # A minimal implementation could be:
-  #
-  #   class Person
-  #     include ActiveModel::Model
-  #     attr_accessor :name, :age
-  #   end
-  #
-  #   person = Person.new(name: 'bob', age: '18')
-  #   person.name # => "bob"
-  #   person.age  # => "18"
-  #
-  # Note that, by default, <tt>ActiveModel::Model</tt> implements <tt>persisted?</tt>
-  # to return +false+, which is the most common case. You may want to override
-  # it in your class to simulate a different scenario:
-  #
-  #   class Person
-  #     include ActiveModel::Model
-  #     attr_accessor :id, :name
-  #
-  #     def persisted?
-  #       self.id == 1
-  #     end
-  #   end
-  #
-  #   person = Person.new(id: 1, name: 'bob')
-  #   person.persisted? # => true
-  #
-  # Also, if for some reason you need to run code on <tt>initialize</tt>, make
-  # sure you call +super+ if you want the attributes hash initialization to
-  # happen.
-  #
-  #   class Person
-  #     include ActiveModel::Model
-  #     attr_accessor :id, :name, :omg
-  #
-  #     def initialize(attributes={})
-  #       super
-  #       @omg ||= true
-  #     end
-  #   end
-  #
-  #   person = Person.new(id: 1, name: 'bob')
-  #   person.omg # => true
-  #
-  # For more detailed information on other functionalities available, please
-  # refer to the specific modules included in <tt>ActiveModel::Model</tt>
-  # (see below).
-  module Model
-    extend ActiveSupport::Concern
-    include ActiveModel::AttributeAssignment
-    include ActiveModel::Validations
-    include ActiveModel::Conversion
-
-    included do
-      extend ActiveModel::Naming
-      extend ActiveModel::Translation
-    end
-
-    # Initializes a new model with the given +params+.
-    #
-    #   class Person
-    #     include ActiveModel::Model
-    #     attr_accessor :name, :age
-    #   end
-    #
-    #   person = Person.new(name: 'bob', age: '18')
-    #   person.name # => "bob"
-    #   person.age  # => "18"
-    def initialize(attributes = {})
-      assign_attributes(attributes) if attributes
-
-      super()
-    end
-
-    # Indicates if the model is persisted. Default is +false+.
-    #
-    #  class Person
-    #    include ActiveModel::Model
-    #    attr_accessor :id, :name
-    #  end
-    #
-    #  person = Person.new(id: 1, name: 'bob')
-    #  person.persisted? # => false
-    def persisted?
-      false
-    end
-  end
-end

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

@@ -1,333 +0,0 @@
-# frozen_string_literal: true
-
-require "active_support/core_ext/hash/except"
-require "active_support/core_ext/module/introspection"
-require "active_support/core_ext/module/redefine_method"
-
-module ActiveModel
-  class Name
-    include Comparable
-
-    attr_accessor :singular, :plural, :element, :collection,
-      :singular_route_key, :route_key, :param_key, :i18n_key,
-      :name
-
-    alias_method :cache_key, :collection
-
-    ##
-    # :method: ==
-    #
-    # :call-seq:
-    #   ==(other)
-    #
-    # Equivalent to <tt>String#==</tt>. Returns +true+ if the class name and
-    # +other+ are equal, otherwise +false+.
-    #
-    #   class BlogPost
-    #     extend ActiveModel::Naming
-    #   end
-    #
-    #   BlogPost.model_name == 'BlogPost'  # => true
-    #   BlogPost.model_name == 'Blog Post' # => false
-
-    ##
-    # :method: ===
-    #
-    # :call-seq:
-    #   ===(other)
-    #
-    # Equivalent to <tt>#==</tt>.
-    #
-    #   class BlogPost
-    #     extend ActiveModel::Naming
-    #   end
-    #
-    #   BlogPost.model_name === 'BlogPost'  # => true
-    #   BlogPost.model_name === 'Blog Post' # => false
-
-    ##
-    # :method: <=>
-    #
-    # :call-seq:
-    #   <=>(other)
-    #
-    # Equivalent to <tt>String#<=></tt>.
-    #
-    #   class BlogPost
-    #     extend ActiveModel::Naming
-    #   end
-    #
-    #   BlogPost.model_name <=> 'BlogPost'  # => 0
-    #   BlogPost.model_name <=> 'Blog'      # => 1
-    #   BlogPost.model_name <=> 'BlogPosts' # => -1
-
-    ##
-    # :method: =~
-    #
-    # :call-seq:
-    #   =~(regexp)
-    #
-    # Equivalent to <tt>String#=~</tt>. Match the class name against the given
-    # regexp. Returns the position where the match starts or +nil+ if there is
-    # no match.
-    #
-    #   class BlogPost
-    #     extend ActiveModel::Naming
-    #   end
-    #
-    #   BlogPost.model_name =~ /Post/ # => 4
-    #   BlogPost.model_name =~ /\d/   # => nil
-
-    ##
-    # :method: !~
-    #
-    # :call-seq:
-    #   !~(regexp)
-    #
-    # Equivalent to <tt>String#!~</tt>. Match the class name against the given
-    # regexp. Returns +true+ if there is no match, otherwise +false+.
-    #
-    #   class BlogPost
-    #     extend ActiveModel::Naming
-    #   end
-    #
-    #   BlogPost.model_name !~ /Post/ # => false
-    #   BlogPost.model_name !~ /\d/   # => true
-
-    ##
-    # :method: eql?
-    #
-    # :call-seq:
-    #   eql?(other)
-    #
-    # Equivalent to <tt>String#eql?</tt>. Returns +true+ if the class name and
-    # +other+ have the same length and content, otherwise +false+.
-    #
-    #   class BlogPost
-    #     extend ActiveModel::Naming
-    #   end
-    #
-    #   BlogPost.model_name.eql?('BlogPost')  # => true
-    #   BlogPost.model_name.eql?('Blog Post') # => false
-
-    ##
-    # :method: match?
-    #
-    # :call-seq:
-    #   match?(regexp)
-    #
-    # Equivalent to <tt>String#match?</tt>. Match the class name against the
-    # given regexp. Returns +true+ if there is a match, otherwise +false+.
-    #
-    #   class BlogPost
-    #     extend ActiveModel::Naming
-    #   end
-    #
-    #   BlogPost.model_name.match?(/Post/) # => true
-    #   BlogPost.model_name.match?(/\d/) # => false
-
-    ##
-    # :method: to_s
-    #
-    # :call-seq:
-    #   to_s()
-    #
-    # Returns the class name.
-    #
-    #   class BlogPost
-    #     extend ActiveModel::Naming
-    #   end
-    #
-    #   BlogPost.model_name.to_s # => "BlogPost"
-
-    ##
-    # :method: to_str
-    #
-    # :call-seq:
-    #   to_str()
-    #
-    # Equivalent to +to_s+.
-    delegate :==, :===, :<=>, :=~, :"!~", :eql?, :match?, :to_s,
-             :to_str, :as_json, to: :name
-
-    # Returns a new ActiveModel::Name instance. By default, the +namespace+
-    # and +name+ option will take the namespace and name of the given class
-    # respectively.
-    #
-    #   module Foo
-    #     class Bar
-    #     end
-    #   end
-    #
-    #   ActiveModel::Name.new(Foo::Bar).to_s
-    #   # => "Foo::Bar"
-    def initialize(klass, namespace = nil, name = nil)
-      @name = name || klass.name
-
-      raise ArgumentError, "Class name cannot be blank. You need to supply a name argument when anonymous class given" if @name.blank?
-
-      @unnamespaced = @name.delete_prefix("#{namespace.name}::") if namespace
-      @klass        = klass
-      @singular     = _singularize(@name)
-      @plural       = ActiveSupport::Inflector.pluralize(@singular)
-      @element      = ActiveSupport::Inflector.underscore(ActiveSupport::Inflector.demodulize(@name))
-      @human        = ActiveSupport::Inflector.humanize(@element)
-      @collection   = ActiveSupport::Inflector.tableize(@name)
-      @param_key    = (namespace ? _singularize(@unnamespaced) : @singular)
-      @i18n_key     = @name.underscore.to_sym
-
-      @route_key          = (namespace ? ActiveSupport::Inflector.pluralize(@param_key) : @plural.dup)
-      @singular_route_key = ActiveSupport::Inflector.singularize(@route_key)
-      @route_key << "_index" if @plural == @singular
-    end
-
-    # Transform the model name into a more human format, using I18n. By default,
-    # it will underscore then humanize the class name.
-    #
-    #   class BlogPost
-    #     extend ActiveModel::Naming
-    #   end
-    #
-    #   BlogPost.model_name.human # => "Blog post"
-    #
-    # Specify +options+ with additional translating options.
-    def human(options = {})
-      return @human unless @klass.respond_to?(:lookup_ancestors) &&
-                           @klass.respond_to?(:i18n_scope)
-
-      defaults = @klass.lookup_ancestors.map do |klass|
-        klass.model_name.i18n_key
-      end
-
-      defaults << options[:default] if options[:default]
-      defaults << @human
-
-      options = { scope: [@klass.i18n_scope, :models], count: 1, default: defaults }.merge!(options.except(:default))
-      I18n.translate(defaults.shift, **options)
-    end
-
-    private
-      def _singularize(string)
-        ActiveSupport::Inflector.underscore(string).tr("/", "_")
-      end
-  end
-
-  # == Active \Model \Naming
-  #
-  # Creates a +model_name+ method on your object.
-  #
-  # To implement, just extend ActiveModel::Naming in your object:
-  #
-  #   class BookCover
-  #     extend ActiveModel::Naming
-  #   end
-  #
-  #   BookCover.model_name.name   # => "BookCover"
-  #   BookCover.model_name.human  # => "Book cover"
-  #
-  #   BookCover.model_name.i18n_key              # => :book_cover
-  #   BookModule::BookCover.model_name.i18n_key  # => :"book_module/book_cover"
-  #
-  # Providing the functionality that ActiveModel::Naming provides in your object
-  # is required to pass the \Active \Model Lint test. So either extending the
-  # provided method below, or rolling your own is required.
-  module Naming
-    def self.extended(base) #:nodoc:
-      base.silence_redefinition_of_method :model_name
-      base.delegate :model_name, to: :class
-    end
-
-    # Returns an ActiveModel::Name object for module. It can be
-    # used to retrieve all kinds of naming-related information
-    # (See ActiveModel::Name for more information).
-    #
-    #   class Person
-    #     extend ActiveModel::Naming
-    #   end
-    #
-    #   Person.model_name.name     # => "Person"
-    #   Person.model_name.class    # => ActiveModel::Name
-    #   Person.model_name.singular # => "person"
-    #   Person.model_name.plural   # => "people"
-    def model_name
-      @_model_name ||= begin
-        namespace = module_parents.detect do |n|
-          n.respond_to?(:use_relative_model_naming?) && n.use_relative_model_naming?
-        end
-        ActiveModel::Name.new(self, namespace)
-      end
-    end
-
-    # Returns the plural class name of a record or class.
-    #
-    #   ActiveModel::Naming.plural(post)             # => "posts"
-    #   ActiveModel::Naming.plural(Highrise::Person) # => "highrise_people"
-    def self.plural(record_or_class)
-      model_name_from_record_or_class(record_or_class).plural
-    end
-
-    # Returns the singular class name of a record or class.
-    #
-    #   ActiveModel::Naming.singular(post)             # => "post"
-    #   ActiveModel::Naming.singular(Highrise::Person) # => "highrise_person"
-    def self.singular(record_or_class)
-      model_name_from_record_or_class(record_or_class).singular
-    end
-
-    # Identifies whether the class name of a record or class is uncountable.
-    #
-    #   ActiveModel::Naming.uncountable?(Sheep) # => true
-    #   ActiveModel::Naming.uncountable?(Post)  # => false
-    def self.uncountable?(record_or_class)
-      plural(record_or_class) == singular(record_or_class)
-    end
-
-    # Returns string to use while generating route names. It differs for
-    # namespaced models regarding whether it's inside isolated engine.
-    #
-    #   # For isolated engine:
-    #   ActiveModel::Naming.singular_route_key(Blog::Post) # => "post"
-    #
-    #   # For shared engine:
-    #   ActiveModel::Naming.singular_route_key(Blog::Post) # => "blog_post"
-    def self.singular_route_key(record_or_class)
-      model_name_from_record_or_class(record_or_class).singular_route_key
-    end
-
-    # Returns string to use while generating route names. It differs for
-    # namespaced models regarding whether it's inside isolated engine.
-    #
-    #   # For isolated engine:
-    #   ActiveModel::Naming.route_key(Blog::Post) # => "posts"
-    #
-    #   # For shared engine:
-    #   ActiveModel::Naming.route_key(Blog::Post) # => "blog_posts"
-    #
-    # The route key also considers if the noun is uncountable and, in
-    # such cases, automatically appends _index.
-    def self.route_key(record_or_class)
-      model_name_from_record_or_class(record_or_class).route_key
-    end
-
-    # Returns string to use for params names. It differs for
-    # namespaced models regarding whether it's inside isolated engine.
-    #
-    #   # For isolated engine:
-    #   ActiveModel::Naming.param_key(Blog::Post) # => "post"
-    #
-    #   # For shared engine:
-    #   ActiveModel::Naming.param_key(Blog::Post) # => "blog_post"
-    def self.param_key(record_or_class)
-      model_name_from_record_or_class(record_or_class).param_key
-    end
-
-    def self.model_name_from_record_or_class(record_or_class) #:nodoc:
-      if record_or_class.respond_to?(:to_model)
-        record_or_class.to_model.model_name
-      else
-        record_or_class.model_name
-      end
-    end
-    private_class_method :model_name_from_record_or_class
-  end
-end

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

@@ -1,22 +0,0 @@
-# frozen_string_literal: true
-
-require "active_model/error"
-require "forwardable"
-
-module ActiveModel
-  class NestedError < Error
-    def initialize(base, inner_error, override_options = {})
-      @base = base
-      @inner_error = inner_error
-      @attribute = override_options.fetch(:attribute) { inner_error.attribute }
-      @type = override_options.fetch(:type) { inner_error.type }
-      @raw_type = inner_error.raw_type
-      @options = inner_error.options
-    end
-
-    attr_reader :inner_error
-
-    extend Forwardable
-    def_delegators :@inner_error, :message
-  end
-end

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

@@ -1,20 +0,0 @@
-# frozen_string_literal: true
-
-require "active_model"
-require "rails"
-
-module ActiveModel
-  class Railtie < Rails::Railtie # :nodoc:
-    config.eager_load_namespaces << ActiveModel
-
-    config.active_model = ActiveSupport::OrderedOptions.new
-
-    initializer "active_model.secure_password" do
-      ActiveModel::SecurePassword.min_cost = Rails.env.test?
-    end
-
-    initializer "active_model.i18n_customize_full_message" do
-      ActiveModel::Error.i18n_customize_full_message = config.active_model.delete(:i18n_customize_full_message) || false
-    end
-  end
-end