nobrainer 0.13.1 → 0.14.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: b5ca498dfa914c0c0178f339485d78ba804c5b95
-  data.tar.gz: c0e0c6f35d8927bb6281f860aac769753df59b88
+  metadata.gz: 43783bcf0d625af679de685ab771782ce9b141f3
+  data.tar.gz: 4b5e4ff205f55adb754133b681b6e71c71772790
 SHA512:
-  metadata.gz: ed914e1eee020658197d596245404a2a088acbf033f5fc3a44cb490620cdc5ef110d62e4da927e7579e5e3383bc90e16dd499269a9bd8952dfa2011d3e2f2a12
-  data.tar.gz: f3204081b4ef7617706ee3c037830bdacbde973ae79e914b782b39fb41f1ec36b0125f78b427d0f21078bdae543ee426f2936ba69a1327bc36176acc6997765e
+  metadata.gz: 1c182d056390dd2c7b51bac68999d79c72cfaca49837239c4eead56ce8d0ff474630cc7b24e9fa12a4ff8d36641a5f6cc46fb7c588c45e975af42e8d4b5dbebc
+  data.tar.gz: 5226adb01498de4e82f8b3a4729c818ed1a40dc07e3596061d64956407b9a62129108046e0625bbe60bcac1804f0b8111cab4ec3a736151b6cfdc3d5799f2d88

data/lib/no_brainer/config.rb

@@ -38,7 +38,7 @@ module NoBrainer::Config
 
     def default_rethinkdb_url
       db = ENV['RETHINKDB_DB'] || ENV['RDB_DB']
-      db ||= "#{Rails.application.class.parent_name.underscore}_#{Rails.env}" if defined?(Rails)
+      db ||= "#{Rails.application.class.parent_name.underscore}_#{Rails.env}" rescue nil
       host = ENV['RETHINKDB_HOST'] || ENV['RDB_HOST'] || 'localhost'
       port = ENV['RETHINKDB_PORT'] || ENV['RDB_PORT']
       auth = ENV['RETHINKDB_AUTH'] || ENV['RDB_AUTH']
@@ -48,11 +48,11 @@ module NoBrainer::Config
     end
 
     def default_logger
-      defined?(Rails) ? Rails.logger : Logger.new(STDERR).tap { |l| l.level = Logger::WARN }
+      defined?(Rails.logger) ? Rails.logger : Logger.new(STDERR).tap { |l| l.level = Logger::WARN }
     end
 
     def default_durability
-      (defined?(Rails) && (Rails.env.test? || Rails.env.development?)) ? :soft : :hard
+      (defined?(Rails.env) && (Rails.env.test? || Rails.env.development?)) ? :soft : :hard
     end
   end
 end

data/lib/no_brainer/criteria/delete.rb

@@ -2,10 +2,10 @@ module NoBrainer::Criteria::Delete
   extend ActiveSupport::Concern
 
   def delete_all
-    run(to_rql.delete)
+    run(without_ordering.to_rql.delete)
   end
 
   def destroy_all
-    to_a.each { |doc| doc.destroy }
+    without_ordering.to_a.each { |doc| doc.destroy }
   end
 end

data/lib/no_brainer/criteria/order_by.rb

@@ -1,7 +1,7 @@
 module NoBrainer::Criteria::OrderBy
   extend ActiveSupport::Concern
 
-  included { attr_accessor :order, :_reverse_order }
+  included { attr_accessor :order, :ordering_mode }
 
   def initialize(options={})
     super
@@ -24,36 +24,55 @@ module NoBrainer::Criteria::OrderBy
 
     chain do |criteria|
       criteria.order = rules
-      criteria._reverse_order = false
+      criteria.ordering_mode = :normal
     end
   end
 
+  def without_ordering
+    chain { |criteria| criteria.ordering_mode = :disabled }
+  end
+
   def merge!(criteria, options={})
     super
     # The latest order_by() wins
     self.order = criteria.order if criteria.order.present?
-    self._reverse_order = criteria._reverse_order unless criteria._reverse_order.nil?
+    self.ordering_mode = criteria.ordering_mode unless criteria.ordering_mode.nil?
     self
   end
 
   def reverse_order
-    chain { |criteria| criteria._reverse_order = !self._reverse_order }
+    chain do |criteria|
+      criteria.ordering_mode =
+        case self.ordering_mode
+        when nil       then :reversed
+        when :normal   then :reversed
+        when :reversed then :normal
+        when :disabled then :disabled
+        end
+    end
   end
 
   private
 
   def effective_order
-    self.order.presence || {:id => :asc}
+    self.order.presence || (klass ? {klass.pk_name => :asc} : {})
   end
 
   def reverse_order?
