nobrainer 0.28.0 → 0.29.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 8406e0c14de6dc8379b7047aa6d7254675e1b1fb
-  data.tar.gz: 0d9906ef55e4f74e5317a6d2377d4c1f19ac9799
+  metadata.gz: 9fbf539d3fd47eeec38c4ae88843297a7462efb5
+  data.tar.gz: e02bde6490ffc0eb21bf3fde637dc6a4dea0350d
 SHA512:
-  metadata.gz: fdcbf5021c15bad13546e7b346eb73fb7f6d0b62ab861578110b0ab81aafda8c364a4b6fe9b282d0f8f8c6d732ebd8dcc3f5be9aada980b79d34d93b0fed6fea
-  data.tar.gz: afa546845837919bb06b01c7ba4168626b74263244986d4d9d3a7428b9b68b24faa968572f110546fb5afb9c4b57dbb236d5c48556b9ae691d271deea62ff816
+  metadata.gz: 586f87afabedec2bc9716949298255c6456b7cbf9846a6b9e3090fe009cf481d68fd3eb852368a2658f1e4b59e432388f690cd2fce24606460229dbad1daf633
+  data.tar.gz: d55889b76d3a1e6dd48338fca51eb1ad636baa00bc20c21a992cf8e5e6d02a4f958f535dc95398a89c3695ceab87cf5ededbd915ac3b0f07f041dda16148e913

data/lib/no_brainer/autoload.rb

@@ -13,8 +13,14 @@ module NoBrainer::Autoload
     super() { autoload(*constants) }
   end
 
+  def eager_load!
+    super
+    @_autoloads.keys.map  { |c| const_get(c) }
+                    .each { |c| c.eager_load! if c.respond_to?(:eager_load!) }
+  end
+
   def autoload_and_include(*constants)
-    autoload(*constants)
+    eager_autoload(*constants)
     constants.each { |constant| include const_get(constant) }
   end
 end

data/lib/no_brainer/config.rb

@@ -6,10 +6,10 @@ module NoBrainer::Config
     :environment            => { :default => ->{ default_environment } },
     :rethinkdb_urls         => { :default => ->{ [default_rethinkdb_url] } },
     :ssl_options            => { :default => ->{ nil } },
+    :driver                 => { :default => ->{ :regular }, :valid_values => [:regular, :em] },
     :logger                 => { :default => ->{ default_logger } },
     :colorize_logger        => { :default => ->{ true }, :valid_values => [true, false] },
     :warn_on_active_record  => { :default => ->{ true }, :valid_values => [true, false] },
-    :max_retries_on_connection_failure => { :default => ->{ default_max_retries_on_connection_failure } },
     :durability             => { :default => ->{ default_durability }, :valid_values => [:hard, :soft] },
     :table_options          => { :default => ->{ {:shards => 1, :replicas => 1, :write_acks => :majority} },
                                  :valid_keys => [:shards, :replicas, :primary_replica_tag, :write_acks, :durability] },
@@ -37,6 +37,11 @@ module NoBrainer::Config
       STDERR.puts "[NoBrainer] The current behavior is now to always auto create tables"
     end
 
+    def max_retries_on_connection_failure=(value)
+      STDERR.puts "[NoBrainer] config.max_retries_on_connection_failure has been removed."
+      STDERR.puts "[NoBrainer] Queries are no longer retried upon failures"
+    end
+
     def apply_defaults
       @applied_defaults_for = SETTINGS.keys.reject { |k| instance_variable_defined?("@#{k}") }
       @applied_defaults_for.each { |k| __send__("#{k}=", SETTINGS[k][:default].call) }
@@ -53,6 +58,10 @@ module NoBrainer::Config
       end
 
       validate_urls
+
+      if driver == :em && per_thread_connection
+        raise "To use EventMachine, disable per_thread_connection"
+      end
     end
 
     def reset!
@@ -119,7 +128,7 @@ module NoBrainer::Config
     def validate_urls
       # This is not connecting, just validating the format.
       dbs = rethinkdb_urls.compact.map { |url| NoBrainer::Connection.new(url).parsed_uri[:db] }.uniq
-      raise "Please specify at least one rethinkdb_url" if dbs.size == 0
+      raise "Please specify the app_name and the environment, or a rethinkdb_url" if dbs.size == 0
       raise "All the rethinkdb_urls must specify the same db name (instead of #{dbs.inspect})" if dbs.size != 1
     end
 
@@ -132,6 +141,7 @@ module NoBrainer::Config
     end
 
     def default_max_retries_on_connection_failure
+      # TODO remove
       dev_mode? ? 1 : 15
     end
 

data/lib/no_brainer/connection.rb

@@ -2,9 +2,10 @@ require 'rethinkdb'
 require 'uri'
 
 class NoBrainer::Connection
-  attr_accessor :parsed_uri
+  attr_accessor :parsed_uri, :orig_uri
 
   def initialize(uri)
+    @orig_uri = uri
     parse_uri(uri)
   end
 
@@ -46,18 +47,4 @@ class NoBrainer::Connection
   def current_db
     NoBrainer.current_run_options.try(:[], :db) || default_db
   end
-
-  def drop!
-    NoBrainer.run { |r| r.db_drop(current_db) }
-  end
-
-  # Note that truncating each table (purge!) is much faster than dropping the database (drop!)
-  def purge!
-    NoBrainer.run { |r| r.table_list }.each do |table_name|
-      # keeping the index meta store because indexes are not going away when purging
-      next if table_name == NoBrainer::Document::Index::MetaStore.table_name
-      NoBrainer.run { |r| r.table(table_name).delete }
-    end
-    true
-  end
 end

