nobrainer 0.18.0 → 0.22.0

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? }
 
@@ -17,7 +16,7 @@ class NoBrainer::Document::Association::EagerLoader
         if owner_keys.present?
           targets = criteria.where(target_key.in => owner_keys)
                             .map { |target| [target.read_attribute(target_key), target] }
-                            .reduce(Hash.new { |k,v| k[v] = [] }) { |h,(k,v)| h[k] << v; h }
+                            .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)]
@@ -40,19 +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._preloads = v._preloads, []
+        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) }
-    else eager_load_association(docs, preloads)
+    when Array then what.each { |v| eager_load(docs, v) }
+    when nil then;
+    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?
@@ -80,18 +96,16 @@ class NoBrainer::Document::Association::HasMany
   end
 
   def set_inverse_proc
-    lambda { |target| set_inverses_of([target]) if target.is_a?(NoBrainer::Document) }
+    ->(target){ set_inverses_of([target]) if target.is_a?(NoBrainer::Document) }
   end
 
   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,103 +2,125 @@ module NoBrainer::Document::AtomicOps
   extend ActiveSupport::Concern
 
   class PendingAtomic
-    def self._new(instance, field, value, is_user_value, options={})
-      model = case value
-              when Array then PendingAtomicArray
-              when Set   then PendingAtomicSet
-              else self
-              end
-      model.new(instance, field, value, is_user_value, options)
+    attr_accessor :type
+
+    def self._new(instance, field, value, is_user_value)
+      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, type)
     end
 
-    def initialize(instance, field, value, is_user_value, options={})
+    def initialize(instance, field, value, is_user_value, type)
       @instance = instance
       @field = field.to_s
       @value = value
       @is_user_value = is_user_value
-      @options = options.dup
+      @type = type
       @ops = []
     end
 
-    def write_access?
-      !!@options[:write_access]
+    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 ensure_writeable!
-      unless write_access?
-        @options[:write_access] = true
-        @instance.write_attribute(@field, self)
-      end
+    def initialize_copy(other)
+      super
+      @ops = @ops.dup
     end
 
     def to_s
-      "<#{@field} with pending atomic operations>"
+      "<`#{@field}' with #{@ops.size} pending atomic operations>"
     end
-    alias inspect to_s
+    alias_method :inspect, :to_s
+
+    def method_missing(method, *a, &b)
+      if method == :<<
+        method = :append
+        modify_source!
+      end
 
-    def method_missing(method_name, *a, &b)
-      @ops << [method_name, a, b]
+      @ops << [method, a, b]
       self
     end
 
     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]
-      @ops.each { |method_name, a, b| value = value.__send__(method_name, *a, &b) }
-      value
+      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)
+      end
     end
   end
 
-  class PendingAtomicArray < PendingAtomic
-    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 delete(value)
-      difference([value])
+    def |(value)
+      @ops << [:set_union, [value.to_a]]
+      self
     end
 
-    def +(value)
-      @ops << [:+, [value.to_a]]
-      self
+    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
-    def add(v); self + v; end
+  end
 
-    def &(value)
-      @ops << [:set_intersection, [value.to_a]]
+  class PendingAtomicSet < PendingAtomicContainer
+    def <<(value)
+      @ops << [:set_union, [[value]]]
+      modify_source!
       self
     end
-    def intersection(v); self & v; end
 
-    def |(value)
+    def +(value)
       @ops << [:set_union, [value.to_a]]
       self
     end
-    def union(v); self | v; end
 
-    def <<(value)
-      @ops << [:append, [value]]
-      ensure_writeable!
+    def -(value)
+      @ops << [:set_difference, [value.to_a]]
       self
     end
   end
 
-  class PendingAtomicSet < PendingAtomicArray
-    def -(value)
-      @ops << [:set_difference, [value.to_a]]
+  class PendingAtomicArray < PendingAtomicContainer
+    def <<(value)
+      @ops << [:append, [value]]
+      modify_source!
       self
     end
 
     def +(value)
-      @ops << [:set_union, [value.to_a]]
+      @ops << [:+, [value.to_a]]
       self
     end
 
-    def <<(value)
-      @ops << [:set_union, [[value]]]
-      ensure_writeable!
+    def -(value)
+      @ops << [:difference, [value.to_a]]
       self
     end
   end
@@ -109,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
 