-    !!self._reverse_order
+    self.ordering_mode == :reversed
+  end
+
+  def should_order?
+    self.ordering_mode != :disabled
   end
 
   def compile_rql_pass1
     rql = super
+    return rql unless should_order?
+    _effective_order = effective_order
+    return rql if _effective_order.empty?
 
-    rql_rules = effective_order.map do |k,v|
+    rql_rules = _effective_order.map do |k,v|
       case v
       when :asc  then reverse_order? ? RethinkDB::RQL.new.desc(k) : RethinkDB::RQL.new.asc(k)
       when :desc then reverse_order? ? RethinkDB::RQL.new.asc(k)  : RethinkDB::RQL.new.desc(k)
@@ -64,9 +83,10 @@ module NoBrainer::Criteria::OrderBy
     # We are going to try to go so and if we cannot, we'll simply apply
     # the ordering in pass2, which will happen after a potential filter().
 
-    if rql.body.type == Term::TermType::TABLE && !without_index?
+    NoBrainer::RQL.is_table?(rql)
+    if NoBrainer::RQL.is_table?(rql) && !without_index?
       options = {}
-      first_key = effective_order.first[0]
+      first_key = _effective_order.first[0]
       if (first_key.is_a?(Symbol) || first_key.is_a?(String)) && klass.has_index?(first_key)
         options[:index] = rql_rules.shift
       end
@@ -83,7 +103,10 @@ module NoBrainer::Criteria::OrderBy
 
   def compile_rql_pass2
     rql = super
-    rql = rql.order_by(*@rql_rules_pass2) if @rql_rules_pass2
+    if @rql_rules_pass2
+      rql = rql.order_by(*@rql_rules_pass2)
+      @rql_rules_pass2 = nil
+    end
     rql
   end
 

data/lib/no_brainer/criteria/update.rb

@@ -2,10 +2,10 @@ module NoBrainer::Criteria::Update
   extend ActiveSupport::Concern
 
   def update_all(*args, &block)
-    run(to_rql.update(*args, &block))
+    run(without_ordering.to_rql.update(*args, &block))
   end
 
   def replace_all(*args, &block)
-    run(to_rql.replace(*args, &block))
+    run(without_ordering.to_rql.replace(*args, &block))
   end
 end

data/lib/no_brainer/criteria/where.rb

@@ -92,7 +92,7 @@ module NoBrainer::Criteria::Where
         target_klass = association.target_klass
         opts = { :attr_name => key, :value => value, :type => target_klass}
         raise NoBrainer::Error::InvalidType.new(opts) unless value.is_a?(target_klass)
-        value.id
+        value.pk_value
       else
         criteria.klass.cast_user_to_db_for(key, value)
       end

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

@@ -2,13 +2,18 @@ class NoBrainer::Document::Association::BelongsTo
   include NoBrainer::Document::Association::Core
 
   class Metadata
-    VALID_OPTIONS = [:foreign_key, :class_name, :index, :validates, :required]
+    VALID_OPTIONS = [:primary_key, :foreign_key, :class_name, :index, :validates, :required]
     include NoBrainer::Document::Association::Core::Metadata
     extend NoBrainer::Document::Association::EagerLoader::Generic
 
     def foreign_key
       # TODO test :foreign_key
-      options[:foreign_key].try(:to_sym) || :"#{target_name}_id"
+      options[:foreign_key].try(:to_sym) || :"#{target_name}_#{primary_key}"
+    end
+
+    def primary_key
+      # TODO test :primary_key
+      options[:primary_key].try(:to_sym) || target_klass.pk_name
     end
 
     def target_klass
@@ -32,7 +37,7 @@ class NoBrainer::Document::Association::BelongsTo
       add_callback_for(:after_validation)
     end
 
-    eager_load_with :owner_key => ->{ foreign_key }, :target_key => ->{ :id },
+    eager_load_with :owner_key => ->{ foreign_key }, :target_key => ->{ primary_key },
                     :unscoped => true
   end
 
@@ -49,13 +54,13 @@ class NoBrainer::Document::Association::BelongsTo
     return target if loaded?
 
     if fk = owner.read_attribute(foreign_key)
-      preload(target_klass.find(fk))
+      preload(target_klass.unscoped.where(primary_key => fk).first)
     end
   end
 
   def write(target)
     assert_target_type(target)
-    owner.write_attribute(foreign_key, target.try(:id))
+    owner.write_attribute(foreign_key, target.try(:pk_value))
     preload(target)
   end
 

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

@@ -49,7 +49,7 @@ module NoBrainer::Document::Association::Core
 
   included { attr_accessor :metadata, :owner }
 
-  delegate :foreign_key, :target_name, :target_klass, :to => :metadata
+  delegate :primary_key, :foreign_key, :target_name, :target_klass, :to => :metadata
 
   def initialize(metadata, owner)
     @metadata, @owner = metadata, owner

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

