all_futures 1.0.2 → 2.0.0

data/lib/vendor/active_entity/core.rb

@@ -0,0 +1,348 @@
+# frozen_string_literal: true
+
+require "active_support/core_ext/hash/indifferent_access"
+require "active_support/core_ext/string/filters"
+require "active_support/parameter_filter"
+require "concurrent/map"
+
+module ActiveEntity
+  module Core
+    extend ActiveSupport::Concern
+
+    included do
+      ##
+      # :singleton-method:
+      #
+      # Accepts a logger conforming to the interface of Log4r which is then
+      # passed on to any new database connections made and which can be
+      # retrieved on both a class and instance level by calling +logger+.
+      mattr_accessor :logger, instance_writer: false
+
+      ##
+      # :singleton-method:
+      # Determines whether to use Time.utc (using :utc) or Time.local (using :local) when pulling
+      # dates and times from the database. This is set to :utc by default.
+      mattr_accessor :default_timezone, instance_writer: false, default: :utc
+
+      self.filter_attributes = []
+    end
+
+    module ClassMethods
+      def initialize_generated_modules # :nodoc:
+        generated_association_methods
+      end
+
+      def generated_association_methods # :nodoc:
+        @generated_association_methods ||= begin
+          mod = const_set(:GeneratedAssociationMethods, Module.new)
+          private_constant :GeneratedAssociationMethods
+          include mod
+
+          mod
+        end
+      end
+
+      # Returns columns which shouldn't be exposed while calling +#inspect+.
+      def filter_attributes
+        if defined?(@filter_attributes)
+          @filter_attributes
+        else
+          superclass.filter_attributes
+        end
+      end
+
+      # Specifies columns which shouldn't be exposed while calling +#inspect+.
+      attr_writer :filter_attributes
+
+      # Returns a string like 'Post(id:integer, title:string, body:text)'
+      def inspect # :nodoc:
+        if self == Base
+          super
+        else
+          attr_list = attribute_types.map { |name, type| "#{name}: #{type.type}" } * ", "
+          "#{super}#{ "(abstract)" if abstract_class? }(#{attr_list})"
+        end
+      end
+
+      # Overwrite the default class equality method to provide support for decorated models.
+      def ===(object) # :nodoc:
+        object.is_a?(self)
+      end
+    end
+
+    # New objects can be instantiated as either empty (pass no construction parameter) or pre-set with
+    # attributes but not yet saved (pass a hash with key names matching the associated table column names).
+    # In both instances, valid attribute keys are determined by the column names of the associated table --
+    # hence you can't have attributes that aren't part of the table columns.
+    #
+    # ==== Example:
+    #   # Instantiates a single new object
+    #   User.new(first_name: 'Jamie')
+    def initialize(attributes = nil)
+      @attributes = self.class._default_attributes.deep_dup
+
+      init_internals
+      initialize_internals_callback
+
+      assign_attributes(attributes) if attributes
+
+      yield self if block_given?
+      _run_initialize_callbacks
+
+      enable_attr_readonly!
+    end
+
+    # Initialize an empty model object from +coder+. +coder+ should be
+    # the result of previously encoding an Active Entity model, using
+    # #encode_with.
+    #
+    #   class Post < ActiveEntity::Base
+    #   end
+    #
+    #   old_post = Post.new(title: "hello world")
+    #   coder = {}
+    #   old_post.encode_with(coder)
+    #
+    #   post = Post.allocate
+    #   post.init_with(coder)
+    #   post.title # => 'hello world'
+    def init_with(coder, &block)
+      attributes = self.class.yaml_encoder.decode(coder)
+      init_with_attributes(attributes, coder["new_record"], &block)
+    end
+
+    ##
+    # Initialize an empty model object from +attributes+.
+    # +attributes+ should be an attributes object, and unlike the
+    # `initialize` method, no assignment calls are made per attribute.
+    def init_with_attributes(attributes) # :nodoc:
+      @attributes = attributes
+
+      init_internals
+
+      yield self if block_given?
+
+      _run_find_callbacks
+      _run_initialize_callbacks
+
+      self
+    end
+
+    ##
+    # :method: clone
+    # Identical to Ruby's clone method.  This is a "shallow" copy.  Be warned that your attributes are not copied.
+    # That means that modifying attributes of the clone will modify the original, since they will both point to the
+    # same attributes hash. If you need a copy of your attributes hash, please use the #dup method.
+    #
+    #   user = User.first
+    #   new_user = user.clone
+    #   user.name               # => "Bob"
+    #   new_user.name = "Joe"
+    #   user.name               # => "Joe"
+    #
+    #   user.object_id == new_user.object_id            # => false
+    #   user.name.object_id == new_user.name.object_id  # => true
+    #
+    #   user.name.object_id == user.dup.name.object_id  # => false
+
+    ##
+    # :method: dup
+    # Duped objects have no id assigned and are treated as new records. Note
+    # that this is a "shallow" copy as it copies the object's attributes
+    # only, not its associations. The extent of a "deep" copy is application
+    # specific and is therefore left to the application to implement according
+    # to its need.
+    # The dup method does not preserve the timestamps (created|updated)_(at|on).
+
+    ##
+    def initialize_dup(other) # :nodoc:
+      @attributes = @attributes.deep_dup
+
+      _run_initialize_callbacks
+
+      super
+    end
+
+    # Populate +coder+ with attributes about this record that should be
+    # serialized. The structure of +coder+ defined in this method is
+    # guaranteed to match the structure of +coder+ passed to the #init_with
+    # method.
+    #
+    # Example:
+    #
+    #   class Post < ActiveEntity::Base
+    #   end
+    #   coder = {}
+    #   Post.new.encode_with(coder)
+    #   coder # => {"attributes" => {"id" => nil, ... }}
+    def encode_with(coder)
+      self.class.yaml_encoder.encode(@attributes, coder)
+      coder["active_entity_yaml_version"] = 2
+    end
+
+    # Returns true if +comparison_object+ is the same exact object, or +comparison_object+
+    # is of the same type and +self+ has an ID and it is equal to +comparison_object.id+.
+    #
+    # Note that new records are different from any other record by definition, unless the
+    # other record is the receiver itself. Besides, if you fetch existing records with
+    # +select+ and leave the ID out, you're on your own, this predicate will return false.
+    #
+    # Note also that destroying a record preserves its ID in the model instance, so deleted
+    # models are still comparable.
+    def ==(comparison_object)
+      super ||
+        comparison_object.instance_of?(self.class) &&
+        !id.nil? &&
+        comparison_object.id == id
+    end
+    alias :eql? :==
+
+    # Delegates to id in order to allow two records of the same type and id to work with something like:
+    #   [ Person.find(1), Person.find(2), Person.find(3) ] & [ Person.find(1), Person.find(4) ] # => [ Person.find(1) ]
+    def hash
+      if id
+        self.class.hash ^ id.hash
+      else
+        super
+      end
+    end
+
+    # Clone and freeze the attributes hash such that associations are still
+    # accessible, even on destroyed records, but cloned models will not be
+    # frozen.
+    def freeze
+      @attributes = @attributes.clone.freeze
+      self
+    end
+
+    # Returns +true+ if the attributes hash has been frozen.
+    def frozen?
+      @attributes.frozen?
+    end
+
+    # Allows sort on objects
+    def <=>(other_object)
+      if other_object.is_a?(self.class)
+        to_key <=> other_object.to_key
+      else
+        super
+      end
+    end
+
+    def present? # :nodoc:
+      true
+    end
+
+    def blank? # :nodoc:
+      false
+    end
+
+    # Returns +true+ if the record is read only. Records loaded through joins with piggy-back
+    # attributes will be marked as read only since they cannot be saved.
+    def readonly?
+      @readonly
+    end
+
+    # Marks this record as read only.
+    def readonly!
+      @readonly = true
+    end
+
+    # Returns the contents of the record as a nicely formatted string.
+    def inspect
+      # We check defined?(@attributes) not to issue warnings if the object is
+      # allocated but not initialized.
+      inspection = if defined?(@attributes) && @attributes
+        self.class.attribute_names.collect do |name|
+          if has_attribute?(name)
+            attr = _read_attribute(name)
+            value = if attr.nil?
+              attr.inspect
+            else
+              attr = format_for_inspect(attr)
+              inspection_filter.filter_param(name, attr)
+            end
+            "#{name}: #{value}"
+          end
+        end.compact.join(", ")
+      else
+        "not initialized"
+      end
+
+      "#<#{self.class} #{inspection}>"
+    end
+
+    # Takes a PP and prettily prints this record to it, allowing you to get a nice result from <tt>pp record</tt>
+    # when pp is required.
+    def pretty_print(pp)
+      return super if custom_inspect_method_defined?
+      pp.object_address_group(self) do
+        if defined?(@attributes) && @attributes
+          attr_names = self.class.attribute_names.select { |name| has_attribute?(name) }
+          pp.seplist(attr_names, proc { pp.text "," }) do |attr_name|
+            pp.breakable " "
+            pp.group(1) do
+              pp.text attr_name
+              pp.text ":"
+              pp.breakable
+              value = _read_attribute(attr_name)
+              value = inspection_filter.filter_param(attr_name, value) unless value.nil?
+              pp.pp value
+            end
+          end
+        else
+          pp.breakable " "
+          pp.text "not initialized"
+        end
+      end
+    end
+
+    # Returns a hash of the given methods with their names as keys and returned values as values.
+    def slice(*methods)
+      Hash[methods.flatten.map! { |method| [method, public_send(method)] }].with_indifferent_access
+    end
+
+    private
+
+      # +Array#flatten+ will call +#to_ary+ (recursively) on each of the elements of
+      # the array, and then rescues from the possible +NoMethodError+. If those elements are
+      # +ActiveEntity::Base+'s, then this triggers the various +method_missing+'s that we have,
+      # which significantly impacts upon performance.
+      #
+      # So we can avoid the +method_missing+ hit by explicitly defining +#to_ary+ as +nil+ here.
+      #
+      # See also https://tenderlovemaking.com/2011/06/28/til-its-ok-to-return-nil-from-to_ary.html
+      def to_ary
+        nil
+      end
+
+      def init_internals
+        @primary_key              = self.class.primary_key
+        @readonly                 = false
+        @marked_for_destruction   = false
+
+        self.class.define_attribute_methods
+      end
+
+      def initialize_internals_callback
+      end
+
+      def custom_inspect_method_defined?
+        self.class.instance_method(:inspect).owner != ActiveEntity::Base.instance_method(:inspect).owner
+      end
+
+      class InspectionMask < DelegateClass(::String)
+        def pretty_print(pp)
+          pp.text __getobj__
+        end
+      end
+      private_constant :InspectionMask
+
+      def inspection_filter
+        @inspection_filter ||= begin
+          mask = InspectionMask.new(ActiveSupport::ParameterFilter::FILTERED)
+          ActiveSupport::ParameterFilter.new(self.class.filter_attributes, mask: mask)
+        end
+      end
+  end
+end

