nobrainer 0.23.0 → 0.24.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: f77c9211fbf5a8c8fb7a695542b862cfd693ed82
-  data.tar.gz: 72bd41593dfbb997eb1dd72a70c00c08f75f4124
+  metadata.gz: 56337a0aa87999793ca7bc6ed3e1de79ef76b427
+  data.tar.gz: 6740efd7304818a5a71638a639b48301d16eb602
 SHA512:
-  metadata.gz: fd5ca8440015b18adfc34f61bb7862e15bc445a459cf1c2310843c3c7194862f1d1abecd72c4ce14a7501a6345704fea20f49b332331b227d8ee0309494a36bb
-  data.tar.gz: cd4d1d5b1e8cb9ee69eed9b6a0956626e407fd3e1c1bf9e60bedd502def6c0adbe8684826afde573dde490ae6db0842cb602eb03b2025166780574bb17c474a5
+  metadata.gz: 69a4a851eb9e3a497a2bff26c65933437e3155b23f6573e1a9d7fcaa04980f59964b7d6f59383e3c7b9bb27014ab95eda52ca8be38d4b4f82144d2c389e211b6
+  data.tar.gz: 03968de9d8391cd208938420fa19d1aa1f2c76191bf938132f5c04dce33f673e725f5336390c010bb70cf3ff660a79a0b7dd72cc27bca994ba6411445f797948

data/lib/no_brainer/criteria/core.rb

@@ -32,11 +32,6 @@ module NoBrainer::Criteria::Core
     to_rql.inspect rescue super
   end
 
-  def run(&block)
-    block ||= proc { to_rql }
-    NoBrainer.run(:criteria => self, &block)
-  end
-
   def merge!(criteria, options={})
     criteria.options.each do |k,v|
       merge_proc = self.class.options_definitions[k]
@@ -61,6 +56,11 @@ module NoBrainer::Criteria::Core
     merge(self.class.new(options), merge_options)
   end
 
+  def run(&block)
+    block ||= proc { to_rql }
+    NoBrainer.run(:criteria => self, &block)
+  end
+
   def compile_rql_pass1
     # This method is overriden by other modules.
     raise "Criteria not bound to a model" unless model

data/lib/no_brainer/criteria/enumerable.rb

@@ -3,7 +3,7 @@ module NoBrainer::Criteria::Enumerable
 
   def each(options={}, &block)
     return enum_for(:each, options) unless block
-    self.run.each { |attrs| block.call(instantiate_doc(attrs)) }
+    run.each { |attrs| block.call(instantiate_doc(attrs)) }
     self
   end
 

data/lib/no_brainer/criteria/first.rb

@@ -26,6 +26,6 @@ module NoBrainer::Criteria::First
   private
 
   def get_one(criteria)
-    instantiate_doc(criteria.limit(1).run.first)
+    instantiate_doc(criteria.limit(1).__send__(:run).first)
   end
 end

data/lib/no_brainer/criteria/order_by.rb

@@ -17,6 +17,8 @@ module NoBrainer::Criteria::OrderBy
       end
     end.reduce({}, :merge)
 
+    rules.keys.each { |k| model.ensure_valid_key!(k) unless k.is_a?(Proc) } if model
+
     chain(:order_by => rules, :ordering_mode => :normal)
   end
 

data/lib/no_brainer/criteria/where.rb

@@ -1,6 +1,6 @@
 module NoBrainer::Criteria::Where
-  NON_CHAINABLE_OPERATORS = %w(in nin eq ne not gt ge gte lt le lte defined near intersects).map(&:to_sym)
-  CHAINABLE_OPERATORS = %w(any all).map(&:to_sym)
+  NON_CHAINABLE_OPERATORS = %w(in eq gt ge gte lt le lte defined near intersects).map(&:to_sym)
+  CHAINABLE_OPERATORS = %w(not any all).map(&:to_sym)
   OPERATORS = CHAINABLE_OPERATORS + NON_CHAINABLE_OPERATORS
 
   require 'symbol_decoration'
@@ -134,12 +134,9 @@ module NoBrainer::Criteria::Where
       when :in         then RethinkDB::RQL.new.expr(value).contains(lvalue)
       when :intersects then lvalue.intersects(value.to_rql)
       when :near
