nobrainer 0.22.0 → 0.28.0

data/lib/no_brainer/document/association/belongs_to.rb

@@ -4,45 +4,72 @@ class NoBrainer::Document::Association::BelongsTo
   class Metadata
     VALID_OPTIONS = [:primary_key, :foreign_key, :class_name, :foreign_key_store_as, :index, :validates, :required]
     include NoBrainer::Document::Association::Core::Metadata
-    extend NoBrainer::Document::Association::EagerLoader::Generic
+    include NoBrainer::Document::Association::EagerLoader::Generic
 
     def foreign_key
-      # TODO test :foreign_key
       options[:foreign_key].try(:to_sym) || :"#{target_name}_#{primary_key}"
     end
 
     def primary_key
-      # TODO test :primary_key
-      options[:primary_key].try(:to_sym) || target_model.pk_name
+      # We default the primary_key to `:id' and not `target_model.pk_name',
+      # because we don't want to require the target_model to be already loaded.
+      # (We want the ability to load models in any order).
+      # Using target_model.pk_name and allowing lazy loading of models is
+      # difficult due to the inexistant API to remove validations if the
+      # foreign_key name was to be changed as the pk_name gets renamed.
+      return options[:primary_key].to_sym if options[:primary_key]
+
+      NoBrainer::Document::PrimaryKey::DEFAULT_PK_NAME.tap do |default_pk_name|
+        # We'll try to give a warning when we see a different target pk name (best effort).
+        real_pk_name = target_model.pk_name rescue nil
+        if real_pk_name && real_pk_name != default_pk_name
+          raise "Please specify the primary_key name on the following belongs_to association as such:\n" +
+                "  belongs_to :#{target_name}, :primary_key => :#{real_pk_name}"
+        end
+      end
     end
 
     def target_model
-      # TODO test :class_name
-      (options[:class_name] || target_name.to_s.camelize).constantize
+      get_model_by_name(options[:class_name] || target_name.to_s.camelize)
     end
 
     def base_criteria
-      target_model.unscoped
+      target_model.without_ordering.unscoped
     end
 
     def hook
       super
 
-      # TODO It would be good to set the type we want to work with, but because
-      # the target class is eager loaded, we are not doing it.
-      # This would have the effect of loading all the models because they
-      # are likely to be related to each other. So we don't know the type
-      # of the primary key of the target.
+      # TODO set the type of the foreign key to be the same as the target's primary key
+      if owner_model.association_metadata.values.any? { |assoc|
+          assoc.is_a?(self.class) && assoc != self && assoc.foreign_key == foreign_key }
+        raise "Cannot declare `#{target_name}' in #{owner_model}: the foreign_key `#{foreign_key}' is already used"
+      end
+
       owner_model.field(foreign_key, :store_as => options[:foreign_key_store_as], :index => options[:index])
-      owner_model.validates(target_name, :presence => options[:required]) if options[:required]
-      owner_model.validates(target_name, options[:validates]) if options[:validates]
+
+      unless options[:validates] == false
+        owner_model.validates(target_name, options[:validates]) if options[:validates]
+
+        if options[:required]
+          owner_model.validates(target_name, :presence => options[:required])
+        else
+          # Always validate the validity of the foreign_key if not nil.
+          owner_model.validates_each(foreign_key) do |doc, attr, value|
+            if !value.nil? && doc.read_attribute_for_validation(target_name).nil?
+              doc.errors.add(attr, :invalid_foreign_key, :target_model => target_model, :primary_key => primary_key)
+            end
+          end
+        end
+      end
 
       delegate("#{foreign_key}=", :assign_foreign_key, :call_super => true)
       delegate("#{target_name}_changed?", "#{foreign_key}_changed?", :to => :self)
       add_callback_for(:after_validation)
     end
 
-    eager_load_with :owner_key => ->{ foreign_key }, :target_key => ->{ primary_key }
+    def eager_load_owner_key;  foreign_key; end
+    def eager_load_target_key; primary_key; end
   end
 
   # Note:
@@ -58,13 +85,13 @@ class NoBrainer::Document::Association::BelongsTo
     return target if loaded?
 
     if fk = owner.read_attribute(foreign_key)
-      preload(target_model.unscoped.where(primary_key => fk).first)
+      preload(base_criteria.where(primary_key => fk).first)
     end
   end
 
   def write(target)
     assert_target_type(target)
-    owner.write_attribute(foreign_key, target.try(:pk_value))
+    owner.write_attribute(foreign_key, target.try(primary_key))
     preload(target)
   end
 

