nobrainer 0.27.0 → 0.28.0

data/lib/no_brainer/document.rb

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

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

@@ -4,7 +4,7 @@ class NoBrainer::Document::Association::BelongsTo
   class Metadata
     VALID_OPTIONS = [:primary_key, :foreign_key, :class_name, :foreign_key_store_as, :index, :validates, :required]
     include NoBrainer::Document::Association::Core::Metadata
-    extend NoBrainer::Document::Association::EagerLoader::Generic
+    include NoBrainer::Document::Association::EagerLoader::Generic
 
     def foreign_key
       options[:foreign_key].try(:to_sym) || :"#{target_name}_#{primary_key}"
@@ -34,7 +34,7 @@ class NoBrainer::Document::Association::BelongsTo
     end
 
     def base_criteria
-      target_model.unscoped
+      target_model.without_ordering.unscoped
     end
 
     def hook
@@ -68,7 +68,8 @@ class NoBrainer::Document::Association::BelongsTo
       add_callback_for(:after_validation)
     end
 
-    eager_load_with :owner_key => ->{ foreign_key }, :target_key => ->{ primary_key }
+    def eager_load_owner_key;  foreign_key; end
+    def eager_load_target_key; primary_key; end
   end
 
   # Note:

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

@@ -1,31 +1,32 @@
-class NoBrainer::Document::Association::EagerLoader
+module NoBrainer::Document::Association::EagerLoader
+  extend self
+
   module Generic
     # Used in associations to declare generic eager loading capabilities
-    # The association should implement loaded? and preload.
-    def eager_load_with(options={})
-      define_method(:eager_load) do |docs, additional_criteria=nil|
-        owner_key  = instance_exec(&options[:owner_key])
-        target_key = instance_exec(&options[:target_key])
-
-        criteria = base_criteria
-        criteria = criteria.merge(additional_criteria) if additional_criteria
-
-        unloaded_docs = docs.reject { |doc| doc.associations[self].loaded? }
-
-        owner_keys = unloaded_docs.map(&owner_key).compact.uniq
-        if owner_keys.present?
-          targets = criteria.where(target_key.in => owner_keys)
-                            .map { |target| [target.read_attribute(target_key), target] }
-                            .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)]
-            doc.associations[self].preload(doc_targets)
-          end
-        end
+    # The association should implement loaded?, preload,
+    # eager_load_owner_key and eager_load_target_key.
+    def eager_load(docs, additional_criteria=nil)
+      owner_key  = eager_load_owner_key
+      target_key = eager_load_target_key
+
+      criteria = base_criteria
+      criteria = criteria.merge(additional_criteria) if additional_criteria
+
+      unloaded_docs = docs.reject { |doc| doc.associations[self].loaded? }
 
-        docs.map { |doc| doc.associations[self].read }.flatten.compact.uniq
+      owner_keys = unloaded_docs.map(&owner_key).compact.uniq
+      if owner_keys.present?
+        targets = criteria.where(target_key.in => owner_keys)
+        .map { |target| [target.read_attribute(target_key), target] }
+        .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)]
+          doc.associations[self].preload(doc_targets)
+        end
       end
+
+      docs.map { |doc| doc.associations[self].read }.flatten.compact.uniq
     end
   end
 
@@ -40,7 +41,7 @@ class NoBrainer::Document::Association::EagerLoader
 
   def eager_load(docs, what)
     case what
-    when Hash  then what.each do |k,v|
+    when Hash then what.each do |k,v|
       if v.is_a?(NoBrainer::Criteria)
         v = v.dup
         nested_preloads, v.options[:eager_load] = v.options[:eager_load], []

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

@@ -4,7 +4,7 @@ class NoBrainer::Document::Association::HasMany
   class Metadata
     VALID_OPTIONS = [:primary_key, :foreign_key, :class_name, :dependent, :scope]
     include NoBrainer::Document::Association::Core::Metadata
-    extend NoBrainer::Document::Association::EagerLoader::Generic
+    include NoBrainer::Document::Association::EagerLoader::Generic
 
     def foreign_key
       options[:foreign_key].try(:to_sym) || :"#{owner_model.name.split('::').last.underscore}_#{primary_key}"
@@ -53,7 +53,8 @@ class NoBrainer::Document::Association::HasMany
       end
     end
 
-    eager_load_with :owner_key => ->{ primary_key }, :target_key => ->{ foreign_key }
+    def eager_load_owner_key;  primary_key; end
+    def eager_load_target_key; foreign_key; end
   end
 
   def target_criteria

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

@@ -17,7 +17,7 @@ class NoBrainer::Document::Association::HasManyThrough
     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
+      NoBrainer::Document::Association::EagerLoader
         .eager_load_association(through_association.eager_load(docs), target_name, criteria)
     end
 