data/lib/no_brainer/connection_manager.rb

@@ -62,11 +62,12 @@ module NoBrainer::ConnectionManager
   end
 
   def _disconnect
-    self.current_connection.try(:close, :noreply_wait => false) rescue nil
-    self.current_connection = nil
+    c, self.current_connection = self.current_connection, nil
+    c.try(:close, :noreply_wait => false) rescue nil
   end
 
   def disconnect
+    return unless self.current_connection
     synchronize { _disconnect }
   end
 
@@ -74,7 +75,7 @@ module NoBrainer::ConnectionManager
     synchronize do
       @urls = nil
       c = current_connection
-      _disconnect if c && !NoBrainer::Config.rethinkdb_urls.include?(c.uri)
+      _disconnect if c && !NoBrainer::Config.rethinkdb_urls.include?(c.orig_uri)
     end
   end
 end

data/lib/no_brainer/criteria/enumerable.rb

@@ -3,7 +3,16 @@ module NoBrainer::Criteria::Enumerable
 
   def each(options={}, &block)
     return enum_for(:each, options) unless block
-    run.each { |attrs| block.call(instantiate_doc(attrs)) }
+    run.tap { |cursor| @cursor = cursor }.each do |attrs|
+      return close if @close_cursor
+      block.call(instantiate_doc(attrs))
+    end
+    self
+  end
+
+  def close
+    @close_cursor = true
+    @cursor.close if NoBrainer::Config.driver == :em
     self
   end
 

data/lib/no_brainer/criteria/first_or_create.rb

@@ -10,11 +10,11 @@ module NoBrainer::Criteria::FirstOrCreate
   end
 
   def upsert(attrs, save_options={})
-    _upsert(attrs, save_options.merge(:save_method => :save?))
+    _upsert(attrs, save_options.merge(:save_method => :save?, :update => true))
   end
 
   def upsert!(attrs, save_options={})
-    _upsert(attrs, save_options.merge(:save_method => :save!))
+    _upsert(attrs, save_options.merge(:save_method => :save!, :update => true))
   end
 
   private
@@ -22,15 +22,27 @@ module NoBrainer::Criteria::FirstOrCreate
   def _upsert(attrs, save_options)
     attrs = attrs.symbolize_keys
     unique_keys = get_model_unique_fields.detect { |keys| keys & attrs.keys == keys }
-    raise "Could not find a uniqueness validator within `#{attrs.keys.inspect}'.\n" +
-           "Please add a corresponding uniqueness validator" unless unique_keys
-    where(attrs.slice(*unique_keys)).__send__(:_first_or_create, attrs, save_options)
+    return where(attrs.slice(*unique_keys)).__send__(:_first_or_create, attrs, save_options) if unique_keys
+
+    # We can't do an upsert :( Let see if we can fail on a validator first...
+    instance = model.new(attrs)
+    unless instance.valid?
+      case save_options[:save_method]
+      when :save! then raise NoBrainer::Error::DocumentInvalid, instance
+      when :save? then return instance
+      end
+    end
+
+    raise "Could not find a uniqueness validator for the following keys: `#{attrs.keys.inspect}'."
   end
 
   def _first_or_create(create_params, save_options, &block)
     raise "Cannot use .raw() with .first_or_create()" if raw?
     raise "Use first_or_create() on the root class `#{model.root_class}'" unless model.is_root_class?
 
+    save_method = save_options.delete(:save_method)
+    should_update = save_options.delete(:update)
+
     where_params = extract_where_params()
 
     # Note that we are not matching a subset of the keys on the uniqueness
@@ -58,7 +70,13 @@ module NoBrainer::Criteria::FirstOrCreate
     new_instance._lock_for_uniqueness_once(lock_key_name)
 
     old_instance = self.first
-    return old_instance if old_instance
+    if old_instance
+      if should_update
+        old_instance.assign_attributes(create_params)
+        old_instance.__send__(save_method, save_options)
+      end
+      return old_instance
+    end
 
     create_params = block.call if block
     create_params = create_params.symbolize_keys
@@ -80,7 +98,6 @@ module NoBrainer::Criteria::FirstOrCreate
     end
 
     new_instance.assign_attributes(create_params)
-    save_method = save_options.delete(:save_method)
     new_instance.__send__(save_method, save_options)
     return new_instance
   ensure

data/lib/no_brainer/document/aliases.rb

@@ -11,7 +11,7 @@ module NoBrainer::Document::Aliases
   end
 
   module ClassMethods
-    def _field(attr, options={})
+    def field(attr, options={})
       if options[:store_as]
         self.alias_map[attr.to_s] = options[:store_as].to_s
         self.alias_reverse_map[options[:store_as].to_s] = attr.to_s
@@ -19,7 +19,7 @@ module NoBrainer::Document::Aliases
       super
     end
 
-    def _remove_field(attr, options={})
+    def remove_field(attr, options={})
       super
 
       self.alias_map.delete(attr.to_s)

data/lib/no_brainer/document/association.rb

@@ -1,6 +1,7 @@
 module NoBrainer::Document::Association
   extend NoBrainer::Autoload
   autoload :Core, :BelongsTo, :HasMany, :HasManyThrough, :HasOne, :HasOneThrough, :EagerLoader
+  eager_autoload :EagerLoader
   METHODS = [:belongs_to, :has_many, :has_one]
 
   extend ActiveSupport::Concern
@@ -24,6 +25,8 @@ module NoBrainer::Document::Association
       define_method(association) do |target, options={}|
         target = target.to_sym
 
