nobrainer 0.15.0 → 0.16.0

data/lib/no_brainer/document/missing_attributes.rb

@@ -0,0 +1,73 @@
+module NoBrainer::Document::MissingAttributes
+  extend ActiveSupport::Concern
+
+  def write_attribute(attr, value)
+    super.tap { clear_missing_field(attr) }
+  end
+
+  def assign_attributes(attrs, options={})
+    if options[:missing_attributes]
+      # there is one and only one key :pluck or :without to missing_attributes
+      @missing_attributes = options[:missing_attributes]
+      assert_access_field(self.class.pk_name, "The primary key is not accessible. Use .raw or")
+      assert_access_field(:_type, "The subclass type is not accessible. Use .raw or") if self.class.is_polymorphic
+    end
+
+    attrs.keys.each { |attr| clear_missing_field(attr) } if @missing_attributes && options[:from_db]
+
+    super
+  end
+
+  def missing_field?(name)
+    return false unless @missing_attributes
+    name = name.to_s
+    return false if @cleared_missing_fields.try(:[], name)
+    if @missing_attributes[:pluck]
+      !@missing_attributes[:pluck][name]
+    else
+      !!@missing_attributes[:without][name]
+    end
+  end
+
+  def clear_missing_field(name)
+    return unless @missing_attributes
+    @cleared_missing_fields ||= {}
+    @cleared_missing_fields[name.to_s] = true
+  end
+
+  def assert_access_field(name, msg=nil)
+    if missing_field?(name)
+      method = @missing_attributes.keys.first
+      msg ||= "The attribute `#{name}' is not accessible,"
+      msg += " add `:#{name}' to pluck()" if method == :pluck
+      msg += " remove `:#{name}' from without()" if method == :without
+      raise NoBrainer::Error::MissingAttribute.new(msg)
+    end
+  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
+  end
+end

data/lib/no_brainer/document/persistance.rb

@@ -18,23 +18,57 @@ module NoBrainer::Document::Persistance
     !new_record? && !destroyed?
   end
 
-  def reload(options={})
-    attrs = NoBrainer.run { self.class.selector_for(pk_value) }
+  def _reload_selector(options={})
+    rql = selector
+    if opt = options[:missing_attributes]
+      rql = rql.pluck(self.class.with_fields_aliased(opt[:pluck])) if opt[:pluck]
+      rql = rql.without(self.class.with_fields_aliased(opt[:without])) if opt[:without]
+    end
+    rql
+  end
+
+  def _reload(options={})
+    attrs = NoBrainer.run { _reload_selector(options) }
     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)
+
+    options = options.merge(:pristine => true, :from_db => true)
+
+    if options[:keep_ivars]
+      assign_attributes(attrs, options)
+    else
+      instance_variables.each { |ivar| remove_instance_variable(ivar) }
+      initialize(attrs, options)
+    end
+
     self
   end
 
+  def reload(options={})
+    [:without, :pluck].each do |type|
+      if v = options.delete(type)
+        v = Hash[v.flatten.map { |k| [k, true] }] if v.is_a?(Array)
+        v = {v => true} if !v.is_a?(Hash)
+        v = v.select { |k,_v| _v }
+        v = v.with_indifferent_access
+        next unless v.present?
+
+        options[:missing_attributes] ||= {}
+        options[:missing_attributes][type] = v
+      end
+    end
+    _reload(options)
+  end
+
   def _create(options={})
     return false if options[:validate] && !valid?
-    keys = self.class.insert_all(self.class.persistable_attributes(@_attributes))
+    keys = self.class.insert_all(@_attributes)
     self.pk_value ||= keys.first
     @new_record = false
     true
   end
 
   def _update(attrs)
+    attrs = self.class.persistable_attributes(attrs)
     NoBrainer.run { selector.update(attrs) }
   end
 
@@ -50,7 +84,7 @@ module NoBrainer::Document::Persistance
       attr = RethinkDB::RQL.new.literal(attr) if attr.is_a?(Hash)
       [k, attr]
     end]
-    _update(self.class.persistable_attributes(attrs)) if attrs.present?
+    _update(attrs) if attrs.present?
     true
   end
 
@@ -94,13 +128,28 @@ module NoBrainer::Document::Persistance
       new(attrs, options).tap { |doc| doc.save!(options) }
     end
 
-    def insert_all(*attrs)
-      result = NoBrainer.run(rql_table.insert(*attrs))
+    def insert_all(*args)
+      docs = args.shift
+      docs = [docs] unless docs.is_a?(Array)
+      docs = docs.map { |doc| persistable_attributes(doc) }
+      result = NoBrainer.run(rql_table.insert(docs, *args))
       result['generated_keys'].to_a
     end
 
     def sync
       NoBrainer.run(rql_table.sync)['synced'] == 1
     end
+
+    def persistable_key(k)
+      k
+    end
+
+    def persistable_value(k, v)
+      v
+    end
+
+    def persistable_attributes(attrs)
+      Hash[attrs.map { |k,v| [persistable_key(k), persistable_value(k, v)] }]
+    end
   end
 end

