nobrainer 0.18.0 → 0.22.0

data/lib/no_brainer/document/index/meta_store.rb

@@ -24,7 +24,7 @@ class NoBrainer::Document::Index::MetaStore
   def self.on(db_name, &block)
     old_db_name = Thread.current[:nobrainer_meta_store_db]
     Thread.current[:nobrainer_meta_store_db] = db_name
-    NoBrainer.with(:auto_create_tables => true) { block.call }
+    block.call
   ensure
     Thread.current[:nobrainer_meta_store_db] = old_db_name
   end

data/lib/no_brainer/document/index.rb

@@ -1,5 +1,5 @@
 module NoBrainer::Document::Index
-  VALID_INDEX_OPTIONS = [:external, :geo, :multi, :as]
+  VALID_INDEX_OPTIONS = [:external, :geo, :multi, :store_as]
   extend ActiveSupport::Concern
   extend NoBrainer::Autoload
 
@@ -33,12 +33,16 @@ module NoBrainer::Document::Index
         raise "Cannot reuse field name #{name}"
       end
 
-      as = options.delete(:as)
-      as ||= fields[name][:as] if has_field?(name)
-      as ||= name
-      as = as.to_sym
+      if kind == :compound && what.size < 2
+        raise "Compound indexes only make sense with 2 or more fields"
+      end
+
+      store_as = options.delete(:store_as)
+      store_as ||= fields[name][:store_as] if has_field?(name)
+      store_as ||= name
+      store_as = store_as.to_sym
 