@@ -2,13 +2,18 @@ class NoBrainer::Document::Association::HasMany
   include NoBrainer::Document::Association::Core
 
   class Metadata
-    VALID_OPTIONS = [:foreign_key, :class_name, :dependent]
+    VALID_OPTIONS = [:primary_key, :foreign_key, :class_name, :dependent]
     include NoBrainer::Document::Association::Core::Metadata
     extend NoBrainer::Document::Association::EagerLoader::Generic
 
     def foreign_key
       # TODO test :foreign_key
-      options[:foreign_key].try(:to_sym) || owner_klass.name.foreign_key.to_sym
+      options[:foreign_key].try(:to_sym) || :"#{owner_klass.name.underscore}_#{owner_klass.pk_name}"
+    end
+
+    def primary_key
+      # TODO test :primary_key
+      options[:primary_key].try(:to_sym) || target_klass.pk_name
     end
 
     def target_klass
@@ -25,6 +30,7 @@ class NoBrainer::Document::Association::HasMany
       target_klass.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
       end
     end
@@ -34,11 +40,11 @@ class NoBrainer::Document::Association::HasMany
       add_callback_for(:before_destroy) if options[:dependent]
     end
 
-    eager_load_with :owner_key => ->{ :id }, :target_key => ->{ foreign_key }
+    eager_load_with :owner_key => ->{ primary_key }, :target_key => ->{ foreign_key }
   end
 
   def target_criteria
-    @target_criteria ||= target_klass.where(foreign_key => owner.id)
+    @target_criteria ||= target_klass.where(foreign_key => owner.pk_value)
                                      .after_find(set_inverse_proc)
   end
 

data/lib/no_brainer/document/attributes.rb

@@ -1,6 +1,9 @@
 module NoBrainer::Document::Attributes
-  VALID_FIELD_OPTIONS = [:index, :default, :type, :cast_user_to_db, :cast_db_to_user, :validates, :required, :unique, :readonly]
-  RESERVED_FIELD_NAMES = [:index, :default, :and, :or, :selector, :associations] + NoBrainer::DecoratedSymbol::MODIFIERS.keys
+  VALID_FIELD_OPTIONS = [:index, :default, :type, :cast_user_to_db,
+                         :cast_db_to_user, :validates, :required, :unique,
+                         :readonly, :primary_key]
+  RESERVED_FIELD_NAMES = [:index, :default, :and, :or, :selector, :associations, :pk_value] \
+                          + NoBrainer::DecoratedSymbol::MODIFIERS.keys
   extend ActiveSupport::Concern
 
   included do
@@ -15,8 +18,12 @@ module NoBrainer::Document::Attributes
     assign_attributes(attrs, options.reverse_merge(:pristine => true))
   end
 
+  def readable_attributes
+    @_attributes.keys & self.class.fields.keys.map(&:to_s)
+  end
+
   def attributes
-    Hash[@_attributes.keys.map { |k| [k, read_attribute(k)] }].with_indifferent_access.freeze
+    Hash[readable_attributes.map { |k| [k, read_attribute(k)] }].with_indifferent_access.freeze
   end
 
   def read_attribute(name)
@@ -97,6 +104,23 @@ module NoBrainer::Document::Attributes
       _field(attr, self.fields[attr])
     end
 
+    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)
+
+      ([self] + descendants).each do |klass|
+        klass.fields.delete(attr)
+      end
+    end
+
     def has_field?(attr)
       !!fields[attr.to_sym]
     end

data/lib/no_brainer/document/callbacks.rb

@@ -1,19 +1,11 @@
 module NoBrainer::Document::Callbacks
   extend ActiveSupport::Concern
 
-  def self.terminator
-    if Gem.loaded_specs['activesupport'].version.release >= Gem::Version.new('4.1')
-      proc { false }
-    else
-      'false'
-    end
-  end
-
   included do
     extend ActiveModel::Callbacks
 
-    define_model_callbacks :initialize, :create, :update, :save, :destroy, :terminator => NoBrainer::Document::Callbacks.terminator
-    define_model_callbacks :find, :only => [:after], :terminator => NoBrainer::Document::Callbacks.terminator
+    define_model_callbacks :initialize, :create, :update, :save, :destroy, :terminator => proc { false }
+    define_model_callbacks :find, :only => [:after], :terminator => proc { false }
   end
 
   def initialize(*args, &block)

data/lib/no_brainer/document/core.rb

@@ -5,16 +5,18 @@ module NoBrainer::Document::Core
     attr_accessor :_all
 
     def all
-      Rails.application.eager_load! if defined?(Rails)
+      Rails.application.eager_load! if defined?(Rails.application.eager_load!)
       @_all
     end
   end
   self._all = []
 