+        options[:class_name] = options.delete(:class) if options[:class]
+
         if r = self.association_metadata[target]
           raise "Cannot change the :through option" unless r.options[:through] == options[:through]
           r.options.merge!(options)

data/lib/no_brainer/document/attributes.rb

@@ -1,6 +1,8 @@
 module NoBrainer::Document::Attributes
-  VALID_FIELD_OPTIONS = [:index, :default, :type, :readonly, :primary_key, :lazy_fetch, :store_as,
-                         :validates, :required, :unique, :uniq, :format, :in, :length, :min_length, :max_length]
+  VALID_FIELD_OPTIONS = [:index, :default, :type, :readonly, :primary_key,
+                         :lazy_fetch, :store_as, :validates, :required, :unique,
+                         :uniq, :format, :in, :length, :min_length, :max_length,
+                         :prefix, :suffix]
   RESERVED_FIELD_NAMES = [:index, :default, :and, :or, :selector, :associations, :pk_value] +
                           NoBrainer::SymbolDecoration::OPERATORS
 
@@ -115,43 +117,32 @@ 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={})
+    def field(attr, options={})
       options.assert_valid_keys(*VALID_FIELD_OPTIONS)
+      unless attr.is_a?(Symbol)
+        raise "The field `#{attr}' must be declared with a Symbol" # we're just being lazy here...
+      end
       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) }
-        define_method("#{attr}") { _read_attribute(attr) }
-      end
-    end
-
-    def field(attr, options={})
-      attr = attr.to_sym
-
       subclass_tree.each do |subclass|
         subclass.fields[attr] ||= {}
         subclass.fields[attr].deep_merge!(options)
       end
 
-      _field(attr, self.fields[attr])
+      attr = attr.to_s
+      inject_in_layer :attributes do
+        define_method("#{attr}=") { |value| _write_attribute(attr, value) }
+        define_method("#{attr}") { _read_attribute(attr) }
+      end
     end
 
-    def _remove_field(attr, options={})
+    def remove_field(attr, options={})
       inject_in_layer :attributes do
         remove_method("#{attr}=")
         remove_method("#{attr}")
       end
-    end
-
-    def remove_field(attr, options={})
-      attr = attr.to_sym
-
-      _remove_field(attr, options)
 
       subclass_tree.each do |subclass|
         subclass.fields.delete(attr)

data/lib/no_brainer/document/dirty.rb

@@ -75,7 +75,7 @@ module NoBrainer::Document::Dirty
   end
 
   module ClassMethods
-    def _field(attr, options={})
+    def field(attr, options={})
       super
       attr = attr.to_s
 
@@ -97,7 +97,7 @@ module NoBrainer::Document::Dirty
       end
     end
 
-    def _remove_field(attr, options={})
+    def remove_field(attr, options={})
       super
       inject_in_layer :dirty_tracking do
         remove_method("#{attr}_change")

data/lib/no_brainer/document/index.rb

@@ -12,7 +12,12 @@ module NoBrainer::Document::Index
 
   module ClassMethods
     def index(name, *args)
-      name = name.to_sym
+      name = case name
+        when String then name.to_sym
+        when Symbol then name
+        else raise ArgumentError, "Incorrect index specification"
+      end
+
       options = args.extract_options!
       options.assert_valid_keys(*VALID_INDEX_OPTIONS)
 
@@ -54,14 +59,14 @@ module NoBrainer::Document::Index
       !!indexes[name.to_sym]
     end
 
-    def _field(attr, options={})
+    def field(attr, options={})
       if has_index?(attr) && indexes[attr].kind != :single
         raise "The index `#{attr}' is already declared. Please remove its definition first."
       end
 
       super
 
-      store_as = {:store_as => options[:store_as]}
+      store_as = {:store_as => fields[attr][:store_as]}
       case options[:index]
       when nil    then
       when Hash   then index(attr, store_as.merge(options[:index]))
@@ -71,7 +76,7 @@ module NoBrainer::Document::Index
       end
     end
 
-    def _remove_field(attr, options={})
+    def remove_field(attr, options={})
       remove_index(attr) if fields[attr][:index]
       super
     end

data/lib/no_brainer/document/lazy_fetch.rb

@@ -28,18 +28,18 @@ module NoBrainer::Document::LazyFetch
       super
     end
 
-    def _field(attr, options={})
+    def field(attr, options={})
       super
       attr = attr.to_s
-      model = self
-      inject_in_layer :lazy_fetch do
-        if options[:lazy_fetch]
-          model.subclass_tree.each { |subclass| subclass.fields_to_lazy_fetch << attr }
-        else
-          model.subclass_tree.each { |subclass| subclass.fields_to_lazy_fetch.delete(attr) }
-        end
 
-        # Lazy loading can also specified through criteria.
+      case options[:lazy_fetch]
+      when true  then subclass_tree.each { |subclass| subclass.fields_to_lazy_fetch << attr }
+      when false then subclass_tree.each { |subclass| subclass.fields_to_lazy_fetch.delete(attr) }
+      end
+
+      inject_in_layer :lazy_fetch do
+        # Lazy loading can also specified through criteria, we have to define
+        # this method regardless of the provided options.
         define_method("#{attr}") do
           return super() unless @lazy_fetch
 
@@ -55,12 +55,12 @@ module NoBrainer::Document::LazyFetch
       end
     end
 
-    def _remove_field(attr, options={})
-      super
-      subclass_tree.each { |subclass| subclass.fields_to_lazy_fetch.delete(attr) }
+    def remove_field(attr, options={})
+      subclass_tree.each { |subclass| subclass.fields_to_lazy_fetch.delete(attr.to_s) }
       inject_in_layer :lazy_fetch do