-      indexes[name] = NoBrainer::Document::Index::Index.new(self.root_class, name, as,
+      indexes[name] = NoBrainer::Document::Index::Index.new(self.root_class, name, store_as,
         kind, what, options[:external], options[:geo], options[:multi], nil)
     end
 
@@ -57,12 +61,12 @@ module NoBrainer::Document::Index
 
       super
 
-      as = {:as => options[:as]}
+      store_as = {:store_as => options[:store_as]}
       case options[:index]
       when nil    then
-      when Hash   then index(attr, as.merge(options[:index]))
-      when Symbol then index(attr, as.merge(options[:index] => true))
-      when true   then index(attr, as)
+      when Hash   then index(attr, store_as.merge(options[:index]))
+      when Symbol then index(attr, store_as.merge(options[:index] => true))
+      when true   then index(attr, store_as)
       when false  then remove_index(attr)
       end
     end

data/lib/no_brainer/document/persistance.rb

@@ -29,7 +29,7 @@ module NoBrainer::Document::Persistance
 
   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
+    raise NoBrainer::Error::DocumentNotFound, "#{self.class} :#{self.class.pk_name}=>\"#{pk_value}\" not found" unless attrs
 
     options = options.merge(:pristine => true, :from_db => true)
 
@@ -45,16 +45,16 @@ module NoBrainer::Document::Persistance
 
   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
+      next unless v = options.delete(type)
+
+      v = Hash[v.flatten.map { |k| [k, true] }] if v.is_a?(Array)
+      v = {v => true} unless 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
     _reload(options)
   end
@@ -113,13 +113,11 @@ module NoBrainer::Document::Persistance
     assign_attributes(attrs, options)
     save?(options)
   end
-  alias_method :update_attributes?, :update?
 
   def update(*args)
     update?(*args) or raise NoBrainer::Error::DocumentInvalid, self
     nil
   end
-  alias_method :update_attributes, :update
 
   def update!(*args)
     update(*args)
@@ -127,6 +125,18 @@ module NoBrainer::Document::Persistance
   end
   alias_method :update_attributes!, :update!
 
+  def update_attributes?(*args)
+    update?(*args).tap { STDERR.puts "[NoBrainer] update_attributes?() is deprecated. Please use update?() instead" }
+  end
+
+  def update_attributes(*args)
+    update(*args).tap { STDERR.puts "[NoBrainer] update_attributes() is deprecated. Please use update() instead" }
+  end
+
+  def update_attributes!(*args)
+    update!(*args).tap { STDERR.puts "[NoBrainer] update_attributes!() is deprecated. Please use update() instead" }
+  end
+
   def delete
     unless @destroyed
       NoBrainer.run { selector.delete }
@@ -144,6 +154,7 @@ module NoBrainer::Document::Persistance
     def create(attrs={}, options={})
       new(attrs, options).tap { |doc| doc.save(options) }
     end
+    alias_method :create!, :create
 
     def insert_all(*args)
       docs = args.shift

data/lib/no_brainer/document/primary_key/generator.rb

@@ -0,0 +1,83 @@
+module NoBrainer::Document::PrimaryKey::Generator
+  class Retry < RuntimeError; end
+
+  BASE_TABLE = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz".freeze
+
+  TIME_OFFSET = Time.parse('2014-01-01').to_i
+
+  # 30 bits timestamp with 1s resolution -> We overflow in year 2048. Good enough.
+  # Math.log(Time.parse('2048-01-01').to_f - TIME_OFFSET)/Math.log(2) = 29.999
+  TIMESTAMP_BITS = 30
+
+  # 14 bits of sequence number. max 16k values per 1s slices.
+  # We want something >10k because we want to be able to do high speed inserts
+  # on a single process for future benchmarks.
+  SEQUENCE_BITS = 14
+
+  # 24 bits of machine id
+  # 0.1% of chance to have a collision with 183 servers:
+  # Math.sqrt(-2*(2**24)*Math.log(0.999)) = 183.2
+  # 1% of chance to have a collision with ~580 servers.
+  # When using more than 500 machines, it's therefore a good
+  # idea to set the machine_id manually to avoid collisions.
+  MACHINE_ID_BITS = 24
+
+  # 15 bits for the current pid. We wouldn't need it if the sequence number was
+  # on a piece of shared memory :)
+  PID_BITS = 15
+
+  # Total: 83 bits
+  # We need at most 14 digits in [A-Za-z0-9] to represent 83 bits:
+  # Math.log(62**14)/Math.log(2) = 83.35
+  ID_STR_LENGTH = 14
+
+  TIMESTAMP_MASK  = (1 <<  TIMESTAMP_BITS)-1
+  SEQUENCE_MASK   = (1 <<   SEQUENCE_BITS)-1
+  MACHINE_ID_MASK = (1 << MACHINE_ID_BITS)-1
+  PID_MASK        = (1 <<        PID_BITS)-1
+
+  PID_SHIFT        = 0
+  MACHINE_ID_SHIFT = PID_SHIFT + PID_BITS
+  SEQUENCE_SHIFT   = MACHINE_ID_SHIFT + MACHINE_ID_BITS
+  TIMESTAMP_SHIFT  = SEQUENCE_SHIFT + SEQUENCE_BITS
+
+  def self._generate
+    timestamp = (Time.now.to_i - TIME_OFFSET) & TIMESTAMP_MASK
+
+    unless @last_timestamp == timestamp
+      # more noise is better in the ID, but we prefer to avoid
+      # wrapping the sequences so that Model.last on a single
+      # machine returns the latest created document.
+      @first_sequence = sequence = rand(SEQUENCE_MASK/2)
+      @last_timestamp = timestamp
+    else
+      sequence = (@sequence + 1) & SEQUENCE_MASK
+      raise Retry if @first_sequence == sequence
+    end
+    @sequence = sequence
+
+    machine_id = NoBrainer::Config.machine_id & MACHINE_ID_MASK
+
+    pid = Process.pid & PID_MASK
+
+    (timestamp << TIMESTAMP_SHIFT) | (sequence << SEQUENCE_SHIFT) |
+      (machine_id << MACHINE_ID_SHIFT) | (pid << PID_SHIFT)
+  rescue Retry
+    sleep 0.1
+    retry
+  end
+
+  def self.convert_to_alphanum(id)
+    result = []
+    until id.zero?
+      id, r = id.divmod(BASE_TABLE.size)
+      result << BASE_TABLE[r]
+    end
+    result.reverse.join.rjust(ID_STR_LENGTH, BASE_TABLE[0])
+  end
+
+  @lock = Mutex.new
+  def self.generate
+    convert_to_alphanum(@lock.synchronize { _generate })
+  end
+end

data/lib/no_brainer/document/{id.rb → primary_key.rb}

@@ -1,8 +1,7 @@
-require 'thread'
-require 'socket'
-require 'digest/md5'
+module NoBrainer::Document::PrimaryKey
+  extend NoBrainer::Autoload
+  autoload :Generator
 
-module NoBrainer::Document::Id
   extend ActiveSupport::Concern
 
   DEFAULT_PK_NAME = :id
@@ -24,41 +23,10 @@ module NoBrainer::Document::Id
 
   delegate :hash, :to => :pk_value
 
-  # The following code is inspired by the mongo-ruby-driver
-
-  @machine_id = Digest::MD5.digest(Socket.gethostname)[0, 3]
-  @lock = Mutex.new
-  @index = 0
-
-  def self.get_inc
-    @lock.synchronize do
-      @index = (@index + 1) % 0xFFFFFF
-    end
-  end
-
-  # TODO Unit test that thing
-  def self.generate
-    oid = ''
-    # 4 bytes current time
-    oid += [Time.now.to_i].pack("N")
-
-    # 3 bytes machine
-    oid += @machine_id
-
-    # 2 bytes pid
-    oid += [Process.pid % 0xFFFF].pack("n")
-
-    # 3 bytes inc
-    oid += [get_inc].pack("N")[1, 3]
-
-    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 }
+      field NoBrainer::Document::PrimaryKey::DEFAULT_PK_NAME, :primary_key => :default
     end
 
     def define_pk(attr)
