nobrainer 0.13.1 → 0.15.0

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
@@ -27,14 +28,14 @@ module NoBrainer::Document::Persistance
 
   def _create(options={})
     return false if options[:validate] && !valid?
-    keys = self.class.insert_all(@_attributes)
-    self.id ||= keys.first
+    keys = self.class.insert_all(self.class.persistable_attributes(@_attributes))
+    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={})
@@ -49,7 +50,7 @@ module NoBrainer::Document::Persistance
       attr = RethinkDB::RQL.new.literal(attr) if attr.is_a?(Hash)
       [k, attr]
     end]
-    _update(attrs) if attrs.present?
+    _update(self.class.persistable_attributes(attrs)) if attrs.present?
     true
   end
 
@@ -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/boolean.rb

@@ -0,0 +1,26 @@
+# We namespace our fake Boolean class to avoid polluting the global namespace
+class NoBrainer::Boolean
+  def initialize; raise; end
+  def self.inspect; 'Boolean'; 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 TrueClass  then true
+      when FalseClass then false
+      when String, Integer
+        value = value.to_s.strip.downcase
+        return true  if value.in? %w(true yes t 1)
+        return false if value.in? %w(false no f 0)
+        raise InvalidType
+      else raise InvalidType
+      end
+    end
+  end
+  extend NoBrainerExtentions
+end
+

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

@@ -0,0 +1,26 @@
+class Date
+  module NoBrainerExtentions
+    InvalidType = NoBrainer::Error::InvalidType
+
+    def nobrainer_cast_user_to_model(value)
+      case value
+      when Date then value
+      when String
+        value = value.strip
+        date = Date.parse(value) rescue (raise InvalidType)
+        raise InvalidType unless date.iso8601 == value
+        date
+      else raise InvalidType
+      end
+    end
+
+    def nobrainer_cast_db_to_model(value)
+      value.is_a?(Time) ? value.to_date : value
+    end
+
+    def nobrainer_cast_model_to_db(value)
+      value.is_a?(Date) ? Time.utc(value.year, value.month, value.day) : value
+    end
+  end
+  extend NoBrainerExtentions
+end

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

@@ -0,0 +1,20 @@
+class Float
+  module NoBrainerExtentions
+    InvalidType = NoBrainer::Error::InvalidType
+
+    def nobrainer_cast_user_to_model(value)
+      case value
+      when Float   then value
+      when Integer then value.to_f
+      when String
+        value = value.strip.gsub(/^\+/, '')
+        value = value.gsub(/0+$/, '') if value['.']
+        value = value.gsub(/\.$/, '')
+        value = "#{value}.0" unless value['.']
+        value.to_f.tap { |new_value| new_value.to_s == value or raise InvalidType }
+      else raise InvalidType
+      end
+    end
+  end
+  extend NoBrainerExtentions
+end

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

@@ -0,0 +1,18 @@
+class Integer
+  module NoBrainerExtentions
+    InvalidType = NoBrainer::Error::InvalidType
+
+    def nobrainer_cast_user_to_model(value)
+      case value
+      when Integer then value
+      when String
+        value = value.strip.gsub(/^\+/, '')
+        value.to_i.tap { |new_value| new_value.to_s == value or raise InvalidType }
+      when Float
+        value.to_i.tap { |new_value| new_value.to_f == value or raise InvalidType }
+      else raise InvalidType
+      end
+    end
+  end
+  extend NoBrainerExtentions
+end

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

@@ -0,0 +1,14 @@
+class String
+  module NoBrainerExtentions
+    InvalidType = NoBrainer::Error::InvalidType
+
+    def nobrainer_cast_user_to_model(value)
+      case value
+      when String then value
+      when Symbol then value.to_s
+      else raise InvalidType
+      end
+    end
+  end
+  extend NoBrainerExtentions
+end

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