-        remove_method("#{attr}") if method_defined?("#{attr}")
+        remove_method("#{attr}")
       end
+      super
     end
 
     def all

data/lib/no_brainer/document/primary_key.rb

@@ -1,6 +1,6 @@
 module NoBrainer::Document::PrimaryKey
   extend NoBrainer::Autoload
-  autoload :Generator
+  eager_autoload :Generator
 
   extend ActiveSupport::Concern
   include ActiveModel::Conversion
@@ -34,50 +34,38 @@ module NoBrainer::Document::PrimaryKey
   end
 
   module ClassMethods
-    def define_default_pk
-      class_variable_set(:@@pk_name, nil)
-      field NoBrainer::Document::PrimaryKey::DEFAULT_PK_NAME, :primary_key => :default
-    end
-
-    def define_pk(attr)
-      return if pk_name == attr
-      if fields[pk_name].try(:[], :primary_key) == :default
-        remove_field(pk_name, :set_default_pk => false)
-      end
-      class_variable_set(:@@pk_name, attr)
-    end
-
     def pk_name
       class_variable_get(:@@pk_name)
     end
 
-    def _field(attr, options={})
-      super
-      define_pk(attr) if options[:primary_key]
+    def define_default_pk
+      class_variable_set(:@@pk_name, nil)
+
+      # TODO Maybe we should let the user configure the pk generator
+      pk_generator = NoBrainer::Document::PrimaryKey::Generator
+
+      field NoBrainer::Document::PrimaryKey::DEFAULT_PK_NAME, :primary_key => true,
+        :type => pk_generator.field_type, :default => ->{ pk_generator.generate }
     end
 
     def field(attr, options={})
-      if attr.to_sym == pk_name || options[:primary_key]
-        options = options.merge(:readonly => true) if options[:readonly].nil?
-        options = options.merge(:index => true)
+      return super unless options[:primary_key]
 
-        # TODO Maybe we should let the user configure the pk generator
-        pk_generator = NoBrainer::Document::PrimaryKey::Generator
-
-        if options[:type].in?([pk_generator.field_type, nil]) && !options.key?(:default)
-          options[:type] = pk_generator.field_type
-          options[:default] = ->{ pk_generator.generate }
-        end
+      if attr != pk_name
+        remove_field(pk_name, :set_default_pk => false) if pk_name
+        class_variable_set(:@@pk_name, attr)
       end
 
+      options[:index] = true
+      options[:readonly] = true
       super
     end
 
-    def _remove_field(attr, options={})
-      super
+    def remove_field(attr, options={})
       if fields[attr][:primary_key] && options[:set_default_pk] != false
         define_default_pk
       end
+      super
     end
   end
 end

data/lib/no_brainer/document/readonly.rb

@@ -2,21 +2,25 @@ module NoBrainer::Document::Readonly
   extend ActiveSupport::Concern
 
   module ClassMethods
-    def _field(attr, options={})
+    def field(attr, options={})
       super
       inject_in_layer :readonly do
-        if options[:readonly]
+        case options[:readonly]
+        when true
           define_method("#{attr}=") do |value|
-            raise NoBrainer::Error::ReadonlyField.new("#{attr} is readonly") unless new_record?
+            unless new_record?
+              if read_attribute(attr) != value
+                raise NoBrainer::Error::ReadonlyField.new("#{attr} is readonly")
+              end
+            end
             super(value)
           end
-        else
-          remove_method("#{attr}=") if method_defined?("#{attr}=")
+        when false then remove_method("#{attr}=") if method_defined?("#{attr}=")
         end
       end
     end
 
-    def _remove_field(attr, options={})
+    def remove_field(attr, options={})
       super
       inject_in_layer :readonly do
         remove_method("#{attr}=") if method_defined?("#{attr}=")

data/lib/no_brainer/document/table_config.rb

@@ -99,7 +99,7 @@ module NoBrainer::Document::TableConfig
     end
 
     def sync_indexes(options={})
-      # nobrainer models don't have indexes
+      # NoBrainer internal models don't have indexes.
       models = NoBrainer::Document.all(:types => [:user])
       NoBrainer::Document::Index::Synchronizer.new(models).sync_indexes(options)
     end
@@ -110,8 +110,22 @@ module NoBrainer::Document::TableConfig
     end
 
     def rebalance(options={})
-      models = NoBrainer::Document.all(:types => [:user])
-      models.each(&:rebalance)
+      NoBrainer.run { |r| r.table_list }.each do |table_name|
+        NoBrainer.run { |r| r.table(table_name).rebalance }
+      end
+      true
+    end
+
+    def drop!
+      NoBrainer.run { |r| r.db_drop(NoBrainer.current_db) }
+    end
+
+    def purge!
+      NoBrainer.run { |r| r.table_list }.each do |table_name|
+        # keeping the index meta store because indexes are not going away when purging
+        next if table_name == NoBrainer::Document::Index::MetaStore.table_name
+        NoBrainer.run { |r| r.table(table_name).delete }
+      end
       true
     end
   end

data/lib/no_brainer/document/types.rb

@@ -58,19 +58,20 @@ module NoBrainer::Document::Types
       cast_model_to_db_for(k, super)
     end
 
-    def _field(attr, options={})
+    def field(attr, options={})
       super
 
-      return unless options[:type]
+      type = options[:type]
+      return unless type
 
