nobrainer 0.20.0 → 0.21.0

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

@@ -21,6 +21,10 @@ class NoBrainer::Document::Association::BelongsTo
       (options[:class_name] || target_name.to_s.camelize).constantize
     end
 
+    def base_criteria
+      target_model.unscoped
+    end
+
     def hook
       super
 
@@ -34,11 +38,11 @@ class NoBrainer::Document::Association::BelongsTo
       owner_model.validates(target_name, options[:validates]) if options[:validates]
 
       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 },
-                    :unscoped => true
+    eager_load_with :owner_key => ->{ foreign_key }, :target_key => ->{ primary_key }
   end
 
   # Note:

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

@@ -20,12 +20,13 @@ module NoBrainer::Document::Association::Core
       association_model.new(self, owner)
     end
 
-    def delegate(method_name, target, options={})
+    def delegate(method_src, method_dst, options={})
       metadata = self
       owner_model.inject_in_layer :associations do
-        define_method(method_name) do |*args, &block|
+        define_method(method_src) do |*args, &block|
           super(*args, &block) if options[:call_super]
-          associations[metadata].__send__(target, *args, &block)
+          target = options[:to] == :self ? self : associations[metadata]
+          target.__send__(method_dst, *args, &block)
         end
       end
     end
@@ -49,7 +50,7 @@ module NoBrainer::Document::Association::Core
 
   included { attr_accessor :metadata, :owner }
 
-  delegate :primary_key, :foreign_key, :target_name, :target_model, :to => :metadata
+  delegate :primary_key, :foreign_key, :target_name, :target_model, :base_criteria, :to => :metadata
 
   def initialize(metadata, owner)
     @metadata, @owner = metadata, owner

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

@@ -7,9 +7,8 @@ class NoBrainer::Document::Association::EagerLoader
         owner_key  = instance_exec(&options[:owner_key])
         target_key = instance_exec(&options[:target_key])
 
-        criteria = target_model.all
+        criteria = base_criteria
         criteria = criteria.merge(additional_criteria) if additional_criteria
-        criteria = criteria.unscoped if options[:unscoped]
 
         unloaded_docs = docs.reject { |doc| doc.associations[self].loaded? }
 
@@ -40,20 +39,20 @@ class NoBrainer::Document::Association::EagerLoader
     association.eager_load(docs, criteria)
   end
 
-  def eager_load(docs, preloads)
-    case preloads
-    when Hash  then preloads.each do |k,v|
+  def eager_load(docs, what)
+    case what
+    when Hash  then what.each do |k,v|
       if v.is_a?(NoBrainer::Criteria)
         v = v.dup
-        nested_preloads, v.options[:preload] = v.options[:preload], []
+        nested_preloads, v.options[:eager_load] = v.options[:eager_load], []
         eager_load(eager_load_association(docs, k, v), nested_preloads)
       else
         eager_load(eager_load_association(docs, k), v)
       end
     end
-    when Array then preloads.each { |v| eager_load(docs, v) }
+    when Array then what.each { |v| eager_load(docs, v) }
     when nil then;
-    else eager_load_association(docs, preloads) # String and Symbol
+    else eager_load_association(docs, what) # String and Symbol
     end
     true
   end

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

@@ -2,7 +2,7 @@ class NoBrainer::Document::Association::HasMany
   include NoBrainer::Document::Association::Core
 
   class Metadata
-    VALID_OPTIONS = [:primary_key, :foreign_key, :class_name, :dependent]
+    VALID_OPTIONS = [:primary_key, :foreign_key, :class_name, :dependent, :scope]
     include NoBrainer::Document::Association::Core::Metadata
     extend NoBrainer::Document::Association::EagerLoader::Generic
 
@@ -21,6 +21,10 @@ class NoBrainer::Document::Association::HasMany
       (options[:class_name] || target_name.to_s.singularize.camelize).constantize
     end
 
+    def base_criteria
+      options[:scope] ? target_model.instance_exec(&options[:scope]) : target_model.all
+    end
+
     def inverses
       # We can always infer the inverse association of a has_many relationship,
       # because a belongs_to association cannot have a scope applied on the
