nobrainer 0.17.0 → 0.18.0

data/lib/no_brainer/document/association.rb

@@ -28,11 +28,11 @@ module NoBrainer::Document::Association
           raise "Cannot change the :through option" unless r.options[:through] == options[:through]
           r.options.merge!(options)
         else
-          klass_name = (options[:through] ? "#{association}_through" : association.to_s).camelize
-          metadata_klass = NoBrainer::Document::Association.const_get(klass_name).const_get(:Metadata)
-          r = metadata_klass.new(self, target, options)
-          ([self] + descendants).each do |klass|
-            klass.association_metadata[target] = r
+          model_name = (options[:through] ? "#{association}_through" : association.to_s).camelize
+          metadata_model = NoBrainer::Document::Association.const_get(model_name).const_get(:Metadata)
+          r = metadata_model.new(self, target, options)
+          ([self] + descendants).each do |model|
+            model.association_metadata[target] = r
           end
         end
         r.hook

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

@@ -13,10 +13,10 @@ class NoBrainer::Document::Association::BelongsTo
 
     def primary_key
       # TODO test :primary_key
-      options[:primary_key].try(:to_sym) || target_klass.pk_name
+      options[:primary_key].try(:to_sym) || target_model.pk_name
     end
 
-    def target_klass
+    def target_model
       # TODO test :class_name
       (options[:class_name] || target_name.to_s.camelize).constantize
     end
@@ -29,9 +29,9 @@ class NoBrainer::Document::Association::BelongsTo
       # This would have the effect of loading all the models because they
       # are likely to be related to each other. So we don't know the type
       # of the primary key of the target.
-      owner_klass.field(foreign_key, :as => options[:foreign_key_as], :index => options[:index])
-      owner_klass.validates(target_name, { :presence => true }) if options[:required]
-      owner_klass.validates(target_name, options[:validates]) if options[:validates]
+      owner_model.field(foreign_key, :as => options[:foreign_key_as], :index => options[:index])
+      owner_model.validates(target_name, { :presence => true }) if options[:required]
+      owner_model.validates(target_name, options[:validates]) if options[:validates]
 
       delegate("#{foreign_key}=", :assign_foreign_key, :call_super => true)
       add_callback_for(:after_validation)
@@ -54,7 +54,7 @@ class NoBrainer::Document::Association::BelongsTo
     return target if loaded?
 
     if fk = owner.read_attribute(foreign_key)
-      preload(target_klass.unscoped.where(primary_key => fk).first)
+      preload(target_model.unscoped.where(primary_key => fk).first)
     end
   end
 

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

@@ -4,25 +4,25 @@ module NoBrainer::Document::Association::Core
   module Metadata
     extend ActiveSupport::Concern
 
-    attr_accessor :owner_klass, :target_name, :options
+    attr_accessor :owner_model, :target_name, :options
 
-    def initialize(owner_klass, target_name, options={})
-      @owner_klass = owner_klass
+    def initialize(owner_model, target_name, options={})
+      @owner_model = owner_model
       @target_name = target_name
       @options = options
     end
 
-    def association_klass
-      @association_klass ||= self.class.name.deconstantize.constantize
+    def association_model
+      @association_model ||= self.class.name.deconstantize.constantize
     end
 
     def new(owner)
-      association_klass.new(self, owner)
+      association_model.new(self, owner)
     end
 
     def delegate(method_name, target, options={})
       metadata = self
-      owner_klass.inject_in_layer :associations do
+      owner_model.inject_in_layer :associations do
         define_method(method_name) do |*args, &block|
           super(*args, &block) if options[:call_super]
           associations[metadata].__send__(target, *args, &block)
@@ -40,7 +40,7 @@ module NoBrainer::Document::Association::Core
       instance_eval <<-RUBY, __FILE__, __LINE__+1
         if !@added_#{what}
           metadata = self
-          owner_klass.#{what} { associations[metadata].#{what}_callback }
+          owner_model.#{what} { associations[metadata].#{what}_callback }
           @added_#{what} = true
         end
       RUBY
@@ -49,15 +49,15 @@ module NoBrainer::Document::Association::Core
 
   included { attr_accessor :metadata, :owner }
 
