nobrainer 0.30.0 → 0.31.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: ebe188d50e06d6ef907cdf043560143e3bd7d703
-  data.tar.gz: 15b1580f27a66b6670386cc117b4767f930e67c7
+  metadata.gz: 657fd4dc2ef9b4dd9383ea99fa14b99d386e19ad
+  data.tar.gz: 63b01fce35c08ffed01ff23496a5cc7eb394e1ab
 SHA512:
-  metadata.gz: ff9b387f2045109c33efb88d36273325edf34573acb134bbb94d3d2e04c1efd6fdf65b761739eac61c185309cfa9deba5a07987fdf56becf3d78308b300838b9
-  data.tar.gz: acb0f33b44d27ac25599352b0d568dd563e13a81da91b0dfef6cf72596a1500026e739f2cc64c63e22edc72ddb57ee3b61a70acf72c139cd502f0b1d95e78c9b
+  metadata.gz: fc92ed2d5c2cbdfee45b3f32504090412820b205f1cdd45f3deca3ed5a98754c23ffafef30f32c2aa2fe3b96d7cecd4a88165a7d014a7c3205efebe81c016501
+  data.tar.gz: 45428c47e16c508b1845314d01221b749b14588ee20c0ca76b9cf981216f6c1728fccd396072c3935eded21491d78596ccc76167f59cb0fbbff7fbfd4ca5fda1

data/lib/no_brainer/criteria/first_or_create.rb

@@ -20,7 +20,10 @@ module NoBrainer::Criteria::FirstOrCreate
   private
 
   def _upsert(attrs, save_options)
-    attrs = attrs.symbolize_keys
+    # Note: we don't do a full cast of user_to_cast because where() takes care
+    # of it. We just need to locate a suitable uniqueness validator, for which
+    # we just need to translate keys.
+    attrs = Hash[attrs.map { |k,v| model.association_user_to_model_cast(k.to_sym, v) }]
     unique_keys = get_model_unique_fields.detect { |keys| keys & attrs.keys == keys }
     return where(attrs.slice(*unique_keys)).__send__(:_first_or_create, attrs, save_options) if unique_keys
 

data/lib/no_brainer/criteria/join.rb

@@ -36,6 +36,7 @@ module NoBrainer::Criteria::Join
 
   def _instantiate_model(attrs, options={})
     return super unless @options[:join] && !raw?
+    return super if attrs.nil?
 
     associated_instances = join_ast.map do |association, criteria|
       [association, criteria.send(:_instantiate_model, attrs.delete(association.target_name.to_s))]
@@ -53,7 +54,7 @@ module NoBrainer::Criteria::Join
     join_ast.reduce(super) do |rql, (association, criteria)|
       rql.concat_map do |doc|
         key = doc[association.eager_load_owner_key]
-        RethinkDB::RQL.new.branch(key.eq(nil), [],
+        RethinkDB::RQL.new.branch(key.default(nil).eq(nil), [],
           criteria.where(association.eager_load_target_key => key).to_rql.map do |assoc_doc|
             doc.merge(association.target_name => assoc_doc)
         end)

data/lib/no_brainer/criteria/virtual_attributes.rb

@@ -8,7 +8,14 @@ module NoBrainer::Criteria::VirtualAttributes
       rql = rql.map do |_doc|
         model.virtual_fields.reduce(_doc) do |doc, field|
           field_rql = model.fields[field][:virtual].call(doc, RethinkDB::RQL.new)
-          field_rql.nil? ? doc : doc.merge(field => field_rql)
+          if field_rql.nil?
+            doc
+          else
+            unless field_rql.is_a?(RethinkDB::RQL)
+              raise "The virtual attribute `#{model}.#{field}' should return a RQL expression"
+            end
+            doc.merge(field => field_rql)
+          end
         end
       end
     end

data/lib/no_brainer/criteria/where.rb

@@ -150,69 +150,57 @@ module NoBrainer::Criteria::Where
       raise "Incorrect use of `#{op}' and `#{key_modifier}'" if key_modifier != :scalar
     end
 
-    def association
-      return nil if key_path.size > 1
-      @association ||= [model.association_metadata[key_path.first]]
-      @association.first
-    end
-
     def cast_value(value)
       return value if casted_values
 
-      case association
-      when NoBrainer::Document::Association::BelongsTo::Metadata
-        target_model = association.target_model
-        unless value.is_a?(target_model)
-          opts = { :model => model, :attr_name => key_path.first, :type => target_model, :value => value }
-          raise NoBrainer::Error::InvalidType.new(opts)
-        end
-        value.pk_value
-      else
-        case op
-        when :defined, :undefined then NoBrainer::Boolean.nobrainer_cast_user_to_model(value)
-        when :intersects
-          raise "Use a geo object with `intersects`" unless value.is_a?(NoBrainer::Geo::Base)
-          value
-        when :near
-          # TODO enforce key is a geo type
-          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] }
+      case op
+      when :defined, :undefined then NoBrainer::Boolean.nobrainer_cast_user_to_model(value)
+      when :intersects
+        raise "Use a geo object with `intersects`" unless value.is_a?(NoBrainer::Geo::Base)
+        value
+      when :near
+        # TODO enforce key is a geo type
+        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
-          when NoBrainer::Geo::Circle then { :circle => value }
-          else raise "Incorrect use of `near': rvalue must be a hash or a circle"
+            { :circle => NoBrainer::Geo::Circle.new(options), :max_results => options[:max_results] }
           end