data/lib/no_brainer/document/association/core.rb

@@ -46,6 +46,17 @@ module NoBrainer::Document::Association::Core
         end
       RUBY
     end
+
+    def get_model_by_name(model_name)
+      return model_name if model_name.is_a?(Module)
+
+      model_name = model_name.to_s
+      current_module = @owner_model.parent
+      return model_name.constantize if current_module == Object
+      return model_name.constantize if model_name =~ /^::/
+      return model_name.constantize if !current_module.const_defined?(model_name)
+      current_module.const_get(model_name)
+    end
   end
 
   included { attr_accessor :metadata, :owner }

data/lib/no_brainer/document/association/eager_loader.rb

@@ -1,31 +1,32 @@
-class NoBrainer::Document::Association::EagerLoader
+module NoBrainer::Document::Association::EagerLoader
+  extend self
+
   module Generic
     # Used in associations to declare generic eager loading capabilities
-    # The association should implement loaded? and preload.
-    def eager_load_with(options={})
-      define_method(:eager_load) do |docs, additional_criteria=nil|
-        owner_key  = instance_exec(&options[:owner_key])
-        target_key = instance_exec(&options[:target_key])
-
-        criteria = base_criteria
-        criteria = criteria.merge(additional_criteria) if additional_criteria
-
-        unloaded_docs = docs.reject { |doc| doc.associations[self].loaded? }
-
-        owner_keys = unloaded_docs.map(&owner_key).compact.uniq
-        if owner_keys.present?
-          targets = criteria.where(target_key.in => owner_keys)
-                            .map { |target| [target.read_attribute(target_key), target] }
-                            .each_with_object(Hash.new { |k,v| k[v] = [] }) { |(k,v),h| h[k] << v }
-
-          unloaded_docs.each do |doc|
-            doc_targets = targets[doc.read_attribute(owner_key)]
-            doc.associations[self].preload(doc_targets)
-          end
-        end
+    # The association should implement loaded?, preload,
+    # eager_load_owner_key and eager_load_target_key.
+    def eager_load(docs, additional_criteria=nil)
+      owner_key  = eager_load_owner_key
+      target_key = eager_load_target_key
+
+      criteria = base_criteria
+      criteria = criteria.merge(additional_criteria) if additional_criteria
+
+      unloaded_docs = docs.reject { |doc| doc.associations[self].loaded? }
 
-        docs.map { |doc| doc.associations[self].read }.flatten.compact.uniq
+      owner_keys = unloaded_docs.map(&owner_key).compact.uniq
+      if owner_keys.present?
+        targets = criteria.where(target_key.in => owner_keys)
+        .map { |target| [target.read_attribute(target_key), target] }
+        .each_with_object(Hash.new { |k,v| k[v] = [] }) { |(k,v),h| h[k] << v }
+
+        unloaded_docs.each do |doc|
+          doc_targets = targets[doc.read_attribute(owner_key)]
+          doc.associations[self].preload(doc_targets)
+        end
       end
+
+      docs.map { |doc| doc.associations[self].read }.flatten.compact.uniq
     end
   end
 
@@ -33,7 +34,6 @@ class NoBrainer::Document::Association::EagerLoader
     docs = docs.compact
     return [] if docs.empty?
     meta = docs.first.root_class.association_metadata
-    # TODO test the singularize thingy.
     association = meta[association_name.to_sym] || meta[association_name.to_s.singularize.to_sym]
     raise "Unknown association #{association_name}" unless association
     association.eager_load(docs, criteria)
@@ -41,7 +41,7 @@ class NoBrainer::Document::Association::EagerLoader
 
   def eager_load(docs, what)
     case what
-    when Hash  then what.each do |k,v|
+    when Hash then what.each do |k,v|
       if v.is_a?(NoBrainer::Criteria)
         v = v.dup
         nested_preloads, v.options[:eager_load] = v.options[:eager_load], []

data/lib/no_brainer/document/association/has_many.rb

@@ -4,21 +4,18 @@ class NoBrainer::Document::Association::HasMany
   class Metadata
     VALID_OPTIONS = [:primary_key, :foreign_key, :class_name, :dependent, :scope]
     include NoBrainer::Document::Association::Core::Metadata
-    extend NoBrainer::Document::Association::EagerLoader::Generic
+    include NoBrainer::Document::Association::EagerLoader::Generic
 
     def foreign_key