@@ -29,7 +29,6 @@ class NoBrainer::Document::Association::HasManyThrough
   end
 
   def read
-    # TODO implement joins
     @targets ||= metadata.eager_load([owner]).freeze
   end
 

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

@@ -3,6 +3,10 @@ class NoBrainer::Document::Association::HasOne < NoBrainer::Document::Associatio
     def target_model
       get_model_by_name(options[:class_name] || target_name.to_s.camelize)
     end
+
+    def base_criteria
+      super.without_ordering
+    end
   end
 
   def read

data/lib/no_brainer/document/atomic_ops.rb

@@ -42,7 +42,7 @@ module NoBrainer::Document::AtomicOps
     def to_s
       "<`#{@field}' with #{@ops.size} pending atomic operations>"
     end
-    alias_method :inspect, :to_s
+    def inspect; to_s; end
 
     def method_missing(method, *a, &b)
       if method == :<<
@@ -131,6 +131,18 @@ module NoBrainer::Document::AtomicOps
     end
   end
 
+  class PendingAtomicUnset < PendingAtomic
+    def to_s
+      "<unset `#{@field}'>"
+    end
+
+    undef_method(:method_missing)
+
+    def compile_rql_value(rql_doc)
+      RethinkDB::RQL.new.literal()
+    end
+  end
+
   def clear_dirtiness(options={})
     super
     @_touched_attributes = Set.new
@@ -172,13 +184,18 @@ module NoBrainer::Document::AtomicOps
   end
 
   def _read_attribute(name)
+    return super if name == self.class.pk_name
+
     ensure_exclusive_atomic!
-    value = super
-    return value unless in_atomic?
+    return super unless in_atomic?
+
+    # If we are missing fields, it's okay, we'll assume nil.
+    value = missing_field?(name) ? nil : super
 
     case value
     when PendingAtomicContainer then value
-    when PendingAtomic then value.dup
+    when PendingAtomicUnset     then raise "Attribute `#{name}' is unset"
+    when PendingAtomic          then value.dup
     else PendingAtomic._new(self, name, value, _is_attribute_touched?(name))
     end
   end
@@ -199,6 +216,11 @@ module NoBrainer::Document::AtomicOps
     super
   end
 
+  def unset(attr)
+    return queue_atomic { unset(attr) } unless in_atomic?
+    _write_attribute(attr, PendingAtomicUnset.new(self, attr, nil, true, nil))
+  end
+
   def save?(options={})
     # TODO allow reload => true as an option to save+reload in a single op.
     raise NoBrainer::Error::AtomicBlock.new('You may persist documents only outside of queue_atomic blocks') if in_atomic?
@@ -212,6 +234,11 @@ module NoBrainer::Document::AtomicOps
     end
   end
 
+  def reload(*)
+    raise NoBrainer::Error::AtomicBlock.new('You may not reload fields within an atomic block') if in_atomic?
+    super
+  end
+
   module ClassMethods
     def persistable_value(k, v, options={})
       v.is_a?(PendingAtomic) ? v.compile_rql_value(options[:rql_doc]) : super

data/lib/no_brainer/document/attributes.rb

@@ -49,8 +49,10 @@ module NoBrainer::Document::Attributes
 
   def assign_defaults(options)
     self.class.fields.each do |name, field_options|
-      next unless field_options.has_key?(:default) &&
-                  !@_attributes.has_key?(name)
+      # :default => nil will not set the value to nil, but :default => ->{ nil } will.
+      # This is useful to unset a default value.
+
+      next if field_options[:default].nil? || @_attributes.key?(name)
 
       if opt = options[:missing_attributes]
         if (opt[:pluck] && !opt[:pluck][name]) ||
@@ -113,8 +115,14 @@ module NoBrainer::Document::Attributes
       super
     end
 
+    # The different between _field and field is that field can set other options
+    # (c.f. primary key module). _field always receive an immutable options list.
     def _field(attr, options={})
-      # Using a layer so the user can use super when overriding these methods
+      options.assert_valid_keys(*VALID_FIELD_OPTIONS)
+      if attr.in?(RESERVED_FIELD_NAMES)
+        raise "The field name `:#{attr}' is reserved. Please use another one."
+      end
+
       attr = attr.to_s
       inject_in_layer :attributes do
         define_method("#{attr}=") { |value| _write_attribute(attr, value) }
@@ -125,11 +133,6 @@ module NoBrainer::Document::Attributes
     def field(attr, options={})
       attr = attr.to_sym
 
