activeentity 0.0.1.beta1

data/lib/active_entity/validations.rb

@@ -0,0 +1,50 @@
+# 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_validation_context
+      output = super(context)
+      errors.empty? && output
+    end
+
+    alias_method :validate, :valid?
+
+  private
+
+    def default_validation_context
+      :default
+    end
+
+    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_embedding"

data/lib/active_entity/validations/absence.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module ActiveEntity
+  module Validations
+    class AbsenceValidator < ActiveModel::Validations::AbsenceValidator # :nodoc:
+      def validate_each(record, attribute, association_or_value)
+        if record.class._reflect_on_association(attribute)
+          association_or_value = Array.wrap(association_or_value).reject(&:marked_for_destruction?)
+        end
+        super
+      end
+    end
+
+    module ClassMethods
+      # Validates that the specified attributes are not present (as defined by
+      # Object#present?). If the attribute is an association, the associated object
+      # is considered absent if it was marked for destruction.
+      #
+      # See ActiveModel::Validations::HelperMethods.validates_absence_of for more information.
+      def validates_absence_of(*attr_names)
+        validates_with AbsenceValidator, _merge_attributes(attr_names)
+      end
+    end
+  end
+end

data/lib/active_entity/validations/associated.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+module ActiveEntity
+  module Validations
+    class AssociatedValidator < ActiveModel::EachValidator #:nodoc:
+      def validate_each(record, attribute, value)
+        if Array(value).reject { |r| valid_object?(r) }.any?
+          record.errors.add(attribute, :invalid, options.merge(value: value))
+        end
+      end
+
+      private
+
+        def valid_object?(record)
+          (record.respond_to?(:marked_for_destruction?) && record.marked_for_destruction?) || record.valid?
+        end
+    end
+
+    module ClassMethods
+      # Validates whether the associated object or objects are all valid.
+      # Works with any kind of association.
+      #
+      #   class Book < ActiveEntity::Base
+      #     has_many :pages
+      #     belongs_to :library
+      #
+      #     validates_associated :pages, :library
+      #   end
+      #
+      # WARNING: This validation must not be used on both ends of an association.
+      # Doing so will lead to a circular dependency and cause infinite recursion.
+      #
+      # NOTE: This validation will not fail if the association hasn't been
+      # assigned. If you want to ensure that the association is both present and
+      # guaranteed to be valid, you also need to use
+      # {validates_presence_of}[rdoc-ref:Validations::ClassMethods#validates_presence_of].
+      #
+      # Configuration options:
+      #
+      # * <tt>:message</tt> - A custom error message (default is: "is invalid").
+      # * <tt>:on</tt> - Specifies the contexts where this validation is active.
+      #   Runs in all validation contexts by default +nil+. You can pass a symbol
+      #   or an array of symbols. (e.g. <tt>on: :create</tt> or
+      #   <tt>on: :custom_validation_context</tt> or
+      #   <tt>on: [:create, :custom_validation_context]</tt>)
+      # * <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.
+      def validates_associated(*attr_names)
+        validates_with AssociatedValidator, _merge_attributes(attr_names)
+      end
+    end
+  end
+end

data/lib/active_entity/validations/length.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module ActiveEntity
+  module Validations
+    class LengthValidator < ActiveModel::Validations::LengthValidator # :nodoc:
+      def validate_each(record, attribute, association_or_value)
+        if association_or_value.respond_to?(:loaded?) && association_or_value.loaded?
+          association_or_value = association_or_value.target.reject(&:marked_for_destruction?)
+        end
+        super
+      end
+    end
+
+    module ClassMethods
+      # Validates that the specified attributes match the length restrictions supplied.
+      # If the attribute is an association, records that are marked for destruction are not counted.
+      #
+      # See ActiveModel::Validations::HelperMethods.validates_length_of for more information.
+      def validates_length_of(*attr_names)
+        validates_with LengthValidator, _merge_attributes(attr_names)
+      end
+
+      alias_method :validates_size_of, :validates_length_of
+    end
+  end
+end