data/lib/vendor/active_entity/enum.rb

@@ -0,0 +1,260 @@
+# frozen_string_literal: true
+
+require "active_support/core_ext/object/deep_dup"
+
+module ActiveEntity
+  # Declare an enum attribute where the values map to integers in the database,
+  # but can be queried by name. Example:
+  #
+  #   class Conversation < ActiveEntity::Base
+  #     enum status: [ :active, :archived ]
+  #   end
+  #
+  #   # conversation.update! status: 0
+  #   conversation.active!
+  #   conversation.active? # => true
+  #   conversation.status  # => "active"
+  #
+  #   # conversation.update! status: 1
+  #   conversation.archived!
+  #   conversation.archived? # => true
+  #   conversation.status    # => "archived"
+  #
+  #   # conversation.status = 1
+  #   conversation.status = "archived"
+  #
+  #   conversation.status = nil
+  #   conversation.status.nil? # => true
+  #   conversation.status      # => nil
+  #
+  # Scopes based on the allowed values of the enum field will be provided
+  # as well. With the above example:
+  #
+  #   Conversation.active
+  #   Conversation.not_active
+  #   Conversation.archived
+  #   Conversation.not_archived
+  #
+  # Of course, you can also query them directly if the scopes don't fit your
+  # needs:
+  #
+  #   Conversation.where(status: [:active, :archived])
+  #   Conversation.where.not(status: :active)
+  #
+  # Defining scopes can be disabled by setting +:_scopes+ to +false+.
+  #
+  #   class Conversation < ActiveEntity::Base
+  #     enum status: [ :active, :archived ], _scopes: false
+  #   end
+  #
+  # You can set the default value from the database declaration, like:
+  #
+  #   create_table :conversations do |t|
+  #     t.column :status, :integer, default: 0
+  #   end
+  #
+  # Good practice is to let the first declared status be the default.
+  #
+  # Finally, it's also possible to explicitly map the relation between attribute and
+  # database integer with a hash:
+  #
+  #   class Conversation < ActiveEntity::Base
+  #     enum status: { active: 0, archived: 1 }
+  #   end
+  #
+  # Note that when an array is used, the implicit mapping from the values to database
+  # integers is derived from the order the values appear in the array. In the example,
+  # <tt>:active</tt> is mapped to +0+ as it's the first element, and <tt>:archived</tt>
+  # is mapped to +1+. In general, the +i+-th element is mapped to <tt>i-1</tt> in the
+  # database.
+  #
+  # Therefore, once a value is added to the enum array, its position in the array must
+  # be maintained, and new values should only be added to the end of the array. To
+  # remove unused values, the explicit hash syntax should be used.
+  #
+  # In rare circumstances you might need to access the mapping directly.
+  # The mappings are exposed through a class method with the pluralized attribute
+  # name, which return the mapping in a +HashWithIndifferentAccess+:
+  #
+  #   Conversation.statuses[:active]    # => 0
+  #   Conversation.statuses["archived"] # => 1
+  #
+  # Use that class method when you need to know the ordinal value of an enum.
+  # For example, you can use that when manually building SQL strings:
+  #
+  #   Conversation.where("status <> ?", Conversation.statuses[:archived])
+  #
+  # You can use the +:_prefix+ or +:_suffix+ options when you need to define
+  # multiple enums with same values. If the passed value is +true+, the methods
+  # are prefixed/suffixed with the name of the enum. It is also possible to
+  # supply a custom value:
+  #
+  #   class Conversation < ActiveEntity::Base
+  #     enum status: [:active, :archived], _suffix: true
+  #     enum comments_status: [:active, :inactive], _prefix: :comments
+  #   end
+  #
+  # With the above example, the bang and predicate methods along with the
+  # associated scopes are now prefixed and/or suffixed accordingly:
+  #
+  #   conversation.active_status!
+  #   conversation.archived_status? # => false
+  #
+  #   conversation.comments_inactive!
+  #   conversation.comments_active? # => false
+
+  module Enum
+    def self.extended(base) # :nodoc:
+      base.class_attribute(:defined_enums, instance_writer: false, default: {})
+    end
+
+    def inherited(base) # :nodoc:
+      base.defined_enums = defined_enums.deep_dup
+      super
+    end
+
+    class EnumType < Type::Value # :nodoc:
+      delegate :type, to: :subtype
+
+      def initialize(name, mapping, subtype)
+        @name = name
+        @mapping = mapping
+        @subtype = subtype
+      end
+
+      def cast(value)
+        if mapping.has_key?(value)
+          value.to_s
+        elsif mapping.has_value?(value)
+          mapping.key(value)
+        elsif value.blank?
+          nil
+        else
+          assert_valid_value(value)
+        end
+      end
+
+      def deserialize(value)
+        return if value.nil?
+        mapping.key(subtype.deserialize(value))
+      end
+
+      def serialize(value)
+        mapping.fetch(value, value)
+      end
+
+      def assert_valid_value(value)
+        unless value.blank? || mapping.has_key?(value) || mapping.has_value?(value)
+          raise ArgumentError, "'#{value}' is not a valid #{name}"
+        end
+      end
+
+      private
+
+        attr_reader :name, :mapping, :subtype
+    end
+
+    def enum(definitions)
+      klass = self
+      enum_prefix = definitions.delete(:_prefix)
+      enum_suffix = definitions.delete(:_suffix)
+      definitions.each do |name, values|
+        assert_valid_enum_definition_values(values)
+        # statuses = { }
+        enum_values = ActiveSupport::HashWithIndifferentAccess.new
+        name = name.to_s
+
+        # def self.statuses() statuses end
+        detect_enum_conflict!(name, name.pluralize, true)
+        singleton_class.define_method(name.pluralize) { enum_values }
+        defined_enums[name] = enum_values
+
+        detect_enum_conflict!(name, name)
+        detect_enum_conflict!(name, "#{name}=")
+
+        attr = attribute_alias?(name) ? attribute_alias(name) : name
+        decorate_attribute_type(attr, :enum) do |subtype|
+          EnumType.new(attr, enum_values, subtype)
+        end
+
+        _enum_methods_module.module_eval do
+          pairs = values.respond_to?(:each_pair) ? values.each_pair : values.each_with_index
+          pairs.each do |label, value|
+            if enum_prefix == true
+              prefix = "#{name}_"
+            elsif enum_prefix
+              prefix = "#{enum_prefix}_"
+            end
+            if enum_suffix == true
+              suffix = "_#{name}"
+            elsif enum_suffix
+              suffix = "_#{enum_suffix}"
+            end
+
+            value_method_name = "#{prefix}#{label}#{suffix}"
+            enum_values[label] = value
+            label = label.to_s
+
+            # def active?() status == "active" end
+            klass.send(:detect_enum_conflict!, name, "#{value_method_name}?")
+            define_method("#{value_method_name}?") { self[attr] == label }
+
+            # def active!() update!(status: 0) end
+            klass.send(:detect_enum_conflict!, name, "#{value_method_name}!")
+            define_method("#{value_method_name}!") { update!(attr => value) }
+          end
+        end
+        enum_values.freeze
+      end
+    end
+
+    private
+
+      def _enum_methods_module
+        @_enum_methods_module ||= begin
+          mod = Module.new
+          include mod
+          mod
+        end
+      end
+
+      def assert_valid_enum_definition_values(values)
+        unless values.is_a?(Hash) || values.all? { |v| v.is_a?(Symbol) } || values.all? { |v| v.is_a?(String) }
+          error_message = <<~MSG
+            Enum values #{values} must be either a hash, an array of symbols, or an array of strings.
+          MSG
+          raise ArgumentError, error_message
+        end
+
+        if values.is_a?(Hash) && values.keys.any?(&:blank?) || values.is_a?(Array) && values.any?(&:blank?)
+          raise ArgumentError, "Enum label name must not be blank."
+        end
+      end
+
+      ENUM_CONFLICT_MESSAGE = \
+        "You tried to define an enum named \"%{enum}\" on the model \"%{klass}\", but " \
+        "this will generate a %{type} method \"%{method}\", which is already defined " \
+        "by %{source}."
+      private_constant :ENUM_CONFLICT_MESSAGE
+
+      def detect_enum_conflict!(enum_name, method_name, klass_method = false)
+        if klass_method && dangerous_class_method?(method_name)
+          raise_conflict_error(enum_name, method_name, type: "class")
+        elsif !klass_method && dangerous_attribute_method?(method_name)
+          raise_conflict_error(enum_name, method_name)
+        elsif !klass_method && method_defined_within?(method_name, _enum_methods_module, Module)
+          raise_conflict_error(enum_name, method_name, source: "another enum")
+        end
+      end
+
+      def raise_conflict_error(enum_name, method_name, type: "instance", source: "Active Entity")
+        raise ArgumentError, ENUM_CONFLICT_MESSAGE % {
+          enum: enum_name,
+          klass: name,
+          type: type,
+          method: method_name,
+          source: source
+        }
+      end
+  end
+end

