nobrainer 0.20.0 → 0.22.0

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

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,24 +45,18 @@ 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
+      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)
 
-    def selector_for(pk)
-      rql_table.get(pk)
-    end
-
-    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 { |doc| raise NoBrainer::Error::DocumentNotFound, "#{self} #{pk_name}: #{pk} not found" unless doc }
+    def inherited(subclass)
+      subclass.default_scopes = self.default_scopes.dup
+      super
     end
-    alias_method :find!, :find
 
     def disable_perf_warnings
       self.perf_warnings_disabled = true

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/meta_store.rb

@@ -24,7 +24,7 @@ class NoBrainer::Document::Index::MetaStore
   def self.on(db_name, &block)
     old_db_name = Thread.current[:nobrainer_meta_store_db]
     Thread.current[:nobrainer_meta_store_db] = db_name
-    NoBrainer.with(:auto_create_tables => true) { block.call }
+    block.call
   ensure
     Thread.current[:nobrainer_meta_store_db] = old_db_name
   end

data/lib/no_brainer/document/index.rb

@@ -14,12 +14,6 @@ module NoBrainer::Document::Index
     def index(name, *args)
       name = name.to_sym
       options = args.extract_options!
-
-      if options[:as]
-        STDERR.puts "[NoBrainer] `:as' is deprecated and will be removed. Please use `:store_as' instead (from the #{self} model)"
-        options[:store_as] = options.delete(:as)
-      end
-
       options.assert_valid_keys(*VALID_INDEX_OPTIONS)
 
       raise "Too many arguments: #{args}" if args.size > 1

data/lib/no_brainer/document/persistance.rb

@@ -29,7 +29,7 @@ module NoBrainer::Document::Persistance
 
   def _reload(options={})
     attrs = NoBrainer.run { _reload_selector(options) }
-    raise NoBrainer::Error::DocumentNotFound, "#{self.class} #{self.class.pk_name}: #{pk_value} not found" unless attrs
+    raise NoBrainer::Error::DocumentNotFound, "#{self.class} :#{self.class.pk_name}=>\"#{pk_value}\" not found" unless attrs
 
     options = options.merge(:pristine => true, :from_db => true)
 
@@ -113,13 +113,11 @@ module NoBrainer::Document::Persistance
     assign_attributes(attrs, options)
     save?(options)
   end
-  alias_method :update_attributes?, :update?
 
   def update(*args)
     update?(*args) or raise NoBrainer::Error::DocumentInvalid, self
     nil
   end
-  alias_method :update_attributes, :update
 
   def update!(*args)
     update(*args)
@@ -127,6 +125,18 @@ module NoBrainer::Document::Persistance
   end
   alias_method :update_attributes!, :update!
 
+  def update_attributes?(*args)
+    update?(*args).tap { STDERR.puts "[NoBrainer] update_attributes?() is deprecated. Please use update?() instead" }
+  end
+
+  def update_attributes(*args)
+    update(*args).tap { STDERR.puts "[NoBrainer] update_attributes() is deprecated. Please use update() instead" }
+  end
+
+  def update_attributes!(*args)
+    update!(*args).tap { STDERR.puts "[NoBrainer] update_attributes!() is deprecated. Please use update() instead" }
+  end
+
   def delete
     unless @destroyed
       NoBrainer.run { selector.delete }

data/lib/no_brainer/document/store_in.rb

@@ -16,13 +16,13 @@ module NoBrainer::Document::StoreIn
 
     def database_name
       db = self.store_in_options[:database]
-      db.is_a?(Proc) ? db.call : db
+      (db.is_a?(Proc) ? db.call : db).try(:to_s)
     end
 
     def table_name
       table = store_in_options[:table]
       table_name = table.is_a?(Proc) ? table.call : table
-      table_name || root_class.name.tableize.gsub('/', '__')
+      table_name.try(:to_s) || root_class.name.tableize.gsub('/', '__')
     end
 
     def rql_table

data/lib/no_brainer/document/types/binary.rb