data/lib/active_entity/validations/presence.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+module ActiveEntity
+  module Validations
+    class PresenceValidator < ActiveModel::Validations::PresenceValidator # :nodoc:
+      def validate_each(record, attribute, association_or_value)
+        if record.class._reflect_on_association(attribute)
+          association_or_value = Array.wrap(association_or_value).reject(&:marked_for_destruction?)
+        end
+        super
+      end
+    end
+
+    module ClassMethods
+      # Validates that the specified attributes are not blank (as defined by
+      # Object#blank?), and, if the attribute is an association, that the
+      # associated object is not marked for destruction. Happens by default
+      # on save.
+      #
+      #   class Person < ActiveEntity::Base
+      #     has_one :face
+      #     validates_presence_of :face
+      #   end
+      #
+      # The face attribute must be in the object and it cannot be blank or marked
+      # for destruction.
+      #
+      # If you want to validate the presence of a boolean field (where the real values
+      # are true and false), you will want to use
+      # <tt>validates_inclusion_of :field_name, in: [true, false]</tt>.
+      #
+      # This is due to the way Object#blank? handles boolean values:
+      # <tt>false.blank? # => true</tt>.
+      #
+      # This validator defers to the Active Model validation for presence, adding the
+      # check to see that an associated object is not marked for destruction. This
+      # prevents the parent object from validating successfully and saving, which then
+      # deletes the associated object, thus putting the parent object into an invalid
+      # state.
+      #
+      # NOTE: This validation will not fail while using it with an association
+      # if the latter was assigned but not valid. If you want to ensure that
+      # it is both present and valid, you also need to use
+      # {validates_associated}[rdoc-ref:Validations::ClassMethods#validates_associated].
+      #
+      # Configuration options:
+      # * <tt>:message</tt> - A custom error message (default is: "can't be blank").
+      # * <tt>:on</tt> - Specifies the contexts where this validation is active.
+      #   Runs in all validation contexts by default +nil+. You can pass a symbol
+      #   or an array of symbols. (e.g. <tt>on: :create</tt> or
+      #   <tt>on: :custom_validation_context</tt> or
+      #   <tt>on: [:create, :custom_validation_context]</tt>)
+      # * <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.
+      # * <tt>:strict</tt> - Specifies whether validation should be strict.
+      #   See ActiveModel::Validations#validates! for more information.
+      def validates_presence_of(*attr_names)
+        validates_with PresenceValidator, _merge_attributes(attr_names)
+      end
+    end
+  end
+end

data/lib/active_entity/validations/subset.rb

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+module ActiveEntity
+  module Validations
+    class SubsetValidator < ActiveModel::EachValidator # :nodoc:
+      ERROR_MESSAGE = "An object with the method #include? or a proc, lambda or symbol is required, " \
+                      "and must be supplied as the :in (or :within) option of the configuration hash"
+
+      def check_validity!
+        unless delimiter.respond_to?(:include?) || delimiter.respond_to?(:call) || delimiter.respond_to?(:to_sym)
+          raise ArgumentError, ERROR_MESSAGE
+        end
+      end
+
+      def validate_each(record, attribute, value)
+        if value && !value.respond_to?(:to_a)
+          raise ArgumentError, "#{record} can't respond `to_a`."
+        end
+
+        unless subset?(record, value)
+          record.errors.add(attribute, :non_subset, options.except(:in, :within).merge!(value: value))
+        end
+      end
+
+      private
+
+        def delimiter
+          @delimiter ||= options[:in] || options[:within]
+        end
+
+        def subset?(record, value)
+          enumerable = value.to_a
+          members =
+            if delimiter.respond_to?(:call)
+              delimiter.call(record)
+            elsif delimiter.respond_to?(:to_sym)
+              record.send(delimiter)
+            else
+              delimiter
+            end
+
+          (members & enumerable).size == enumerable.size
+        end
+    end
+
+    module ClassMethods
+      # Validates whether the value of the specified attribute is available in a
+      # particular enumerable object.
+      #
+      #   class Person < ActiveRecord::Base
+      #     validates :tags, subset: %w( m f )
+      #     validates_subset_of :tags, in: %w( m f )
+      #     validates_inclusion_of :tags, in: %w( m f ), message: "tag %{value} is not included in the list"
+      #     validates_inclusion_of :tags, in: ->(record) { record.available_tags }
+      #     validates_inclusion_of :tags, in: :available_tags
+      #   end
+      #
+      # Configuration options:
+      # * <tt>:in</tt> - An enumerable object of available items. This can be
+      #   supplied as a proc, lambda or symbol which returns an enumerable. If the
+      #   enumerable is a numerical, time or datetime range the test is performed
+      #   with <tt>Range#cover?</tt>, otherwise with <tt>include?</tt>. When using
+      #   a proc or lambda the instance under validation is passed as an argument.
+      # * <tt>:within</tt> - A synonym(or alias) for <tt>:in</tt>
+      # * <tt>:message</tt> - Specifies a custom error message (default is: "is
+      #   not included in the list").
+      #
+      # There is also a list of default options supported by every validator:
+      # +:if+, +:unless+, +:on+, +:allow_nil+, +:allow_blank+, and +:strict+.
+      # See <tt>ActiveModel::Validations#validates</tt> for more information
+      def validates_subset_of(*attr_names)
+        validates_with SubsetValidator, _merge_attributes(attr_names)
+      end
+    end
+  end
+end

data/lib/active_entity/validations/uniqueness_in_embedding.rb

@@ -0,0 +1,99 @@
+# frozen_string_literal: true
+
+module ActiveEntity
+  module Validations
+    class UniquenessInEmbeddingValidator < 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[normalized_attribute].concat r.errors.messages[key]
+            record.errors[normalized_attribute].uniq!
+
+            record.errors.details[normalized_attribute.to_sym].concat r.errors.details[key]
+            record.errors.details[normalized_attribute.to_sym].uniq!
+          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[normalized_attribute].concat r.errors.messages[attr]
+              record.errors[normalized_attribute].uniq!
+
+              record.errors.details[normalized_attribute.to_sym].concat r.errors.details[attr]
+              record.errors.details[normalized_attribute.to_sym].uniq!
+            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/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/tasks/active_entity_tasks.rake

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+# desc "Explaining what the task does"
+# task :active_entity do
+#   # Task goes here
+# end