-  # TODO This assume the primary key is id.
-  # RethinkDB can have a custom primary key. careful.
   include ActiveModel::Conversion
 
+  def to_key
+    [pk_value]
+  end
+
   included do
     # TODO test these includes
     extend ActiveModel::Naming

data/lib/no_brainer/document/criteria.rb

@@ -2,7 +2,7 @@ module NoBrainer::Document::Criteria
   extend ActiveSupport::Concern
 
   def selector
-    self.class.selector_for(id)
+    self.class.selector_for(pk_value)
   end
 
   included { cattr_accessor :default_scope_proc, :instance_accessor => false }
@@ -40,20 +40,20 @@ module NoBrainer::Document::Criteria
       self.default_scope_proc = criteria.is_a?(Proc) ? criteria : proc { criteria }
     end
 
-    def selector_for(id)
-      # TODO Pass primary key if not default
-      unscoped.where(:id => id)
+    def selector_for(pk)
+      rql_table.get(pk)
     end
 
     # XXX this doesn't have the same semantics as
     # other ORMs. the equivalent is find!.
-    def find(id)
-      selector_for(id).first
+    def find(pk)
+      attrs = NoBrainer.run { selector_for(pk) }
+      new_from_db(attrs).tap { |doc| doc.run_callbacks(:find) } if attrs
     end
 
-    def find!(id)
-      find(id).tap do |doc|
-        raise NoBrainer::Error::DocumentNotFound, "#{self.class} id #{id} not found" unless doc
+    def find!(pk)
+      find(pk).tap do |doc|
+        raise NoBrainer::Error::DocumentNotFound, "#{self} #{pk_name}: #{pk} not found" unless doc
       end
     end
   end

data/lib/no_brainer/document/dirty.rb

@@ -79,5 +79,16 @@ module NoBrainer::Document::Dirty
         end
       end
     end
+
+    def _remove_field(attr, options={})
+      super
+      inject_in_layer :dirty_tracking do
+        remove_method("#{attr}_change")
+        remove_method("#{attr}_changed?")
+        remove_method("#{attr}_was")
+        remove_method("#{attr}=")
+        remove_method("#{attr}")
+      end
+    end
   end
 end

data/lib/no_brainer/document/dynamic_attributes.rb

@@ -17,4 +17,8 @@ module NoBrainer::Document::DynamicAttributes
       @_attributes[name] = value
     end
   end
+
+  def readable_attributes
+    @_attributes.keys
+  end
 end

data/lib/no_brainer/document/id.rb

@@ -5,17 +5,23 @@ require 'digest/md5'
 module NoBrainer::Document::Id
   extend ActiveSupport::Concern
 
-  included do
-    self.field :id, :type => String, :default => ->{ NoBrainer::Document::Id.generate }, :readonly => true
+  DEFAULT_PK_NAME = :id
+
+  def pk_value
+    __send__(self.class.pk_name)
+  end
+
+  def pk_value=(value)
+    __send__("#{self.class.pk_name}=", value)
   end
 
   def ==(other)
     return super unless self.class == other.class
-    !id.nil? && id == other.id
+    !pk_value.nil? && pk_value == other.pk_value
   end
   alias_method :eql?, :==
 
-  delegate :hash, :to => :id
+  delegate :hash, :to => :pk_value
 
   # The following code is inspired by the mongo-ruby-driver
 
@@ -46,4 +52,43 @@ module NoBrainer::Document::Id
 
     oid.unpack("C12").map {|e| v=e.to_s(16); v.size == 1 ? "0#{v}" : v }.join
   end
+
+  module ClassMethods
+    def define_default_pk
+      class_variable_set(:@@pk_name, nil)
+      field NoBrainer::Document::Id::DEFAULT_PK_NAME, :primary_key => :default,
+        :type => String, :default => ->{ NoBrainer::Document::Id.generate }
+    end
+
+    def define_pk(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]
+    end
+
+    def field(attr, options={})
+      if options[:primary_key]
+        options = options.merge(:readonly => true) if options[:readonly].nil?
+        options = options.merge(:index => true)
+      end
+      super
+    end
+
+    def _remove_field(attr, options={})
+      super
+      if fields[attr][:primary_key] && options[:set_default_pk] != false
+        define_default_pk
+      end
+    end
+  end
 end

data/lib/no_brainer/document/index.rb

@@ -5,7 +5,6 @@ module NoBrainer::Document::Index
   included do
     cattr_accessor :indexes, :instance_accessor => false
     self.indexes = {}
-    self.index :id
   end
 
   module ClassMethods
@@ -57,6 +56,11 @@ module NoBrainer::Document::Index
       end
     end
 
