nobrainer 0.16.0 → 0.17.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: fe36d41b56c9780a4d16f3085d31de0361d34cae
-  data.tar.gz: 9f89b0da1f34d65c8861345307adc79f93a5593d
+  metadata.gz: 6cf2f24165387c78884eaffc90c04da535bc571f
+  data.tar.gz: b8d3b1bd887c454e3f017664a559c70bec9a6312
 SHA512:
-  metadata.gz: 43e0cf6f767028a46068635713cb9c1d639a8e03de6503493a6af05179977dfe1ae01b5c6a49d93ec0f2e4012a24b0386b6f66d31c7dd274ec05f5f69b252ba3
-  data.tar.gz: e728763fc6095d493db2ed93a9141f72d7cfc927f35300993f0ca6272996a5bac120f6f9cbfc9a985d80329a78da88ec5d827d5af31ccce93c833704b3a17f0b
+  metadata.gz: fa00190b18bbd8a498c855ef04fe7720c169c51edbb0d360939dc2ea5c4b76db47361615bc86153207e22be8096946bdce120c35d3b3da6fe99a9db4a4b58f94
+  data.tar.gz: 034d21dabdce9c900b11c899e20d5e69af34560ec2980bbfdba386974bc30828ac6fb9d590fc73a4ac9b568dbfdbdb9a9fb60760c4aeceac963396fd8128e679

data/lib/no_brainer/config.rb

@@ -6,7 +6,7 @@ module NoBrainer::Config
                    :auto_create_databases, :auto_create_tables,
                    :max_reconnection_tries, :durability,
                    :user_timezone, :db_timezone, :colorize_logger,
-                   :distributed_lock_class
+                   :distributed_lock_class, :per_thread_connection
 
     def apply_defaults
       self.rethinkdb_url           = default_rethinkdb_url
@@ -20,6 +20,7 @@ module NoBrainer::Config
       self.db_timezone             = :utc
       self.colorize_logger         = true
       self.distributed_lock_class  = nil
+      self.per_thread_connection   = false
     end
 
     def reset!
@@ -33,7 +34,7 @@ module NoBrainer::Config
       assert_valid_options!
       @configured = true
 
-      NoBrainer.disconnect_if_url_changed
+      NoBrainer::ConnectionManager.disconnect_if_url_changed
     end
 
     def configured?

data/lib/no_brainer/connection_manager.rb

@@ -0,0 +1,60 @@
+module NoBrainer::ConnectionManager
+  extend self
+
+  @lock = Mutex.new
+
+  def synchronize(&block)
+    if NoBrainer::Config.per_thread_connection
+      block.call
+    else
+      @lock.synchronize { block.call }
+    end
+  end
+
+  def get_new_connection
+    url = NoBrainer::Config.rethinkdb_url
+    raise "Please specify a database connection to RethinkDB" unless url
+    NoBrainer::Connection.new(url)
+  end
+
+  def current_connection
+    if NoBrainer::Config.per_thread_connection
+      Thread.current[:nobrainer_connection]
+    else
+      @connection
+    end
+  end
+
+  def current_connection=(value)
+    if NoBrainer::Config.per_thread_connection
+      Thread.current[:nobrainer_connection] = value
+    else
+      @connection = value
+    end
+  end
+
+  def connection
+    c = self.current_connection
+    return c if c
+
+    synchronize do
+      self.current_connection ||= get_new_connection
+    end
+  end
+
+  def _disconnect
+    self.current_connection.try(:disconnect, :noreply_wait => true) rescue nil
+    self.current_connection = nil
+  end
+
+  def disconnect
+    synchronize { _disconnect }
+  end
+
+  def disconnect_if_url_changed
+    synchronize do
+      c = current_connection
+      _disconnect if c && c.uri != NoBrainer::Config.rethinkdb_url
+    end
+  end
+end

data/lib/no_brainer/document.rb

@@ -7,7 +7,7 @@ module NoBrainer::Document
   autoload_and_include :Core, :StoreIn, :InjectionLayer, :Attributes, :Readonly,
                        :Validation, :Persistance, :Types, :Uniqueness, :Callbacks, :Dirty, :Id,
                        :Association, :Serialization, :Criteria, :Polymorphic, :Index, :Aliases,