@@ -37,15 +41,27 @@ class NoBrainer::Document::Association::HasMany
 
     def hook
       super
-      add_callback_for(:before_destroy) if options[:dependent]
+
+      if options[:scope]
+        raise ":scope must be passed a lambda like this: `:scope => ->{ where(...) }'" unless options[:scope].is_a?(Proc)
+        raise ":dependent and :scope cannot be used together" if options[:dependent]
+      end
+
+      if options[:dependent]
+        unless [:destroy, :delete, :nullify, :restrict, nil].include?(options[:dependent])
+          raise "Invalid dependent option: `#{options[:dependent].inspect}'. " +
+                "Valid options are: :destroy, :delete, :nullify, or :restrict"
+        end
+        add_callback_for(:before_destroy)
+      end
     end
 
     eager_load_with :owner_key => ->{ primary_key }, :target_key => ->{ foreign_key }
   end
 
   def target_criteria
-    @target_criteria ||= target_model.where(foreign_key => owner.pk_value)
-                                     .after_find(set_inverse_proc)
+    @target_criteria ||= base_criteria.where(foreign_key => owner.pk_value)
+                                      .after_find(set_inverse_proc)
   end
 
   def read
@@ -53,8 +69,8 @@ class NoBrainer::Document::Association::HasMany
   end
 
   def write(new_children)
-    raise "You can't assign #{target_name}. " \
-          "Instead, you must modify delete and create #{target_model} manually."
+    raise "You can't assign `#{target_name}'. " \
+          "Instead, you must modify delete and create `#{target_model}' manually."
   end
 
   def loaded?
@@ -86,12 +102,10 @@ class NoBrainer::Document::Association::HasMany
   def before_destroy_callback
     criteria = target_criteria.unscoped.without_cache
     case metadata.options[:dependent]
-    when nil       then
     when :destroy  then criteria.destroy_all
     when :delete   then criteria.delete_all
     when :nullify  then criteria.update_all(foreign_key => nil)
     when :restrict then raise NoBrainer::Error::ChildrenExist unless criteria.count.zero?
-    else raise "Unrecognized dependent option: #{metadata.options[:dependent]}"
     end
   end
 end

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

@@ -2,7 +2,7 @@ class NoBrainer::Document::Association::HasManyThrough
   include NoBrainer::Document::Association::Core
 
   class Metadata
-    VALID_OPTIONS = [:through]
+    VALID_OPTIONS = [:through, :scope]
     include NoBrainer::Document::Association::Core::Metadata
 
     def through_association_name
@@ -14,10 +14,18 @@ class NoBrainer::Document::Association::HasManyThrough
         raise "#{through_association_name} association not found"
     end
 
-    def eager_load(docs, criteria=nil)
+    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
         .eager_load_association(through_association.eager_load(docs), target_name, criteria)
     end
+
+    def target_model
+      meta = through_association.target_model.association_metadata
+      association = meta[target_name.to_sym] || meta[target_name.to_s.singularize.to_sym]
+      association.target_model
+    end
   end
 
   def read
@@ -26,6 +34,7 @@ class NoBrainer::Document::Association::HasManyThrough
   end
 
   def write(new_children)
-    raise "You can't assign #{target_name}"
+    raise "You can't assign `#{target_name}'. " \
+          "Instead, you must modify delete and create `#{target_model}' manually."
   end
 end

data/lib/no_brainer/document/atomic_ops.rb

@@ -2,22 +2,38 @@ module NoBrainer::Document::AtomicOps
   extend ActiveSupport::Concern
 
   class PendingAtomic
+    attr_accessor :type
+
     def self._new(instance, field, value, is_user_value)
-      case value
-      when Array then PendingAtomicArray
-      when Set   then PendingAtomicSet
+      type = instance.class.fields[field.to_sym].try(:[], :type)
+      type ||= value.class unless value.nil?
+
+      case
+      when type == Array then PendingAtomicArray
+      when type == Set   then PendingAtomicSet
       else self
-      end.new(instance, field, value, is_user_value)
+      end.new(instance, field, value, is_user_value, type)
     end
 