+    def _remove_field(attr, options={})
+      super
+      remove_index(attr) if fields[attr][:index]
+    end
+
     def perform_create_index(index_name, options={})
       index_name = index_name.to_sym
       index_args = self.indexes[index_name]
@@ -79,7 +83,7 @@ module NoBrainer::Document::Index
 
     def perform_update_indexes(options={})
       current_indexes = NoBrainer.run(self.rql_table.index_list).map(&:to_sym)
-      wanted_indexes = self.indexes.keys - [:id] # XXX Primary key?
+      wanted_indexes = self.indexes.keys - [self.pk_name]
 
       (current_indexes - wanted_indexes).each do |index_name|
         perform_drop_index(index_name, options)

data/lib/no_brainer/document/persistance.rb

@@ -19,7 +19,8 @@ module NoBrainer::Document::Persistance
   end
 
   def reload(options={})
-    attrs = selector.raw.first!
+    attrs = NoBrainer.run { self.class.selector_for(pk_value) }
+    raise NoBrainer::Error::DocumentNotFound, "#{self.class} #{self.class.pk_name}: #{pk_value} not found" unless attrs
     instance_variables.each { |ivar| remove_instance_variable(ivar) } unless options[:keep_ivars]
     initialize(attrs, :pristine => true, :from_db => true)
     self
@@ -28,13 +29,13 @@ module NoBrainer::Document::Persistance
   def _create(options={})
     return false if options[:validate] && !valid?
     keys = self.class.insert_all(@_attributes)
-    self.id ||= keys.first
+    self.pk_value ||= keys.first
     @new_record = false
     true
   end
 
   def _update(attrs)
-    selector.update_all(attrs)
+    NoBrainer.run { selector.update(attrs) }
   end
 
   def _update_only_changed_attrs(options={})
@@ -73,7 +74,7 @@ module NoBrainer::Document::Persistance
 
   def delete
     unless @destroyed
-      selector.delete_all
+      NoBrainer.run { selector.delete }
       @destroyed = true
     end
     @_attributes.freeze

data/lib/no_brainer/document/readonly.rb

@@ -15,5 +15,12 @@ module NoBrainer::Document::Readonly
         end
       end
     end
+
+    def _remove_field(attr, options={})
+      super
+      inject_in_layer :readonly do
+        remove_method("#{attr}=") if method_defined?("#{attr}=")
+      end
+    end
   end
 end

data/lib/no_brainer/document/serialization.rb

@@ -5,4 +5,8 @@ module NoBrainer::Document::Serialization
   include ActiveModel::Serializers::JSON
 
   included { self.include_root_in_json = false }
+
+  def read_attribute_for_serialization(*a, &b)
+    read_attribute(*a, &b)
+  end
 end

data/lib/no_brainer/document/types.rb

@@ -171,5 +171,13 @@ module NoBrainer::Document::Types
       end
       super
     end
+
+    def _remove_field(attr, options={})
+      super
+      inject_in_layer :types do
+        remove_method("#{attr}=")
+        remove_method("#{attr}?") if method_defined?("#{attr}?")
+      end
+    end
   end
 end

data/lib/no_brainer/document/uniqueness.rb

@@ -64,7 +64,9 @@ module NoBrainer::Document::Uniqueness
   class UniquenessValidator < ActiveModel::EachValidator
     attr_accessor :scope
 
-    def setup(klass)
+    def initialize(options={})
+      super
+      klass = options[:class]
       self.scope = [*options[:scope]]
       ([klass] + klass.descendants).each do |_klass|
         _klass.unique_validators << self
@@ -91,7 +93,7 @@ module NoBrainer::Document::Uniqueness
     end
 
     def exclude_doc(criteria, doc)
-      criteria.where(:id.ne => doc.id)
+      criteria.where(doc.class.pk_name.ne => doc.pk_value)
     end
   end
 end

data/lib/no_brainer/document/validation.rb

@@ -6,7 +6,7 @@ module NoBrainer::Document::Validation
   included do
     # We don't want before_validation returning false to halt the chain.
     define_callbacks :validation, :skip_after_callbacks_if_terminated => true, :scope => [:kind, :name],
-                     :terminator => NoBrainer::Document::Callbacks.terminator
+                     :terminator => proc { false }
   end
 
   def valid?(context=nil)

data/lib/no_brainer/document.rb

@@ -10,5 +10,7 @@ module NoBrainer::Document
 
   autoload :DynamicAttributes, :Timestamps
 
+  included { define_default_pk }
+
   singleton_class.delegate :all, :to => Core
 end

data/lib/no_brainer/error.rb

@@ -1,13 +1,13 @@
 module NoBrainer::Error