-        options = value.dup
-        point = options.delete(:point)
-        max_dist = options.delete(:max_dist)
-        # XXX max_results is not used, seems to be a workaround of rethinkdb index implemetnation.
-        _ = options.delete(:max_results)
-        RethinkDB::RQL.new.distance(lvalue, point.to_rql, options) <= max_dist
+        # XXX options[:max_results] is not used, seems to be a workaround of rethinkdb index implementation.
+        circle = value[:circle]
+        RethinkDB::RQL.new.distance(lvalue, circle.center.to_rql, circle.options) <= circle.radius
       else lvalue.__send__(op, value)
       end
     end
@@ -176,18 +173,23 @@ module NoBrainer::Criteria::Where
           raise "Use a geo object with `intersects`" unless value.is_a?(NoBrainer::Geo::Base)
           value
         when :near
-          raise "Incorrect use of `near': rvalue must be a hash" unless value.is_a?(Hash)
-          options = NoBrainer::Geo::Base.normalize_geo_options(value)
-
-          unless options[:point] && options[:max_dist]
-            raise "`near' takes something like {:point => P, :max_distance => d}"
-          end
-
-          unless options[:point].is_a?(NoBrainer::Geo::Point)
-            options[:point] = NoBrainer::Geo::Point.nobrainer_cast_user_to_model(options[:point])
+          case value
+            when Hash
+              options = NoBrainer::Geo::Base.normalize_geo_options(value)
+
+              options[:radius] = options.delete(:max_distance) if options[:max_distance]
+              options[:radius] = options.delete(:max_dist) if options[:max_dist]
+              options[:center] = options.delete(:point) if options[:point]
+
+              unless options[:circle]
+                unless options[:center] && options[:radius]
+                  raise "`near' takes something like {:center => P, :radius => d}"
+                end
+                { :circle => NoBrainer::Geo::Circle.new(options), :max_results => options[:max_results] }
+              end
+            when NoBrainer::Geo::Circle then { :circle => value }
+            else raise "Incorrect use of `near': rvalue must be a hash or a circle"
           end
-
-          options
         else
           case key_modifier
           when :scalar    then model.cast_user_to_db_for(key, value)
@@ -202,24 +204,28 @@ module NoBrainer::Criteria::Where
 
       case association
       when NoBrainer::Document::Association::BelongsTo::Metadata then association.foreign_key
-      else ensure_valid_key!(key); key
+      else model.ensure_valid_key!(key); key
       end
     end
-
-    def ensure_valid_key!(key)
-      return if model.has_field?(key) || model.has_index?(key) || model < NoBrainer::Document::DynamicAttributes
-      raise NoBrainer::Error::UnknownAttribute, "`#{key}' is not a declared attribute of #{model}"
-    end
   end
 
-  class UnaryOperator < Struct.new(:op, :value)
+  class UnaryOperator < Struct.new(:op, :clause)
     def simplify
-      value.is_a?(UnaryOperator) && [self.op, value.op] == [:not, :not] ? value.value : self
+      simplified_clause = self.clause.simplify
+
+      case simplified_clause
+      when UnaryOperator then
+        case [self.op, simplified_clause.op]
+        when [:not, :not] then simplified_clause.clause
+        else self.class.new(op, simplified_clause)
+        end
+      else self.class.new(op, simplified_clause)
+      end
     end
 
     def to_rql(doc)
       case op
-      when :not then value.to_rql(doc).not
+      when :not then clause.to_rql(doc).not
       end
     end
   end
@@ -256,15 +262,12 @@ module NoBrainer::Criteria::Where
     when :_and then parse_multi_value(:and, value, :safe => true)
     when :_or  then parse_multi_value(:or,  value, :safe => true)
     when :not  then UnaryOperator.new(:not, parse_clause(value))
-    when String, Symbol then parse_clause_stub_eq(key, value)
+    when String, Symbol then instantiate_binary_op(key, :eq, value)
     when Symbol::Decoration then
       case key.decorator