@@ -0,0 +1,21 @@
+class Symbol
+  module NoBrainerExtentions
+    InvalidType = NoBrainer::Error::InvalidType
+
+    def nobrainer_cast_user_to_model(value)
+      case value
+      when Symbol then value
+      when String
+        value = value.strip
+        raise InvalidType if value.empty?
+        value.to_sym
+      else raise InvalidType
+      end
+    end
+
+    def nobrainer_cast_db_to_model(value)
+      value.to_sym rescue (value.to_s.to_sym rescue value)
+    end
+  end
+  extend NoBrainerExtentions
+end

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

@@ -0,0 +1,41 @@
+require 'time'
+
+class Time
+  module NoBrainerExtentions
+    InvalidType = NoBrainer::Error::InvalidType
+
+    def nobrainer_cast_user_to_model(value)
+      case value
+      when Time then time = value
+      when String
+        value = value.strip.sub(/Z$/, '+00:00')
+        # 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)
+        raise InvalidType unless time.iso8601 == value
+      else raise InvalidType
+      end
+
+      nobrainer_timezoned(NoBrainer::Config.user_timezone, time)
+    end
+
+    def nobrainer_cast_db_to_model(value)
+      return value unless value.is_a?(Time)
+      nobrainer_timezoned(NoBrainer::Config.user_timezone, value)
+    end
+
+    def nobrainer_cast_model_to_db(value)
+      return value unless value.is_a?(Time)
+      nobrainer_timezoned(NoBrainer::Config.db_timezone, value)
+    end
+
+    def nobrainer_timezoned(tz, value)
+      case tz
+      when :local     then value.getlocal
+      when :utc       then value.getutc
+      when :unchanged then value
+      end
+    end
+  end
+  extend NoBrainerExtentions
+end

data/lib/no_brainer/document/types.rb

@@ -1,102 +1,7 @@
 module NoBrainer::Document::Types
   extend ActiveSupport::Concern
 
-  module CastUserToDB
-    extend self
-    InvalidType = NoBrainer::Error::InvalidType
-
-    def String(value)
-      case value
-      when Symbol then value.to_s
-      else raise InvalidType
-      end
-    end
-
-    def Integer(value)
-      case value
-      when String
-        value = value.strip.gsub(/^\+/, '')
-        value.to_i.tap { |new_value| new_value.to_s == value or raise InvalidType }
-      when Float
-        value.to_i.tap { |new_value| new_value.to_f == value or raise InvalidType }
-      else raise InvalidType
-      end
-    end
-
-    def Float(value)
-      case value
-      when Integer then value.to_f
-      when String
-        value = value.strip.gsub(/^\+/, '')
-        value = value.gsub(/0+$/, '') if value['.']
-        value = value.gsub(/\.$/, '')
-        value = "#{value}.0" unless value['.']
-        value.to_f.tap { |new_value| new_value.to_s == value or raise InvalidType }
-      else raise InvalidType
-      end
-    end
-
-    def Boolean(value)
-      case value
-      when TrueClass  then true
-      when FalseClass then false
-      when String, Integer
-        value = value.to_s.strip.downcase
-        return true  if value.in? %w(true yes t 1)
-        return false if value.in? %w(false no f 0)
-        raise InvalidType
-      else raise InvalidType
-      end
-    end
-
-    def Symbol(value)
-      case value
-      when String
-        value = value.strip
-        raise InvalidType if value.empty?
-        value.to_sym
-      else raise InvalidType
-      end
-    end
-
-    def lookup(type)
-      public_method(type.to_s)
-    rescue NameError
-      proc { raise InvalidType }
-    end
-  end
-
-  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
-
-  included do
-    # We namespace our fake Boolean class to avoid polluting the global namespace
-    class_exec do
-      class Boolean
-        def initialize; raise; end
-        def self.inspect; 'Boolean'; end
-        def self.to_s; inspect; end
-        def self.name; inspect; end
-      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
+  included { before_validation :add_type_errors }
 
   def add_type_errors
     return unless @pending_type_errors