-      raise "Please use a class for the type option" unless options[:type].is_a?(Class)
-      case options[:type].to_s
+      raise "Please use a class for the type option" unless type.is_a?(Class)
+      case type.to_s
       when "NoBrainer::Geo::Circle" then raise "Cannot store circles :("
       when "NoBrainer::Geo::Polygon", "NoBrainer::Geo::LineString"
         raise "Make a request on github if you'd like to store polygons/linestrings"
       end
 
-      NoBrainer::Document::Types.load_type_extensions(options[:type]) if options[:type]
+      NoBrainer::Document::Types.load_type_extensions(type) if type
 
       inject_in_layer :types do
         define_method("#{attr}=") do |value|
@@ -83,22 +84,28 @@ module NoBrainer::Document::Types
           end
           super(value)
         end
+      end
 
-        define_method("#{attr}?") { !!read_attribute(attr) } if options[:type] == Boolean
+      if type.respond_to?(:nobrainer_field_defined)
+        type.nobrainer_field_defined(self, attr, options)
       end
     end
 
-    def _remove_field(attr, options={})
-      super
+    def remove_field(attr, options={})
+      if type = fields[attr][:type]
+        inject_in_layer :types do
+          remove_method("#{attr}=")
+        end
 
-      inject_in_layer :types do
-        remove_method("#{attr}=")
-        remove_method("#{attr}?") if method_defined?("#{attr}?")
+        if type.respond_to?(:nobrainer_field_undefined)
+          type.nobrainer_field_undefined(self, attr, options)
+        end
       end
+      super
     end
   end
 
-  %w(binary boolean text geo).each do |type|
+  %w(binary boolean text geo enum).each do |type|
     require File.join(File.dirname(__FILE__), 'types', type)
     const_set(type.camelize, NoBrainer.const_get(type.camelize))
   end

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

@@ -19,6 +19,18 @@ class NoBrainer::Boolean
       else raise InvalidType
       end
     end
+
+    def nobrainer_field_defined(model, attr, options={})
+      model.inject_in_layer :types do
+        define_method("#{attr}?") { !!read_attribute(attr) }
+      end
+    end
+
+    def nobrainer_field_undefined(model, attr, options={})
+      model.inject_in_layer :types do
+        remove_method("#{attr}?")
+      end
+    end
   end
   extend NoBrainerExtensions
 end

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

@@ -0,0 +1,63 @@
+class NoBrainer::Enum
+  def initialize; raise; end
+  def self.inspect; 'Enum'; end
+  def self.to_s; inspect; end
+  def self.name; inspect; end
+
+  module NoBrainerExtensions
+    InvalidType = NoBrainer::Error::InvalidType
+
+    def nobrainer_cast_user_to_model(value)
+      Symbol.nobrainer_cast_user_to_model(value)
+    end
+
+    def nobrainer_cast_db_to_model(value)
+      Symbol.nobrainer_cast_db_to_model(value)
+    end
+
+    def nobrainer_field_defined(model, attr, options={})
+      NoBrainer::Document::Types.load_type_extensions(Symbol)
+
+      unless options[:in].present?
+        raise "When using Enum on `#{model}.#{attr}', you must provide the `:in` option to specify values"
+      end
+      unless options[:in].all? { |v| v.is_a?(Symbol) }
+        raise "The `:in` option must specify symbol values"
+      end
+
+      model.inject_in_layer :enum do
+        extend ActiveSupport::Concern
+
+        const_set(:ClassMethods, Module.new) unless const_defined?(:ClassMethods)
+
+        options[:in].each do |value|
+          method = NoBrainer::Enum::NoBrainerExtensions.method_name(value, attr, options)
+          if method_defined?("#{method}?")
+            raise "The method `#{method}' is already taken. You may specify a :prefix or :suffix option"
+          end
+
+          define_method("#{method}?") { read_attribute(attr) == value }
+          define_method("#{method}!") { write_attribute(attr, value) }
+          const_get(:ClassMethods).__send__(:define_method, "#{method}") { where(attr => value) }
+        end
+      end
+    end
+
+    def nobrainer_field_undefined(model, attr, options={})
+      model.inject_in_layer :enum do
+        model.fields[attr][:in].each do |value|
+          method = NoBrainer::Enum::NoBrainerExtensions.method_name(value, attr, model.fields[attr])
+          remove_method("#{method}?")
+          remove_method("#{method}!")
+          const_get(:ClassMethods).__send__(:remove_method, "#{method}")
+        end
+      end
+    end
+
+    def self.method_name(value, attr, options)
+      [options[:prefix] == true ? attr : options[:prefix], value,
+       options[:suffix] == true ? attr : options[:suffix]].compact.join("_")
+    end
+  end
+  extend NoBrainerExtensions
+end

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

@@ -8,7 +8,8 @@ class Time
       case value
       when Time then time = value
       when String
-        value = value.strip.sub(/Z$/, '+00:00')
+        value = value.strip
+        value = value.sub(/Z$/, '+00:00') unless NoBrainer.jruby?
         # Using DateTime to preserve the timezone offset
         dt = DateTime.parse(value) rescue (raise InvalidType)
         time = Time.new(dt.year, dt.month, dt.day, dt.hour, dt.minute, dt.second, dt.zone)

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

@@ -27,7 +27,7 @@ module NoBrainer::Document::Validation::Core
                  :uniq => :uniqueness, :unique => :uniqueness, :in => :inclusion }
 
   module ClassMethods
-    def _field(attr, options={})
+    def field(attr, options={})
       super
 
       shorthands = SHORTHANDS

data/lib/no_brainer/query_runner.rb

@@ -10,31 +10,49 @@ module NoBrainer::QueryRunner
     end
   end
 
