nobrainer 0.16.0 → 0.18.1

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]
 
@@ -45,14 +45,15 @@ class NoBrainer::Document::Association::EagerLoader
     when Hash  then preloads.each do |k,v|
       if v.is_a?(NoBrainer::Criteria)
         v = v.dup
-        nested_preloads, v._preloads = v._preloads, []
+        nested_preloads, v.options[:preload] = v.options[:preload], []
         eager_load(eager_load_association(docs, k, v), nested_preloads)
       else
         eager_load(eager_load_association(docs, k), v)
       end
     end
     when Array then preloads.each { |v| eager_load(docs, v) }
-    else eager_load_association(docs, preloads)
+    when nil then;
+    else eager_load_association(docs, preloads) # String and Symbol
     end
     true
   end

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

@@ -0,0 +1,213 @@
+module NoBrainer::Document::AtomicOps
+  extend ActiveSupport::Concern
+
+  class PendingAtomic
+    def self._new(instance, field, value, is_user_value, options={})
+      model = case value
+              when Array then PendingAtomicArray
+              when Set   then PendingAtomicSet
+              else self
+              end
+      model.new(instance, field, value, is_user_value, options)
+    end
+
+    def initialize(instance, field, value, is_user_value, options={})
+      @instance = instance
+      @field = field.to_s
+      @value = value
+      @is_user_value = is_user_value
+      @options = options.dup
+      @ops = []
+    end
+
+    def write_access?
+      !!@options[:write_access]
+    end
+
+    def ensure_writeable!
+      unless write_access?
+        @options[:write_access] = true
+        @instance.write_attribute(@field, self)
+      end
+    end
+
+    def to_s
+      "<#{@field} with pending atomic operations>"
+    end
+    alias inspect to_s
+
+    def method_missing(method_name, *a, &b)
+      @ops << [method_name, a, b]
+      self
+    end
+
+    def compile_rql_value(rql_doc)
+      field = @instance.class.lookup_field_alias(@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
+  end
+
+  class PendingAtomicArray < PendingAtomic
+    def -(value)
+      @ops << [:difference, [value.to_a]]
+      self
+    end
+    def difference(v); self - v; end
+
+    def delete(value)
+      difference([value])
+    end
+
+    def +(value)
+      @ops << [:+, [value.to_a]]
+      self
+    end
+    def add(v); self + v; end
+
+    def &(value)
+      @ops << [:set_intersection, [value.to_a]]
+      self
+    end
+    def intersection(v); self & v; end
+
+    def |(value)
+      @ops << [:set_union, [value.to_a]]
+      self
+    end
+    def union(v); self | v; end
+
+    def <<(value)
+      @ops << [:append, [value]]
+      ensure_writeable!
+      self
+    end
+  end
+
+  class PendingAtomicSet < PendingAtomicArray
+    def -(value)
+      @ops << [:set_difference, [value.to_a]]
+      self
+    end
+
+    def +(value)
+      @ops << [:set_union, [value.to_a]]
+      self
+    end
+
+    def <<(value)
+      @ops << [:set_union, [[value]]]
+      ensure_writeable!
+      self
+    end
+  end
+
+  def clear_dirtiness(options={})
+    super
+    @_touched_attributes = Set.new
+  end
+
+  def _touch_attribute(name)
+    @_touched_attributes << name.to_s
+  end
+
+  def _is_attribute_touched?(name)
+    @_touched_attributes.include?(name.to_s)
+  end
+
+  def in_atomic?
+    !!Thread.current[:nobrainer_atomic]
+  end
+
+  def in_other_atomic?
+    v = Thread.current[:nobrainer_atomic]
+    !v.nil? && !v.equal?(self)
+  end
+
+  def ensure_exclusive_atomic!
+    raise NoBrainer::Error::AtomicBlock.new('You may not access other documents within an atomic block') if in_other_atomic?
+  end
+
+  def queue_atomic(&block)
+    ensure_exclusive_atomic!
+
+    begin
+      old_atomic, Thread.current[:nobrainer_atomic] = Thread.current[:nobrainer_atomic], self
+      block.call(RethinkDB::RQL.new)
+    ensure
+      Thread.current[:nobrainer_atomic] = old_atomic
+    end
+  end
+
+  def _read_attribute(name)
+    ensure_exclusive_atomic!
+    value = super
+
+    case [in_atomic?, value.is_a?(PendingAtomic)]
+    when [true, true]   then value
+    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
+  end
+
+  def _write_attribute(name, value)
+    ensure_exclusive_atomic!
+
+    case [in_atomic?, value.is_a?(PendingAtomic)]
+    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 { _touch_attribute(name) }
+    end
+  end
+
+  def assign_attributes(attrs, options={})
+    ensure_exclusive_atomic!
+    super
+  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.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)
+    super
+  rescue NoBrainer::Error::CannotReadAtomic => e
+    e.value
+  end
+
+  def read_attribute_for_validation(attr)
+    super
+  rescue NoBrainer::Error::CannotReadAtomic => e
+    e.value
+  end
+
+  module ClassMethods
+    def persistable_value(k, v, options={})
+      v.is_a?(PendingAtomic) ? v.compile_rql_value(options[:rql_doc]) : super
+    end
+  end
+end
+
+class ActiveModel::EachValidator
+  # XXX Monkey Patching :(
+  def validate(record)
+    attributes.each do |attribute|
+      value = record.read_attribute_for_validation(attribute)
+      next if value.is_a?(NoBrainer::Document::AtomicOps::PendingAtomic) # <--- This is the added line
+      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/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
@@ -25,6 +26,14 @@ module NoBrainer::Document::Attributes
     Hash[readable_attributes.map { |k| [k, read_attribute(k)] }].with_indifferent_access.freeze
   end
 