-  class Connection          < RuntimeError; end
-  class DocumentNotFound    < RuntimeError; end
-  class DocumentNotSaved    < RuntimeError; end
-  class ChildrenExist       < RuntimeError; end
-  class CannotUseIndex      < RuntimeError; end
-  class MissingIndex        < RuntimeError; end
-  class InvalidType         < RuntimeError; end
+  class Connection              < RuntimeError; end
+  class DocumentNotFound        < RuntimeError; end
+  class DocumentNotPersisted    < RuntimeError; end
+  class ChildrenExist           < RuntimeError; end
+  class CannotUseIndex          < RuntimeError; end
+  class MissingIndex            < RuntimeError; end
+  class InvalidType             < RuntimeError; end
   class AssociationNotPersisted < RuntimeError; end
-  class ReadonlyField       < RuntimeError; end
+  class ReadonlyField           < RuntimeError; end
 
   class DocumentInvalid < RuntimeError
     attr_accessor :instance

data/lib/no_brainer/query_runner/logger.rb

@@ -13,23 +13,29 @@ class NoBrainer::QueryRunner::Logger < NoBrainer::QueryRunner::Middleware
     return unless NoBrainer.logger.debug?
 
     duration = Time.now - start_time
-    msg = env[:query].inspect.gsub(/\n/, '').gsub(/ +/, ' ')
 
-    msg = "(#{env[:db_name]}) #{msg}" if env[:db_name]
-    msg = "[#{(duration * 1000.0).round(1)}ms] #{msg}"
+    msg_duration = (duration * 1000.0).round(1).to_s
+    msg_duration = " " * [0, 5 - msg_duration.size].max + msg_duration
+    msg_duration = "[#{msg_duration}ms] "
+
+    msg_db = "[#{env[:db_name]}] " if env[:db_name]
+    msg_query = env[:query].inspect.gsub(/\n/, '').gsub(/ +/, ' ')
+    msg_exception = " #{exception.class} #{exception.message.split("\n").first}" if exception
+    msg_last = nil
 
     if NoBrainer::Config.colorize_logger
-      if exception
-        msg = "#{msg} \e[0;31m#{exception.class} #{exception.message.split("\n").first}\e[0m"
-      else
-        case NoBrainer::Util.rql_type(env[:query])
-        when :write      then msg = "\e[1;31m#{msg}\e[0m" # red
-        when :read       then msg = "\e[1;32m#{msg}\e[0m" # green
-        when :management then msg = "\e[1;33m#{msg}\e[0m" # yellow
-        end
-      end
+      query_color = case NoBrainer::RQL.type_of(env[:query])
+                    when :write      then "\e[1;31m" # red
+                    when :read       then "\e[1;32m" # green
+                    when :management then "\e[1;33m" # yellow
+                    end
+      msg_duration = [query_color, msg_duration].join
+      msg_db = ["\e[0;34m", msg_db, query_color].join if msg_db
+      msg_exception = ["\e[0;31m", msg_exception].join if msg_exception
+      msg_last = "\e[0m"
     end
 
+    msg = [msg_duration, msg_db, msg_query, msg_exception, msg_last].join
     NoBrainer.logger.debug(msg)
   end
 end

data/lib/no_brainer/query_runner/missing_index.rb

@@ -2,9 +2,21 @@ class NoBrainer::QueryRunner::MissingIndex < NoBrainer::QueryRunner::Middleware
   def call(env)
     @runner.call(env)
   rescue RethinkDB::RqlRuntimeError => e
-    if e.message =~ /^Index `(.+)` was not found\.$/
-      raise NoBrainer::Error::MissingIndex.new("Please run \"rake db:update_indexes\" to create the index `#{$1}`\n" +
-                                               "--> Read http://nobrainer.io/docs/indexes for more information.")
+    if e.message =~ /^Index `(.+)` was not found on table `(.+)\.(.+)`\.$/
+      index_name = $1
+      database_name = $2
+      table_name = $3
+
+      klass = NoBrainer::Document.all.select { |m| m.table_name == table_name }.first
+      if klass && klass.pk_name.to_s == index_name
+        err_msg  = "Please run update the primary key `#{index_name}` in the table `#{database_name}.#{table_name}`."
+      else
+        err_msg  = "Please run \"rake db:update_indexes\" to create the index `#{index_name}`"
+        err_msg += " in the table `#{database_name}.#{table_name}`."
+        err_msg += "\n--> Read http://nobrainer.io/docs/indexes for more information."
+      end
+
+      raise NoBrainer::Error::MissingIndex.new(err_msg)
     end
     raise
   end

data/lib/no_brainer/query_runner/reconnect.rb

@@ -4,20 +4,20 @@ class NoBrainer::QueryRunner::Reconnect < NoBrainer::QueryRunner::Middleware
   rescue StandardError => e
     # TODO test that thing
     if is_connection_error_exception?(e)
-      retry if reconnect
+      retry if reconnect(e)
     end
     raise
   end
 
   private
 