-      # TODO test :foreign_key
-      options[:foreign_key].try(:to_sym) || :"#{owner_model.name.underscore}_#{owner_model.pk_name}"
+      options[:foreign_key].try(:to_sym) || :"#{owner_model.name.split('::').last.underscore}_#{primary_key}"
     end
 
     def primary_key
-      # TODO test :primary_key
-      options[:primary_key].try(:to_sym) || target_model.pk_name
+      options[:primary_key].try(:to_sym) || owner_model.pk_name
     end
 
     def target_model
-      # TODO test :class_name
-      (options[:class_name] || target_name.to_s.singularize.camelize).constantize
+      get_model_by_name(options[:class_name] || target_name.to_s.singularize.camelize)
     end
 
     def base_criteria
@@ -56,11 +53,12 @@ class NoBrainer::Document::Association::HasMany
       end
     end
 
-    eager_load_with :owner_key => ->{ primary_key }, :target_key => ->{ foreign_key }
+    def eager_load_owner_key;  primary_key; end
+    def eager_load_target_key; foreign_key; end
   end
 
   def target_criteria
-    @target_criteria ||= base_criteria.where(foreign_key => owner.pk_value)
+    @target_criteria ||= base_criteria.where(foreign_key => owner.__send__(primary_key))
                                       .after_find(set_inverse_proc)
   end
 

data/lib/no_brainer/document/association/has_many_through.rb

@@ -17,7 +17,7 @@ class NoBrainer::Document::Association::HasManyThrough
     def eager_load(docs, additional_criteria=nil)
       criteria = target_model.instance_exec(&options[:scope]) if options[:scope]
       criteria = criteria ? criteria.merge(additional_criteria) : additional_criteria if additional_criteria
-      NoBrainer::Document::Association::EagerLoader.new
+      NoBrainer::Document::Association::EagerLoader
         .eager_load_association(through_association.eager_load(docs), target_name, criteria)
     end
 
@@ -29,7 +29,6 @@ class NoBrainer::Document::Association::HasManyThrough
   end
 
   def read
-    # TODO implement joins
     @targets ||= metadata.eager_load([owner]).freeze
   end
 

data/lib/no_brainer/document/association/has_one.rb

@@ -1,7 +1,11 @@
 class NoBrainer::Document::Association::HasOne < NoBrainer::Document::Association::HasMany
   class Metadata < NoBrainer::Document::Association::HasMany::Metadata
     def target_model
-      (options[:class_name] || target_name.to_s.camelize).constantize
+      get_model_by_name(options[:class_name] || target_name.to_s.camelize)
+    end
+
+    def base_criteria
+      super.without_ordering
     end
   end
 

data/lib/no_brainer/document/association.rb

@@ -28,11 +28,11 @@ module NoBrainer::Document::Association
           raise "Cannot change the :through option" unless r.options[:through] == options[:through]
           r.options.merge!(options)
         else
-          model_name = (options[:through] ? "#{association}_through" : association.to_s).camelize
-          metadata_model = NoBrainer::Document::Association.const_get(model_name).const_get(:Metadata)
-          r = metadata_model.new(self, target, options)
-          ([self] + descendants).each do |model|
-            model.association_metadata[target] = r
+          class_name = (options[:through] ? "#{association}_through" : association.to_s).camelize
+          metadata_class = NoBrainer::Document::Association.const_get(class_name).const_get(:Metadata)
+          r = metadata_class.new(self, target, options)
+          subclass_tree.each do |subclass|
+            subclass.association_metadata[target] = r
           end
         end
         r.hook

data/lib/no_brainer/document/atomic_ops.rb

@@ -42,7 +42,7 @@ module NoBrainer::Document::AtomicOps
     def to_s
       "<`#{@field}' with #{@ops.size} pending atomic operations>"
     end
-    alias_method :inspect, :to_s
+    def inspect; to_s; end
 
     def method_missing(method, *a, &b)
       if method == :<<
@@ -56,14 +56,20 @@ module NoBrainer::Document::AtomicOps
 
     def compile_rql_value(rql_doc)
       field = @instance.class.lookup_field_alias(@field)
-      value = @is_user_value ? RethinkDB::RQL.new.expr(@value) : rql_doc[field]
+      if @is_user_value
+        casted_value = @instance.class.cast_model_to_db_for(@field, @value)
+        value = RethinkDB::RQL.new.expr(casted_value)
+      else
+        value = rql_doc[field]
+      end
       value = value.default(default_value) if default_value
       @ops.reduce(value) { |v, (method, a, b)| v.__send__(method, *a, &b) }
     end
 
     def modify_source!
