activeentity 0.0.1.beta14 → 0.0.1.beta15

data/lib/active_entity/attribute_methods.rb

@@ -16,6 +16,7 @@ module ActiveEntity
       include Query
       include PrimaryKey
       include TimeZoneConversion
+      include Dirty
       include Serialization
     end
 
@@ -32,7 +33,8 @@ module ActiveEntity
       end
 
       def initialize_generated_modules # :nodoc:
-        @generated_attribute_methods = GeneratedAttributeMethods.new
+        @generated_attribute_methods = const_set(:GeneratedAttributeMethods, GeneratedAttributeMethods.new)
+        private_constant :GeneratedAttributeMethods
         @attribute_methods_generated = false
         include @generated_attribute_methods
 
@@ -111,13 +113,11 @@ module ActiveEntity
       # A class method is 'dangerous' if it is already (re)defined by Active Entity, but
       # not by any ancestors. (So 'puts' is not dangerous but 'new' is.)
       def dangerous_class_method?(method_name)
-        RESTRICTED_CLASS_METHODS.include?(method_name.to_s) || class_method_defined_within?(method_name, Base)
-      end
+        return true if RESTRICTED_CLASS_METHODS.include?(method_name.to_s)
 
-      def class_method_defined_within?(name, klass, superklass = klass.superclass) # :nodoc:
-        if klass.respond_to?(name, true)
-          if superklass.respond_to?(name, true)
-            klass.method(name).owner != superklass.method(name).owner
+        if Base.respond_to?(method_name, true)
+          if Object.respond_to?(method_name, true)
+            Base.method(method_name).owner != Object.method(method_name).owner
           else
             true
           end
@@ -126,8 +126,8 @@ module ActiveEntity
         end
       end
 
-      # Returns an array of column names as strings if it's not an abstract class and
-      # table exists. Otherwise it returns an empty array.
+      # Returns an array of column names as strings if it's not an abstract class.
+      # Otherwise it returns an empty array.
       #
       #   class Person < ActiveEntity::Base
       #   end
@@ -302,6 +302,7 @@ module ActiveEntity
     end
 
     private
+
       def attribute_method?(attr_name)
         # We check defined? because Syck calls respond_to? before actually calling initialize.
         defined?(@attributes) && @attributes.key?(attr_name)
@@ -323,8 +324,8 @@ module ActiveEntity
         end
       end
 
-      def readonly_attribute?(name)
-        self.class.readonly_attributes.include?(name)
+      def pk_attribute?(name)
+        name == @primary_key
       end
   end
 end

data/lib/active_entity/attribute_methods/before_type_cast.rb

@@ -65,7 +65,7 @@ module ActiveEntity
 
       private
 
-        # Handle *_before_type_cast for method_missing.
+        # Dispatch target for <tt>*_before_type_cast</tt> attribute methods.
         def attribute_before_type_cast(attribute_name)
           read_attribute_before_type_cast(attribute_name)
         end

data/lib/active_entity/attribute_methods/dirty.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+require "active_support/core_ext/module/attribute_accessors"
+
+module ActiveEntity
+  module AttributeMethods
+    module Dirty
+      extend ActiveSupport::Concern
+
+      include ActiveModel::Dirty
+    end
+  end
+end

data/lib/active_entity/attribute_methods/primary_key.rb

@@ -90,7 +90,7 @@ module ActiveEntity
           #
           #   Project.primary_key # => "foo_id"
           def primary_key=(value)
-            @primary_key = value&.to_s
+            @primary_key = value && -value.to_s
           end
         end
     end

data/lib/active_entity/attribute_methods/query.rb

@@ -16,17 +16,24 @@ module ActiveEntity
         when true        then true
         when false, nil  then false
         else
-          if Numeric === value || value !~ /[^0-9]/
-            !value.to_i.zero?
+          if !type_for_attribute(attr_name) { false }
+            if Numeric === value || !value.match?(/[^0-9]/)
+              !value.to_i.zero?
+            else
+              return false if ActiveModel::Type::Boolean::FALSE_VALUES.include?(value)
+              !value.blank?
+            end
+          elsif value.respond_to?(:zero?)
+            !value.zero?
           else
-            return false if ActiveModel::Type::Boolean::FALSE_VALUES.include?(value)
             !value.blank?
           end
         end
       end
 
       private
-        # Handle *? for method_missing.
+
+        # Dispatch target for <tt>*?</tt> attribute methods.
         def attribute?(attribute_name)
           query_attribute(attribute_name)
         end

data/lib/active_entity/attribute_methods/read.rb

@@ -27,9 +27,7 @@ module ActiveEntity
       # to a date object, like Date.new(2004, 12, 12)).
       def read_attribute(attr_name, &block)
         name = attr_name.to_s
-        if self.class.attribute_alias?(name)
-          name = self.class.attribute_alias(name)
-        end
+        name = self.class.attribute_aliases[name] || name
 
         _read_attribute(name, &block)
       end

data/lib/active_entity/attribute_methods/time_zone_conversion.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require "active_support/core_ext/object/try"
+
 module ActiveEntity
   module AttributeMethods
     module TimeZoneConversion

data/lib/active_entity/attribute_methods/write.rb

@@ -31,9 +31,7 @@ module ActiveEntity
       # turned into +nil+.
       def write_attribute(attr_name, value)
         name = attr_name.to_s
-        if self.class.attribute_alias?(name)
-          name = self.class.attribute_alias(name)
-        end
+        name = self.class.attribute_aliases[name] || name
 
         _write_attribute(name, value)
       end
@@ -48,13 +46,13 @@ module ActiveEntity
       end
 
       private
+
         def write_attribute_without_type_cast(attr_name, value)
-          name = attr_name.to_s
-          @attributes.write_cast_value(name, value)
+          @attributes.write_cast_value(attr_name.to_s, value)
           value
         end
 
-        # Handle *= for method_missing.
+        # Dispatch target for <tt>*=</tt> attribute methods.
         def attribute=(attribute_name, value)
           _write_attribute(attribute_name, value)
         end

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,12 @@
 # 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 +18,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
   #
@@ -292,8 +282,9 @@ module ActiveEntity #:nodoc:
     include AttributeDecorators
     include DefineCallbacks
     include AttributeMethods
+    include Callbacks
     include Associations
-    include ValidateEmbeddedAssociation
+    include ValidateEmbedsAssociation
     include NestedAttributes
     include Reflection
     include Serialization

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