-    def initialize(instance, field, value, is_user_value)
+    def initialize(instance, field, value, is_user_value, type)
       @instance = instance
       @field = field.to_s
       @value = value
       @is_user_value = is_user_value
+      @type = type
       @ops = []
     end
 
+    def default_value
+      case
+      when @type == Array   then []
+      when @type == Set     then []
+      when @type == Integer then 0
+      when @type == Float   then 0.0
+      when @type == String  then ""
+      end
+    end
+
     def initialize_copy(other)
       super
       @ops = @ops.dup
@@ -29,6 +45,11 @@ module NoBrainer::Document::AtomicOps
     alias_method :inspect, :to_s
 
     def method_missing(method, *a, &b)
+      if method == :<<
+        method = :append
+        modify_source!
+      end
+
       @ops << [method, a, b]
       self
     end
@@ -36,11 +57,10 @@ 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]
+      value = value.default(default_value) if default_value
       @ops.reduce(value) { |v, (method, a, b)| v.__send__(method, *a, &b) }
     end
-  end
 
-  class PendingAtomicContainer < PendingAtomic
     def modify_source!
       unless @instance._is_attribute_touched?(@field)
         @instance.write_attribute(@field, self)
@@ -48,56 +68,59 @@ module NoBrainer::Document::AtomicOps
     end
   end
 
-  class PendingAtomicArray < PendingAtomicContainer
-    def -(value)
-      @ops << [:difference, [value.to_a]]
+  class PendingAtomicContainer < PendingAtomic
+    def &(value)
+      @ops << [:set_intersection, [value.to_a]]
       self
     end
-    def difference(v); self - v; end
+
+    def |(value)
+      @ops << [:set_union, [value.to_a]]
+      self
+    end
+
+    def add(v);          self + v; end
+    def difference(v);   self - v; end
+    def intersection(v); self & v; end
+    def union(v);        self | v; end
 
     def delete(value)
       difference([value])
     end
+  end
 
-    def +(value)
-      @ops << [:+, [value.to_a]]
+  class PendingAtomicSet < PendingAtomicContainer
+    def <<(value)
+      @ops << [:set_union, [[value]]]
+      modify_source!
       self
     end
-    def add(v); self + v; end
 
-    def &(value)
-      @ops << [:set_intersection, [value.to_a]]
+    def +(value)
+      @ops << [:set_union, [value.to_a]]
       self
     end
-    def intersection(v); self & v; end
 
-    def |(value)
-      @ops << [:set_union, [value.to_a]]
+    def -(value)
+      @ops << [:set_difference, [value.to_a]]
       self
     end
-    def union(v); self | v; end
+  end
 
+  class PendingAtomicArray < PendingAtomicContainer
     def <<(value)
       @ops << [:append, [value]]
       modify_source!
       self
     end
-  end
-
-  class PendingAtomicSet < PendingAtomicContainer
-    def -(value)
-      @ops << [:set_difference, [value.to_a]]
-      self
-    end
 
     def +(value)
-      @ops << [:set_union, [value.to_a]]
+      @ops << [:+, [value.to_a]]
       self
     end
 
-    def <<(value)
-      @ops << [:set_union, [[value]]]
-      modify_source!
+    def -(value)
+      @ops << [:difference, [value.to_a]]
       self
     end
   end
@@ -108,6 +131,9 @@ module NoBrainer::Document::AtomicOps
   end
 
   def _touch_attribute(name)
+    # The difference with dirty tracking and this is that dirty tracking does
+    # not take into account fields that are set with their old value, whereas the
+    # touched attribute does.
     @_touched_attributes << name.to_s
   end
 
@@ -142,12 +168,12 @@ module NoBrainer::Document::AtomicOps
   def _read_attribute(name)
     ensure_exclusive_atomic!
     value = super
+    return value unless in_atomic?
 