-      unless @instance._is_attribute_touched?(@field)
-        @instance.write_attribute(@field, self)
+      if (@is_user_value && @instance.instance_eval { @_attributes[@field].equal?(@value) }) ||
+          !@instance._is_attribute_touched?(@field)
+        @instance._write_attribute(@field, self)
       end
     end
   end
@@ -125,6 +131,18 @@ module NoBrainer::Document::AtomicOps
     end
   end
 
+  class PendingAtomicUnset < PendingAtomic
+    def to_s
+      "<unset `#{@field}'>"
+    end
+
+    undef_method(:method_missing)
+
+    def compile_rql_value(rql_doc)
+      RethinkDB::RQL.new.literal()
+    end
+  end
+
   def clear_dirtiness(options={})
     super
     @_touched_attributes = Set.new
@@ -166,13 +184,18 @@ module NoBrainer::Document::AtomicOps
   end
 
   def _read_attribute(name)
+    return super if name == self.class.pk_name
+
     ensure_exclusive_atomic!
-    value = super
-    return value unless in_atomic?
+    return super unless in_atomic?
+
+    # If we are missing fields, it's okay, we'll assume nil.
+    value = missing_field?(name) ? nil : super
 
     case value
     when PendingAtomicContainer then value
-    when PendingAtomic then value.dup
+    when PendingAtomicUnset     then raise "Attribute `#{name}' is unset"
+    when PendingAtomic          then value.dup
     else PendingAtomic._new(self, name, value, _is_attribute_touched?(name))
     end
   end
@@ -193,6 +216,11 @@ module NoBrainer::Document::AtomicOps
     super
   end
 
+  def unset(attr)
+    return queue_atomic { unset(attr) } unless in_atomic?
+    _write_attribute(attr, PendingAtomicUnset.new(self, attr, nil, true, nil))
+  end
+
   def save?(options={})
     # TODO allow reload => true as an option to save+reload in a single op.
     raise NoBrainer::Error::AtomicBlock.new('You may persist documents only outside of queue_atomic blocks') if in_atomic?
@@ -206,6 +234,11 @@ module NoBrainer::Document::AtomicOps
     end
   end
 
+  def reload(*)
+    raise NoBrainer::Error::AtomicBlock.new('You may not reload fields within an atomic block') if in_atomic?
+    super
+  end
+
   module ClassMethods
     def persistable_value(k, v, options={})
       v.is_a?(PendingAtomic) ? v.compile_rql_value(options[:rql_doc]) : super

data/lib/no_brainer/document/attributes.rb

@@ -1,8 +1,9 @@
 module NoBrainer::Document::Attributes
   VALID_FIELD_OPTIONS = [:index, :default, :type, :readonly, :primary_key, :lazy_fetch, :store_as,
                          :validates, :required, :unique, :uniq, :format, :in, :length, :min_length, :max_length]
-  RESERVED_FIELD_NAMES = [:index, :default, :and, :or, :selector, :associations, :pk_value] \
-                          + NoBrainer::Criteria::Where::OPERATORS
+  RESERVED_FIELD_NAMES = [:index, :default, :and, :or, :selector, :associations, :pk_value] +
+                          NoBrainer::SymbolDecoration::OPERATORS
+
   extend ActiveSupport::Concern
   include ActiveModel::ForbiddenAttributesProtection
 
@@ -48,8 +49,10 @@ module NoBrainer::Document::Attributes
 
   def assign_defaults(options)
     self.class.fields.each do |name, field_options|
-      next unless field_options.has_key?(:default) &&
-                  !@_attributes.has_key?(name)
+      # :default => nil will not set the value to nil, but :default => ->{ nil } will.
+      # This is useful to unset a default value.
+
+      next if field_options[:default].nil? || @_attributes.key?(name)
 
       if opt = options[:missing_attributes]
         if (opt[:pluck] && !opt[:pluck][name]) ||
@@ -112,8 +115,14 @@ module NoBrainer::Document::Attributes
       super
     end
 
+    # The different between _field and field is that field can set other options
+    # (c.f. primary key module). _field always receive an immutable options list.
     def _field(attr, options={})
-      # Using a layer so the user can use super when overriding these methods
+      options.assert_valid_keys(*VALID_FIELD_OPTIONS)
+      if attr.in?(RESERVED_FIELD_NAMES)
+        raise "The field name `:#{attr}' is reserved. Please use another one."
+      end
+
       attr = attr.to_s
       inject_in_layer :attributes do
         define_method("#{attr}=") { |value| _write_attribute(attr, value) }