-  delegate :primary_key, :foreign_key, :target_name, :target_klass, :to => :metadata
+  delegate :primary_key, :foreign_key, :target_name, :target_model, :to => :metadata
 
   def initialize(metadata, owner)
     @metadata, @owner = metadata, owner
   end
 
   def assert_target_type(value)
-    unless value.is_a?(target_klass) || value.nil?
-      options = { :attr_name => target_name, :value => value, :type => target_klass }
+    unless value.is_a?(target_model) || value.nil?
+      options = { :attr_name => target_name, :value => value, :type => target_model }
       raise NoBrainer::Error::InvalidType.new(options)
     end
   end

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

@@ -7,7 +7,7 @@ class NoBrainer::Document::Association::EagerLoader
         owner_key  = instance_exec(&options[:owner_key])
         target_key = instance_exec(&options[:target_key])
 
-        criteria = target_klass.all
+        criteria = target_model.all
         criteria = criteria.merge(additional_criteria) if additional_criteria
         criteria = criteria.unscoped if options[:unscoped]
 

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

@@ -8,15 +8,15 @@ class NoBrainer::Document::Association::HasMany
 
     def foreign_key
       # TODO test :foreign_key
-      options[:foreign_key].try(:to_sym) || :"#{owner_klass.name.underscore}_#{owner_klass.pk_name}"
+      options[:foreign_key].try(:to_sym) || :"#{owner_model.name.underscore}_#{owner_model.pk_name}"
     end
 
     def primary_key
       # TODO test :primary_key
-      options[:primary_key].try(:to_sym) || target_klass.pk_name
+      options[:primary_key].try(:to_sym) || target_model.pk_name
     end
 
-    def target_klass
+    def target_model
       # TODO test :class_name
       (options[:class_name] || target_name.to_s.singularize.camelize).constantize
     end
@@ -27,11 +27,11 @@ class NoBrainer::Document::Association::HasMany
       # selector.
       # XXX Without caching, this is going to get CPU intensive quickly, but
       # caching is hard (rails console reload, etc.).
-      target_klass.association_metadata.values.select do |assoc|
+      target_model.association_metadata.values.select do |assoc|
         assoc.is_a?(NoBrainer::Document::Association::BelongsTo::Metadata) and
         assoc.foreign_key == self.foreign_key                              and
         assoc.primary_key == self.primary_key                              and
-        assoc.target_klass.root_class == owner_klass.root_class
+        assoc.target_model.root_class == owner_model.root_class
       end
     end
 
@@ -44,7 +44,7 @@ class NoBrainer::Document::Association::HasMany
   end
 
   def target_criteria
-    @target_criteria ||= target_klass.where(foreign_key => owner.pk_value)
+    @target_criteria ||= target_model.where(foreign_key => owner.pk_value)
                                      .after_find(set_inverse_proc)
   end
 
@@ -54,7 +54,7 @@ class NoBrainer::Document::Association::HasMany
 
   def write(new_children)
     raise "You can't assign #{target_name}. " +
-          "Instead, you must modify delete and create #{target_klass} manually."
+          "Instead, you must modify delete and create #{target_model} manually."
   end
 
   def loaded?

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

@@ -10,7 +10,7 @@ class NoBrainer::Document::Association::HasManyThrough
     end
 
     def through_association
-      owner_klass.association_metadata[through_association_name] or
+      owner_model.association_metadata[through_association_name] or
         raise "#{through_association_name} association not found"
     end
 

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

@@ -1,6 +1,6 @@
 class NoBrainer::Document::Association::HasOne < NoBrainer::Document::Association::HasMany
   class Metadata < NoBrainer::Document::Association::HasMany::Metadata
-    def target_klass
+    def target_model
       (options[:class_name] || target_name.to_s.camelize).constantize
     end
   end

data/lib/no_brainer/document/atomic_ops.rb

@@ -2,26 +2,26 @@ module NoBrainer::Document::AtomicOps
   extend ActiveSupport::Concern
 
   class PendingAtomic