-        else
-          # 1) Box value in array if we have an any/all modifier
-          # 2) Box value in hash if we have a nested query.
-          box_value = key_modifier.in?([:any, :all]) || op == :include
-          value = [value] if box_value
-          value_hash = key_path.reverse.reduce(value) { |v,k| {k => v} }
-          value = model.cast_user_to_db_for(*value_hash.first)
-          value = key_path[1..-1].reduce(value) { |h,k| h[k] }
-          value = value.first if box_value
-          value
+        when NoBrainer::Geo::Circle then { :circle => value }
+        else raise "Incorrect use of `near': rvalue must be a hash or a circle"
         end
+      else
+        # 1) Box value in array if we have an any/all modifier
+        # 2) Box value in hash if we have a nested query.
+        box_value = key_modifier.in?([:any, :all]) || op == :include
+        value = [value] if box_value
+        k_v = key_path.reverse.reduce(value) { |v,k| {k => v} }.first
+        k_v = model.association_user_to_model_cast(*k_v)
+        value = model.cast_user_to_db_for(*k_v)
+        value = key_path[1..-1].reduce(value) { |h,k| h[k] }
+        value = value.first if box_value
+        value
       end
     end
 
-    def cast_key_path(key)
-      return key if casted_values
+    def cast_key_path(key_path)
+      return key_path if casted_values
 
-      case association
-      when NoBrainer::Document::Association::BelongsTo::Metadata then [association.foreign_key]
-      else model.ensure_valid_key!(key_path.first); key_path
+      if key_path.size == 1
+        k, _v = model.association_user_to_model_cast(key_path.first, nil)
+        key_path = [k]
       end
+
+      model.ensure_valid_key!(key_path.first)
+      key_path
     end
   end
 
@@ -365,7 +353,7 @@ module NoBrainer::Criteria::Where
     end
 
     def find_strategy_canonical
-      clauses = get_candidate_clauses(:eq, :in, :between, :near, :intersects)
+      clauses = get_candidate_clauses(:eq, :in, :between, :near, :intersects, :defined)
       return nil unless clauses.present?
 
       usable_indexes = Hash[get_usable_indexes.map { |i| [[i.name], i] }]