@@ -81,6 +49,11 @@ module NoBrainer::Document::Id
       if options[:primary_key]
         options = options.merge(:readonly => true) if options[:readonly].nil?
         options = options.merge(:index => true)
+
+        if options[:type].in?([String, nil]) && options[:default].nil?
+          options[:type] = String
+          options[:default] = ->{ NoBrainer::Document::PrimaryKey::Generator.generate }
+        end
       end
       super
     end

data/lib/no_brainer/document/store_in.rb

@@ -16,13 +16,13 @@ module NoBrainer::Document::StoreIn
 
     def database_name
       db = self.store_in_options[:database]
-      db.is_a?(Proc) ? db.call : db
+      (db.is_a?(Proc) ? db.call : db).try(:to_s)
     end
 
     def table_name
       table = store_in_options[:table]
       table_name = table.is_a?(Proc) ? table.call : table
-      table_name || root_class.name.tableize.gsub('/', '__')
+      table_name.try(:to_s) || root_class.name.tableize.gsub('/', '__')
     end
 
     def rql_table

data/lib/no_brainer/document/timestamps.rb

@@ -7,12 +7,14 @@ module NoBrainer::Document::Timestamps
   end
 
   def _create(options={})
-    self.created_at = self.updated_at = Time.now
+    now = Time.now
+    self.created_at = now unless created_at_changed?
+    self.updated_at = now unless updated_at_changed?
     super
   end
 
   def _update(attrs)
-    self.updated_at = Time.now
+    self.updated_at = Time.now unless updated_at_changed?
     super(attrs.merge('updated_at' => @_attributes['updated_at']))
   end
 end

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

@@ -4,7 +4,7 @@ class NoBrainer::Binary
   def self.to_s; inspect; end
   def self.name; inspect; end
 
-  module NoBrainerExtentions
+  module NoBrainerExtensions
     InvalidType = NoBrainer::Error::InvalidType
 
     def nobrainer_cast_user_to_model(value)
@@ -13,11 +13,6 @@ class NoBrainer::Binary
       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
+  extend NoBrainerExtensions
 end
-

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

@@ -1,11 +1,10 @@
-# 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
+  module NoBrainerExtensions
     InvalidType = NoBrainer::Error::InvalidType
 
     def nobrainer_cast_user_to_model(value)
@@ -21,6 +20,5 @@ class NoBrainer::Boolean
       end
     end
   end
-  extend NoBrainerExtentions
+  extend NoBrainerExtensions
 end
-

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

@@ -1,5 +1,5 @@
 class Date
-  module NoBrainerExtentions
+  module NoBrainerExtensions
     InvalidType = NoBrainer::Error::InvalidType
 
     def nobrainer_cast_user_to_model(value)
@@ -22,5 +22,5 @@ class Date
       value.is_a?(Date) ? Time.utc(value.year, value.month, value.day) : value
     end
   end
-  extend NoBrainerExtentions
+  extend NoBrainerExtensions
 end

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