+  def _read_attribute(name)
+    @_attributes[name]
+  end
+
+  def _write_attribute(name, value)
+    @_attributes[name] = value
+  end
+
   def read_attribute(name)
     __send__("#{name}")
   end
@@ -91,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)
@@ -103,8 +112,8 @@ module NoBrainer::Document::Attributes
       # Using a layer so the user can use super when overriding these methods
       attr = attr.to_s
       inject_in_layer :attributes do
-        define_method("#{attr}=") { |value| @_attributes[attr] = value }
-        define_method("#{attr}")  { @_attributes[attr] }
+        define_method("#{attr}=") { |value| _write_attribute(attr, value) }
+        define_method("#{attr}") { _read_attribute(attr) }
       end
     end
 
@@ -116,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])
@@ -136,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
@@ -33,10 +31,14 @@ 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(attr)
+      current_value = read_attribute_for_change(attr)
       if current_value != old_value || !@_old_attributes_keys.include?(attr)
         result[attr] = [old_value, current_value]
       end
@@ -48,7 +50,7 @@ module NoBrainer::Document::Dirty
     attr = args.first
     current_value = begin
       case args.size
-      when 1 then assert_access_field(attr); read_attribute(attr)
+      when 1 then assert_access_field(attr); read_attribute_for_change(attr)
       when 2 then args.last
       else raise
       end
@@ -61,6 +63,19 @@ module NoBrainer::Document::Dirty
     end
   end
 
+  def _read_attribute(name)
+    super.tap do |value|
+      # This take care of string/arrays/hashes that could change without going
+      # through the setter.
+      attribute_may_change(name, value) if value.respond_to?(:size)
+    end
+  end
+
+  def _write_attribute(name, value)
+    attribute_may_change(name)
+    super
+  end
+
   module ClassMethods
     def _field(attr, options={})
       super
@@ -69,7 +84,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(attr)]
+            result = [@_old_attributes[attr], read_attribute_for_change(attr)]
             result if result.first != result.last || !@_old_attributes_keys.include?(attr)
           end
         end
@@ -79,20 +94,7 @@ module NoBrainer::Document::Dirty
         end
 
         define_method("#{attr}_was") do
-          @_old_attributes.has_key?(attr) ? @_old_attributes[attr] : read_attribute(attr)
-        end
-
-        define_method("#{attr}") do
-          super().tap do |value|
-            # This take care of string/arrays/hashes that could change without going
-            # through the setter.
-            attribute_may_change(attr, value) if value.respond_to?(:size)
-          end
-        end
-
-        define_method("#{attr}=") do |value|
-          attribute_may_change(attr)
-          super(value)
+          @_old_attributes.has_key?(attr) ? @_old_attributes[attr] : read_attribute_for_change(attr)
         end
       end
     end
@@ -103,8 +105,6 @@ module NoBrainer::Document::Dirty
         remove_method("#{attr}_change")
         remove_method("#{attr}_changed?")
         remove_method("#{attr}_was")
-        remove_method("#{attr}=")
-        remove_method("#{attr}")
       end
     end
   end

data/lib/no_brainer/document/dynamic_attributes.rb