-  autoload :Driver, :DatabaseOnDemand, :TableOnDemand, :WriteError,
-           :Reconnect, :Selection, :RunOptions, :Profiler, :MissingIndex,
-           :ConnectionLock
+  autoload :EMDriver, :Driver, :DatabaseOnDemand, :TableOnDemand, :WriteError,
+           :Reconnect, :RunOptions, :Profiler, :MissingIndex, :ConnectionLock
 
   class << self
-    attr_accessor :stack
-
     def run(*args, &block)
       options = args.extract_options!
       raise ArgumentError unless args.size == 1 || block
       query = args.first || block.call(RethinkDB::RQL.new)
       stack.call(:query => query, :options => options)
     end
-  end
 
-  # thread-safe, since require() is ran with a mutex.
-  self.stack = ::Middleware::Builder.new do
-    use RunOptions
-    use MissingIndex
-    use DatabaseOnDemand
-    use TableOnDemand
-    use Profiler
-    use WriteError
-    use ConnectionLock
-    use Reconnect
-    use Driver
+    def stack
+      case NoBrainer::Config.driver
+      when :regular then normal_stack
+      when :em      then em_stack
+      end
+    end
+
+    def normal_stack
+      @normal_stack ||= ::Middleware::Builder.new do
+        use RunOptions
+        use MissingIndex
+        use DatabaseOnDemand
+        use TableOnDemand
+        use Profiler
+        use WriteError
+        use ConnectionLock
+        use Reconnect
+        use Driver
+      end
+    end
+
+    def em_stack
+      @em_stack ||= ::Middleware::Builder.new do
+        use RunOptions
+        use MissingIndex
+        use DatabaseOnDemand
+        use TableOnDemand
+        use Profiler
+        use WriteError
+        use Reconnect
+        use EMDriver
+      end
+    end
   end
 end

data/lib/no_brainer/query_runner/database_on_demand.rb

@@ -3,6 +3,9 @@ class NoBrainer::QueryRunner::DatabaseOnDemand < NoBrainer::QueryRunner::Middlew
     @runner.call(env)
   rescue RuntimeError => e
     if db_name = handle_database_on_demand_exception?(env, e)
+      # Don't auto create on db_drop.
+      return {} if NoBrainer::RQL.db_drop?(env[:query])
+
       auto_create_database(env, db_name)
       retry
     end
@@ -10,7 +13,7 @@ class NoBrainer::QueryRunner::DatabaseOnDemand < NoBrainer::QueryRunner::Middlew
   end
 
   def handle_database_on_demand_exception?(env, e)
-    e.message =~ /^Database `(.+)` does not exist\.$/ && $1
+    /^Database `(.+)` does not exist\.$/.match(e.message).try(:[], 1)
   end
 
   private

data/lib/no_brainer/query_runner/em_driver.rb

@@ -0,0 +1,128 @@
+require 'eventmachine'
+require 'fiber'
+
+class NoBrainer::QueryRunner::EMDriver < NoBrainer::QueryRunner::Middleware
+  def call(env)
+    options = env[:options]
+    options = options.merge(:db => RethinkDB::RQL.new.db(options[:db])) if options[:db]
+
+    handler = ResponseHandler.new
+    query_handler = env[:query].em_run(NoBrainer.connection.raw, handler, options)
+    handler.on_dispatch(query_handler)
+    handler.value
+  end
+
+  def self.sync(&block)
+    # Similar to em-synchrony's sync.
+    f = Fiber.current
+    block.call(proc do |val|
+      if f == Fiber.current
+        return val
+      else
+        f.resume(val)
+      end
+    end)
+    Fiber.yield
+  end
+
+  class ResponseHandler < RethinkDB::Handler
+    def initialize
+      @ready = EventMachine::DefaultDeferrable.new
+    end
+
+    def close_query_handle
+      @query_handle.close
+    end
+
+    def on_dispatch(caller)
+      @query_handle = caller
+    end
+
+    def on_open(caller)
+      @has_data = true
+    end
+
+    def on_close(caller)
+      return if @has_atom
+      return on_error(RethinkDB::RqlRuntimeError.new("NoBrainer EM driver: No data received"), caller) unless @has_data
+      @queue ? push(:close) : set_atom([])
+    end
+
+    def on_error(err, caller)
+      @error = err
+      push(err)
+    end
+
+    def on_atom(val, caller)
+      set_atom(val)
+    end
+
+    def on_array(arr, caller)
+      set_atom(arr)
+    end
+
+    def on_stream_val(val, caller)
+      push([val])
+    end
+
+    def on_unhandled_change(val, caller)
+      push([val])
+    end
+
+    def push(v)
+      raise "internal error: unexpected stream" if @has_atom
+      @queue ||= EventMachine::Queue.new
+      @queue.push(v)
+      response_ready!
+    end
+
+    def set_atom(v)
+      raise "internal error: unexpected atom" if @queue
+      @has_atom = true
+      @value = v
+      response_ready!
+    end
+
+    def response_ready!
+      @ready.succeed(nil) if @ready
+    end
+
+    def wait_for_response
+      NoBrainer::QueryRunner::EMDriver.sync { |w| @ready.callback(&w) } if @ready
+      @ready = nil
+    end
+
+    def value
+      wait_for_response
+      raise @error if @error
+      @has_atom ? @value : Cursor.new(self, @queue)
+    end
+
+    class Cursor
+      include Enumerable
+      def initialize(handler, queue)
+        @handler = handler
+        @queue = queue
+      end
+
+      def close
+        @handler.close_query_handle
+      end
+
+      def each(&block)
+        return enum_for(:each) unless block
+
+        raise "Can only iterate over a cursor once." if @iterated
+        @iterated = true
+
+        loop do
+          case result = NoBrainer::QueryRunner::EMDriver.sync { |w| @queue.pop(&w) }
+          when :close then return self
+          when Exception then raise result
+          else result.each { |v| block.call(v) }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/no_brainer/query_runner/missing_index.rb