@@ -1,5 +1,5 @@
 class Float
-  module NoBrainerExtentions
+  module NoBrainerExtensions
     InvalidType = NoBrainer::Error::InvalidType
 
     def nobrainer_cast_user_to_model(value)
@@ -16,5 +16,5 @@ class Float
       end
     end
   end
-  extend NoBrainerExtentions
+  extend NoBrainerExtensions
 end

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

@@ -0,0 +1 @@
+# Look in lib/no_brainer/geo.rb instead

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

@@ -1,5 +1,5 @@
 class Integer
-  module NoBrainerExtentions
+  module NoBrainerExtensions
     InvalidType = NoBrainer::Error::InvalidType
 
     def nobrainer_cast_user_to_model(value)
@@ -14,5 +14,5 @@ class Integer
       end
     end
   end
-  extend NoBrainerExtentions
+  extend NoBrainerExtensions
 end

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

@@ -1,5 +1,5 @@
 class Set
-  module NoBrainerExtentions
+  module NoBrainerExtensions
     InvalidType = NoBrainer::Error::InvalidType
 
     def nobrainer_cast_user_to_model(value)
@@ -19,5 +19,5 @@ class Set
     end
   end
 
-  extend NoBrainerExtentions
+  extend NoBrainerExtensions
 end

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

@@ -1,5 +1,5 @@
 class String
-  module NoBrainerExtentions
+  module NoBrainerExtensions
     InvalidType = NoBrainer::Error::InvalidType
 
     def nobrainer_cast_user_to_model(value)
@@ -7,8 +7,11 @@ class String
       when String then value
       when Symbol then value.to_s
       else raise InvalidType
+      end.tap do |str|
+        max_length = NoBrainer::Config.max_string_length
+        raise InvalidType.new(:error => { :message => :too_long, :count => max_length }) if str.size > max_length
       end
     end
   end
-  extend NoBrainerExtentions
+  extend NoBrainerExtensions
 end

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

@@ -1,5 +1,5 @@
 class Symbol
-  module NoBrainerExtentions
+  module NoBrainerExtensions
     InvalidType = NoBrainer::Error::InvalidType
 
     def nobrainer_cast_user_to_model(value)
@@ -17,5 +17,5 @@ class Symbol
       value.to_sym rescue (value.to_s.to_sym rescue value)
     end
   end
-  extend NoBrainerExtentions
+  extend NoBrainerExtensions
 end

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

@@ -0,0 +1,18 @@
+class NoBrainer::Text
+  def initialize; raise; end
+  def self.inspect; 'Text'; end
+  def self.to_s; inspect; end
+  def self.name; inspect; end
+
+  module NoBrainerExtensions
+    InvalidType = NoBrainer::Error::InvalidType
+
+    def nobrainer_cast_user_to_model(value)
+      case value
+      when String then value
+      else raise InvalidType
+      end
+    end
+  end
+  extend NoBrainerExtensions
+end

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

@@ -1,7 +1,7 @@
 require 'time'
 
 class Time
-  module NoBrainerExtentions
+  module NoBrainerExtensions
     InvalidType = NoBrainer::Error::InvalidType
 
     def nobrainer_cast_user_to_model(value)
@@ -37,5 +37,5 @@ class Time
       end
     end
   end
-  extend NoBrainerExtentions
+  extend NoBrainerExtensions
 end

data/lib/no_brainer/document/types.rb

@@ -6,7 +6,7 @@ module NoBrainer::Document::Types
   def add_type_errors
     return unless @pending_type_errors
     @pending_type_errors.each do |name, error|
-      errors.add(name, :invalid_type, :type => error.human_type_name)
+      errors.add(name, :invalid_type, error.error)
     end
   end
 
@@ -22,7 +22,10 @@ module NoBrainer::Document::Types
   module ClassMethods
     def cast_user_to_model_for(attr, value)
       type = fields[attr.to_sym].try(:[], :type)
-      return value if type.nil? || value.nil? || value.is_a?(NoBrainer::Document::AtomicOps::PendingAtomic)
+      return value if type.nil? || value.nil? ||
+        value.is_a?(NoBrainer::Document::AtomicOps::PendingAtomic) ||
+        value.is_a?(RethinkDB::RQL)
+
       if type.respond_to?(:nobrainer_cast_user_to_model)
         type.nobrainer_cast_user_to_model(value)
       else
