nobrainer 0.13.0 → 0.14.0

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]
@@ -68,7 +72,7 @@ module NoBrainer::Document::Index
       end
 
       NoBrainer.run(self.rql_table.index_create(index_name, index_args[:options], &index_proc))
-      NoBrainer.run(self.rql_table.index_wait(index_name)) if options[:wait]
+      wait_for_index(index_name) unless options[:wait] == false
       STDERR.puts "Created index #{self}.#{index_name}" if options[:verbose]
     end
 
@@ -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)
@@ -90,5 +94,10 @@ module NoBrainer::Document::Index
       end
     end
     alias_method :update_indexes, :perform_update_indexes
+
+    def wait_for_index(index_name=nil, options={})
+      args = [index_name].compact
+      NoBrainer.run(self.rql_table.index_wait(*args))
+    end
   end
 end

data/lib/no_brainer/document/persistance.rb

@@ -1,11 +1,6 @@
 module NoBrainer::Document::Persistance
   extend ActiveSupport::Concern
 
-  included do
-    extend ActiveModel::Callbacks
-    define_model_callbacks :create, :update, :save, :destroy, :terminator => 'false'
-  end
-
   def _initialize(attrs={}, options={})
     @new_record = !options[:from_db]
     super
@@ -24,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
@@ -33,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={})
@@ -78,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

@@ -1,7 +1,7 @@
 module NoBrainer::Document::Types
   extend ActiveSupport::Concern
 
-  module CastingRules
+  module CastUserToDB
     extend self
     InvalidType = NoBrainer::Error::InvalidType
 
@@ -60,14 +60,23 @@ module NoBrainer::Document::Types
     end
 
     def lookup(type)
-      CastingRules.method(type.to_s)
+      public_method(type.to_s)
     rescue NameError
       proc { raise InvalidType }
     end
+  end
 
-    def cast(value, type, type_cast_method)
-      return value if value.nil? || type.nil? || value.is_a?(type)
-      type_cast_method.call(value)
+  module CastDBToUser
+    extend self
+
+    def Symbol(value)
+      value.to_sym rescue value
+    end
+
+    def lookup(type)
+      public_method(type.to_s)
+    rescue NameError
+      nil
     end
   end
 
@@ -82,6 +91,11 @@ module NoBrainer::Document::Types
       end
     end
     before_validation :add_type_errors
+
+    # Fast access for db->user cast methods for performance when reading from
+    # the database.
+    singleton_class.send(:attr_accessor, :cast_db_to_user_fields)
+    self.cast_db_to_user_fields = Set.new
   end
 
   def add_type_errors
@@ -91,12 +105,27 @@ module NoBrainer::Document::Types
     end
   end
 
+  def assign_attributes(attrs, options={})
+    super
+    if options[:from_db]
+      self.class.cast_db_to_user_fields.each do |attr|
+        field_def = self.class.fields[attr]
+        type = field_def[:type]
+        value = @_attributes[attr.to_s]
+        unless value.nil? || value.is_a?(type)
+          @_attributes[attr.to_s] = field_def[:cast_db_to_user].call(value)
+        end
+      end
+    end
+  end
+
   module ClassMethods
-    def cast_value_for(attr, value)
-      attr = attr.to_sym
-      field_def = fields[attr]
-      return value unless field_def && field_def[:type]
-      NoBrainer::Document::Types::CastingRules.cast(value, field_def[:type], field_def[:type_cast_method])
+    def cast_user_to_db_for(attr, value)
+      field_def = fields[attr.to_sym]
+      return value if !field_def
+      type = field_def[:type]
+      return value if value.nil? || type.nil? || value.is_a?(type)
+      field_def[:cast_user_to_db].call(value)
     rescue NoBrainer::Error::InvalidType => error
       error.type = field_def[:type]
       error.value = value
@@ -104,13 +133,24 @@ module NoBrainer::Document::Types
       raise error
     end
 
+    def inherited(subclass)
+      super
+      subclass.cast_db_to_user_fields = self.cast_db_to_user_fields.dup
+    end
+
     def _field(attr, options={})
       super
 
+      if options[:cast_db_to_user]
+        ([self] + descendants).each do |klass|
+          klass.cast_db_to_user_fields << attr
+        end
+      end
+
       inject_in_layer :types do
         define_method("#{attr}=") do |value|
           begin
-            value = self.class.cast_value_for(attr, value)
+            value = self.class.cast_user_to_db_for(attr, value)
             @pending_type_errors.try(:delete, attr)
           rescue NoBrainer::Error::InvalidType => error
             @pending_type_errors ||= {}