-      when :any, :all then parse_clause_stub_eq(key, value)
-      when :not, :ne  then parse_clause(:not => { key.symbol.eq => value })
-      when :nin then parse_clause(:not => { key.symbol.in => value })
-      when :gte then parse_clause(key.symbol.ge => value)
-      when :lte then parse_clause(key.symbol.le => value)
-      when :eq  then parse_clause_stub_eq(key.symbol, value)
+      when :any, :all, :not then instantiate_binary_op(key, :eq, value)
+      when :gte then instantiate_binary_op(key.symbol, :ge, value)
+      when :lte then instantiate_binary_op(key.symbol, :le, value)
       else instantiate_binary_op(key.symbol, key.decorator, value)
       end
     else raise "Invalid key: #{key}"
@@ -282,14 +285,6 @@ module NoBrainer::Criteria::Where
     MultiOperator.new(op, value.map { |v| parse_clause(v) })
   end
 
-  def parse_clause_stub_eq(key, value)
-    case value
-    when Range  then instantiate_binary_op(key, :between, value)
-    when Regexp then instantiate_binary_op(key, :match, translate_regexp_to_re2_syntax(value))
-    else instantiate_binary_op(key, :eq, value)
-    end
-  end
-
   def translate_regexp_to_re2_syntax(value)
     # Ruby always uses what RE2 calls "multiline mode" (the "m" flag),
     # meaning that "foo\nbar" matches /^bar$/.
@@ -304,8 +299,19 @@ module NoBrainer::Criteria::Where
   end
 
   def instantiate_binary_op(key, op, value)
+    op, value = case value
+                when Range  then [:between, value]
+                when Regexp then [:match, translate_regexp_to_re2_syntax(value)]
+                else [:eq, value]
+                end if op == :eq
+
     case key
-    when Symbol::Decoration then BinaryOperator.new(key.symbol, key.decorator, op, value, self.model)
+    when Symbol::Decoration
+      raise "Use only one .not, .all or .any modifiers in the query" if key.symbol.is_a?(Symbol::Decoration)
+      case key.decorator
+        when :any, :all then BinaryOperator.new(key.symbol, key.decorator, op, value, self.model)
+        when :not       then UnaryOperator.new(:not, BinaryOperator.new(key.symbol, :scalar, op, value, self.model))
+      end
     else BinaryOperator.new(key, :scalar, op, value, self.model)
     end
   end
@@ -319,12 +325,12 @@ module NoBrainer::Criteria::Where
 
       def rql_proc
         lambda do |rql|
+          return RethinkDB::RQL.new.expr([]) if rql_op == :get_all && rql_args.empty?
+
           opt = (rql_options || {}).merge(:index => index.aliased_name)
           r = rql.__send__(rql_op, *rql_args, opt)
           r = r.map { |i| i['doc'] } if rql_op == :get_nearest
-          # TODO distinct: waiting for issue #3345
-          # TODO coerce_to: waiting for issue #3346
-          r = r.coerce_to('array').distinct if index.multi && !index_finder.criteria.options[:without_distinct]
+          r = r.distinct if index.multi && !index_finder.criteria.options[:without_distinct]
           r
         end
       end
@@ -357,8 +363,10 @@ module NoBrainer::Criteria::Where
           when :intersects then [:get_intersecting, clause.value.to_rql]
           when :near
             options = clause.value.dup