-    def self._new(instance, field, user_value, options={})
-      klass = case user_value
+    def self._new(instance, field, value, is_user_value, options={})
+      model = case value
               when Array then PendingAtomicArray
               when Set   then PendingAtomicSet
               else self
               end
-      klass.new(instance, field, user_value, options)
+      model.new(instance, field, value, is_user_value, options)
     end
 
-    def initialize(instance, field, user_value, options={})
+    def initialize(instance, field, value, is_user_value, options={})
       @instance = instance
-      @field = field
-      @user_value = user_value
-      @value_tainted = instance._is_attribute_tainted?(field)
-      @options = options
+      @field = field.to_s
+      @value = value
+      @is_user_value = is_user_value
+      @options = options.dup
       @ops = []
     end
 
     def write_access?
-      @options[:write_access] == true
+      !!@options[:write_access]
     end
 
     def ensure_writeable!
@@ -43,7 +43,7 @@ module NoBrainer::Document::AtomicOps
 
     def compile_rql_value(rql_doc)
       field = @instance.class.lookup_field_alias(@field)
-      value = @value_tainted ? RethinkDB::RQL.new.expr(@user_value) : rql_doc[field]
+      value = @is_user_value ? RethinkDB::RQL.new.expr(@value) : rql_doc[field]
       @ops.each { |method_name, a, b| value = value.__send__(method_name, *a, &b) }
       value
     end
@@ -105,15 +105,15 @@ module NoBrainer::Document::AtomicOps
 
   def clear_dirtiness(options={})
     super
-    @_tainted_attributes = Set.new
+    @_touched_attributes = Set.new
   end
 
-  def _taint_attribute(name)
-    @_tainted_attributes << name
+  def _touch_attribute(name)
+    @_touched_attributes << name.to_s
   end
 
-  def _is_attribute_tainted?(name)
-    @_tainted_attributes.include?(name)
+  def _is_attribute_touched?(name)
+    @_touched_attributes.include?(name.to_s)
   end
 
   def in_atomic?
@@ -146,7 +146,7 @@ module NoBrainer::Document::AtomicOps
 
     case [in_atomic?, value.is_a?(PendingAtomic)]
     when [true, true]   then value
-    when [true, false]  then PendingAtomic._new(self, name.to_s, value, :write_access => false)
+    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 [false, false] then value
     end
@@ -159,7 +159,7 @@ module NoBrainer::Document::AtomicOps
     when [true, true]   then super
     when [true, false]  then raise NoBrainer::Error::AtomicBlock.new('Avoid the use of atomic blocks for non atomic operations')
     when [false, true]  then raise NoBrainer::Error::AtomicBlock.new('Use atomic blocks for atomic operations')
-    when [false, false] then super.tap { _taint_attribute(name.to_s) }
+    when [false, false] then super.tap { _touch_attribute(name) }
     end
   end
 
@@ -169,8 +169,16 @@ module NoBrainer::Document::AtomicOps
   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?
-    super
+    super.tap do |saved|
+      if saved
+        @_attributes.each do |attr, value|
+          next unless value.is_a?(PendingAtomic)
+          @_attributes[attr] = value.class.new(self, attr, nil, false)
+        end
+      end
+    end
   end
 
   def read_attribute_for_change(attr)

data/lib/no_brainer/document/attributes.rb

@@ -1,6 +1,7 @@
 module NoBrainer::Document::Attributes
-  VALID_FIELD_OPTIONS = [:index, :default, :type, :real_type, :validates, :required, :unique,
-                         :in, :readonly, :primary_key, :as, :lazy_fetch]
+  VALID_FIELD_OPTIONS = [:index, :default, :type, :real_type,
+                         :validates, :required, :unique, :uniq, :format, :in,
+                         :readonly, :primary_key, :as, :lazy_fetch]
   RESERVED_FIELD_NAMES = [:index, :default, :and, :or, :selector, :associations, :pk_value] \
                           + NoBrainer::DecoratedSymbol::MODIFIERS.keys
   extend ActiveSupport::Concern
@@ -99,7 +100,7 @@ module NoBrainer::Document::Attributes
   module ClassMethods
     def new_from_db(attrs, options={})
       options = options.reverse_merge(:pristine => true, :from_db => true)