@@ -125,10 +165,19 @@ module NoBrainer::Document::Types
 
     def field(attr, options={})
       if options[:type]
-        type_cast_method = NoBrainer::Document::Types::CastingRules.lookup(options[:type])
-        options = options.merge(:type_cast_method => type_cast_method)
+        options = options.merge(
+          :cast_user_to_db => NoBrainer::Document::Types::CastUserToDB.lookup(options[:type]),
+          :cast_db_to_user => NoBrainer::Document::Types::CastDBToUser.lookup(options[:type]))
       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

@@ -0,0 +1,99 @@
+module NoBrainer::Document::Uniqueness
+  extend ActiveSupport::Concern
+
+  def _create(options={})
+    lock_unique_fields
+    super
+  ensure
+    unlock_unique_fields
+  end
+
+  def _update_only_changed_attrs(options={})
+    lock_unique_fields
+    super
+  ensure
+    unlock_unique_fields
+  end
+
+  def _lock_key_from_field(field)
+    value = read_attribute(field).to_s
+    ['nobrainer', self.class.database_name || NoBrainer.connection.parsed_uri[:db],
+     self.class.table_name, field, value.empty? ? 'nil' : value].join(':')
+  end
+
+  def lock_unique_fields
+    return unless NoBrainer::Config.distributed_lock_class && !self.class.unique_validators.empty?
+
+    self.class.unique_validators
+      .map { |validator| validator.attributes.map { |attr| [attr, validator] } }
+      .flatten(1)
+      .select { |f, validator| validator.should_validate_uniquess_of?(self, f) }
+      .map { |f, options| _lock_key_from_field(f) }
+      .sort
+      .uniq
+      .each do |key|
+        lock = NoBrainer::Config.distributed_lock_class.new(key)
+        lock.lock
+        @locked_unique_fields ||= []
+        @locked_unique_fields << lock
+      end
+  end
+
+  def unlock_unique_fields
+    return unless @locked_unique_fields
+    @locked_unique_fields.pop.unlock until @locked_unique_fields.empty?
+  end
+
+  included do
+    singleton_class.send(:attr_accessor, :unique_validators)
+    self.unique_validators = []
+  end
+
+  module ClassMethods
+    def validates_uniqueness_of(*attr_names)
+      validates_with UniquenessValidator, _merge_attributes(attr_names)
+    end
+
+    def inherited(subclass)
+      super
+      subclass.unique_validators = self.unique_validators.dup
+    end
+
+  end
+
+  class UniquenessValidator < ActiveModel::EachValidator
+    attr_accessor :scope
+
+    def initialize(options={})
+      super
+      klass = options[:class]
+      self.scope = [*options[:scope]]
+      ([klass] + klass.descendants).each do |_klass|
+        _klass.unique_validators << self
+      end
+    end
+
+    def should_validate_uniquess_of?(doc, field)
+      (scope + [field]).any? { |f| doc.__send__("#{f}_changed?") }
+    end
+
+    def validate_each(doc, attr, value)
+      return true unless should_validate_uniquess_of?(doc, attr)
+
+      criteria = doc.root_class.unscoped.where(attr => value)
+      criteria = apply_scopes(criteria, doc)
+      criteria = exclude_doc(criteria, doc) if doc.persisted?
+      is_unique = criteria.count == 0
+      doc.errors.add(attr, :taken, options.except(:scope).merge(:value => value)) unless is_unique
+      is_unique
+    end
+
+    def apply_scopes(criteria, doc)
+      criteria.where(scope.map { |k| {k => doc.read_attribute(k)} })
+    end
+
+    def exclude_doc(criteria, doc)
+      criteria.where(doc.class.pk_name.ne => doc.pk_value)
+    end
+  end
+end

data/lib/no_brainer/document/validation.rb

@@ -3,6 +3,12 @@ module NoBrainer::Document::Validation
   include ActiveModel::Validations
   include ActiveModel::Validations::Callbacks
 
+  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 => proc { false }
+  end
+
   def valid?(context=nil)
     super(context || (new_record? ? :create : :update))
   end
@@ -10,31 +16,9 @@ module NoBrainer::Document::Validation
   module ClassMethods
     def _field(attr, options={})
       super
-      validates(attr, { :presence => true }) if options[:required]
+      validates(attr, { :presence => options[:required] }) if options.has_key?(:required)
+      validates(attr, { :uniqueness => options[:unique] }) if options.has_key?(:unique)
       validates(attr, options[:validates]) if options[:validates]
     end