-      options.assert_valid_keys(*VALID_FIELD_OPTIONS)
-      if attr.in?(RESERVED_FIELD_NAMES)
-        raise "Cannot use a reserved field attr: #{attr}"
-      end
-
       subclass_tree.each do |subclass|
         subclass.fields[attr] ||= {}
         subclass.fields[attr].deep_merge!(options)
@@ -161,7 +164,7 @@ module NoBrainer::Document::Attributes
 
     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}"
+      raise NoBrainer::Error::UnknownAttribute, "`#{key}' is not a valid attribute of #{self}"
     end
   end
 end

data/lib/no_brainer/document/core.rb

@@ -1,30 +1,30 @@
 module NoBrainer::Document::Core
   extend ActiveSupport::Concern
 
-  singleton_class.class_eval do
-    attr_accessor :_all, :_all_nobrainer
-
-    def all
-      Rails.application.eager_load! if defined?(Rails.application.eager_load!)
-      @_all
-    end
-  end
+  singleton_class.class_eval { attr_accessor :_all }
   self._all = []
-  self._all_nobrainer = []
-
-  include ActiveModel::Conversion
-
-  def to_key
-     # ActiveModel::Conversion stuff
-    [pk_value]
-  end
 
   included do
     # TODO test these includes
     extend ActiveModel::Naming
     extend ActiveModel::Translation
 
-    list_name = self.name =~ /^NoBrainer::/ ? :_all_nobrainer : :_all
-    NoBrainer::Document::Core.__send__(list_name) << self
+    NoBrainer::Document::Core._all << self unless name =~ /^NoBrainer::/
+  end
+
+  def self.all(options={})
+    (options[:types] || [:user]).map do |type|
+      case type
+      when :user
+        Rails.application.eager_load! if defined?(Rails.application.eager_load!)
+        _all
+      when :nobrainer
+        [NoBrainer::Document::Index::MetaStore, NoBrainer::Lock]
+      when :system
+        NoBrainer::System.constants
+          .map { |c| NoBrainer::System.const_get(c) }
+          .select { |m| m < NoBrainer::Document }
+      end
+    end.reduce([], &:+)
   end
 end

data/lib/no_brainer/document/criteria.rb

@@ -18,7 +18,7 @@ module NoBrainer::Document::Criteria
              :limit, :offset, :skip,         # Limit
              :order_by, :reverse_order, :without_ordering, :order_by_indexed?, :order_by_index_name, # OrderBy
              :unscoped,                      # Scope
-             :where, :where_indexed?, :where_index_name, :where_index_type, # Where
+             :_where, :where, :where_indexed?, :where_index_name, :where_index_type, # Where
              :with_index, :without_index, :used_index, # Index
              :with_cache, :without_cache,    # Cache
              :count, :empty?, :any?,         # Count
@@ -26,12 +26,13 @@ module NoBrainer::Document::Criteria
              :preload, :eager_load,          # EagerLoad
              :each, :to_a,                   # Enumerable
              :first, :last, :first!, :last!, :sample, # First
-             :first_or_create, :first_or_create!, # FirstOrCreate
+             :upsert, :upsert!, :first_or_create, :first_or_create!, # FirstOrCreate
              :min, :max, :sum, :avg,         # Aggregate
              :update_all, :replace_all,      # Update
              :changes,                       # Changes
              :pluck, :without, :lazy_fetch, :without_plucking, # Pluck
              :find_by?, :find_by, :find_by!, :find?, :find, :find!, # Find
+             :join,                          #Join
              :to => :all
 
     def all

data/lib/no_brainer/document/dirty.rb

@@ -56,7 +56,7 @@ module NoBrainer::Document::Dirty
       end
     end
 
-    unless @_old_attributes.has_key?(attr)
+    unless @_old_attributes.key?(attr)
       @_old_attributes[attr] = current_value.deep_dup
     end
   end
@@ -81,7 +81,7 @@ module NoBrainer::Document::Dirty
 
       inject_in_layer :dirty_tracking do
         define_method("#{attr}_change") do
-          if @_old_attributes.has_key?(attr)
+          if @_old_attributes.key?(attr)
             result = [@_old_attributes[attr], _read_attribute(attr)]
             result if result.first != result.last || !@_old_attributes_keys.include?(attr)
           end
@@ -92,7 +92,7 @@ module NoBrainer::Document::Dirty
         end
 
         define_method("#{attr}_was") do
-          @_old_attributes.has_key?(attr) ? @_old_attributes[attr] : _read_attribute(attr)
+          @_old_attributes.key?(attr) ? @_old_attributes[attr] : _read_attribute(attr)
         end
       end
     end

data/lib/no_brainer/document/index.rb

@@ -26,11 +26,11 @@ module NoBrainer::Document::Index
       end
 
       if name.in?(NoBrainer::Document::Attributes::RESERVED_FIELD_NAMES)
