nobrainer 0.20.0 → 0.21.0

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

@@ -6,8 +6,9 @@ module NoBrainer::Document::Criteria
   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,7 +22,7 @@ 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
@@ -42,9 +43,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 }
+      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
+      end
+    end
+
+    def inherited(subclass)
+      subclass.default_scopes = self.default_scopes.dup
+      super
     end
 
     def selector_for(pk)

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

@@ -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_attribute?() is deprecated. Please use update?() instead" }
+  end
+
+  def update_attributes(*args)
+    update(*args).tap { STDERR.puts "[NoBrainer] update_attribute() is deprecated. Please use update() instead" }
+  end
+
+  def update_attributes!(*args)
+    update!(*args).tap { STDERR.puts "[NoBrainer] update_attribute!() is deprecated. Please use update() instead" }
+  end
+
   def delete
     unless @destroyed
       NoBrainer.run { selector.delete }

data/lib/no_brainer/document/types.rb

@@ -6,7 +6,7 @@ module NoBrainer::Document::Types
   def add_type_errors
     return unless @pending_type_errors
     @pending_type_errors.each do |name, error|
-      errors.add(name, :invalid_type, :type => error.human_type_name)
+      errors.add(name, :invalid_type, error.error)
     end
   end
 
@@ -22,7 +22,10 @@ module NoBrainer::Document::Types
   module ClassMethods
     def cast_user_to_model_for(attr, value)
       type = fields[attr.to_sym].try(:[], :type)
-      return value if type.nil? || value.nil? || value.is_a?(NoBrainer::Document::AtomicOps::PendingAtomic)
+      return value if type.nil? || value.nil? ||
+        value.is_a?(NoBrainer::Document::AtomicOps::PendingAtomic) ||
+        value.is_a?(RethinkDB::RQL)
+
       if type.respond_to?(:nobrainer_cast_user_to_model)
         type.nobrainer_cast_user_to_model(value)
       else
@@ -30,9 +33,7 @@ module NoBrainer::Document::Types
         value
       end
     rescue NoBrainer::Error::InvalidType => error
-      error.type = type
-      error.value = value
-      error.attr_name = attr
+      error.update(:model => self, :value => value, :attr_name => attr, :type => type)
       raise error
     end
 
@@ -62,14 +63,15 @@ module NoBrainer::Document::Types
 
       return unless options[:type]
 
-      NoBrainer::Document::Types.load_type_extensions(options[:type]) if options[:type]
-
+      raise "Please use a class for the type option" unless options[:type].is_a?(Class)
       case options[:type].to_s
       when "NoBrainer::Geo::Circle" then raise "Cannot store circles :("
       when "NoBrainer::Geo::Polygon", "NoBrainer::Geo::LineString"
         raise "Make a request on github if you'd like to store polygons/linestrings"
       end
 
+      NoBrainer::Document::Types.load_type_extensions(options[:type]) if options[:type]
+
       inject_in_layer :types do
         define_method("#{attr}=") do |value|
           begin
@@ -96,11 +98,10 @@ module NoBrainer::Document::Types
     end
   end
 
-  require File.join(File.dirname(__FILE__), 'types', 'binary')
-  require File.join(File.dirname(__FILE__), 'types', 'boolean')
-  Binary = NoBrainer::Binary
-  Boolean = NoBrainer::Boolean
-  Geo = NoBrainer::Geo
+  %w(binary boolean text geo).each do |type|
+    require File.join(File.dirname(__FILE__), 'types', type)
+    const_set(type.camelize, NoBrainer.const_get(type.camelize))
+  end
 
   class << self
     mattr_accessor :loaded_extensions

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

@@ -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
 end

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

@@ -1,4 +1,3 @@
-# We namespace our fake Boolean class to avoid polluting the global namespace
 class NoBrainer::Boolean
   def initialize; raise; end
   def self.inspect; 'Boolean'; 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/string.rb

@@ -7,6 +7,9 @@ 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

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