-  def reconnect
+  def reconnect(e)
     # FIXME thread safety? perhaps we need to use a connection pool
     # XXX Possibly dangerous, as we could reexecute a non idempotent operation
     # Check the semantics of the db
     NoBrainer::Config.max_reconnection_tries.times do
       begin
-        NoBrainer.logger.try(:warn, "Lost connection to #{NoBrainer::Config.rethinkdb_url}, retrying...")
+        warn_reconnect(e)
         sleep 1
         NoBrainer.connection.reconnect(:noreply_wait => false)
         return true
@@ -35,10 +35,21 @@ class NoBrainer::QueryRunner::Reconnect < NoBrainer::QueryRunner::Middleware
       Errno::ECONNRESET, Errno::ETIMEDOUT, IOError
       true
     when RethinkDB::RqlRuntimeError
-      e.message =~ /cannot perform (read|write): No master available/ ||
+      e.message =~ /No master available/ ||
+      e.message =~ /Master .* not available/ ||
       e.message =~ /Error: Connection Closed/
     else
       false
     end
   end
+
+  def warn_reconnect(e)
+    if e.is_a?(RethinkDB::RqlRuntimeError)
+      e_msg = e.message.split("\n").first
+      msg = "Server #{NoBrainer::Config.rethinkdb_url} not ready - #{e_msg}, retrying..."
+    else
+      msg = "Connection issue with #{NoBrainer::Config.rethinkdb_url} - #{e}, retrying..."
+    end
+    NoBrainer.logger.try(:warn, msg)
+  end
 end

data/lib/no_brainer/query_runner/table_on_demand.rb

@@ -3,8 +3,8 @@ class NoBrainer::QueryRunner::TableOnDemand < NoBrainer::QueryRunner::Middleware
     @runner.call(env)
   rescue RuntimeError => e
     if NoBrainer::Config.auto_create_tables &&
-       e.message =~ /^Table `(.+)` does not exist\.$/
-      auto_create_table(env, $1)
+       e.message =~ /^Table `(.+)\.(.+)` does not exist\.$/
+      auto_create_table(env, $1, $2)
       retry
     end
     raise
@@ -12,33 +12,22 @@ class NoBrainer::QueryRunner::TableOnDemand < NoBrainer::QueryRunner::Middleware
 
   private
 
-  def auto_create_table(env, table_name)
-    if env[:auto_create_table] == table_name
-      raise "Auto table creation is not working with #{table_name}"
+  def auto_create_table(env, database_name, table_name)
+    klass = NoBrainer::Document.all.select { |m| m.table_name == table_name }.first
+    if klass.nil?
+      raise "Auto table creation is not working for `#{database_name}.#{table_name}` -- Can't find the corresponding model."
     end
-    env[:auto_create_table] = table_name
 
-    # FIXME This stinks.
-    database_names = find_db_names(env[:query])
-    case database_names.size
-    when 0 then NoBrainer.table_create(table_name)
-    when 1 then NoBrainer.with_database(database_names.first) { NoBrainer.table_create(table_name) }
-    else raise "Ambiguous database name for creation on demand: #{database_names}"
+    if env[:auto_create_table] == [database_name, table_name]
+      raise "Auto table creation is not working for `#{database_name}.#{table_name}`"
+    end
+    env[:auto_create_table] = [database_name, table_name]
+
+    NoBrainer.with_database(database_name) do
+      NoBrainer.table_create(table_name, :primary_key => klass.pk_name)
     end
   rescue RuntimeError => e
     # We might have raced with another table create
-    raise unless e.message =~ /Table `#{table_name}` already exists/
-  end
-
-  def find_db_names(terms)
-    terms = terms.body.args if terms.is_a?(RethinkDB::RQL)
-    terms.map do |term|
-      next unless term.is_a?(Term)
-      if term.type == Term::TermType::DB
-        term.args.first.datum.r_str
-      else
-        find_db_names(term.args)
-      end
-    end.flatten.uniq
+    raise unless e.message =~ /Table `#{database_name}\.#{table_name}` already exists/
   end
 end

data/lib/no_brainer/query_runner/write_error.rb

@@ -1,13 +1,10 @@
 class NoBrainer::QueryRunner::WriteError < NoBrainer::QueryRunner::Middleware
   def call(env)
-    write_query = NoBrainer::Util.is_write_query?(env[:query])
+    write_query = NoBrainer::RQL.is_write_query?(env[:query])
     @runner.call(env).tap do |result|