@@ -30,9 +33,7 @@ module NoBrainer::Document::Types
         value
       end
     rescue NoBrainer::Error::InvalidType => error
-      error.type = type
-      error.value = value
-      error.attr_name = attr
+      error.update(:model => self, :value => value, :attr_name => attr, :type => type)
       raise error
     end
 
@@ -62,6 +63,13 @@ module NoBrainer::Document::Types
 
       return unless options[:type]
 
+      raise "Please use a class for the type option" unless options[:type].is_a?(Class)
+      case options[:type].to_s
+      when "NoBrainer::Geo::Circle" then raise "Cannot store circles :("
+      when "NoBrainer::Geo::Polygon", "NoBrainer::Geo::LineString"
+        raise "Make a request on github if you'd like to store polygons/linestrings"
+      end
+
       NoBrainer::Document::Types.load_type_extensions(options[:type]) if options[:type]
 
       inject_in_layer :types do
@@ -88,21 +96,12 @@ module NoBrainer::Document::Types
         remove_method("#{attr}?") if method_defined?("#{attr}?")
       end
     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)
-      end
-      super
-    end
   end
 
-  require File.join(File.dirname(__FILE__), 'types', 'binary')
-  require File.join(File.dirname(__FILE__), 'types', 'boolean')
-  Binary = NoBrainer::Binary
-  Boolean = NoBrainer::Boolean
+  %w(binary boolean text geo).each do |type|
+    require File.join(File.dirname(__FILE__), 'types', type)
+    const_set(type.camelize, NoBrainer.const_get(type.camelize))
+  end
 
   class << self
     mattr_accessor :loaded_extensions

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

@@ -0,0 +1,15 @@
+module NoBrainer::Document::Validation::NotNull
+  extend ActiveSupport::Concern
+
+  module ClassMethods
+    def validates_not_null(*attr_names)
+      validates_with(NotNullValidator, _merge_attributes(attr_names))
+    end
+  end
+
+  class NotNullValidator < ActiveModel::EachValidator
+    def validate_each(doc, attr, value)
+      doc.errors.add(attr, :undefined, options) if value.nil?
+    end
+  end
+end

data/lib/no_brainer/document/{uniqueness.rb → validation/uniqueness.rb}

@@ -1,4 +1,4 @@
-module NoBrainer::Document::Uniqueness
+module NoBrainer::Document::Validation::Uniqueness
   extend ActiveSupport::Concern
 
   def _create(options={})
@@ -27,7 +27,7 @@ module NoBrainer::Document::Uniqueness
     self.class.unique_validators
       .map { |validator| validator.attributes.map { |attr| [attr, validator] } }
       .flatten(1)
-      .select { |f, validator| validator.should_validate_uniquess_of?(self, f) }
+      .select { |f, validator| validator.should_validate_field?(self, f) }
       .map { |f, options| _lock_key_from_field(f) }
       .sort
       .uniq
@@ -51,14 +51,13 @@ module NoBrainer::Document::Uniqueness
 
   module ClassMethods
     def validates_uniqueness_of(*attr_names)
-      validates_with UniquenessValidator, _merge_attributes(attr_names)
+      validates_with(UniquenessValidator, _merge_attributes(attr_names))
     end
 
     def inherited(subclass)
       subclass.unique_validators = self.unique_validators.dup
       super
     end
-
   end
 
   class UniquenessValidator < ActiveModel::EachValidator
@@ -73,19 +72,20 @@ module NoBrainer::Document::Uniqueness
       end
     end
 
-    def should_validate_uniquess_of?(doc, field)
-      (scope + [field]).any? { |f| doc.__send__("#{f}_changed?") }
+    def should_validate_field?(doc, field)
+      doc.new_record? || (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
+      doc.errors.add(attr, :taken, options.except(:scope).merge(:value => value)) unless criteria.empty?
+    rescue NoBrainer::Error::InvalidType
+      # We can't run the uniqueness validator: where() won't accept bad types
+      # and we have some values that don't have the right type.
+      # Note that it's fine to not add errors because the type validations will
+      # prevent the document from being saved.
     end
 
     def apply_scopes(criteria, doc)