data/lib/no_brainer/document/polymorphic.rb

@@ -3,8 +3,9 @@ module NoBrainer::Document::Polymorphic
   include ActiveSupport::DescendantsTracker
 
   included do
-    cattr_accessor :root_class
+    cattr_accessor :root_class, :is_polymorphic
     self.root_class = self
+    self.is_polymorphic = false
   end
 
   def assign_attributes(*args)
@@ -14,6 +15,7 @@ module NoBrainer::Document::Polymorphic
 
   module ClassMethods
     def inherited(subclass)
+      subclass.is_polymorphic = true
       super
       subclass.field :_type if is_root_class?
     end
@@ -22,22 +24,26 @@ module NoBrainer::Document::Polymorphic
       name
     end
 
-    def descendants_type_values
-      ([self] + descendants).map(&:type_value)
-    end
-
     def is_root_class?
       self == root_class
     end
 
+    def for_each_subclass(&block)
+      ([self] + self.descendants).each(&block)
+    end
+
+    def descendants_type_values
+      for_each_subclass.map(&:type_value)
+    end
+
     def klass_from_attrs(attrs)
       attrs['_type'].try(:constantize) || root_class
     end
 
     def all
-      criterion = super
-      criterion = criterion.where(:_type.in => descendants_type_values) unless is_root_class?
-      criterion
+      criteria = super
+      criteria = criteria.where(:_type.in => descendants_type_values) unless is_root_class?
+      criteria
     end
   end
 end

data/lib/no_brainer/document/types.rb

@@ -53,8 +53,8 @@ module NoBrainer::Document::Types
       cast_model_to_db_for(attr, value)
     end
 
-    def persistable_attributes(attrs)
-      Hash[attrs.map { |k,v| [k, cast_model_to_db_for(k, v)] }]
+    def persistable_value(k, v)
+      cast_model_to_db_for(k, super)
     end
 
     def _field(attr, options={})
@@ -88,6 +88,7 @@ module NoBrainer::Document::Types
     end
 
     def field(attr, options={})
+      options[:real_type] = options[:type]
       if options[:type] == Array || options[:type] == Hash
         # XXX For the moment, NoBrainer does not support these complex types
         options.delete(:type)
@@ -96,7 +97,9 @@ module NoBrainer::Document::Types
     end
   end
 
+  require File.join(File.dirname(__FILE__), 'types', 'binary')
   require File.join(File.dirname(__FILE__), 'types', 'boolean')
+  Binary = NoBrainer::Binary
   Boolean = NoBrainer::Boolean
 
   class << self

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

@@ -0,0 +1,23 @@
+class NoBrainer::Binary
+  def initialize; raise; end
+  def self.inspect; 'Binary'; end
+  def self.to_s; inspect; end
+  def self.name; inspect; end
+
+  module NoBrainerExtentions
+    InvalidType = NoBrainer::Error::InvalidType
+
+    def nobrainer_cast_user_to_model(value)
+      case value
+      when String then RethinkDB::Binary.new(value)
+      else raise InvalidType
+      end
+    end
+
+    def nobrainer_cast_db_to_model(value)
+      value.is_a?(String) ? RethinkDB::Binary.new(value) : value
+    end
+  end
+  extend NoBrainerExtentions
+end
+

data/lib/no_brainer/document/uniqueness.rb

@@ -55,8 +55,8 @@ module NoBrainer::Document::Uniqueness
     end
 
     def inherited(subclass)
-      super
       subclass.unique_validators = self.unique_validators.dup
+      super
     end
 
   end

data/lib/no_brainer/error.rb

@@ -8,6 +8,7 @@ module NoBrainer::Error
   class InvalidType             < RuntimeError; end
   class AssociationNotPersisted < RuntimeError; end
   class ReadonlyField           < RuntimeError; end
+  class MissingAttribute        < RuntimeError; end
 
   class DocumentInvalid < RuntimeError
     attr_accessor :instance
@@ -36,4 +37,19 @@ module NoBrainer::Error
       "#{attr_name} should be used with a #{human_type_name}. Got `#{value}` (#{value.class})"
     end
   end
+
+  class CannotUseIndex < RuntimeError
+    attr_accessor :index_name
+    def initialize(index_name)
+      @index_name = index_name
+    end
+
+    def message
+      if index_name == true
+        "Cannot use any indexes"
+      else
+        "Cannot use index #{index_name}"
+      end
+    end
+  end
 end

data/lib/no_brainer/index_manager.rb

@@ -4,5 +4,6 @@ module NoBrainer::IndexManager
     unless options[:wait] == false
       NoBrainer::Document.all.each { |model| model.wait_for_index(nil) }
     end
+    true
   end
 end

data/lib/no_brainer/query_runner.rb