-                       :MissingAttributes, :LazyFetch
+                       :MissingAttributes, :LazyFetch, :AtomicOps
 
   autoload :DynamicAttributes, :Timestamps
 

data/lib/no_brainer/document/aliases.rb

@@ -48,7 +48,7 @@ module NoBrainer::Document::Aliases
       end
     end
 
-    def persistable_key(k)
+    def persistable_key(k, options={})
       lookup_field_alias(super)
     end
   end

data/lib/no_brainer/document/atomic_ops.rb

@@ -0,0 +1,205 @@
+module NoBrainer::Document::AtomicOps
+  extend ActiveSupport::Concern
+
+  class PendingAtomic
+    def self._new(instance, field, user_value, options={})
+      klass = case user_value
+              when Array then PendingAtomicArray
+              when Set   then PendingAtomicSet
+              else self
+              end
+      klass.new(instance, field, user_value, options)
+    end
+
+    def initialize(instance, field, user_value, options={})
+      @instance = instance
+      @field = field
+      @user_value = user_value
+      @value_tainted = instance._is_attribute_tainted?(field)
+      @options = options
+      @ops = []
+    end
+
+    def write_access?
+      @options[:write_access] == true
+    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 = @value_tainted ? RethinkDB::RQL.new.expr(@user_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
+    @_tainted_attributes = Set.new
+  end
+
+  def _taint_attribute(name)
+    @_tainted_attributes << name
+  end
+
+  def _is_attribute_tainted?(name)
+    @_tainted_attributes.include?(name)
+  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.to_s, value, :write_access => false)
+    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 { _taint_attribute(name.to_s) }
+    end
+  end
+
+  def assign_attributes(attrs, options={})
+    ensure_exclusive_atomic!
+    super
+  end
+
+  def save?(options={})
+    raise NoBrainer::Error::AtomicBlock.new('You may persist documents only outside of queue_atomic blocks') if in_atomic?
+    super
+  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

@@ -25,6 +25,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
@@ -103,8 +111,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
 

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

@@ -33,10 +33,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 +52,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 +65,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 +86,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 +96,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 +107,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.rb

@@ -75,6 +75,7 @@ module NoBrainer::Document::Index
     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)] }
@@ -82,29 +83,33 @@ module NoBrainer::Document::Index
         when :proc     then index_args[:what]
       end
 
-      NoBrainer.run(self.rql_table.index_create(index_args[:as], index_args[:options], &index_proc))
+      NoBrainer.run(self.rql_table.index_create(aliased_name, index_args[:options], &index_proc))
       wait_for_index(index_name) unless options[:wait] == false
 
-      if options[:verbose]
-        if index_name == index_args[:as]
-          STDERR.puts "Created index #{self}.#{index_name}"
-        else
-          STDERR.puts "Created index #{self}.#{index_name} as #{index_args[:as]}"
-        end
-      end
+      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
-      NoBrainer.run(self.rql_table.index_drop(aliased_name))
 
-      if options[:verbose]
-        if index_name == index_args[:as]
-          STDERR.puts "Dropped index #{self}.#{index_name}"
-        else
-          STDERR.puts "Dreated index #{self}.#{index_name} as #{index_args[:as]}"
+      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
@@ -120,6 +125,8 @@ module NoBrainer::Document::Index
       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

data/lib/no_brainer/document/missing_attributes.rb

@@ -45,29 +45,12 @@ module NoBrainer::Document::MissingAttributes
     end
   end
 
+  def _read_attribute(name)
+    assert_access_field(name)
+    super
+  end
 
-  module ClassMethods
-    def _field(attr, options={})
-      super
-
-      inject_in_layer :missing_attributes do
-        define_method("#{attr}") do
-          assert_access_field(attr)
-          super()
-        end
-
-        define_method("#{attr}=") do |value|
-          super(value).tap { clear_missing_field(attr) }
-        end
-      end
-    end
-
-    def _remove_field(attr, options={})
-      super
-      inject_in_layer :missing_attributes do
-        remove_method("#{attr}=")
-        remove_method("#{attr}")
-      end
-    end
+  def _write_attribute(name, value)
+    super.tap { clear_missing_field(name) }
   end
 end

data/lib/no_brainer/document/persistance.rb

@@ -61,15 +61,16 @@ module NoBrainer::Document::Persistance
 
   def _create(options={})
     return false if options[:validate] && !valid?
