activeentity 0.0.1.beta14 → 6.1.0

data/lib/active_entity/attributes.rb

@@ -12,7 +12,13 @@ module ActiveEntity
     end
 
     module ClassMethods
-      # Defines an attribute with a type on this model.
+      # Defines an attribute with a type on this model. It will override the
+      # type of existing attributes if needed. This allows control over how
+      # values are converted to and from SQL when assigned to a model. It also
+      # changes the behavior of values passed to
+      # {ActiveEntity::Base.where}[rdoc-ref:QueryMethods#where]. This will let you use
+      # your domain objects across much of Active Entity, without having to
+      # rely on implementation details or monkey patching.
       #
       # +name+ The name of the methods to define attribute methods for, and the
       # column which this will persist to.
@@ -29,11 +35,66 @@ module ActiveEntity
       # is not passed, the previous default value (if any) will be used.
       # Otherwise, the default will be +nil+.
       #
-      # +array+ Specifies that the type should be an array (see the
+      # +array+ (PostgreSQL only) specifies that the type should be an array (see the
       # examples below).
       #
+      # +range+ (PostgreSQL only) specifies that the type should be a range (see the
+      # examples below).
+      #
+      # When using a symbol for +cast_type+, extra options are forwarded to the
+      # constructor of the type object.
+      #
       # ==== Examples
       #
+      # The type detected by Active Entity can be overridden.
+      #
+      #   # db/schema.rb
+      #   create_table :store_listings, force: true do |t|
+      #     t.decimal :price_in_cents
+      #   end
+      #
+      #   # app/models/store_listing.rb
+      #   class StoreListing < ActiveEntity::Base
+      #   end
+      #
+      #   store_listing = StoreListing.new(price_in_cents: '10.1')
+      #
+      #   # before
+      #   store_listing.price_in_cents # => BigDecimal(10.1)
+      #
+      #   class StoreListing < ActiveEntity::Base
+      #     attribute :price_in_cents, :integer
+      #   end
+      #
+      #   # after
+      #   store_listing.price_in_cents # => 10
+      #
+      # A default can also be provided.
+      #
+      #   # db/schema.rb
+      #   create_table :store_listings, force: true do |t|
+      #     t.string :my_string, default: "original default"
+      #   end
+      #
+      #   StoreListing.new.my_string # => "original default"
+      #
+      #   # app/models/store_listing.rb
+      #   class StoreListing < ActiveEntity::Base
+      #     attribute :my_string, :string, default: "new default"
+      #   end
+      #
+      #   StoreListing.new.my_string # => "new default"
+      #
+      #   class Product < ActiveEntity::Base
+      #     attribute :my_default_proc, :datetime, default: -> { Time.now }
+      #   end
+      #
+      #   Product.new.my_default_proc # => 2015-05-30 11:04:48 -0600
+      #   sleep 1
+      #   Product.new.my_default_proc # => 2015-05-30 11:04:49 -0600
+      #
+      # \Attributes do not need to be backed by a database column.
+      #
       #   # app/models/my_model.rb
       #   class MyModel < ActiveEntity::Base
       #     attribute :my_string, :string
@@ -54,6 +115,16 @@ module ActiveEntity
       #       my_float_range: 1.0..3.5
       #     }
       #
+      # Passing options to the type constructor
+      #
+      #   # app/models/my_model.rb
+      #   class MyModel < ActiveEntity::Base
+      #     attribute :small_int, :integer, limit: 2
+      #   end
+      #
+      #   MyModel.create(small_int: 65537)
+      #   # => Error: 65537 is out of range for the limit of two bytes
+      #
       # ==== Creating Custom Types
       #
       # Users may also define their own custom types, as long as they respond
@@ -121,6 +192,8 @@ module ActiveEntity
       # is not passed, the previous default value (if any) will be used.
       # Otherwise, the default will be +nil+. A proc can also be passed, and
       # will be called once each time a new value is needed.
+      #
+      # +cast+ or +deserialize+.
       def define_attribute(
         name,
         cast_type,
@@ -158,6 +231,7 @@ module ActiveEntity
                 _default_attributes.fetch(name.to_s) { nil },
                 )
             end
+
           _default_attributes[name] = default_attribute
         end
     end

data/lib/active_entity/base.rb

@@ -1,22 +1,11 @@
 # frozen_string_literal: true
 
-require "yaml"
 require "active_support/benchmarkable"
 require "active_support/dependencies"
 require "active_support/descendants_tracker"
 require "active_support/time"
-require "active_support/core_ext/module/attribute_accessors"
-require "active_support/core_ext/array/extract_options"
-require "active_support/core_ext/hash/deep_merge"
-require "active_support/core_ext/hash/slice"
-require "active_support/core_ext/string/behavior"
-require "active_support/core_ext/kernel/singleton_class"
-require "active_support/core_ext/module/introspection"
-require "active_support/core_ext/object/duplicable"
 require "active_support/core_ext/class/subclasses"
 require "active_entity/attribute_decorators"
-require "active_entity/define_callbacks"
-require "active_entity/errors"
 require "active_entity/attributes"
 
 module ActiveEntity #:nodoc:
