all_futures 1.0.3 → 2.0.0

data/lib/vendor/active_entity/validations/uniqueness_in_embeds.rb

@@ -0,0 +1,91 @@
+# frozen_string_literal: true
+
+module ActiveEntity
+  module Validations
+    class UniquenessInEmbedsValidator < ActiveModel::EachValidator # :nodoc:
+      ERROR_MESSAGE = "`key` option of the configuration hash must be symbol or array of symbols."
+
+      def check_validity!
+        return if key.is_a?(Symbol) || key.is_a?(Array)
+
+        raise ArgumentError, ERROR_MESSAGE
+      end
+
+      def validate_each(record, attribute, association_or_value)
+        reflection = record.class._reflect_on_association(attribute)
+        if reflection
+          return unless reflection.is_a?(ActiveEntity::Reflection::EmbeddedAssociationReflection)
+          return unless reflection.collection?
+        end
+
+        indexed_attribute =
+          if reflection
+            reflection.options[:index_errors] || ActiveEntity::Base.index_nested_attribute_errors
+          else
+            options[:index_errors] || true
+          end
+
+        association_or_value =
+          if reflection
+            Array.wrap(association_or_value).reject(&:marked_for_destruction?)
+          else
+            Array.wrap(association_or_value)
+          end
+
+        return if association_or_value.size <= 1
+
+        duplicate_records =
+          if key.is_a? Symbol
+            association_or_value.group_by(&key)
+          elsif key.is_a? Array
+            association_or_value.group_by { |r| key.map { |attr| r.send(attr) } }
+          end
+            .values
+            .select { |v| v.size > 1 }
+            .flatten
+
+        return if duplicate_records.empty?
+
+        duplicate_records.each do |r|
+          if key.is_a? Symbol
+            r.errors.add(key, :duplicated, **options)
+
+            # Hack the record
+            normalized_attribute = normalize_attribute(attribute, indexed_attribute, association_or_value.index(r), key)
+            record.errors.import r.errors.where(key).first, attribute: normalized_attribute
+          elsif key.is_a? Array
+            key.each do |attr|
+              r.errors.add(attr, :duplicated, **options)
+
+              # Hack the record
+              normalized_attribute = normalize_attribute(attribute, indexed_attribute, association_or_value.index(r), attr)
+              record.errors.import r.errors.where(key).first, attribute: normalized_attribute
+            end
+          end
+        end
+      end
+
+      private
+
+        def key
+          @key ||= options[:key]
+        end
+
+        def normalize_attribute(attribute, indexed_attribute, index, nested_attribute)
+          if indexed_attribute
+            "#{attribute}[#{index}].#{nested_attribute}"
+          else
+            "#{attribute}.#{nested_attribute}"
+          end
+        end
+    end
+
+    module ClassMethods
+      # Validates whether the value of the specified attributes are unique
+      # in the embedded association.
+      def validates_uniqueness_in_embedding_of(*attr_names)
+        validates_with UniquenessInEmbeddingValidator, _merge_attributes(attr_names)
+      end
+    end
+  end
+end

data/lib/vendor/active_entity/validations/uniqueness_on_active_record.rb