@@ -143,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, true]   then value
-    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 [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
 
@@ -156,9 +181,9 @@ module NoBrainer::Document::AtomicOps
     ensure_exclusive_atomic!
 
     case [in_atomic?, value.is_a?(PendingAtomic)]
-    when [true, true]   then super
     when [true, false]  then raise NoBrainer::Error::AtomicBlock.new('Avoid the use of atomic blocks for non atomic operations')
     when [false, true]  then raise NoBrainer::Error::AtomicBlock.new('Use atomic blocks for atomic operations')
+    when [true, true]   then super.tap { _touch_attribute(name) }
     when [false, false] then super.tap { _touch_attribute(name) }
     end
   end
@@ -175,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,14 +1,12 @@
 module NoBrainer::Document::Attributes
-  VALID_FIELD_OPTIONS = [:index, :default, :type, :real_type,
-                         :validates, :required, :unique, :uniq, :format, :in,
-                         :readonly, :primary_key, :as, :lazy_fetch]
+  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::DecoratedSymbol::MODIFIERS.keys
+                          + NoBrainer::Criteria::Where::OPERATORS
   extend ActiveSupport::Concern
+  include ActiveModel::ForbiddenAttributesProtection
 
   included do
-    # Not using class_attribute because we want to
-    # use our custom logic
     singleton_class.send(:attr_accessor, :fields)
     self.fields = {}
   end
@@ -26,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
@@ -46,24 +48,25 @@ module NoBrainer::Document::Attributes
 
   def assign_defaults(options)
     self.class.fields.each do |name, field_options|
-      if field_options.has_key?(:default) &&
-         !@_attributes.has_key?(name)
-
-         if opt = options[:missing_attributes]
-           if (opt[:pluck] && !opt[:pluck][name]) ||
-              (opt[:without] && opt[:without][name])
-             next
-           end
-         end
-
-        default_value = field_options[:default]
-        default_value = default_value.call if default_value.is_a?(Proc)
-        self.write_attribute(name, default_value)
+      next unless field_options.has_key?(:default) &&
+                  !@_attributes.has_key?(name)
+
+      if opt = options[:missing_attributes]
+        if (opt[:pluck] && !opt[:pluck][name]) ||
+           (opt[:without] && opt[:without][name])
+          next
+        end
       end
+
+      default_value = field_options[:default]
+      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) }
@@ -78,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]
@@ -86,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

data/lib/no_brainer/document/callbacks.rb

@@ -9,7 +9,7 @@ module NoBrainer::Document::Callbacks
   end
 
   def initialize(*args, &block)
-    run_callbacks(:initialize) { _initialize(*args); true }
+    run_callbacks(:initialize) { _initialize(*args, &block); true }
   end
 
   def _create(*args, &block)

data/lib/no_brainer/document/core.rb

@@ -2,7 +2,7 @@ module NoBrainer::Document::Core
   extend ActiveSupport::Concern
 
   singleton_class.class_eval do
-    attr_accessor :_all
+    attr_accessor :_all, :_all_nobrainer
 
     def all
       Rails.application.eager_load! if defined?(Rails.application.eager_load!)
@@ -10,10 +10,12 @@ module NoBrainer::Document::Core
     end
   end
   self._all = []
+  self._all_nobrainer = []
 
   include ActiveModel::Conversion
 
   def to_key
+     # ActiveModel::Conversion stuff
     [pk_value]
   end
 
@@ -22,6 +24,7 @@ module NoBrainer::Document::Core
     extend ActiveModel::Naming
     extend ActiveModel::Translation
 
-    NoBrainer::Document::Core._all << self unless self.name =~ /^NoBrainer::/
+    list_name = self.name =~ /^NoBrainer::/ ? :_all_nobrainer : :_all
+    NoBrainer::Document::Core.__send__(list_name) << self
   end
 end

data/lib/no_brainer/document/criteria.rb

@@ -2,12 +2,14 @@ module NoBrainer::Document::Criteria
   extend ActiveSupport::Concern
 
   def selector
-    self.class.selector_for(pk_value)
+    # Used for writes
+    self.class.rql_table.get(pk_value)
   end
 
   included do
-    cattr_accessor :default_scope_proc,     :instance_accessor => false
     cattr_accessor :perf_warnings_disabled, :instance_accessor => false