@@ -384,6 +372,11 @@ module NoBrainer::Criteria::Where
             [: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 :defined then
+            next unless clause.value == true
+            next unless clause.key_modifier == :scalar && index.multi == false
+            [:between, [RethinkDB::RQL.new.minval, RethinkDB::RQL.new.maxval],
+             :left_bound => :open, :right_bound => :open]
           when :between then [:between, [clause.value.min, clause.value.max],
                               :left_bound => :closed, :right_bound => :closed]
         end

data/lib/no_brainer/document/association.rb

@@ -21,6 +21,14 @@ module NoBrainer::Document::Association
       super
     end
 
+    def association_user_to_model_cast(k,v)
+      association = association_metadata[k]
+      case association
+      when NoBrainer::Document::Association::BelongsTo::Metadata then association.cast_attr(k,v)
+      else [k,v]
+      end
+    end
+
     METHODS.each do |association|
       define_method(association) do |target, options={}|
         target = target.to_sym

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

@@ -2,7 +2,8 @@ class NoBrainer::Document::Association::BelongsTo
   include NoBrainer::Document::Association::Core
 
   class Metadata
-    VALID_OPTIONS = [:primary_key, :foreign_key, :class_name, :foreign_key_store_as, :index, :validates, :required]
+    VALID_OPTIONS = [:primary_key, :foreign_key, :class_name, :foreign_key_store_as,
+                     :index, :validates, :required, :uniq, :unique]
     include NoBrainer::Document::Association::Core::Metadata
     include NoBrainer::Document::Association::EagerLoader::Generic
 
@@ -51,12 +52,17 @@ class NoBrainer::Document::Association::BelongsTo
       unless options[:validates] == false
         owner_model.validates(target_name, options[:validates]) if options[:validates]
 
+        uniq = options[:uniq] || options[:unique]
+        if uniq
+          owner_model.validates(foreign_key, :uniqueness => uniq)
+        end
+
         if options[:required]
           owner_model.validates(target_name, :presence => options[:required])
         else
-          # Always validate the validity of the foreign_key if not nil.
+          # Always validate the foreign_key if not nil.
           owner_model.validates_each(foreign_key) do |doc, attr, value|
-            if !value.nil? && doc.read_attribute_for_validation(target_name).nil?
+            if !value.nil? && value != doc.pk_value && doc.read_attribute_for_validation(target_name).nil?
               doc.errors.add(attr, :invalid_foreign_key, :target_model => target_model, :primary_key => primary_key)
             end
           end
@@ -68,6 +74,16 @@ class NoBrainer::Document::Association::BelongsTo
       add_callback_for(:after_validation)
     end
 
+    def cast_attr(k, v)
+      case v
+      when target_model then [foreign_key, v.__send__(primary_key)]
+      when nil          then [foreign_key, nil]
+      else
+        opts = { :model => owner_model, :attr_name => k, :type => target_model, :value => v }
+        raise NoBrainer::Error::InvalidType.new(opts)
+      end
+    end
+
     def eager_load_owner_key;  foreign_key; end
     def eager_load_target_key; primary_key; end
   end
@@ -109,7 +125,7 @@ class NoBrainer::Document::Association::BelongsTo
   end
 
   def after_validation_callback
-    if loaded? && target && !target.persisted?
+    if loaded? && target && !target.persisted? && target != owner
       raise NoBrainer::Error::AssociationNotPersisted.new("#{target_name} must be saved first")
     end
   end

data/lib/no_brainer/document/core.rb

@@ -9,7 +9,16 @@ module NoBrainer::Document::Core
     extend ActiveModel::Naming
     extend ActiveModel::Translation
 
-    NoBrainer::Document::Core._all << self unless name =~ /^NoBrainer::/
+    unless name =~ /^NoBrainer::/
+      if NoBrainer::Document::Core._all.map(&:name).include?(name)
+        raise "Fatal: The model `#{name}' is already registered and partially loaded.\n" +
+              "This may happen when an exception occured while loading the model definitions\n" +
+              "(e.g. calling a missing class method on another model, having circular dependencies).\n" +
+              "In this situation, ActiveSupport autoloader may retry loading the model.\n" +
+              "Try moving all class methods declaration at the top of the model."
+      end
+      NoBrainer::Document::Core._all << self
+    end
   end
 
   def self.all(options={})

data/lib/no_brainer/document/lazy_fetch.rb

@@ -49,6 +49,7 @@ module NoBrainer::Document::LazyFetch
             raise e unless attr.in?(@lazy_fetch)
             reload(:pluck => attr, :keep_ivars => true)
             @lazy_fetch.delete(attr)
+            clear_missing_field(attr)
             retry
           end
         end

data/lib/no_brainer/document/persistance.rb

@@ -112,6 +112,7 @@ module NoBrainer::Document::Persistance
   def update(*args)
     update?(*args)
   end
+  alias_method :update_attributes, :update # for API compat like devise
 
   def delete
     unless @destroyed

data/lib/no_brainer/document/primary_key/generator.rb

@@ -3,7 +3,7 @@ module NoBrainer::Document::PrimaryKey::Generator
 
   BASE_TABLE = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz".freeze
 
-  TIME_OFFSET = Time.parse('2014-01-01').to_i
+  TIME_OFFSET = Time.utc(2014, 01, 01).to_i
 
   # 30 bits timestamp with 1s resolution -> We overflow in year 2048. Good enough.
   # Math.log(Time.parse('2048-01-01').to_f - TIME_OFFSET)/Math.log(2) = 29.999

data/lib/no_brainer/document/table_config/synchronizer.rb

@@ -4,12 +4,7 @@ class NoBrainer::Document::TableConfig::Synchronizer
   end
 
   def sync_table_config(options={})
-    # XXX A bit funny since we might touch the lock table...
-    lock = NoBrainer::Lock.new('nobrainer:sync_table_config')
-
-    lock.synchronize do
-      @models.each(&:sync_table_config)
-    end
+    @models.each(&:sync_table_config)
 
     unless options[:wait] == false
       # Waiting on all models due to possible races

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: nobrainer
 version: !ruby/object:Gem::Version
-  version: 0.30.0
+  version: 0.31.0
 platform: ruby
 authors:
 - Nicolas Viennot
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-10-03 00:00:00.000000000 Z
+date: 2016-02-07 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rethinkdb
@@ -237,7 +237,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.4.6
+rubygems_version: 2.5.1
 signing_key: 
 specification_version: 4
 summary: ORM for RethinkDB