metadata

@@ -0,0 +1,155 @@
+--- !ruby/object:Gem::Specification
+name: activeentity
+version: !ruby/object:Gem::Version
+  version: 0.0.1.beta1
+platform: ruby
+authors:
+- jasl
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2019-01-19 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 6.0.0.beta1
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '7.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 6.0.0.beta1
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '7.0'
+- !ruby/object:Gem::Dependency
+  name: activemodel
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 6.0.0.beta1
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '7.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 6.0.0.beta1
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '7.0'
+description: Rails virtual model solution based on ActiveModel design for Rails 6+.
+email:
+- jasl9187@hotmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- MIT-LICENSE
+- README.md
+- Rakefile
+- lib/active_entity.rb
+- lib/active_entity/aggregations.rb
+- lib/active_entity/associations.rb
+- lib/active_entity/associations/embedded/association.rb
+- lib/active_entity/associations/embedded/builder/association.rb
+- lib/active_entity/associations/embedded/builder/collection_association.rb
+- lib/active_entity/associations/embedded/builder/embedded_in.rb
+- lib/active_entity/associations/embedded/builder/embeds_many.rb
+- lib/active_entity/associations/embedded/builder/embeds_one.rb
+- lib/active_entity/associations/embedded/builder/singular_association.rb
+- lib/active_entity/associations/embedded/collection_association.rb
+- lib/active_entity/associations/embedded/collection_proxy.rb
+- lib/active_entity/associations/embedded/embedded_in_association.rb
+- lib/active_entity/associations/embedded/embeds_many_association.rb
+- lib/active_entity/associations/embedded/embeds_one_association.rb
+- lib/active_entity/associations/embedded/singular_association.rb
+- lib/active_entity/attribute_assignment.rb
+- lib/active_entity/attribute_decorators.rb
+- lib/active_entity/attribute_methods.rb
+- lib/active_entity/attribute_methods/before_type_cast.rb
+- lib/active_entity/attribute_methods/primary_key.rb
+- lib/active_entity/attribute_methods/query.rb
+- lib/active_entity/attribute_methods/read.rb
+- lib/active_entity/attribute_methods/serialization.rb
+- lib/active_entity/attribute_methods/time_zone_conversion.rb
+- lib/active_entity/attribute_methods/write.rb
+- lib/active_entity/attributes.rb
+- lib/active_entity/base.rb
+- lib/active_entity/coders/json.rb
+- lib/active_entity/coders/yaml_column.rb
+- lib/active_entity/core.rb
+- lib/active_entity/define_callbacks.rb
+- lib/active_entity/enum.rb
+- lib/active_entity/errors.rb
+- lib/active_entity/gem_version.rb
+- lib/active_entity/inheritance.rb
+- lib/active_entity/integration.rb
+- lib/active_entity/locale/en.yml
+- lib/active_entity/model_schema.rb
+- lib/active_entity/nested_attributes.rb
+- lib/active_entity/readonly_attributes.rb
+- lib/active_entity/reflection.rb
+- lib/active_entity/serialization.rb
+- lib/active_entity/store.rb
+- lib/active_entity/translation.rb
+- lib/active_entity/type.rb
+- lib/active_entity/type/date.rb
+- lib/active_entity/type/date_time.rb
+- lib/active_entity/type/decimal_without_scale.rb
+- lib/active_entity/type/hash_lookup_type_map.rb
+- lib/active_entity/type/internal/timezone.rb
+- lib/active_entity/type/json.rb
+- lib/active_entity/type/modifiers/array.rb
+- lib/active_entity/type/registry.rb
+- lib/active_entity/type/serialized.rb
+- lib/active_entity/type/text.rb
+- lib/active_entity/type/time.rb
+- lib/active_entity/type/type_map.rb
+- lib/active_entity/type/unsigned_integer.rb
+- lib/active_entity/validate_embedded_association.rb
+- lib/active_entity/validations.rb
+- lib/active_entity/validations/absence.rb
+- lib/active_entity/validations/associated.rb
+- lib/active_entity/validations/length.rb
+- lib/active_entity/validations/presence.rb
+- lib/active_entity/validations/subset.rb
+- lib/active_entity/validations/uniqueness_in_embedding.rb
+- lib/active_entity/version.rb
+- lib/tasks/active_entity_tasks.rake
+homepage: https://github.com/jasl/activeentity
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.5.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">"
+    - !ruby/object:Gem::Version
+      version: 1.3.1
+requirements: []
+rubygems_version: 3.0.2
+signing_key: 
+specification_version: 4
+summary: Rails virtual model solution based on ActiveModel.
+test_files: []