@@ -108,49 +13,59 @@ module NoBrainer::Document::Types
   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
+      @_attributes = Hash[@_attributes.map do |k,v|
+        [k, self.class.cast_db_to_model_for(k, v)]
+      end].with_indifferent_access
     end
   end
 
   module ClassMethods
-    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)
+    def cast_user_to_model_for(attr, value)
+      type = fields[attr.to_sym].try(:[], :type)
+      return value if type.nil? || value.nil?
+      if type.respond_to?(:nobrainer_cast_user_to_model)
+        type.nobrainer_cast_user_to_model(value)
+      else
+        raise NoBrainer::Error::InvalidType unless value.is_a?(type)
+        value
+      end
     rescue NoBrainer::Error::InvalidType => error
-      error.type = field_def[:type]
+      error.type = type
       error.value = value
       error.attr_name = attr
       raise error
     end
 
-    def inherited(subclass)
-      super
-      subclass.cast_db_to_user_fields = self.cast_db_to_user_fields.dup
+    def cast_model_to_db_for(attr, value)
+      type = fields[attr.to_sym].try(:[], :type)
+      return value if type.nil? || value.nil? || !type.respond_to?(:nobrainer_cast_model_to_db)
+      type.nobrainer_cast_model_to_db(value)
+    end
+
+    def cast_db_to_model_for(attr, value)
+      type = fields[attr.to_sym].try(:[], :type)
+      return value if type.nil? || value.nil? || !type.respond_to?(:nobrainer_cast_db_to_model)
+      type.nobrainer_cast_db_to_model(value)
+    end
+
+    def cast_user_to_db_for(attr, value)
+      value = cast_user_to_model_for(attr, value)
+      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)] }]
     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
+      NoBrainer::Document::Types.load_type_extensions(options[:type]) if options[:type]
 
       inject_in_layer :types do
         define_method("#{attr}=") do |value|
           begin
-            value = self.class.cast_user_to_db_for(attr, value)
+            value = self.class.cast_user_to_model_for(attr, value)
             @pending_type_errors.try(:delete, attr)
           rescue NoBrainer::Error::InvalidType => error
             @pending_type_errors ||= {}
@@ -163,13 +78,38 @@ module NoBrainer::Document::Types
       end
     end
 
+    def _remove_field(attr, options={})
+      super
+
+      inject_in_layer :types do
+        remove_method("#{attr}=")
+        remove_method("#{attr}?") if method_defined?("#{attr}?")
+      end
+    end
+
     def field(attr, options={})
-      if options[:type]
-        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]))
+      if options[:type] == Array || options[:type] == Hash
+        # XXX For the moment, NoBrainer does not support these complex types
+        options.delete(:type)
       end
       super
     end
   end
+
+  require File.join(File.dirname(__FILE__), 'types', 'boolean')
+  Boolean = NoBrainer::Boolean
+
+  class << self
+    mattr_accessor :loaded_extensions
+    self.loaded_extensions = Set.new
+    def load_type_extensions(klass)
+      unless loaded_extensions.include?(klass)
+        begin
+          require File.join(File.dirname(__FILE__), 'types', klass.name.underscore)
+        rescue LoadError
+        end
+        loaded_extensions << klass
+      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)
@@ -18,6 +18,7 @@ module NoBrainer::Document::Validation
       super
       validates(attr, { :presence => options[:required] }) if options.has_key?(:required)
       validates(attr, { :uniqueness => options[:unique] }) if options.has_key?(:unique)
+      validates(attr, { :inclusion => {:in => options[:in]} }) if options.has_key?(:in)
       validates(attr, options[:validates]) if options[:validates]
     end
   end

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
@@ -33,7 +33,7 @@ module NoBrainer::Error
     end
 
     def message
-      "#{attr_name} should be used with a #{human_type_name}. Got `#{value}`"
+      "#{attr_name} should be used with a #{human_type_name}. Got `#{value}` (#{value.class})"
     end
   end
 end

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