@@ -0,0 +1,18 @@
+class NoBrainer::Text
+  def initialize; raise; end
+  def self.inspect; 'Text'; end
+  def self.to_s; inspect; end
+  def self.name; inspect; end
+
+  module NoBrainerExtentions
+    InvalidType = NoBrainer::Error::InvalidType
+
+    def nobrainer_cast_user_to_model(value)
+      case value
+      when String then value
+      else raise InvalidType
+      end
+    end
+  end
+  extend NoBrainerExtentions
+end

data/lib/no_brainer/document/validation.rb

@@ -1,8 +1,11 @@
 module NoBrainer::Document::Validation
+  extend NoBrainer::Autoload
   extend ActiveSupport::Concern
   include ActiveModel::Validations
   include ActiveModel::Validations::Callbacks
 
+  autoload_and_include :Uniqueness, :NotNull
+
   included do
     # We don't want before_validation returning false to halt the chain.
     define_callbacks :validation, :skip_after_callbacks_if_terminated => true,
@@ -12,7 +15,7 @@ module NoBrainer::Document::Validation
   def valid?(context=nil, options={})
     context ||= new_record? ? :create : :update
 
-  # copy/pasted, because we need to have control on errors.clear
+   # XXX Monkey Patching, because we need to have control on errors.clear
     current_context, self.validation_context = validation_context, context
     errors.clear unless options[:clear_errors] == false
     run_validations!
@@ -20,15 +23,37 @@ module NoBrainer::Document::Validation
     self.validation_context = current_context
   end
 
+  SHORTHANDS = { :format => :format, :length => :length, :required => :presence,
+                 :uniq => :uniqueness, :unique => :uniqueness, :in => :inclusion }
+
   module ClassMethods
     def _field(attr, options={})
       super
-      validates(attr, :format => { :with => options[:format] }) if options.has_key?(:format)
-      validates(attr, :presence => options[:required]) if options.has_key?(:required)
-      validates(attr, :uniqueness => options[:unique]) if options.has_key?(:unique)
-      validates(attr, :uniqueness => options[:uniq]) if options.has_key?(:uniq)
-      validates(attr, :inclusion => {:in => options[:in]}) if options.has_key?(:in)
+
+      shorthands = SHORTHANDS
+      shorthands = shorthands.merge(:required => :not_null) if options[:type] == NoBrainer::Boolean
+      shorthands.each { |k,v| validates(attr, v => options[k]) if options.has_key?(k) }
+
       validates(attr, options[:validates]) if options[:validates]
+      validates(attr, :length => { :minimum => options[:min_length] }) if options[:min_length]
+      validates(attr, :length => { :maximum => options[:max_length] }) if options[:max_length]
+    end
+  end
+end
+
+class ActiveModel::EachValidator
+  def should_validate_field?(record, attribute)
+    record.new_record? || record.__send__("#{attribute}_changed?")
+  end
+
+  # XXX Monkey Patching :(
+  def validate(record)
+    attributes.each do |attribute|
+      next unless should_validate_field?(record, attribute) # <--- Added
+      value = record.read_attribute_for_validation(attribute)
+      next if value.is_a?(NoBrainer::Document::AtomicOps::PendingAtomic) # <--- Added
+      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/validation/not_null.rb

@@ -0,0 +1,15 @@
+module NoBrainer::Document::Validation::NotNull
+  extend ActiveSupport::Concern
+
+  module ClassMethods
+    def validates_not_null(*attr_names)
+      validates_with(NotNullValidator, _merge_attributes(attr_names))
+    end
+  end
+
+  class NotNullValidator < ActiveModel::EachValidator
+    def validate_each(doc, attr, value)
+      doc.errors.add(attr, :undefined, options) if value.nil?
+    end
+  end
+end

data/lib/no_brainer/document/{uniqueness.rb → validation/uniqueness.rb}

@@ -1,4 +1,4 @@
-module NoBrainer::Document::Uniqueness
+module NoBrainer::Document::Validation::Uniqueness
   extend ActiveSupport::Concern
 
   def _create(options={})
@@ -27,7 +27,7 @@ module NoBrainer::Document::Uniqueness
     self.class.unique_validators
       .map { |validator| validator.attributes.map { |attr| [attr, validator] } }
       .flatten(1)