-      # TODO Fix rethinkdb driver: Their classes Term, Query, Response are
-      # not scoped to the RethinkDB module! (that would prevent a user from
-      # creating a Response model for example).
-
-      if write_query && (result['errors'].to_i != 0 || result['skipped'].to_i != 0)
-        raise_write_error(env, result['first_error'])
+      if write_query && (result['errors'].to_i != 0)
+        error_msg = result['first_error']
+        raise_write_error(env, error_msg)
       end
     end
   rescue RethinkDB::RqlRuntimeError => e
@@ -23,6 +20,6 @@ class NoBrainer::QueryRunner::WriteError < NoBrainer::QueryRunner::Middleware
   def raise_write_error(env, error_msg)
     error_msg ||= "Unknown error"
     error_msg += "\nQuery was: #{env[:query].inspect[0..1000]}"
-    raise NoBrainer::Error::DocumentNotSaved, error_msg
+    raise NoBrainer::Error::DocumentNotPersisted, error_msg
   end
 end

data/lib/no_brainer/rql.rb

@@ -0,0 +1,25 @@
+module NoBrainer::RQL
+  include RethinkDB::Term::TermType
+  extend self
+
+  def is_write_query?(rql_query)
+    type_of(rql_query) == :write
+  end
+
+  def type_of(rql_query)
+    case rql_query.body.first
+    when UPDATE, DELETE, REPLACE, INSERT
+      :write
+    when DB_CREATE,DB_DROP, DB_LIST, TABLE_CREATE, TABLE_DROP, TABLE_LIST, SYNC,
+         INDEX_CREATE, INDEX_DROP, INDEX_LIST, INDEX_STATUS, INDEX_WAIT
+      :management
+    else
+      # XXX Not sure if that's correct, but we'll be happy for logging colors.
+      :read
+    end
+  end
+
+  def is_table?(rql)
+    rql.body.first == TABLE
+  end
+end

data/lib/nobrainer.rb

@@ -7,19 +7,18 @@ module NoBrainer
   require 'no_brainer/autoload'
   extend NoBrainer::Autoload
 
-  # We eager load things that could be loaded for the first time during the web request
+  # 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, :Util
+  eager_autoload :Config, :Connection, :Error, :QueryRunner, :Criteria, :RQL
 
   class << self
-    # Note: we always access the connection explicitly, so that in the future,
-    # we can refactor to return a connection depending on the context.
-    # Note that a connection is tied to a database in NoBrainer.
+    # 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).tap { |c| c.connect }
+        Connection.new(url)
       end
     end
 

metadata

@@ -1,57 +1,57 @@
 --- !ruby/object:Gem::Specification
 name: nobrainer
 version: !ruby/object:Gem::Version
-  version: 0.13.1
+  version: 0.14.0
 platform: ruby
 authors:
 - Nicolas Viennot
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-03-31 00:00:00.000000000 Z
+date: 2014-06-17 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rethinkdb
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: 1.12.0.1
+        version: 1.13.0.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: 1.12.0.1
+        version: 1.13.0.0
 - !ruby/object:Gem::Dependency
   name: activesupport
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 4.0.0
+        version: 4.1.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 4.0.0
+        version: 4.1.0
 - !ruby/object:Gem::Dependency
   name: activemodel
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 4.0.0
+        version: 4.1.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 4.0.0
+        version: 4.1.0
 - !ruby/object:Gem::Dependency
   name: middleware
   requirement: !ruby/object:Gem::Requirement
@@ -137,7 +137,7 @@ files:
 - lib/no_brainer/query_runner/write_error.rb
 - lib/no_brainer/railtie.rb
 - lib/no_brainer/railtie/database.rake
-- lib/no_brainer/util.rb
+- lib/no_brainer/rql.rb
 - lib/nobrainer.rb
 - lib/rails/generators/nobrainer.rb
 - lib/rails/generators/nobrainer/model/model_generator.rb

data/lib/no_brainer/util.rb

@@ -1,23 +0,0 @@
-module NoBrainer::Util
-  def self.is_write_query?(rql_query)
-    rql_type(rql_query) == :write
-  end
-
-  def self.rql_type(rql_query)
-    case rql_query.body.type
-    when Term::TermType::UPDATE,  Term::TermType::DELETE,
-         Term::TermType::REPLACE, Term::TermType::INSERT
-      :write
-    when Term::TermType::DB_CREATE,    Term::TermType::DB_DROP,
-         Term::TermType::DB_LIST,      Term::TermType::TABLE_CREATE,
-         Term::TermType::TABLE_DROP,   Term::TermType::TABLE_LIST,
-         Term::TermType::SYNC,         Term::TermType::INDEX_CREATE,
-         Term::TermType::INDEX_DROP,   Term::TermType::INDEX_LIST,
-         Term::TermType::INDEX_STATUS, Term::TermType::INDEX_WAIT
-      :management
-    else
-      # XXX Not sure if that's correct, but we'll be happy for logging colors.
-      :read
-    end
-  end
-end