@@ -28,7 +17,7 @@ module ActiveEntity #:nodoc:
   # Active Entity objects. The mapping that binds a given Active Entity class to a certain
   # database table will happen automatically in most common cases, but can be overwritten for the uncommon ones.
   #
-  # See the mapping rules in table_name and the full example in link:files/activerecord/README_rdoc.html for more insight.
+  # See the mapping rules in table_name and the full example in link:files/activeentity/README_rdoc.html for more insight.
   #
   # == Creation
   #
@@ -290,10 +279,10 @@ module ActiveEntity #:nodoc:
     include Validations
     include Attributes
     include AttributeDecorators
-    include DefineCallbacks
     include AttributeMethods
+    include Callbacks
     include Associations
-    include ValidateEmbeddedAssociation
+    include ValidateEmbedsAssociation
     include NestedAttributes
     include Reflection
     include Serialization

data/lib/active_entity/{define_callbacks.rb → callbacks.rb}

@@ -1,9 +1,13 @@
 # frozen_string_literal: true
 
 module ActiveEntity
-  module DefineCallbacks
+  module Callbacks
     extend ActiveSupport::Concern
 
+    CALLBACKS = [
+      :after_initialize, :before_validation, :after_validation
+    ]
+
     module ClassMethods # :nodoc:
       include ActiveModel::Callbacks
     end

data/lib/active_entity/core.rb

@@ -58,11 +58,9 @@ module ActiveEntity
       def inspect # :nodoc:
         if self == Base
           super
-        elsif abstract_class?
-          "#{super}(abstract)"
         else
           attr_list = attribute_types.map { |name, type| "#{name}: #{type.type}" } * ", "
-          "#{super}(#{attr_list})"
+          "#{super}#{ "(abstract)" if abstract_class? }(#{attr_list})"
         end
       end
 
@@ -81,7 +79,6 @@ module ActiveEntity
     #   # Instantiates a single new object
     #   User.new(first_name: 'Jamie')
     def initialize(attributes = nil)
-      self.class.define_attribute_methods
       @attributes = self.class._default_attributes.deep_dup
 
       init_internals
@@ -95,6 +92,42 @@ module ActiveEntity
       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.
@@ -147,6 +180,33 @@ module ActiveEntity
       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.
@@ -169,6 +229,14 @@ module ActiveEntity
       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?
@@ -184,24 +252,22 @@ module ActiveEntity
     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}"
+      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
-          end.compact.join(", ")
-        else
-          "not initialized"
-        end
+            "#{name}: #{value}"
+          end
+        end.compact.join(", ")
+      else
+        "not initialized"
+      end
 
       "#<#{self.class} #{inspection}>"
     end
@@ -236,14 +302,6 @@ module ActiveEntity
       Hash[methods.flatten.map! { |method| [method, public_send(method)] }].with_indifferent_access
     end
 
-    def present? # :nodoc:
-      true
-    end
-
-    def blank? # :nodoc:
-      false
-    end
-
     private
 
       # +Array#flatten+ will call +#to_ary+ (recursively) on each of the elements of
@@ -261,27 +319,27 @@ module ActiveEntity
       def init_internals
         @readonly                 = false
         @marked_for_destruction   = false
-      end
 
-      def initialize_internals_callback
+        self.class.define_attribute_methods
       end
 
-      def thaw
-        if frozen?
-          @attributes = @attributes.dup
-        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 = DelegateClass(::String).new(ActiveSupport::ParameterFilter::FILTERED)
-          def mask.pretty_print(pp)
-            pp.text __getobj__
-          end
+          mask = InspectionMask.new(ActiveSupport::ParameterFilter::FILTERED)
           ActiveSupport::ParameterFilter.new(self.class.filter_attributes, mask: mask)
         end
       end

data/lib/active_entity/enum.rb

@@ -27,6 +27,32 @@ module ActiveEntity
   #   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
@@ -97,12 +123,12 @@ module ActiveEntity
       end
 
       def cast(value)
-        return if value.blank?
-
         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
@@ -124,6 +150,7 @@ module ActiveEntity
       end
 
       private
+
         attr_reader :name, :mapping, :subtype
     end
 
@@ -182,6 +209,7 @@ module ActiveEntity
     end
 
     private
+
       def _enum_methods_module
         @_enum_methods_module ||= begin
           mod = Module.new
@@ -212,8 +240,6 @@ module ActiveEntity
       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 && method_defined_within?(method_name, Relation)
-        #   raise_conflict_error(enum_name, method_name, type: "class", source: Relation.name)
         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)

data/lib/active_entity/errors.rb

@@ -7,13 +7,6 @@ module ActiveEntity
   class ActiveEntityError < StandardError
   end
 
-  # Raised when the single-table inheritance mechanism fails to locate the subclass
-  # (for example due to improper usage of column that
-  # {ActiveEntity::Base.inheritance_attribute}[rdoc-ref:ModelSchema::ClassMethods#inheritance_attribute]
-  # points to).
-  class SubclassNotFound < ActiveEntityError
-  end
-
   # Raised when an object assigned to an association has an incorrect type.
   #
   #   class Ticket < ActiveEntity::Base
@@ -41,10 +34,6 @@ module ActiveEntity
   class ConfigurationError < ActiveEntityError
   end
 
-  # Raised on attempt to update record that is instantiated as read only.
-  class ReadOnlyRecord < 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