-      .select { |f, validator| validator.should_validate_uniquess_of?(self, f) }
+      .select { |f, validator| validator.should_validate_field?(self, f) }
       .map { |f, options| _lock_key_from_field(f) }
       .sort
       .uniq
@@ -51,7 +51,7 @@ module NoBrainer::Document::Uniqueness
 
   module ClassMethods
     def validates_uniqueness_of(*attr_names)
-      validates_with UniquenessValidator, _merge_attributes(attr_names)
+      validates_with(UniquenessValidator, _merge_attributes(attr_names))
     end
 
     def inherited(subclass)
@@ -72,19 +72,20 @@ module NoBrainer::Document::Uniqueness
       end
     end
 
-    def should_validate_uniquess_of?(doc, field)
-      (scope + [field]).any? { |f| doc.__send__("#{f}_changed?") }
+    def should_validate_field?(doc, field)
+      doc.new_record? || (scope + [field]).any? { |f| doc.__send__("#{f}_changed?") }
     end
 
     def validate_each(doc, attr, value)
-      return true unless should_validate_uniquess_of?(doc, attr)
-
       criteria = doc.root_class.unscoped.where(attr => value)
       criteria = apply_scopes(criteria, doc)
       criteria = exclude_doc(criteria, doc) if doc.persisted?
-      is_unique = criteria.count == 0
-      doc.errors.add(attr, :taken, options.except(:scope).merge(:value => value)) unless is_unique
-      is_unique
+      doc.errors.add(attr, :taken, options.except(:scope).merge(:value => value)) unless criteria.empty?
+    rescue NoBrainer::Error::InvalidType
+      # We can't run the uniqueness validator: where() won't accept bad types
+      # and we have some values that don't have the right type.
+      # Note that it's fine to not add errors because the type validations will
+      # prevent the document from being saved.
     end
 
     def apply_scopes(criteria, doc)

data/lib/no_brainer/error.rb

@@ -5,25 +5,13 @@ module NoBrainer::Error
   class ChildrenExist           < RuntimeError; end
   class CannotUseIndex          < RuntimeError; end
   class MissingIndex            < RuntimeError; end
-  class InvalidType             < RuntimeError; end
   class AssociationNotPersisted < RuntimeError; end
   class ReadonlyField           < RuntimeError; end
   class MissingAttribute        < RuntimeError; end
   class UnknownAttribute        < RuntimeError; end
   class AtomicBlock             < RuntimeError; end
-
-  class CannotReadAtomic < RuntimeError
-    attr_accessor :instance, :field, :value
-    def initialize(instance, field, value)
-      @instance = instance
-      @field = field
-      @value = value
-    end
-
-    def message
-      "Cannot read #{field}, atomic operations are pending"
-    end
-  end
+  class LostLock                < RuntimeError; end
+  class LockUnavailable         < RuntimeError; end
 
   class DocumentInvalid < RuntimeError
     attr_accessor :instance
@@ -37,23 +25,32 @@ module NoBrainer::Error
   end
 
   class InvalidType < RuntimeError
-    attr_accessor :attr_name, :value, :type
+    attr_accessor :model, :attr_name, :value, :type, :error
     def initialize(options={})
-      @attr_name = options[:attr_name]
-      @value     = options[:value]
-      @type      = options[:type]
+      update(options)
+    end
+
+    def update(options={})
+      options.assert_valid_keys(:model, :attr_name, :type, :value, :error)
+      options.each { |k,v| instance_variable_set("@#{k}", v) }
     end
 
     def human_type_name
       type.to_s.underscore.humanize.downcase
     end
 
+    def error
+      # dup because errors.add eventually .delete() on our option.
+      @error.nil? ? (type && { :type => human_type_name }) : @error.dup
+    end
+
     def message
-      if attr_name && type && value
-        "#{attr_name} should be used with a #{human_type_name}. Got `#{value}` (#{value.class})"
-      else
-        super
-      end
+      return super unless model && attr_name && error
+      value = self.value
+      mock = model.allocate
+      mock.singleton_class.send(:define_method, :read_attribute_for_validation) { |_| value }
+      mock.errors.add(attr_name, :invalid_type, error)
+      mock.errors.full_messages.first
     end
   end