-        raise "Cannot use a reserved field name: #{name}"
+        raise "The index name `:#{name}' is reserved. Please use another one."
       end
 
       if has_field?(name) && kind != :single
-        raise "Cannot reuse field name #{name}"
+        raise "The field `#{name}' is already declared. Please remove its definition first."
       end
 
       if kind == :compound && what.size < 2
@@ -56,7 +56,7 @@ module NoBrainer::Document::Index
 
     def _field(attr, options={})
       if has_index?(attr) && indexes[attr].kind != :single
-        raise "Cannot reuse index attr #{attr}"
+        raise "The index `#{attr}' is already declared. Please remove its definition first."
       end
 
       super

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

@@ -1,8 +1,6 @@
 class NoBrainer::Document::Index::Index < Struct.new(
     :model, :name, :aliased_name, :kind, :what, :external, :geo, :multi, :meta)
 
-  MetaStore = NoBrainer::Document::Index::MetaStore
-
   def initialize(*args)
     super
 
@@ -59,8 +57,9 @@ class NoBrainer::Document::Index::Index < Struct.new(
     NoBrainer::RQL.reset_lambda_var_counter
     NoBrainer.run(model.rql_table.index_create(aliased_name, opt, &rql_proc))
 
-    MetaStore.create(:table_name => model.table_name, :index_name => aliased_name,
-                     :rql_function => serialized_rql_proc)
+    NoBrainer::Document::Index::MetaStore.create(
+      :table_name => model.table_name, :index_name => aliased_name,
+      :rql_function => serialized_rql_proc)
   end
 
   def delete(options={})
@@ -68,7 +67,8 @@ class NoBrainer::Document::Index::Index < Struct.new(
 
     NoBrainer.run(model.rql_table.index_drop(aliased_name))
 
-    MetaStore.where(:table_name => model.table_name, :index_name => aliased_name).delete_all
+    NoBrainer::Document::Index::MetaStore.where(
+      :table_name => model.table_name, :index_name => aliased_name).delete_all
   end
 
   def update(wanted_index, options={})

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

@@ -6,7 +6,7 @@ class NoBrainer::Document::Index::MetaStore
 
   default_scope ->{ order_by(:created_at) }
 
-  store_in :table => 'nobrainer_index_meta'
+  table_config :name => 'nobrainer_index_meta'
 
   field :table_name,   :type => String, :required => true
   field :index_name,   :type => String, :required => true

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

@@ -1,7 +1,4 @@
 class NoBrainer::Document::Index::Synchronizer
-  Index = NoBrainer::Document::Index::Index
-  MetaStore = NoBrainer::Document::Index::MetaStore
-
   def initialize(models)
     @models_indexes_map = Hash[models.map do |model|
       [model, model.indexes.values.reject { |index| index.name == model.pk_name }]
@@ -9,7 +6,7 @@ class NoBrainer::Document::Index::Synchronizer
   end
 
   def meta_store
-    @meta_store ||= MetaStore.to_a
+    @meta_store ||= NoBrainer::Document::Index::MetaStore.to_a
   end
 
   class Op < Struct.new(:index, :op, :args)
@@ -21,7 +18,8 @@ class NoBrainer::Document::Index::Synchronizer
   def _generate_plan_for(model, wanted_indexes)
     current_indexes = NoBrainer.run(model.rql_table.index_status).map do |s|
       meta = meta_store.select { |i| i.table_name == model.table_name && i.index_name == s['index'] }.last
-      Index.new(model, s['index'], s['index'], nil, nil, nil, s['geo'], s['multi'], meta)
+      NoBrainer::Document::Index::Index.new(
+        model, s['index'], s['index'], nil, nil, nil, s['geo'], s['multi'], meta)
     end
 
     all_aliased_names = (wanted_indexes + current_indexes).map(&:aliased_name).uniq
@@ -51,13 +49,11 @@ class NoBrainer::Document::Index::Synchronizer
     lock = NoBrainer::Lock.new('nobrainer:sync_indexes')
 
     lock.synchronize do
-      plan = generate_plan
-      plan.each { |op| lock.refresh; op.run(options) }
+      generate_plan.each { |op| op.run(options) }
     end
 
     unless options[:wait] == false
-      # Waiting on all models due to possible races when performing concurrent
-      # sync_indexes()
+      # Waiting on all models due to possible races
       @models_indexes_map.each_key do |model|
         NoBrainer.run(model.rql_table.index_wait())
       end
@@ -65,12 +61,4 @@ class NoBrainer::Document::Index::Synchronizer
 
     true
   end
-
-  class << self
-    def instance
-      new(NoBrainer::Document.all)
-    end
-
-    delegate :sync_indexes, :to => :instance
-  end
 end