-            point = options.delete(:point)
-            [:get_nearest, point.to_rql, options]
+            circle = options.delete(:circle)
+            options.delete(:max_results) if options[:max_results].nil?
+            options[:max_dist] = circle.radius
+            [:get_nearest, circle.center.to_rql, circle.options.merge(options)]
           when :eq      then [:get_all, [clause.value]]
           when :in      then [:get_all, clause.value]
           when :between then [:between, [clause.value.min, clause.value.max],

data/lib/no_brainer/document.rb

@@ -5,7 +5,7 @@ module NoBrainer::Document
   extend NoBrainer::Autoload
 
   autoload_and_include :Core, :StoreIn, :InjectionLayer, :Attributes, :Readonly,
-                       :Persistance, :Validation, :Types, :Callbacks, :Dirty, :PrimaryKey,
+                       :Persistance, :Callbacks, :Validation, :Types, :Dirty, :PrimaryKey,
                        :Association, :Serialization, :Criteria, :Polymorphic, :Index, :Aliases,
                        :MissingAttributes, :LazyFetch, :AtomicOps
 

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

@@ -15,7 +15,7 @@ class NoBrainer::Document::Association::BelongsTo
     end
 
     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
@@ -24,14 +24,18 @@ class NoBrainer::Document::Association::BelongsTo
 
     def hook
       super
-      # XXX We are loading the target_model unless the primary_key is not
-      # specified. This may eager load a part of the application.
-      # Oh well.
+      # XXX We are loading the target_model unless the primary_key is specified.
+      # This may eager load a part of the application  Oh well.
 
       # TODO if the primary key of the target_model changes, we need to revisit
       # our default foreign_key/primary_key value
 
       # 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])
 
       unless options[:validates] == false

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

@@ -7,7 +7,7 @@ class NoBrainer::Document::Association::HasMany
     extend NoBrainer::Document::Association::EagerLoader::Generic
 
     def foreign_key
-      options[:foreign_key].try(:to_sym) || :"#{owner_model.name.underscore}_#{primary_key}"
+      options[:foreign_key].try(:to_sym) || :"#{owner_model.name.split('::').last.underscore}_#{primary_key}"
     end
 
     def primary_key
@@ -15,7 +15,7 @@ class NoBrainer::Document::Association::HasMany
     end
 
     def target_model
-      (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

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

@@ -1,7 +1,7 @@
 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
   end
 

data/lib/no_brainer/document/attributes.rb

@@ -157,5 +157,10 @@ module NoBrainer::Document::Attributes
     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 declared 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/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

data/lib/no_brainer/document/persistance.rb

@@ -60,12 +60,11 @@ module NoBrainer::Document::Persistance
   end
 
   def _create(options={})
-    return false if options[:validate] != false && !valid?(nil, :clear_errors => false)
-
     attrs = self.class.persistable_attributes(@_attributes, :instance => self)
     result = NoBrainer.run(self.class.rql_table.insert(attrs))
     self.pk_value ||= result['generated_keys'].to_a.first
     @new_record = false
+    unlock_unique_fields # just an optimization for the uniquness validation
     true
   end
 
@@ -75,8 +74,6 @@ module NoBrainer::Document::Persistance
   end
 
   def _update_only_changed_attrs(options={})
-    return false if options[:validate] != false && !valid?(nil, :clear_errors => false)
-
     # We won't be using the `changes` values, because they went through
     # read_attribute(), and we want the raw values.
     attrs = Hash[self.changed.map do |k|
@@ -87,26 +84,24 @@ module NoBrainer::Document::Persistance
       [k, attr]
     end]
     _update(attrs) if attrs.present?
+    unlock_unique_fields # just an optimization for the uniquness validation
     true
   end
 
-  def _save?(options)
+  def _save?(options={})
     new_record? ? _create(options) : _update_only_changed_attrs(options)
   end
 
   def save?(options={})
-    errors.clear
     _save?(options)
   end
 
-  def save(*args)
+  def save!(*args)
     save?(*args) or raise NoBrainer::Error::DocumentInvalid, self
-    nil
   end
 
-  def save!(*args)
-    save(*args)
-    :you_should_be_using_the_non_bang_version_of_save
+  def save(*args)
+    save?(*args)
   end
 
   def update?(attrs, options={})
@@ -114,27 +109,13 @@ module NoBrainer::Document::Persistance
     save?(options)
   end
 
-  def update(*args)
-    update?(*args) or raise NoBrainer::Error::DocumentInvalid, self
-    nil
-  end
-
   def update!(*args)
-    update(*args)
-    :you_should_be_using_the_non_bang_version_of_update
+    update?(*args) or raise NoBrainer::Error::DocumentInvalid, self
   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" }
+  def update(*args)
+    update?(*args)
   end
 
   def delete
@@ -152,9 +133,12 @@ module NoBrainer::Document::Persistance
 
   module ClassMethods
     def create(attrs={}, options={})
-      new(attrs, options).tap { |doc| doc.save(options) }
+      new(attrs, options).tap { |doc| doc.save?(options) }
+    end
+
+    def create!(attrs={}, options={})
+      new(attrs, options).tap { |doc| doc.save!(options) }
     end
-    alias_method :create!, :create
 
     def insert_all(*args)
       docs = args.shift

data/lib/no_brainer/document/validation.rb

@@ -1,63 +1,6 @@
 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,
-                     :scope => [:kind, :name], :terminator => proc { false }
-  end
-
-  def valid?(context=nil, options={})
-    context ||= new_record? ? :create : :update
-
-   # 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!
-  ensure
-    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
-
-      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)
-    return true unless record.is_a?(NoBrainer::Document)
-    return true if record.new_record?
-
-    attr_changed = "#{attribute}_changed?"
-    return record.respond_to?(attr_changed) ? record.__send__(attr_changed) : true
-  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
+  autoload_and_include :Core, :Uniqueness, :NotNull
 end

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

@@ -0,0 +1,63 @@
+module NoBrainer::Document::Validation::Core
+  extend ActiveSupport::Concern
+  include ActiveModel::Validations
+  include ActiveModel::Validations::Callbacks
+
+  included do
+    # We don't want before_validation returning false to halt the chain.
+    define_callbacks :validation, :skip_after_callbacks_if_terminated => true,
+                     :scope => [:kind, :name], :terminator => proc { false }
+  end
+
+  def valid?(context=nil, options={})
+    super(context || (new_record? ? :create : :update))
+  end
+
+  def save?(options={})
+    options = { :validate => true }.merge(options)
+
+    if options[:validate]
+      valid? ? super : false
+    else
+      super
+    end
+  end
+
+  SHORTHANDS = { :format => :format, :length => :length, :required => :presence,
+                 :uniq => :uniqueness, :unique => :uniqueness, :in => :inclusion }
+
+  module ClassMethods
+    def _field(attr, options={})
+      super
+
+      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)
+    return true unless record.is_a?(NoBrainer::Document)
+    return true if record.new_record?
+
+    attr_changed = "#{attribute}_changed?"
+    return record.respond_to?(attr_changed) ? record.__send__(attr_changed) : true
+  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/uniqueness.rb