-      klass_from_attrs(attrs).new(attrs, options) if attrs
+      model_from_attrs(attrs).new(attrs, options) if attrs
     end
 
     def inherited(subclass)
@@ -124,9 +125,9 @@ module NoBrainer::Document::Attributes
         raise "Cannot use a reserved field attr: #{attr}"
       end
 
-      ([self] + descendants).each do |klass|
-        klass.fields[attr] ||= {}
-        klass.fields[attr].deep_merge!(options)
+      ([self] + descendants).each do |model|
+        model.fields[attr] ||= {}
+        model.fields[attr].deep_merge!(options)
       end
 
       _field(attr, self.fields[attr])
@@ -144,8 +145,8 @@ module NoBrainer::Document::Attributes
 
       _remove_field(attr, options)
 
-      ([self] + descendants).each do |klass|
-        klass.fields.delete(attr)
+      ([self] + descendants).each do |model|
+        model.fields.delete(attr)
       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/core.rb

@@ -22,6 +22,6 @@ module NoBrainer::Document::Core
     extend ActiveModel::Naming
     extend ActiveModel::Translation
 
-    NoBrainer::Document::Core._all << self
+    NoBrainer::Document::Core._all << self unless self.name =~ /^NoBrainer::/
   end
 end

data/lib/no_brainer/document/criteria.rb

@@ -5,7 +5,10 @@ module NoBrainer::Document::Criteria
     self.class.selector_for(pk_value)
   end
 
-  included { cattr_accessor :default_scope_proc, :instance_accessor => false }
+  included do
+    cattr_accessor :default_scope_proc,     :instance_accessor => false
+    cattr_accessor :perf_warnings_disabled, :instance_accessor => false
+  end
 
   module ClassMethods
     delegate :to_rql,                        # Core
@@ -27,7 +30,7 @@ module NoBrainer::Document::Criteria
              :to => :all
 
     def all
-      NoBrainer::Criteria.new(:klass => self)
+      NoBrainer::Criteria.new(:model => self)
     end
 
     def scope(name, criteria=nil, &block)
@@ -59,5 +62,9 @@ module NoBrainer::Document::Criteria
         raise NoBrainer::Error::DocumentNotFound, "#{self} #{pk_name}: #{pk} not found" unless doc
       end
     end
+
+    def disable_perf_warnings
+      self.perf_warnings_disabled = true
+    end
   end
 end

data/lib/no_brainer/document/dirty.rb

@@ -17,9 +17,7 @@ module NoBrainer::Document::Dirty
   def clear_dirtiness(options={})
     if options[:keep_ivars] && options[:missing_attributes].try(:[], :pluck)
       attrs = options[:missing_attributes][:pluck].keys
-      @_old_attributes = @_old_attributes.reject { |k,v| attrs.include?(k) }
-    else
-      @_old_attributes = {}.with_indifferent_access
+      @_old_attributes = @_old_attributes.reject { |k,v| attrs.include?(k) } else @_old_attributes = {}.with_indifferent_access
     end
 
     @_old_attributes_keys = @_attributes.keys # to track undefined -> nil changes

data/lib/no_brainer/document/index.rb

@@ -1,6 +1,9 @@
 module NoBrainer::Document::Index
-  VALID_INDEX_OPTIONS = [:multi, :as]
+  VALID_INDEX_OPTIONS = [:external, :geo, :multi, :as]
   extend ActiveSupport::Concern
+  extend NoBrainer::Autoload
+
+  autoload :Index, :Synchronizer, :MetaStore
 
   included do
     cattr_accessor :indexes, :instance_accessor => false
@@ -16,9 +19,9 @@ module NoBrainer::Document::Index
       raise "Too many arguments: #{args}" if args.size > 1
 
       kind, what = case args.first
-        when nil   then [:single,   name.to_sym]
-        when Array then [:compound, args.first.map(&:to_sym)]
-        when Proc  then [:proc,     args.first]
+        when nil    then [:single,   name.to_sym]
+        when Array  then [:compound, args.first.map(&:to_sym)]
+        when Proc   then [:proc,     args.first]
         else raise "Index argument must be a lambda or a list of fields"
       end
 