@@ -4,7 +4,7 @@ class NoBrainer::Binary
   def self.to_s; inspect; end
   def self.name; inspect; end
 
-  module NoBrainerExtentions
+  module NoBrainerExtensions
     InvalidType = NoBrainer::Error::InvalidType
 
     def nobrainer_cast_user_to_model(value)
@@ -13,10 +13,6 @@ class NoBrainer::Binary
       else raise InvalidType
       end
     end
-
-    def nobrainer_cast_db_to_model(value)
-      value.is_a?(String) ? RethinkDB::Binary.new(value) : value
-    end
   end
-  extend NoBrainerExtentions
+  extend NoBrainerExtensions
 end

data/lib/no_brainer/document/types/boolean.rb

@@ -1,11 +1,10 @@
-# We namespace our fake Boolean class to avoid polluting the global namespace
 class NoBrainer::Boolean
   def initialize; raise; end
   def self.inspect; 'Boolean'; end
   def self.to_s; inspect; end
   def self.name; inspect; end
 
-  module NoBrainerExtentions
+  module NoBrainerExtensions
     InvalidType = NoBrainer::Error::InvalidType
 
     def nobrainer_cast_user_to_model(value)
@@ -21,5 +20,5 @@ class NoBrainer::Boolean
       end
     end
   end
-  extend NoBrainerExtentions
+  extend NoBrainerExtensions
 end

data/lib/no_brainer/document/types/date.rb

@@ -1,5 +1,5 @@
 class Date
-  module NoBrainerExtentions
+  module NoBrainerExtensions
     InvalidType = NoBrainer::Error::InvalidType
 
     def nobrainer_cast_user_to_model(value)
@@ -22,5 +22,5 @@ class Date
       value.is_a?(Date) ? Time.utc(value.year, value.month, value.day) : value
     end
   end
-  extend NoBrainerExtentions
+  extend NoBrainerExtensions
 end

data/lib/no_brainer/document/types/float.rb

@@ -1,5 +1,5 @@
 class Float
-  module NoBrainerExtentions
+  module NoBrainerExtensions
     InvalidType = NoBrainer::Error::InvalidType
 
     def nobrainer_cast_user_to_model(value)
@@ -16,5 +16,5 @@ class Float
       end
     end
   end
-  extend NoBrainerExtentions
+  extend NoBrainerExtensions
 end

data/lib/no_brainer/document/types/geo.rb

@@ -0,0 +1 @@
+# Look in lib/no_brainer/geo.rb instead

data/lib/no_brainer/document/types/integer.rb

@@ -1,5 +1,5 @@
 class Integer
-  module NoBrainerExtentions
+  module NoBrainerExtensions
     InvalidType = NoBrainer::Error::InvalidType
 
     def nobrainer_cast_user_to_model(value)
@@ -14,5 +14,5 @@ class Integer
       end
     end
   end
-  extend NoBrainerExtentions
+  extend NoBrainerExtensions
 end

data/lib/no_brainer/document/types/set.rb

@@ -1,5 +1,5 @@
 class Set
-  module NoBrainerExtentions
+  module NoBrainerExtensions
     InvalidType = NoBrainer::Error::InvalidType
 
     def nobrainer_cast_user_to_model(value)
@@ -19,5 +19,5 @@ class Set
     end
   end
 
-  extend NoBrainerExtentions
+  extend NoBrainerExtensions
 end

data/lib/no_brainer/document/types/string.rb

@@ -1,5 +1,5 @@
 class String
-  module NoBrainerExtentions
+  module NoBrainerExtensions
     InvalidType = NoBrainer::Error::InvalidType
 
     def nobrainer_cast_user_to_model(value)
@@ -7,8 +7,11 @@ class String
       when String then value
       when Symbol then value.to_s
       else raise InvalidType
+      end.tap do |str|
+        max_length = NoBrainer::Config.max_string_length
+        raise InvalidType.new(:error => { :message => :too_long, :count => max_length }) if str.size > max_length
       end
     end
   end
-  extend NoBrainerExtentions
+  extend NoBrainerExtensions
 end