@@ -11,7 +11,8 @@ module NoBrainer::QueryRunner
   end
 
   autoload :Driver, :DatabaseOnDemand, :TableOnDemand, :WriteError,
-           :Reconnect, :Selection, :RunOptions, :Logger, :MissingIndex
+           :Reconnect, :Selection, :RunOptions, :Logger, :MissingIndex,
+           :ConnectionLock
 
   class << self
     attr_accessor :stack
@@ -32,6 +33,7 @@ module NoBrainer::QueryRunner
     use DatabaseOnDemand
     use TableOnDemand
     use Logger
+    use ConnectionLock
     use Reconnect
     use Driver
   end

data/lib/no_brainer/query_runner/connection_lock.rb

@@ -0,0 +1,7 @@
+class NoBrainer::QueryRunner::ConnectionLock < NoBrainer::QueryRunner::Middleware
+  @@lock = Mutex.new
+
+  def call(env)
+    @@lock.synchronize { @runner.call(env) }
+  end
+end

data/lib/no_brainer/query_runner/database_on_demand.rb

@@ -2,14 +2,17 @@ class NoBrainer::QueryRunner::DatabaseOnDemand < NoBrainer::QueryRunner::Middlew
   def call(env)
     @runner.call(env)
   rescue RuntimeError => e
-    if NoBrainer::Config.auto_create_databases &&
-       e.message =~ /^Database `(.+)` does not exist\.$/
-      auto_create_database(env, $1)
+    if database_name = database_on_demand_exception?(e)
+      auto_create_database(env, database_name)
       retry
     end
     raise
   end
 
+  def database_on_demand_exception?(e)
+    NoBrainer::Config.auto_create_databases && e.message =~ /^Database `(.+)` does not exist\.$/ && $1
+  end
+
   private
 
   def auto_create_database(env, database_name)

data/lib/no_brainer/query_runner/logger.rb

@@ -3,14 +3,18 @@ class NoBrainer::QueryRunner::Logger < NoBrainer::QueryRunner::Middleware
     start_time = Time.now
     @runner.call(env).tap { log_query(env, start_time) }
   rescue Exception => e
-    log_query(env, start_time, e) rescue nil
+    log_query(env, start_time, e)
     raise e
   end
 
   private
 
   def log_query(env, start_time, exception=nil)
-    return unless NoBrainer.logger.debug?
+    return if on_demand_exception?(exception)
+    not_indexed = env[:criteria] && env[:criteria].where_present? && !env[:criteria].where_indexed?
+    level = exception ? Logger::ERROR :
+             not_indexed ? Logger::INFO : Logger::DEBUG
+    return if NoBrainer.logger.nil? || NoBrainer.logger.level > level
 
     duration = Time.now - start_time
 
@@ -18,9 +22,12 @@ class NoBrainer::QueryRunner::Logger < NoBrainer::QueryRunner::Middleware
     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_db = "[#{env[:db_name]}] " if env[:db_name] && env[:db_name].to_s != NoBrainer.connection.parsed_uri[:db]
     msg_query = env[:query].inspect.gsub(/\n/, '').gsub(/ +/, ' ')
-    msg_exception = " #{exception.class} #{exception.message.split("\n").first}" if exception
+
+    msg_exception = "#{exception.class} #{exception.message.split("\n").first}" if exception
+    msg_exception ||= "perf: filtering without using an index" if not_indexed
+
     msg_last = nil
 
     if NoBrainer::Config.colorize_logger
@@ -31,11 +38,20 @@ class NoBrainer::QueryRunner::Logger < NoBrainer::QueryRunner::Middleware
                     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
+      if msg_exception
+        exception_color = "\e[0;31m" if level == Logger::ERROR
+        msg_exception = ["\e[0;39m", " -- ", exception_color, msg_exception].compact.join
+      end
       msg_last = "\e[0m"
     end
 
     msg = [msg_duration, msg_db, msg_query, msg_exception, msg_last].join
-    NoBrainer.logger.debug(msg)
+    NoBrainer.logger.add(level, msg)
+  end
+
+  def on_demand_exception?(e)
+    # pretty gross I must say.
+    e && (NoBrainer::QueryRunner::DatabaseOnDemand.new(nil).database_on_demand_exception?(e) ||
+          NoBrainer::QueryRunner::TableOnDemand.new(nil).table_on_demand_exception?(e))
   end
 end

data/lib/no_brainer/query_runner/missing_index.rb

@@ -8,12 +8,14 @@ class NoBrainer::QueryRunner::MissingIndex < NoBrainer::QueryRunner::Middleware
       table_name = $3
 
       klass = NoBrainer::Document.all.select { |m| m.table_name == table_name }.first
+      index_name = klass.get_index_alias_reverse_map[index_name.to_sym]
+
       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}`."
+        err_msg  = "Please 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  = "Please run `NoBrainer.update_indexes' or `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."
+        err_msg += " Read http://nobrainer.io/docs/indexes for more information."
       end
 
       raise NoBrainer::Error::MissingIndex.new(err_msg)