-    case [in_atomic?, value.is_a?(PendingAtomic)]
-    when [true, false]  then PendingAtomic._new(self, name, value, _is_attribute_touched?(name))
-    when [false, true]  then raise NoBrainer::Error::CannotReadAtomic.new(self, name, value)
-    when [true, true]   then value.is_a?(PendingAtomicContainer) ? value : value.dup
-    when [false, false] then value
+    case value
+    when PendingAtomicContainer then value
+    when PendingAtomic then value.dup
+    else PendingAtomic._new(self, name, value, _is_attribute_touched?(name))
     end
   end
 
@@ -174,39 +200,15 @@ module NoBrainer::Document::AtomicOps
       if saved
         @_attributes.each do |attr, value|
           next unless value.is_a?(PendingAtomic)
-          @_attributes[attr] = value.class.new(self, attr, nil, false)
+          @_attributes[attr] = value.class.new(self, attr, nil, false, value.type)
         end
       end
     end
   end
 
-  def read_attribute_for_change(attr)
-    super
-  rescue NoBrainer::Error::CannotReadAtomic => e
-    e.value
-  end
-
-  def read_attribute_for_validation(attr)
-    super
-  rescue NoBrainer::Error::CannotReadAtomic => e
-    e.value
-  end
-
   module ClassMethods
     def persistable_value(k, v, options={})
       v.is_a?(PendingAtomic) ? v.compile_rql_value(options[:rql_doc]) : super
     end
   end
 end
-
-class ActiveModel::EachValidator
-  # XXX Monkey Patching :(
-  def validate(record)
-    attributes.each do |attribute|
-      value = record.read_attribute_for_validation(attribute)
-      next if value.is_a?(NoBrainer::Document::AtomicOps::PendingAtomic) # <--- This is the added line
-      next if (value.nil? && options[:allow_nil]) || (value.blank? && options[:allow_blank])
-      validate_each(record, attribute, value)
-    end
-  end
-end

data/lib/no_brainer/document/attributes.rb

@@ -1,9 +1,10 @@
 module NoBrainer::Document::Attributes
   VALID_FIELD_OPTIONS = [:index, :default, :type, :readonly, :primary_key, :lazy_fetch, :store_as,
-                         :validates, :required, :unique, :uniq, :format, :in]
+                         :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
   extend ActiveSupport::Concern
+  include ActiveModel::ForbiddenAttributesProtection
 
   included do
     singleton_class.send(:attr_accessor, :fields)
@@ -23,6 +24,10 @@ module NoBrainer::Document::Attributes
     Hash[readable_attributes.map { |k| [k, read_attribute(k)] }].with_indifferent_access.freeze
   end
 
+  def raw_attributes
+    @_attributes
+  end
+
   def _read_attribute(name)
     @_attributes[name]
   end
@@ -54,12 +59,14 @@ module NoBrainer::Document::Attributes
       end
 
       default_value = field_options[:default]
-      default_value = default_value.call if default_value.is_a?(Proc)
+      default_value = instance_exec(&default_value) if default_value.is_a?(Proc)
       self.write_attribute(name, default_value)
     end
   end
 
   def assign_attributes(attrs, options={})
+    raise ArgumentError, "To assign attributes, please pass a hash instead of `#{attrs.class}'" unless attrs.is_a?(Hash)
+
     if options[:pristine]
       if options[:keep_ivars] && options[:missing_attributes].try(:[], :pluck)
         options[:missing_attributes][:pluck].keys.each { |k| @_attributes.delete(k) }
@@ -74,6 +81,7 @@ module NoBrainer::Document::Attributes
       clear_dirtiness(options)
     else
       clear_dirtiness(options) if options[:pristine]
+      attrs = sanitize_for_mass_assignment(attrs)
       attrs.each { |k,v| self.write_attribute(k,v) }
     end
     assign_defaults(options) if options[:pristine]
@@ -82,7 +90,7 @@ module NoBrainer::Document::Attributes
 
   def inspectable_attributes
     # TODO test that thing
-    Hash[@_attributes.sort_by { |k,v| self.class.fields.keys.index(k.to_sym) || 2**10 }]
+    Hash[@_attributes.sort_by { |k,v| self.class.fields.keys.index(k.to_sym) || 2**10 }].with_indifferent_access.freeze
   end
 
   def to_s