@@ -1,14 +1,7 @@
 module NoBrainer::Document::Validation::Uniqueness
   extend ActiveSupport::Concern
 
-  def _create(options={})
-    lock_unique_fields
-    super
-  ensure
-    unlock_unique_fields
-  end
-
-  def _update_only_changed_attrs(options={})
+  def save?(options={})
     lock_unique_fields
     super
   ensure
@@ -93,7 +86,7 @@ module NoBrainer::Document::Validation::Uniqueness
     end
 
     def exclude_doc(criteria, doc)
-      criteria.where(doc.class.pk_name.ne => doc.pk_value)
+      criteria.where(doc.class.pk_name.not => doc.pk_value)
     end
   end
 end

data/lib/no_brainer/geo/base.rb

@@ -9,7 +9,6 @@ module NoBrainer::Geo::Base
 
     options[:unit] = unit if unit && unit.to_s != 'm'
     options[:geo_system] = geo_system if geo_system && geo_system.to_s != 'WGS84'
-    options[:max_dist] = options.delete(:max_distance) if options[:max_distance]
 
     options
   end

data/lib/nobrainer.rb

@@ -1,5 +1,6 @@
 require 'set'
 require 'active_support'
+require 'active_model'
 require 'thread'
 %w(module/delegation module/attribute_accessors module/introspection
    class/attribute object/blank object/inclusion object/deep_dup

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: nobrainer
 version: !ruby/object:Gem::Version
-  version: 0.23.0
+  version: 0.24.0
 platform: ruby
 authors:
 - Nicolas Viennot
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-04-19 00:00:00.000000000 Z
+date: 2015-05-20 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rethinkdb
@@ -158,6 +158,7 @@ files:
 - lib/no_brainer/document/types/text.rb
 - lib/no_brainer/document/types/time.rb
 - lib/no_brainer/document/validation.rb
+- lib/no_brainer/document/validation/core.rb
 - lib/no_brainer/document/validation/not_null.rb
 - lib/no_brainer/document/validation/uniqueness.rb
 - lib/no_brainer/error.rb