@@ -124,14 +133,9 @@ module NoBrainer::Document::Attributes
     def field(attr, options={})
       attr = attr.to_sym
 
-      options.assert_valid_keys(*VALID_FIELD_OPTIONS)
-      if attr.in?(RESERVED_FIELD_NAMES)
-        raise "Cannot use a reserved field attr: #{attr}"
-      end
-
-      ([self] + descendants).each do |model|
-        model.fields[attr] ||= {}
-        model.fields[attr].deep_merge!(options)
+      subclass_tree.each do |subclass|
+        subclass.fields[attr] ||= {}
+        subclass.fields[attr].deep_merge!(options)
       end
 
       _field(attr, self.fields[attr])
@@ -149,13 +153,18 @@ module NoBrainer::Document::Attributes
 
       _remove_field(attr, options)
 
-      ([self] + descendants).each do |model|
-        model.fields.delete(attr)
+      subclass_tree.each do |subclass|
+        subclass.fields.delete(attr)
       end
     end
 
     def has_field?(attr)
       !!fields[attr.to_sym]
     end
+
+    def ensure_valid_key!(key)
+      return if has_field?(key) || has_index?(key)
+      raise NoBrainer::Error::UnknownAttribute, "`#{key}' is not a valid attribute of #{self}"
+    end
   end
 end

data/lib/no_brainer/document/callbacks.rb

@@ -20,7 +20,7 @@ module NoBrainer::Document::Callbacks
     run_callbacks(:update) { super }
   end
 
-  def _save?(*args, &block)
+  def save?(*args, &block)
     run_callbacks(:save) { super }
   end
 

data/lib/no_brainer/document/core.rb

@@ -1,30 +1,30 @@
 module NoBrainer::Document::Core
   extend ActiveSupport::Concern
 
-  singleton_class.class_eval do
-    attr_accessor :_all, :_all_nobrainer
-
-    def all
-      Rails.application.eager_load! if defined?(Rails.application.eager_load!)
-      @_all
-    end
-  end
+  singleton_class.class_eval { attr_accessor :_all }
   self._all = []
-  self._all_nobrainer = []
-
-  include ActiveModel::Conversion
-
-  def to_key
-     # ActiveModel::Conversion stuff
-    [pk_value]
-  end
 
   included do
     # TODO test these includes
     extend ActiveModel::Naming
     extend ActiveModel::Translation
 
-    list_name = self.name =~ /^NoBrainer::/ ? :_all_nobrainer : :_all
-    NoBrainer::Document::Core.__send__(list_name) << self
+    NoBrainer::Document::Core._all << self unless name =~ /^NoBrainer::/
+  end
+
+  def self.all(options={})
+    (options[:types] || [:user]).map do |type|
+      case type
+      when :user
+        Rails.application.eager_load! if defined?(Rails.application.eager_load!)
+        _all
+      when :nobrainer
+        [NoBrainer::Document::Index::MetaStore, NoBrainer::Lock]
+      when :system
+        NoBrainer::System.constants
+          .map { |c| NoBrainer::System.const_get(c) }
+          .select { |m| m < NoBrainer::Document }
+      end
+    end.reduce([], &:+)
   end
 end

data/lib/no_brainer/document/criteria.rb

@@ -17,8 +17,8 @@ module NoBrainer::Document::Criteria
              :raw,                           # Raw
              :limit, :offset, :skip,         # Limit
              :order_by, :reverse_order, :without_ordering, :order_by_indexed?, :order_by_index_name, # OrderBy
-             :scoped, :unscoped,             # Scope
-             :where, :where_indexed?, :where_index_name, :where_index_type, # Where
+             :unscoped,                      # Scope
+             :_where, :where, :where_indexed?, :where_index_name, :where_index_type, # Where
              :with_index, :without_index, :used_index, # Index
              :with_cache, :without_cache,    # Cache
              :count, :empty?, :any?,         # Count
@@ -26,14 +26,18 @@ module NoBrainer::Document::Criteria
              :preload, :eager_load,          # EagerLoad
              :each, :to_a,                   # Enumerable
              :first, :last, :first!, :last!, :sample, # First
+             :upsert, :upsert!, :first_or_create, :first_or_create!, # FirstOrCreate
              :min, :max, :sum, :avg,         # Aggregate
              :update_all, :replace_all,      # Update