-
-    def validates_uniqueness_of(*attr_names)
-      validates_with UniquenessValidator, _merge_attributes(attr_names)
-    end
-  end
-
-  class UniquenessValidator < ActiveModel::EachValidator
-    def validate_each(doc, attr, value)
-      criteria = doc.root_class.unscoped.where(attr => value)
-      criteria = apply_scopes(criteria, doc)
-      criteria = exclude_doc(criteria, doc) if doc.persisted?
-      is_unique = criteria.count == 0
-      doc.errors.add(attr, :taken, options.except(:scope).merge(:value => value)) unless is_unique
-      is_unique
-    end
-
-    def apply_scopes(criteria, doc)
-      criteria.where([*options[:scope]].map { |k| {k => doc.read_attribute(k)} })
-    end
-
-    def exclude_doc(criteria, doc)
-      criteria.where(:id.ne => doc.id)
-    end
   end
 end

data/lib/no_brainer/document.rb

@@ -5,10 +5,12 @@ module NoBrainer::Document
   extend NoBrainer::Autoload
 
   autoload_and_include :Core, :StoreIn, :InjectionLayer, :Attributes, :Readonly, :Validation, :Types,
-                       :Persistance, :Callbacks, :Dirty, :Id, :Association, :Serialization,
+                       :Persistance, :Uniqueness, :Callbacks, :Dirty, :Id, :Association, :Serialization,
                        :Criteria, :Polymorphic, :Index
 
   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 AssociationNotSaved < RuntimeError; end
-  class ReadonlyField       < 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 DocumentInvalid < RuntimeError
     attr_accessor :instance

data/lib/no_brainer/index_manager.rb

@@ -1,6 +1,8 @@
 module NoBrainer::IndexManager
   def self.update_indexes(options={})
-    Rails.application.eager_load! if defined?(Rails)
-    NoBrainer::Document.all.each { |model| model.perform_update_indexes(options) }
+    NoBrainer::Document.all.each { |model| model.perform_update_indexes(options.merge(:wait => false)) }
+    unless options[:wait] == false
+      NoBrainer::Document.all.each { |model| model.wait_for_index(nil) }
+    end
   end
 end

data/lib/no_brainer/loader.rb

@@ -1,5 +1,5 @@
 module NoBrainer::Loader
   def self.cleanup
-    NoBrainer::Document.all.clear
+    NoBrainer::Document::Core._all.clear
   end
 end

data/lib/no_brainer/query_runner/logger.rb

@@ -1,29 +1,41 @@
 class NoBrainer::QueryRunner::Logger < NoBrainer::QueryRunner::Middleware
   def call(env)
     start_time = Time.now
-    res = @runner.call(env)
-    if NoBrainer.logger and NoBrainer.logger.debug?
-      duration = Time.now - start_time
-      msg = env[:query].inspect.gsub(/\n/, '').gsub(/ +/, ' ')
+    @runner.call(env).tap { log_query(env, start_time) }
+  rescue Exception => e
+    log_query(env, start_time, e) rescue nil
+    raise e
+  end
+
+  private
 
-      # Need to fix the rethinkdb gem.
-      if msg =~ /Erroneous_Portion_Constructed/
-        msg = "r.the_rethinkdb_gem_is_flipping_out_with_Erroneous_Portion_Constructed"
-      end
+  def log_query(env, start_time, exception=nil)
+    return unless NoBrainer.logger.debug?
 
-      msg = "(#{env[:db_name]}) #{msg}" if env[:db_name]
-      msg = "[#{(duration * 1000.0).round(1)}ms] #{msg}"
+    duration = Time.now - start_time
 
-      if NoBrainer::Config.colorize_logger
-        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
+    msg_duration = (duration * 1000.0).round(1).to_s
+    msg_duration = " " * [0, 5 - msg_duration.size].max + msg_duration
+    msg_duration = "[#{msg_duration}ms] "
 
-      NoBrainer.logger.debug(msg)
+    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
+      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
-    res
+
+    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/{connection.rb → reconnect.rb}

@@ -1,23 +1,23 @@
-class NoBrainer::QueryRunner::Connection < NoBrainer::QueryRunner::Middleware
+class NoBrainer::QueryRunner::Reconnect < NoBrainer::QueryRunner::Middleware
   def call(env)
     @runner.call(env)
   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::Connection < 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