-    keys = self.class.insert_all(@_attributes)
-    self.pk_value ||= keys.first
+    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
     true
   end
 
   def _update(attrs)
-    attrs = self.class.persistable_attributes(attrs)
-    NoBrainer.run { selector.update(attrs) }
+    rql = ->(doc){ self.class.persistable_attributes(attrs, :instance => self, :rql_doc => doc) }
+    NoBrainer.run { selector.update(&rql) }
   end
 
   def _update_only_changed_attrs(options={})
@@ -88,22 +89,22 @@ module NoBrainer::Document::Persistance
     true
   end
 
-  def save(options={})
+  def save?(options={})
     options = options.reverse_merge(:validate => true)
     new_record? ? _create(options) : _update_only_changed_attrs(options)
   end
 
-  def save!(*args)
-    save(*args) or raise NoBrainer::Error::DocumentInvalid, self
+  def save(*args)
+    save?(*args) or raise NoBrainer::Error::DocumentInvalid, self
   end
 
-  def update_attributes(attrs, options={})
+  def update_attributes?(attrs, options={})
     assign_attributes(attrs, options)
-    save(options)
+    save?(options)
   end
 
-  def update_attributes!(*args)
-    update_attributes(*args) or raise NoBrainer::Error::DocumentInvalid, self
+  def update_attributes(*args)
+    update_attributes?(*args) or raise NoBrainer::Error::DocumentInvalid, self
   end
 
   def delete
@@ -124,10 +125,6 @@ module NoBrainer::Document::Persistance
       new(attrs, options).tap { |doc| doc.save(options) }
     end
 
-    def create!(attrs={}, options={})
-      new(attrs, options).tap { |doc| doc.save!(options) }
-    end
-
     def insert_all(*args)
       docs = args.shift
       docs = [docs] unless docs.is_a?(Array)
@@ -140,16 +137,16 @@ module NoBrainer::Document::Persistance
       NoBrainer.run(rql_table.sync)['synced'] == 1
     end
 
-    def persistable_key(k)
+    def persistable_key(k, options={})
       k
     end
 
-    def persistable_value(k, v)
+    def persistable_value(k, v, options={})
       v
     end
 
-    def persistable_attributes(attrs)
-      Hash[attrs.map { |k,v| [persistable_key(k), persistable_value(k, v)] }]
+    def persistable_attributes(attrs, options={})
+      Hash[attrs.map { |k,v| [persistable_key(k, options), persistable_value(k, v, options)] }]
     end
   end
 end

data/lib/no_brainer/document/types.rb

@@ -22,7 +22,7 @@ module NoBrainer::Document::Types
   module ClassMethods
     def cast_user_to_model_for(attr, value)
       type = fields[attr.to_sym].try(:[], :type)
-      return value if type.nil? || value.nil?
+      return value if type.nil? || value.nil? || value.is_a?(NoBrainer::Document::AtomicOps::PendingAtomic)
       if type.respond_to?(:nobrainer_cast_user_to_model)
         type.nobrainer_cast_user_to_model(value)
       else
@@ -53,7 +53,7 @@ module NoBrainer::Document::Types
       cast_model_to_db_for(attr, value)
     end
 
-    def persistable_value(k, v)
+    def persistable_value(k, v, options={})
       cast_model_to_db_for(k, super)
     end
 

data/lib/no_brainer/document/types/set.rb

@@ -0,0 +1,23 @@
+class Set
+  module NoBrainerExtentions
+    InvalidType = NoBrainer::Error::InvalidType
+
+    def nobrainer_cast_user_to_model(value)
+      case value
+      when Set   then value
+      when Array then Set.new(value)
+      else raise InvalidType
+      end
+    end
+
+    def nobrainer_cast_db_to_model(value)
+      value.is_a?(Array) ? Set.new(value) : value
+    end
+
+    def nobrainer_cast_model_to_db(value)
+      value.is_a?(Set) ? value.to_a : value
+    end
+  end
+
+  extend NoBrainerExtentions
+end

data/lib/no_brainer/error.rb

@@ -9,6 +9,20 @@ module NoBrainer::Error
   class AssociationNotPersisted < RuntimeError; end
   class ReadonlyField           < RuntimeError; end
   class MissingAttribute        < RuntimeError; end