@@ -35,7 +38,8 @@ module NoBrainer::Document::Index
       as ||= name
       as = as.to_sym
 
-      indexes[name] = {:kind => kind, :what => what, :as => as, :options => options}
+      indexes[name] = NoBrainer::Document::Index::Index.new(self.root_class, name, as,
+        kind, what, options[:external], options[:geo], options[:multi], nil)
     end
 
     def remove_index(name)
@@ -46,12 +50,8 @@ module NoBrainer::Document::Index
       !!indexes[name.to_sym]
     end
 
-    def lookup_index_alias(attr)
-      indexes[attr.to_sym].try(:[], :as) || attr
-    end
-
     def _field(attr, options={})
-      if has_index?(attr) && indexes[attr][:kind] != :single
+      if has_index?(attr) && indexes[attr].kind != :single
         raise "Cannot reuse index attr #{attr}"
       end
 
@@ -68,78 +68,12 @@ module NoBrainer::Document::Index
     end
 
     def _remove_field(attr, options={})
-      super
       remove_index(attr) if fields[attr][:index]
+      super
     end
 
-    def perform_create_index(index_name, options={})
-      index_name = index_name.to_sym
-      index_args = self.indexes[index_name]
-      aliased_name = index_args[:as]
-
-      index_proc = case index_args[:kind]
-        when :single   then ->(doc) { doc[lookup_field_alias(index_name)] }
-        when :compound then ->(doc) { index_args[:what].map { |field| doc[lookup_field_alias(field)] } }
-        when :proc     then index_args[:what]
-      end
-
-      NoBrainer.run(self.rql_table.index_create(aliased_name, index_args[:options], &index_proc))
-      wait_for_index(index_name) unless options[:wait] == false
-
-      readable_index_name = "index #{self}.#{index_name}"
-      readable_index_name += " as #{aliased_name}" unless index_name == aliased_name
-
-      STDERR.puts "Created index #{readable_index_name}" if options[:verbose]
-    end
-
-    def perform_drop_index(index_name, options={})
-      index_name = index_name.to_sym
-      aliased_name = self.indexes[index_name].try(:[], :as) || index_name
-
-      readable_index_name = "index #{self}.#{index_name}"
-      readable_index_name += " as #{aliased_name}" unless index_name == aliased_name
-
-      if STDIN.stat.chardev? && STDERR.stat.chardev? && !options[:no_confirmation]
-        STDERR.print "Confirm dropping #{readable_index_name} [yna]: "
-        case STDIN.gets.strip.chomp
-        when 'y' then
-        when 'n' then return
-        when 'a' then options[:no_confirmation] = true
-        end
-      end
-
-      NoBrainer.run(self.rql_table.index_drop(aliased_name))
-      STDERR.puts "Dropped #{readable_index_name}" if options[:verbose]
-    end
-
-    def get_index_alias_reverse_map
-      Hash[self.indexes.map { |k,v| [v[:as], k] }].tap do |mapping|
-        raise "Detected clashing index aliases" if mapping.count != self.indexes.count
-      end
-    end
-
-    def perform_update_indexes(options={})
-      alias_mapping = self.get_index_alias_reverse_map
-      current_indexes = NoBrainer.run(self.rql_table.index_list).map do |index|
-        alias_mapping[index.to_sym] || index.to_sym
-      end
-      wanted_indexes = self.indexes.keys - [self.pk_name]
-
-      # FIXME removing an aliased field is not going to work well with this method
-
-      (current_indexes - wanted_indexes).each do |index_name|
-        perform_drop_index(index_name, options)
-      end
-
-      (wanted_indexes - current_indexes).each do |index_name|
-        perform_create_index(index_name, options)
-      end
-    end
-    alias_method :update_indexes, :perform_update_indexes
-
-    def wait_for_index(index_name=nil, options={})
-      args = [index_name].compact
-      NoBrainer.run(self.rql_table.index_wait(*args))
+    def lookup_index_alias(attr)
+      indexes[attr.to_sym].try(:aliased_name) || attr
     end
   end
 end