@@ -1,11 +1,9 @@
 class NoBrainer::QueryRunner::MissingIndex < NoBrainer::QueryRunner::Middleware
   def call(env)
     @runner.call(env)
-  rescue RethinkDB::RqlRuntimeError => e
-    if e.message =~ /^Index `(.+)` was not found on table `(.+)\.(.+)`\.$/
-      index_name = $1
-      db_name = $2
-      table_name = $3
+  rescue RuntimeError => e
+    if match_data = /^Index `(.+)` was not found on table `(.+)\.(.+)`\.$/.match(e.message)
+      _, index_name, db_name, table_name = *match_data
 
       model = NoBrainer::Document.all.select { |m| m.table_name == table_name }.first
       index = model.indexes.values.select { |i| i.aliased_name == index_name.to_sym }.first if model

data/lib/no_brainer/query_runner/reconnect.rb

@@ -2,56 +2,18 @@ class NoBrainer::QueryRunner::Reconnect < NoBrainer::QueryRunner::Middleware
   def call(env)
     @runner.call(env)
   rescue StandardError => e
-    if is_connection_error_exception?(e)
-      context ||= {}
-      # XXX Possibly dangerous, as we could reexecute a non idempotent operation
-      retry if reconnect(e, context)
-    end
+    NoBrainer.disconnect if is_connection_error_exception?(e)
     raise
   end
 
   private
 
-  def max_tries
-    NoBrainer::Config.max_retries_on_connection_failure
-  end
-
-  def reconnect(e, context)
-    context[:connection_retries] ||= max_tries
-    context[:previous_connection] ||= NoBrainer.connection
-    NoBrainer.disconnect
-
-    unless context[:lost_connection_logged]
-      context[:lost_connection_logged] = true
-
-      msg = server_not_ready?(e) ? "Server %s not ready: %s" : "Connection issue with %s: %s"
-      NoBrainer.logger.warn(msg % [context[:previous_connection].try(:uri), exception_msg(e)])
-    end
-
-    if context[:connection_retries].zero?
-      NoBrainer.logger.info("Retry limit exceeded (#{max_tries}). Giving up.")
-      return false
-    end
-    context[:connection_retries] -= 1
-
-    sleep 1
-
-    c = NoBrainer.connection
-    NoBrainer.logger.info("Connecting to #{c.uri}... (last error: #{exception_msg(e)})")
-    c.connect
-
-    true
-  rescue StandardError => e
-    retry if is_connection_error_exception?(e)
-    raise
-  end
-
   def is_connection_error_exception?(e)
     case e
     when Errno::ECONNREFUSED, Errno::EHOSTUNREACH, Errno::EPIPE,
       Errno::ECONNRESET, Errno::ETIMEDOUT, IOError
       true
-    when RethinkDB::RqlRuntimeError
+    when RethinkDB::RqlError
       e.message =~ /lost contact/ ||
       e.message =~ /(P|p)rimary .* not available/||
       e.message =~ /Connection.*closed/
@@ -59,13 +21,4 @@ class NoBrainer::QueryRunner::Reconnect < NoBrainer::QueryRunner::Middleware
       false
     end
   end
-
-  def exception_msg(e)
-    e.is_a?(RethinkDB::RqlRuntimeError) ? e.message.split("\n").first : e.to_s
-  end
-
-  def server_not_ready?(e)
-    e.message =~ /lost contact/ ||
-    e.message =~ /(P|p)rimary .* not available/
-  end
 end

data/lib/no_brainer/query_runner/table_on_demand.rb

@@ -1,6 +1,7 @@
 class NoBrainer::QueryRunner::TableOnDemand < NoBrainer::QueryRunner::Middleware
   def call(env)
     @runner.call(env)
+  # Not matching in RqlRuntimeError because we can get a DocumentNotPersisted
   rescue RuntimeError => e
     if table_info = handle_table_on_demand_exception?(env, e)
       auto_create_table(env, *table_info)
@@ -10,7 +11,7 @@ class NoBrainer::QueryRunner::TableOnDemand < NoBrainer::QueryRunner::Middleware
   end
 
   def handle_table_on_demand_exception?(env, e)
-    e.message =~ /^Table `(.+)\.(.+)` does not exist\.$/ && [$1, $2]
+    /^Table `(.+)\.(.+)` does not exist\.$/.match(e.message).try(:[], 1..2)
   end
 
   private

data/lib/no_brainer/railtie/database.rake

@@ -4,17 +4,20 @@ namespace :nobrainer do
     NoBrainer.drop!
   end
 
-  desc 'Synchronize index definitions'
+  desc 'Rebalance all tables'
+  task :rebalance => :environment do
+    NoBrainer.rebalance(:verbose => true)
+  end
+
   task :sync_indexes => :environment do
     NoBrainer.sync_indexes(:verbose => true)
   end
 
-  desc 'Synchronize table configuration'
   task :sync_table_config => :environment do
     NoBrainer.sync_table_config(:verbose => true)
   end
 
-  desc 'Synchronize indexes and table configuration'
+  desc 'Synchronize schema'
   task :sync_schema => :environment do
     NoBrainer.sync_schema(:verbose => true)
   end