+             :changes,                       # Changes
              :pluck, :without, :lazy_fetch, :without_plucking, # Pluck
              :find_by?, :find_by, :find_by!, :find?, :find, :find!, # Find
+             :join,                          #Join
              :to => :all
 
     def all
-      NoBrainer::Criteria.new(:model => self)
+      NoBrainer::Criteria.new(:initial_run_options => NoBrainer.current_run_options,
+                              :model => self)
     end
 
     def scope(name, criteria=nil, &block)
@@ -48,8 +52,8 @@ module NoBrainer::Document::Criteria
       criteria_proc = block || (criteria.is_a?(Proc) ? criteria : proc { criteria })
       raise "default_scope only accepts a criteria or a proc that returns criteria" unless criteria_proc.is_a?(Proc)
 
-      ([self] + self.descendants).each do |model|
-        model.default_scopes << criteria_proc
+      subclass_tree.each do |subclass|
+        subclass.default_scopes << criteria_proc
       end
     end
 

data/lib/no_brainer/document/dirty.rb

@@ -1,10 +1,11 @@
 module NoBrainer::Document::Dirty
   extend ActiveSupport::Concern
-  # We need to save the changes as seen through read_attribute because
-  # the user sees attributes through the read_attribute getters.
-  # But we want to detect changes based on @_attributes to track
-  # things like undefined -> nil. Going through the getters will
-  # not give us that.
+  # 1) We should save the changes as seen through read_attribute, because the
+  # user sees attributes through the read_attribute getters, but it's near
+  # impossible because we would need to wrap the user defined getters, so we'll
+  # go through _read_attribute.
+  # 2) We want to detect changes based on @_attributes to track things like
+  # undefined -> nil. Going through the getters will not give us that.
 
   def _create(*args)
     super.tap { clear_dirtiness }
@@ -17,7 +18,9 @@ module NoBrainer::Document::Dirty
   def clear_dirtiness(options={})
     if options[:keep_ivars] && options[:missing_attributes].try(:[], :pluck)
       attrs = options[:missing_attributes][:pluck].keys
-      @_old_attributes = @_old_attributes.reject { |k,v| attrs.include?(k) } else @_old_attributes = {}.with_indifferent_access
+      @_old_attributes = @_old_attributes.reject { |k,v| attrs.include?(k) }
+    else
+      @_old_attributes = {}.with_indifferent_access
     end
 
     @_old_attributes_keys = @_attributes.keys # to track undefined -> nil changes
@@ -34,7 +37,7 @@ module NoBrainer::Document::Dirty
   def changes
     result = {}.with_indifferent_access
     @_old_attributes.each do |attr, old_value|
-      current_value = read_attribute(attr)
+      current_value = _read_attribute(attr)
       if current_value != old_value || !@_old_attributes_keys.include?(attr)
         result[attr] = [old_value, current_value]
       end
@@ -47,13 +50,13 @@ module NoBrainer::Document::Dirty
     if current_value == None
       current_value = begin
         assert_access_field(attr)
-        read_attribute(attr)
+        _read_attribute(attr)
       rescue NoBrainer::Error::MissingAttribute => e
         e
       end
     end
 
-    unless @_old_attributes.has_key?(attr)
+    unless @_old_attributes.key?(attr)
       @_old_attributes[attr] = current_value.deep_dup
     end
   end
@@ -78,8 +81,8 @@ module NoBrainer::Document::Dirty
 
       inject_in_layer :dirty_tracking do
         define_method("#{attr}_change") do
-          if @_old_attributes.has_key?(attr)
-            result = [@_old_attributes[attr], read_attribute(attr)]
+          if @_old_attributes.key?(attr)
+            result = [@_old_attributes[attr], _read_attribute(attr)]
             result if result.first != result.last || !@_old_attributes_keys.include?(attr)
           end
         end
@@ -89,7 +92,7 @@ module NoBrainer::Document::Dirty
         end
 
         define_method("#{attr}_was") do
-          @_old_attributes.has_key?(attr) ? @_old_attributes[attr] : read_attribute(attr)
+          @_old_attributes.key?(attr) ? @_old_attributes[attr] : _read_attribute(attr)
         end
       end
     end

data/lib/no_brainer/document/dynamic_attributes.rb

@@ -12,4 +12,10 @@ module NoBrainer::Document::DynamicAttributes
   def readable_attributes
     @_attributes.keys
   end
+
+  module ClassMethods
+    def ensure_valid_key!(key)
+      # we never raise
+    end
+  end
 end