@@ -0,0 +1,234 @@
+# frozen_string_literal: true
+
+module ActiveEntity
+  module Validations
+    class UniquenessOnActiveRecordValidator < ActiveModel::EachValidator # :nodoc:
+      def initialize(options)
+        if options[:conditions] && !options[:conditions].respond_to?(:call)
+          raise ArgumentError, "#{options[:conditions]} was passed as :conditions but is not callable. " \
+                               "Pass a callable instead: `conditions: -> { where(approved: true) }`"
+        end
+        unless Array(options[:scope]).all? { |scope| scope.respond_to?(:to_sym) }
+          raise ArgumentError, "#{options[:scope]} is not supported format for :scope option. " \
+            "Pass a symbol or an array of symbols instead: `scope: :user_id`"
+        end
+        super
+
+        @klass =
+          if options[:class].present?
+            options[:class]
+          elsif options[:class_name].present?
+            options[:class_name].safe_constantize
+          else
+            nil
+          end
+
+        unless @klass
+          raise ArgumentError, "Must provide one of option :class_name or :class."
+        end
+        unless @klass < ActiveRecord::Base
+          raise ArgumentError, "Class must be an Active Entity model, but got #{@klass}."
+        end
+        if @klass.abstract_class?
+          raise ArgumentError, "Class can't be an abstract class."
+        end
+      end
+
+      def validate_each(record, attribute, value)
+        finder_class = find_finder_class_for(record)
+        value = map_enum_attribute(finder_class, attribute, value)
+
+        relation = build_relation(finder_class, attribute, value)
+        relation = scope_relation(record, relation)
+        relation = relation.merge(options[:conditions]) if options[:conditions]
+
+        if relation.exists?
+          error_options = options.except(:case_sensitive, :scope, :conditions)
+          error_options[:value] = value
+
+          record.errors.add(attribute, :taken, **error_options)
+        end
+      end
+
+    private
+
+      # The check for an existing value should be run from a class that
+      # isn't abstract. This means working down from the current class
+      # (self), to the first non-abstract class. Since classes don't know
+      # their subclasses, we have to build the hierarchy between self and
+      # the record's class.
+      def find_finder_class_for(record)
+        class_hierarchy = [record.class]
+
+        while class_hierarchy.first != @klass
+          class_hierarchy.unshift(class_hierarchy.first.superclass)
+        end
+
+        class_hierarchy.detect { |klass| !klass.abstract_class? }
+      end
+
+      def build_relation(klass, attribute, value)
+        relation = klass.unscoped
+        comparison = relation.bind_attribute(attribute, value) do |attr, bind|
+          return relation.none! if bind.unboundable?
+
+          if !options.key?(:case_sensitive) || bind.nil?
+            klass.connection.default_uniqueness_comparison(attr, bind, klass)
+          elsif options[:case_sensitive]
+            klass.connection.case_sensitive_comparison(attr, bind)
+          else
+            # will use SQL LOWER function before comparison, unless it detects a case insensitive collation
+            klass.connection.case_insensitive_comparison(attr, bind)
+          end
+        end
+
+        relation.where!(comparison)
+      end
+
+      def scope_relation(record, relation)
+        Array(options[:scope]).each do |scope_item|
+          scope_value = record._read_attribute(scope_item)
+          relation = relation.where(scope_item => scope_value)
+        end
+
+        relation
+      end
+
+      def map_enum_attribute(klass, attribute, value)
+        mapping = klass.defined_enums[attribute.to_s]
+        value = mapping[value] if value && mapping
+        value
+      end
+    end
+
+    module ClassMethods
+      # Validates whether the value of the specified attributes are unique
+      # across the system. Useful for making sure that only one user
+      # can be named "davidhh".
+      #
+      #   class Person < ActiveEntity::Base
+      #     validates_uniqueness_of :user_name
+      #   end
+      #
+      # It can also validate whether the value of the specified attributes are
+      # unique based on a <tt>:scope</tt> parameter:
+      #
+      #   class Person < ActiveEntity::Base
+      #     validates_uniqueness_of :user_name, scope: :account_id
+      #   end
+      #
+      # Or even multiple scope parameters. For example, making sure that a
+      # teacher can only be on the schedule once per semester for a particular
+      # class.
+      #
+      #   class TeacherSchedule < ActiveEntity::Base
+      #     validates_uniqueness_of :teacher_id, scope: [:semester_id, :class_id]
+      #   end
+      #
+      # It is also possible to limit the uniqueness constraint to a set of
+      # records matching certain conditions. In this example archived articles
+      # are not being taken into consideration when validating uniqueness
+      # of the title attribute:
+      #
+      #   class Article < ActiveEntity::Base
+      #     validates_uniqueness_of :title, conditions: -> { where.not(status: 'archived') }
+      #   end
+      #
+      # When the record is created, a check is performed to make sure that no
+      # record exists in the database with the given value for the specified
+      # attribute (that maps to a column). When the record is updated,
+      # the same check is made but disregarding the record itself.
+      #
+      # Configuration options:
+      #
+      # * <tt>:message</tt> - Specifies a custom error message (default is:
+      #   "has already been taken").
+      # * <tt>:scope</tt> - One or more columns by which to limit the scope of
+      #   the uniqueness constraint.
+      # * <tt>:conditions</tt> - Specify the conditions to be included as a
+      #   <tt>WHERE</tt> SQL fragment to limit the uniqueness constraint lookup
+      #   (e.g. <tt>conditions: -> { where(status: 'active') }</tt>).
+      # * <tt>:case_sensitive</tt> - Looks for an exact match. Ignored by
+      #   non-text columns (+true+ by default).
+      # * <tt>:allow_nil</tt> - If set to +true+, skips this validation if the
+      #   attribute is +nil+ (default is +false+).
+      # * <tt>:allow_blank</tt> - If set to +true+, skips this validation if the
+      #   attribute is blank (default is +false+).
+      # * <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.
+      #
+      # === Concurrency and integrity
+      #
+      # Using this validation method in conjunction with
+      # {ActiveEntity::Base#save}[rdoc-ref:Persistence#save]
+      # does not guarantee the absence of duplicate record insertions, because
+      # uniqueness checks on the application level are inherently prone to race
+      # conditions. For example, suppose that two users try to post a Comment at
+      # the same time, and a Comment's title must be unique. At the database-level,
+      # the actions performed by these users could be interleaved in the following manner:
+      #
+      #               User 1                 |               User 2
+      #  ------------------------------------+--------------------------------------
+      #  # User 1 checks whether there's     |
+      #  # already a comment with the title  |
+      #  # 'My Post'. This is not the case.  |
+      #  SELECT * FROM comments              |
+      #  WHERE title = 'My Post'             |
+      #                                      |
+      #                                      | # User 2 does the same thing and also
+      #                                      | # infers that their title is unique.
+      #                                      | SELECT * FROM comments
+      #                                      | WHERE title = 'My Post'
+      #                                      |
+      #  # User 1 inserts their comment.     |
+      #  INSERT INTO comments                |
+      #  (title, content) VALUES             |
+      #  ('My Post', 'hi!')                  |
+      #                                      |
+      #                                      | # User 2 does the same thing.
+      #                                      | INSERT INTO comments
+      #                                      | (title, content) VALUES
+      #                                      | ('My Post', 'hello!')
+      #                                      |
+      #                                      | # ^^^^^^
+      #                                      | # Boom! We now have a duplicate
+      #                                      | # title!
+      #
+      # The best way to work around this problem is to add a unique index to the database table using
+      # {connection.add_index}[rdoc-ref:ConnectionAdapters::SchemaStatements#add_index].
+      # In the rare case that a race condition occurs, the database will guarantee
+      # the field's uniqueness.
+      #
+      # When the database catches such a duplicate insertion,
+      # {ActiveEntity::Base#save}[rdoc-ref:Persistence#save] will raise an ActiveEntity::StatementInvalid
+      # exception. You can either choose to let this error propagate (which
+      # will result in the default Rails exception page being shown), or you
+      # can catch it and restart the transaction (e.g. by telling the user
+      # that the title already exists, and asking them to re-enter the title).
+      # This technique is also known as
+      # {optimistic concurrency control}[https://en.wikipedia.org/wiki/Optimistic_concurrency_control].
+      #
+      # The bundled ActiveEntity::ConnectionAdapters distinguish unique index
+      # constraint errors from other types of database errors by throwing an
+      # ActiveEntity::RecordNotUnique exception. For other adapters you will
+      # have to parse the (database-specific) exception message to detect such
+      # a case.
+      #
+      # The following bundled adapters throw the ActiveEntity::RecordNotUnique exception:
+      #
+      # * ActiveEntity::ConnectionAdapters::Mysql2Adapter.
+      # * ActiveEntity::ConnectionAdapters::SQLite3Adapter.
+      # * ActiveEntity::ConnectionAdapters::PostgreSQLAdapter.
+      def validates_uniqueness_on_active_record_of(*attr_names)
+        validates_with UniquenessOnActiveRecordValidator, _merge_attributes(attr_names)
+      end
+    end
+  end
+end