+    singleton_class.send(:attr_accessor, :default_scopes)
+    self.default_scopes = []
   end
 
   module ClassMethods
@@ -21,12 +23,13 @@ module NoBrainer::Document::Criteria
              :with_cache, :without_cache,    # Cache
              :count, :empty?, :any?,         # Count
              :delete_all, :destroy_all,      # Delete
-             :includes, :preload,            # Preload
+             :preload, :eager_load,          # EagerLoad
              :each, :to_a,                   # Enumerable
              :first, :last, :first!, :last!, :sample, # First
              :min, :max, :sum, :avg,         # Aggregate
              :update_all, :replace_all,      # Update
              :pluck, :without, :lazy_fetch, :without_plucking, # Pluck
+             :find_by?, :find_by, :find_by!, :find?, :find, :find!, # Find
              :to => :all
 
     def all
@@ -42,25 +45,17 @@ module NoBrainer::Document::Criteria
     end
 
     def default_scope(criteria=nil, &block)
-      criteria ||= block
-      raise "store_in() must be called on the parent class" unless is_root_class?
-      self.default_scope_proc = criteria.is_a?(Proc) ? criteria : proc { criteria }
-    end
-
-    def selector_for(pk)
-      rql_table.get(pk)
-    end
+      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)
 
-    # XXX this doesn't have the same semantics as other ORMs. the equivalent is find!.
-    def find(pk)
-      attrs = NoBrainer.run { selector_for(pk) }
-      new_from_db(attrs).tap { |doc| doc.run_callbacks(:find) } if attrs
+      ([self] + self.descendants).each do |model|
+        model.default_scopes << criteria_proc
+      end
     end
 
-    def find!(pk)
-      find(pk).tap do |doc|
-        raise NoBrainer::Error::DocumentNotFound, "#{self} #{pk_name}: #{pk} not found" unless doc
-      end
+    def inherited(subclass)
+      subclass.default_scopes = self.default_scopes.dup
+      super
     end
 
     def disable_perf_warnings

data/lib/no_brainer/document/dirty.rb

@@ -31,14 +31,10 @@ module NoBrainer::Document::Dirty
     changes.keys
   end
 
-  def read_attribute_for_change(attr)
-    read_attribute(attr)
-  end
-
   def changes
     result = {}.with_indifferent_access
     @_old_attributes.each do |attr, old_value|
-      current_value = read_attribute_for_change(attr)
+      current_value = read_attribute(attr)
       if current_value != old_value || !@_old_attributes_keys.include?(attr)
         result[attr] = [old_value, current_value]
       end
@@ -46,16 +42,15 @@ module NoBrainer::Document::Dirty
     result
   end
 
-  def attribute_may_change(*args)
-    attr = args.first
-    current_value = begin
-      case args.size
-      when 1 then assert_access_field(attr); read_attribute_for_change(attr)
-      when 2 then args.last
-      else raise
+  class None; end
+  def attribute_may_change(attr, current_value = None)
+    if current_value == None
+      current_value = begin
+        assert_access_field(attr)
+        read_attribute(attr)
+      rescue NoBrainer::Error::MissingAttribute => e
+        e
       end
-    rescue NoBrainer::Error::MissingAttribute => e
-      e
     end
 
     unless @_old_attributes.has_key?(attr)
@@ -84,7 +79,7 @@ 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_for_change(attr)]
+            result = [@_old_attributes[attr], read_attribute(attr)]
             result if result.first != result.last || !@_old_attributes_keys.include?(attr)
           end
         end
@@ -94,7 +89,7 @@ module NoBrainer::Document::Dirty
         end
 
         define_method("#{attr}_was") do
-          @_old_attributes.has_key?(attr) ? @_old_attributes[attr] : read_attribute_for_change(attr)
+          @_old_attributes.has_key?(attr) ? @_old_attributes[attr] : read_attribute(attr)
         end
       end
     end

data/lib/no_brainer/document/index/index.rb

@@ -9,7 +9,8 @@ class NoBrainer::Document::Index::Index < Struct.new(
     self.name = self.name.to_sym
     self.aliased_name = self.aliased_name.to_sym
     self.external = !!self.external
-    self.geo = !!self.geo
+    # geo defaults for true with geo types.
+    self.geo = !!model.fields[name].try(:[], :type).try(:<, NoBrainer::Geo::Base) if self.geo.nil?
     self.multi = !!self.multi
   end