@@ -2,23 +2,11 @@ module NoBrainer::Document::DynamicAttributes
   extend ActiveSupport::Concern
 
   def read_attribute(name)
-    if self.respond_to?("#{name}") 
-      super
-    else
-      assert_access_field(name)
-      @_attributes[name].tap { |value| attribute_may_change(name, value) if value.respond_to?(:size) }
-    end
+    self.respond_to?("#{name}") ? super : _read_attribute(name)
   end
 
   def write_attribute(name, value)
-    if self.respond_to?("#{name}=")
-      super
-    else
-      attribute_may_change(name)
-      @_attributes[name] = value
-      clear_missing_field(name)
-      value
-    end
+    self.respond_to?("#{name}=") ? super : _write_attribute(name, value)
   end
 
   def readable_attributes

data/lib/no_brainer/document/id.rb

@@ -17,6 +17,7 @@ module NoBrainer::Document::Id
 
   def ==(other)
     return super unless self.class == other.class
+    return self.equal?(other) if in_atomic?
     !pk_value.nil? && pk_value == other.pk_value
   end
   alias_method :eql?, :==

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

@@ -0,0 +1,83 @@
+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
+
+    self.name = self.name.to_sym
+    self.aliased_name = self.aliased_name.to_sym
+    self.external = !!self.external
+    self.geo = !!self.geo
+    self.multi = !!self.multi
+  end
+
+  def same_definition?(other)
+    # allow name to change through renames
+    self.model == other.model &&
+    self.geo == other.geo &&
+    self.multi == other.multi &&
+    self.serialized_rql_proc == other.serialized_rql_proc
+  end
+
+  def human_name
+    index_name = "index #{model}.#{name}"
+    index_name += " as #{aliased_name}" unless name == aliased_name
+    index_name
+  end
+
+  def rql_proc
+    case kind
+      when :single   then ->(doc) { doc[model.lookup_field_alias(what)] }
+      when :compound then ->(doc) { what.map { |field| doc[model.lookup_field_alias(field)] } }
+      when :proc     then what # TODO XXX not translating the field aliases
+    end
+  end
+
+  def serialized_rql_proc
+    meta.try(:rql_function) || (rql_proc && NoBrainer::RQL.rql_proc_as_json(rql_proc))
+  end
+
+  def show_op(verb, options={})
+    color = case verb
+            when :create then "\e[1;32m" # green
+            when :delete then "\e[1;31m" # red
+            when :update then "\e[1;33m" # yellow
+            end
+    STDERR.puts "[NoBrainer] #{color}#{verb.to_s.capitalize} #{human_name}\e[0m" if options[:verbose]
+  end
+
+  def create(options={})
+    show_op(:create, options)
+
+    opt = {}
+    opt[:multi] = true if multi
+    opt[:geo] = true if geo
+
+    NoBrainer::RQL.reset_lambda_var_counter
+    NoBrainer.run(model.rql_table.index_create(aliased_name, opt, &rql_proc))
+
+    MetaStore.on(model.database_name) do
+      MetaStore.create(:table_name => model.table_name, :index_name => aliased_name,
+                       :rql_function => serialized_rql_proc)
+    end
+  end
+
+  def delete(options={})
+    show_op(:delete, options)
+
+    NoBrainer.run(model.rql_table.index_drop(aliased_name))
+
+    MetaStore.on(model.database_name) do
+      MetaStore.where(:table_name => model.table_name, :index_name => aliased_name).delete_all
+    end
+  end
+
+  def update(wanted_index, options={})
+    wanted_index.show_op(:update, options)
+
+    self.delete(options.merge(:verbose => false))
+    wanted_index.create(options.merge(:verbose => false))
+  end
+end

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

@@ -0,0 +1,31 @@
+class NoBrainer::Document::Index::MetaStore
+  include NoBrainer::Document
+  include NoBrainer::Document::Timestamps
+
+  disable_perf_warnings
+
+  default_scope ->{ order_by(:created_at) }
+
+  store_in :database => ->{ Thread.current[:nobrainer_meta_store_db] },
+           :table    => 'nobrainer_index_meta'
+
+  field :table_name,   :type => String, :required => true
+  field :index_name,   :type => String, :required => true
+  field :rql_function, :type => String, :required => true
+
+  def rql_function=(value)
+    super(JSON.dump(value))
+  end
+
+  def rql_function
+    JSON.load(super)
+  end
+
+  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 }
+  ensure
+    Thread.current[:nobrainer_meta_store_db] = old_db_name
+  end
+end