data/lib/vendor/active_entity/validations.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module ActiveEntity
+  # = Active Entity \Validations
+  #
+  # Active Entity includes the majority of its validations from ActiveModel::Validations
+  # all of which accept the <tt>:on</tt> argument to define the context where the
+  # validations are active. Active Entity will always supply either the context of
+  # <tt>:create</tt> or <tt>:update</tt> dependent on whether the model is a
+  # {new_record?}[rdoc-ref:Persistence#new_record?].
+  module Validations
+    extend ActiveSupport::Concern
+    include ActiveModel::Validations
+
+    # Runs all the validations within the specified context. Returns +true+ if
+    # no errors are found, +false+ otherwise.
+    #
+    # Aliased as #validate.
+    #
+    # If the argument is +false+ (default is +nil+), the context is set to <tt>:create</tt> if
+    # {new_record?}[rdoc-ref:Persistence#new_record?] is +true+, and to <tt>:update</tt> if it is not.
+    #
+    # \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 valid?(context = nil)
+      context ||= :default
+      output = super(context)
+      errors.empty? && output
+    end
+
+    alias_method :validate, :valid?
+
+  private
+
+    def perform_validations(options = {})
+      options[:validate] == false || valid?(options[:context])
+    end
+  end
+end
+
+require "active_entity/validations/associated"
+require "active_entity/validations/presence"
+require "active_entity/validations/absence"
+require "active_entity/validations/length"
+require "active_entity/validations/subset"
+require "active_entity/validations/uniqueness_in_embeds"
+require "active_entity/validations/uniqueness_on_active_record"