+  class AtomicBlock             < RuntimeError; end
+
+  class CannotReadAtomic < RuntimeError
+    attr_accessor :instance, :field, :value
+    def initialize(instance, field, value)
+      @instance = instance
+      @field = field
+      @value = value
+    end
+
+    def message
+      "Cannot read #{field}, atomic operations are pending"
+    end
+  end
 
   class DocumentInvalid < RuntimeError
     attr_accessor :instance

data/lib/no_brainer/query_runner/connection_lock.rb

@@ -2,6 +2,10 @@ class NoBrainer::QueryRunner::ConnectionLock < NoBrainer::QueryRunner::Middlewar
   @@lock = Mutex.new
 
   def call(env)
-    @@lock.synchronize { @runner.call(env) }
+    if NoBrainer::Config.per_thread_connection
+      @runner.call(env) 
+    else
+      @@lock.synchronize { @runner.call(env) }
+    end
   end
 end

data/lib/nobrainer.rb

@@ -1,3 +1,4 @@
+require 'set'
 require 'active_support'
 %w(module/delegation module/attribute_accessors class/attribute object/blank object/inclusion object/deep_dup
    object/try hash/keys hash/indifferent_access hash/reverse_merge hash/deep_merge array/extract_options)
@@ -10,28 +11,11 @@ module NoBrainer
   # We eager load things that could be loaded when handling the first web request.
   # Code that is loaded through the DSL of NoBrainer should not be eager loaded.
   autoload :Document, :IndexManager, :Loader, :Fork, :DecoratedSymbol
-  eager_autoload :Config, :Connection, :Error, :QueryRunner, :Criteria, :RQL
+  eager_autoload :Config, :Connection, :ConnectionManager,  :Error,
+                 :QueryRunner, :Criteria, :RQL
 
   class << self
-    # A connection is tied to a database.
-    def connection
-      @connection ||= begin
-        url = NoBrainer::Config.rethinkdb_url
-        raise "Please specify a database connection to RethinkDB" unless url
-        Connection.new(url)
-      end
-    end
-
-    def disconnect
-      @connection.try(:disconnect, :noreply_wait => true)
-      @connection = nil
-    end
-
-    def disconnect_if_url_changed
-      if @connection && @connection.uri != NoBrainer::Config.rethinkdb_url
-        disconnect
-      end
-    end
+    delegate :connection, :disconnect, :to => 'NoBrainer::ConnectionManager'
 
     delegate :db_create, :db_drop, :db_list,
              :table_create, :table_drop, :table_list,

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: nobrainer
 version: !ruby/object:Gem::Version
-  version: 0.16.0
+  version: 0.17.0
 platform: ruby
 authors:
 - Nicolas Viennot
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-08-28 00:00:00.000000000 Z
+date: 2014-09-25 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rethinkdb
@@ -78,6 +78,7 @@ files:
 - lib/no_brainer/autoload.rb
 - lib/no_brainer/config.rb
 - lib/no_brainer/connection.rb
+- lib/no_brainer/connection_manager.rb
 - lib/no_brainer/criteria.rb
 - lib/no_brainer/criteria/after_find.rb
 - lib/no_brainer/criteria/aggregate.rb
@@ -107,6 +108,7 @@ files:
 - lib/no_brainer/document/association/has_many_through.rb
 - lib/no_brainer/document/association/has_one.rb
 - lib/no_brainer/document/association/has_one_through.rb
+- lib/no_brainer/document/atomic_ops.rb
 - lib/no_brainer/document/attributes.rb
 - lib/no_brainer/document/callbacks.rb
 - lib/no_brainer/document/core.rb
@@ -130,6 +132,7 @@ files:
 - lib/no_brainer/document/types/date.rb
 - lib/no_brainer/document/types/float.rb
 - lib/no_brainer/document/types/integer.rb
+- lib/no_brainer/document/types/set.rb
 - lib/no_brainer/document/types/string.rb
 - lib/no_brainer/document/types/symbol.rb
 - lib/no_brainer/document/types/time.rb
@@ -161,7 +164,10 @@ homepage: http://nobrainer.io
 licenses:
 - LGPLv3
 metadata: {}
-post_install_message: 
+post_install_message: |2
+
+  WARNING [NoBrainer] API change: save() is now save?() and save!() is now save()
+  WARNING [NoBrainer] Same for update_attributes
 rdoc_options: []
 require_paths:
 - lib