data/lib/vendor/active_entity/errors.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+module ActiveEntity
+  # = Active Entity Errors
+  #
+  # Generic Active Entity exception class.
+  class ActiveEntityError < StandardError
+  end
+
+  # Raised when an object assigned to an association has an incorrect type.
+  #
+  #   class Ticket < ActiveEntity::Base
+  #     has_many :patches
+  #   end
+  #
+  #   class Patch < ActiveEntity::Base
+  #     belongs_to :ticket
+  #   end
+  #
+  #   # Comments are not patches, this assignment raises AssociationTypeMismatch.
+  #   @ticket.patches << Comment.new(content: "Please attach tests to your patch.")
+  class AssociationTypeMismatch < ActiveEntityError
+  end
+
+  # Raised when unserialized object's type mismatches one specified for serializable field.
+  class SerializationTypeMismatch < ActiveEntityError
+  end
+
+  # Raised when association is being configured improperly or user tries to use
+  # offset and limit together with
+  # {ActiveEntity::Base.has_many}[rdoc-ref:Associations::ClassMethods#has_many] or
+  # {ActiveEntity::Base.has_and_belongs_to_many}[rdoc-ref:Associations::ClassMethods#has_and_belongs_to_many]
+  # associations.
+  class ConfigurationError < ActiveEntityError
+  end
+
+  # Raised when attribute has a name reserved by Active Entity (when attribute
+  # has name of one of Active Entity instance methods).
+  class DangerousAttributeError < ActiveEntityError
+  end
+
+  # Raised when unknown attributes are supplied via mass assignment.
+  UnknownAttributeError = ActiveModel::UnknownAttributeError
+
+  # Raised when an error occurred while doing a mass assignment to an attribute through the
+  # {ActiveEntity::Base#attributes=}[rdoc-ref:AttributeAssignment#attributes=] method.
+  # The exception has an +attribute+ property that is the name of the offending attribute.
+  class AttributeAssignmentError < ActiveEntityError
+    attr_reader :exception, :attribute
+
+    def initialize(message = nil, exception = nil, attribute = nil)
+      super(message)
+      @exception = exception
+      @attribute = attribute
+    end
+  end
+
+  # Raised when there are multiple errors while doing a mass assignment through the
+  # {ActiveEntity::Base#attributes=}[rdoc-ref:AttributeAssignment#attributes=]
+  # method. The exception has an +errors+ property that contains an array of AttributeAssignmentError
+  # objects, each corresponding to the error while assigning to an attribute.
+  class MultiparameterAssignmentErrors < ActiveEntityError
+    attr_reader :errors
+
+    def initialize(errors = nil)
+      @errors = errors
+    end
+  end
+end

data/lib/vendor/active_entity/gem_version.rb

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