data/lib/vendor/active_entity/version.rb

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

data/lib/vendor/active_entity.rb

@@ -0,0 +1,99 @@
+# frozen_string_literal: true
+
+#--
+# Copyright (c) 2004-2020 David Heinemeier Hansson
+#
+# Permission is hereby granted, free of charge, to any person obtaining
+# a copy of this software and associated documentation files (the
+# "Software"), to deal in the Software without restriction, including
+# without limitation the rights to use, copy, modify, merge, publish,
+# distribute, sublicense, and/or sell copies of the Software, and to
+# permit persons to whom the Software is furnished to do so, subject to
+# the following conditions:
+#
+# The above copyright notice and this permission notice shall be
+# included in all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+#++
+
+require "active_support"
+require "active_support/rails"
+require "active_model"
+require "yaml"
+
+require "core_ext/array_without_blank"
+
+require "active_entity/version"
+require "active_model/attribute_set"
+require "active_entity/errors"
+
+module ActiveEntity
+  extend ActiveSupport::Autoload
+
+  autoload :Base
+  autoload :Callbacks
+  autoload :Core
+  autoload :Enum
+  autoload :Inheritance
+  autoload :Integration
+  autoload :ModelSchema
+  autoload :NestedAttributes
+  autoload :Persistence
+  autoload :ReadonlyAttributes
+  autoload :Reflection
+  autoload :Serialization
+  autoload :Store
+  autoload :Translation
+  autoload :Validations
+
+  eager_autoload do
+    autoload :Aggregations
+    autoload :Associations
+    autoload :AttributeAssignment
+    autoload :AttributeMethods
+    autoload :ValidateEmbedsAssociation
+
+    autoload :Type
+  end
+
+  module Coders
+    autoload :YAMLColumn, "active_entity/coders/yaml_column"
+    autoload :JSON, "active_entity/coders/json"
+  end
+
+  module AttributeMethods
+    extend ActiveSupport::Autoload
+
+    eager_autoload do
+      autoload :BeforeTypeCast
+      autoload :Dirty
+      autoload :PrimaryKey
+      autoload :Query
+      autoload :Read
+      autoload :TimeZoneConversion
+      autoload :Write
+      autoload :Serialization
+    end
+  end
+
+  def self.eager_load!
+    super
+
+    ActiveEntity::Associations.eager_load!
+    ActiveEntity::AttributeMethods.eager_load!
+  end
+end
+
+ActiveSupport.on_load(:i18n) do
+  I18n.load_path << File.expand_path("active_entity/locale/en.yml", __dir__)
+end
+
+YAML.load_tags["!ruby/object:ActiveEntity::AttributeSet"] = "ActiveModel::AttributeSet"
+YAML.load_tags["!ruby/object:ActiveEntity::LazyAttributeHash"] = "ActiveModel::LazyAttributeHash"

data/lib/vendor/core_ext/array_without_blank.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+class ArrayWithoutBlank < Array
+  def self.new(*several_variants)
+    arr = super
+    arr.reject!(&:blank?)
+    arr
+  end
+
+  def initialize_copy(other_ary)
+    super other_ary.reject(&:blank?)
+  end
+
+  def replace(other_ary)
+    super other_ary.reject(&:blank?)
+  end
+
+  def push(obj, *smth)
+    return self if obj.blank?
+    super
+  end
+
+  def insert(*args)
+    super(*args.reject(&:blank?))
+  end
+
+  def []=(index, obj)
+    return self[index] if obj.blank?
+    super
+  end
+
+  def concat(other_ary)
+    super other_ary.reject(&:blank?)
+  end
+
+  def +(other_ary)
+    super other_ary.reject(&:blank?)
+  end
+
+  def <<(obj)
+    return self if obj.blank?
+    super
+  end
+
+  def to_ary
+    Array.new(self)
+  end
+end