@@ -28,17 +31,11 @@ namespace :nobrainer do
     Rails.application.load_seed
   end
 
-  desc 'Equivalent to :sync_schema_quiet + :seed'
   task :setup => [:sync_schema_quiet, :seed]
 
-  desc 'Equivalent to :drop + :setup'
-  task :reset => [:drop, :setup]
+  desc 'Equivalent to :drop + :sync_schema + :seed'
+  task :reset => [:drop, :sync_schema_quiet, :seed]
 
-  task :create => :environment do
-    # noop
-  end
-
-  task :migrate => :environment do
-    # noop
-  end
+  task :create => [:sync_schema]
+  task :migrate => [:sync_schema]
 end

data/lib/no_brainer/rql.rb

@@ -17,8 +17,16 @@ module NoBrainer::RQL
     type_of(rql) == :write
   end
 
+  def get_rql_statement(rql)
+    rql.is_a?(RethinkDB::RQL) && rql.body.is_a?(Array) && rql.body.first
+  end
+
+  def db_drop?(rql)
+    get_rql_statement(rql) == DB_DROP
+  end
+
   def type_of(rql)
-    case rql.is_a?(RethinkDB::RQL) && rql.body.is_a?(Array) && rql.body.first
+    case get_rql_statement(rql)
     when UPDATE, DELETE, REPLACE, INSERT
       :write
     when DB_CREATE, DB_DROP, DB_LIST, TABLE_CREATE, TABLE_DROP, TABLE_LIST,

data/lib/nobrainer.rb

@@ -20,8 +20,7 @@ module NoBrainer
 
   class << self
     delegate :connection, :disconnect, :to => 'NoBrainer::ConnectionManager'
-
-    delegate :drop!, :purge!, :default_db, :current_db, :to => :connection
+    delegate :default_db, :current_db, :to => :connection
 
     delegate :configure, :logger,             :to => 'NoBrainer::Config'
     delegate :run,                            :to => 'NoBrainer::QueryRunner'
@@ -29,13 +28,22 @@ module NoBrainer
 
     delegate :with, :with_database, :to => 'NoBrainer::QueryRunner::RunOptions' # deprecated
 
-    delegate :sync_indexes, :sync_table_config, :sync_schema, :rebalance, :to => 'NoBrainer::Document::TableConfig'
+    delegate :sync_indexes, :sync_table_config, :sync_schema, :rebalance,
+             :drop!, :purge!, :to => 'NoBrainer::Document::TableConfig'
 
     delegate :eager_load, :to => 'NoBrainer::Document::Association::EagerLoader'
 
     def jruby?
       RUBY_PLATFORM == 'java'
     end
+
+    def eager_load!
+      # XXX This forces all the NoBrainer code to be loaded in memory.
+      # Not to be confused with eager_load() that operates on documents.
+      # We assume that NoBrainer is already configured at this point.
+      super
+      NoBrainer::QueryRunner.stack # load the code for the current stack
+    end
   end
 
   Fork.hook unless jruby?

data/lib/rails/generators/templates/nobrainer.rb

@@ -22,6 +22,10 @@ NoBrainer.configure do |config|
   # an SSL connection to the RethinkDB servers.
   # config.ssl_options = nil
 
+  # driver specifies which driver to use. You may use :regular or :em.
+  # Use :em if you use EventMachine with em-synchrony.
+  # config.driver = :regular
+
   # NoBrainer uses logger to emit debugging information.
   # The default logger is the Rails logger if run with Rails,
   # otherwise Logger.new(STDERR) with a WARN level.
@@ -39,14 +43,6 @@ NoBrainer.configure do |config|
   # You can turn off the warning if you want to use both.
   # config.warn_on_active_record = true
 
-  # When the network connection is lost, NoBrainer can retry running a given
-  # query a few times before giving up. Note that this can be a problem with
-  # non idempotent write queries such as increments.
-  # Setting it to 0 disable retries during reconnections.
-  # The default is 1 for development or test environment, otherwise 15.
-  # config.max_retries_on_connection_failure = \
-  #   config.default_max_retries_on_connection_failure
-
   # Configures the durability for database writes.
   # The default is :soft for development or test environment, otherwise :hard.
   # config.durability = config.default_durability

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: nobrainer
 version: !ruby/object:Gem::Version
-  version: 0.28.0
+  version: 0.29.0
 platform: ruby
 authors:
 - Nicolas Viennot
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-08-02 00:00:00.000000000 Z
+date: 2015-08-19 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rethinkdb
@@ -16,14 +16,14 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 2.0.0.0
+        version: 2.1.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 2.0.0.0
+        version: 2.1.0
 - !ruby/object:Gem::Dependency
   name: activesupport
   requirement: !ruby/object:Gem::Requirement
@@ -154,6 +154,7 @@ files:
 - lib/no_brainer/document/types/binary.rb
 - lib/no_brainer/document/types/boolean.rb
 - lib/no_brainer/document/types/date.rb
+- lib/no_brainer/document/types/enum.rb
 - lib/no_brainer/document/types/float.rb
 - lib/no_brainer/document/types/geo.rb
 - lib/no_brainer/document/types/integer.rb
@@ -184,6 +185,7 @@ files:
 - lib/no_brainer/query_runner/connection_lock.rb
 - lib/no_brainer/query_runner/database_on_demand.rb
 - lib/no_brainer/query_runner/driver.rb
+- lib/no_brainer/query_runner/em_driver.rb
 - lib/no_brainer/query_runner/missing_index.rb
 - lib/no_brainer/query_runner/profiler.rb
 - lib/no_brainer/query_runner/reconnect.rb