nobrainer 0.20.0 → 0.22.0

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,14 +63,15 @@ module NoBrainer::Document::Types
 
       return unless options[:type]
 
-      NoBrainer::Document::Types.load_type_extensions(options[:type]) if 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
         define_method("#{attr}=") do |value|
           begin
@@ -96,11 +98,10 @@ 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
-  Geo = NoBrainer::Geo
+  %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,7 +51,7 @@ 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)
@@ -72,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)

data/lib/no_brainer/document/validation.rb

@@ -1,8 +1,11 @@
 module NoBrainer::Document::Validation
+  extend NoBrainer::Autoload
   extend ActiveSupport::Concern
   include ActiveModel::Validations
   include ActiveModel::Validations::Callbacks
 
+  autoload_and_include :Uniqueness, :NotNull
+
   included do
     # We don't want before_validation returning false to halt the chain.
     define_callbacks :validation, :skip_after_callbacks_if_terminated => true,
@@ -12,7 +15,7 @@ module NoBrainer::Document::Validation
   def valid?(context=nil, options={})
     context ||= new_record? ? :create : :update
 
-  # copy/pasted, because we need to have control on errors.clear
+   # XXX Monkey Patching, because we need to have control on errors.clear
     current_context, self.validation_context = validation_context, context
     errors.clear unless options[:clear_errors] == false
     run_validations!
@@ -20,15 +23,41 @@ module NoBrainer::Document::Validation
     self.validation_context = current_context
   end
 
+  SHORTHANDS = { :format => :format, :length => :length, :required => :presence,
+                 :uniq => :uniqueness, :unique => :uniqueness, :in => :inclusion }
+
   module ClassMethods
     def _field(attr, options={})
       super
-      validates(attr, :format => { :with => options[:format] }) if options.has_key?(:format)
-      validates(attr, :presence => options[:required]) if options.has_key?(:required)
-      validates(attr, :uniqueness => options[:unique]) if options.has_key?(:unique)
-      validates(attr, :uniqueness => options[:uniq]) if options.has_key?(:uniq)
-      validates(attr, :inclusion => {:in => options[:in]}) if options.has_key?(:in)
+
+      shorthands = SHORTHANDS
+      shorthands = shorthands.merge(:required => :not_null) if options[:type] == NoBrainer::Boolean
+      shorthands.each { |k,v| validates(attr, v => options[k]) if options.has_key?(k) }
+
       validates(attr, options[:validates]) if options[:validates]
+      validates(attr, :length => { :minimum => options[:min_length] }) if options[:min_length]
+      validates(attr, :length => { :maximum => options[:max_length] }) if options[:max_length]
+    end
+  end
+end
+
+class ActiveModel::EachValidator
+  def should_validate_field?(record, attribute)
+    return true unless record.is_a?(NoBrainer::Document)
+    return true if record.new_record?
+
+    attr_changed = "#{attribute}_changed?"
+    return record.respond_to?(attr_changed) ? record.__send__(attr_changed) : true
+  end
+
+  # XXX Monkey Patching :(
+  def validate(record)
+    attributes.each do |attribute|
+      next unless should_validate_field?(record, attribute) # <--- Added
+      value = record.read_attribute_for_validation(attribute)
+      next if value.is_a?(NoBrainer::Document::AtomicOps::PendingAtomic) # <--- Added
+      next if (value.nil? && options[:allow_nil]) || (value.blank? && options[:allow_blank])
+      validate_each(record, attribute, value)
     end
   end
 end

data/lib/no_brainer/document.rb

@@ -4,8 +4,8 @@ module NoBrainer::Document
   extend ActiveSupport::Concern
   extend NoBrainer::Autoload
 
-  autoload_and_include :Core, :StoreIn, :InjectionLayer, :Attributes, :Readonly, :Validation,
-                       :Persistance, :Types, :Uniqueness, :Callbacks, :Dirty, :PrimaryKey,
+  autoload_and_include :Core, :StoreIn, :InjectionLayer, :Attributes, :Readonly,
+                       :Persistance, :Validation, :Types, :Callbacks, :Dirty, :PrimaryKey,
                        :Association, :Serialization, :Criteria, :Polymorphic, :Index, :Aliases,
                        :MissingAttributes, :LazyFetch, :AtomicOps
 

data/lib/no_brainer/error.rb

@@ -5,25 +5,13 @@ module NoBrainer::Error
   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 MissingAttribute        < RuntimeError; end
   class UnknownAttribute        < RuntimeError; end
   class AtomicBlock             < RuntimeError; end
-
-  class CannotReadAtomic < RuntimeError
-    attr_accessor :instance, :field, :value
-    def initialize(instance, field, value)
-      @instance = instance
-      @field = field
-      @value = value
-    end
-
-    def message
-      "Cannot read #{field}, atomic operations are pending"
-    end
-  end
+  class LostLock                < RuntimeError; end
+  class LockUnavailable         < RuntimeError; end
 
   class DocumentInvalid < RuntimeError
     attr_accessor :instance
@@ -37,23 +25,32 @@ module NoBrainer::Error
   end
 
   class InvalidType < RuntimeError
-    attr_accessor :attr_name, :value, :type
+    attr_accessor :model, :attr_name, :value, :type, :error
     def initialize(options={})
-      @attr_name = options[:attr_name]
-      @value     = options[:value]
-      @type      = options[:type]
+      update(options)
+    end
+
+    def update(options={})
+      options.assert_valid_keys(:model, :attr_name, :type, :value, :error)
+      options.each { |k,v| instance_variable_set("@#{k}", v) }
     end
 
     def human_type_name
       type.to_s.underscore.humanize.downcase
     end
 
+    def error
+      # dup because errors.add eventually .delete() on our option.
+      @error.nil? ? (type && { :type => human_type_name }) : @error.dup
+    end
+
     def message
-      if attr_name && type && value
-        "#{attr_name} should be used with a #{human_type_name}. Got `#{value}` (#{value.class})"
-      else
-        super
-      end
+      return super unless model && attr_name && error
+      value = self.value
+      mock = model.allocate
+      mock.singleton_class.send(:define_method, :read_attribute_for_validation) { |_| value }
+      mock.errors.add(attr_name, :invalid_type, error)
+      mock.errors.full_messages.first
     end
   end
 

data/lib/no_brainer/locale/en.yml

@@ -3,3 +3,4 @@ en:
     messages:
       taken: "is already taken"
       invalid_type: "should be a %{type}"
+      undefined: "must be defined"

data/lib/no_brainer/lock.rb

@@ -0,0 +1,114 @@
+require 'digest/sha1'
+
+class NoBrainer::Lock
+  include NoBrainer::Document
+
+  store_in :table => 'nobrainer_locks'
+
+  # Since PKs are limited to 127 characters, we can't use the user's key as a PK
+  # as it could be arbitrarily long.
+  field :key_hash,   :type => String, :primary_key => true, :default => ->{ Digest::SHA1.base64digest(key) }
+  field :key,        :type => String
+  field :token,      :type => String
+  field :expires_at, :type => Time
+
+  # We always use a new token, even when reading from the DB, because that's
+  # what represent our instance.
+  after_initialize { self.token = NoBrainer::Document::PrimaryKey::Generator.generate }
+
+  scope :expired, where(:expires_at.lt(RethinkDB::RQL.new.now))
+
+  def initialize(key, options={})
+    return super if options[:from_db]
+
+    key = case key
+      when Symbol then key.to_s
+      when String then key
+      else raise ArgumentError
+    end
+
+    super(options.merge(:key => key))
+  end
+
+  def lock(options={}, &block)
+    if block
+      lock(options)
+      return block.call.tap { unlock }
+    end
+
+    options.assert_valid_keys(:expire, :timeout)
+    timeout = NoBrainer::Config.lock_options.merge(options)[:timeout]
+    sleep_amount = 0.1
+
+    start_at = Time.now
+    while Time.now - start_at < timeout
+      return if try_lock(options.select { |k,_| k == :expire })
+      sleep(sleep_amount)
+      sleep_amount = [1, sleep_amount * 2].min
+    end
+
+    raise NoBrainer::Error::LockUnavailable.new("Lock on `#{key}' unavailable")
+  end
+
+  def try_lock(options={})
+    options.assert_valid_keys(:expire)
+    raise "Lock instance `#{key}' already locked" if @locked
+
+    set_expiration(options)
+
+    result = NoBrainer.run do |r|
+      selector.replace do |doc|
+        r.branch(doc.eq(nil).or(doc[:expires_at] < r.now),
+                 self.attributes, doc)
+      end
+    end
+
+    return @locked = (result['inserted'] + result['replaced']) == 1
+  end
+
+  def unlock
+    raise "Lock instance `#{key}' not locked" unless @locked
+
+    result = NoBrainer.run do |r|
+      selector.replace do |doc|
+        r.branch(doc[:token].eq(self.token),
+                 nil, doc)
+      end
+    end
+
+    @locked = false
+    raise NoBrainer::Error::LostLock.new("Lost lock on `#{key}'") unless result['deleted'] == 1
+  end
+
+  def refresh(options={})
+    options.assert_valid_keys(:expire)
+    raise "Lock instance `#{key}' not locked" unless @locked
+
+    set_expiration(options)
+
+    result = NoBrainer.run do |r|
+      selector.update do |doc|
+        r.branch(doc[:token].eq(self.token),
+                 { :expires_at => self.expires_at }, nil)
+      end
+    end
+
+    # Note: If we are too quick, expires_at may not change, and the returned
+    # 'replaced' won't be 1. We'll generate a spurious error. This is very
+    # unlikely to happen and should not harmful.
+    unless result['replaced'] == 1
+      @locked = false
+      raise NoBrainer::Error::LostLock.new("Lost lock on `#{key}'")
+    end
+  end
+
+  private
+
+  def set_expiration(options)
+    expire = NoBrainer::Config.lock_options.merge(options)[:expire]
+    self.expires_at = RethinkDB::RQL.new.now + expire
+  end
+
+  def save?; raise; end
+  def delete; raise; end
+end

data/lib/no_brainer/query_runner/database_on_demand.rb

@@ -10,7 +10,6 @@ class NoBrainer::QueryRunner::DatabaseOnDemand < NoBrainer::QueryRunner::Middlew
   end
 
   def handle_database_on_demand_exception?(env, e)
-    (NoBrainer::Config.auto_create_databases || env[:auto_create_databases]) &&
     e.message =~ /^Database `(.+)` does not exist\.$/ && $1
   end
 

data/lib/no_brainer/query_runner/missing_index.rb

@@ -11,7 +11,7 @@ class NoBrainer::QueryRunner::MissingIndex < NoBrainer::QueryRunner::Middleware
       index = model.indexes.values.select { |i| i.aliased_name == index_name.to_sym }.first if model
       index_name = index.name if index
 
-      if model.try(:pk_name).try(:to_s) == index_name
+      if model.try(:pk_name).try(:to_s) == index_name.to_s
         err_msg  = "Please update the primary key `#{index_name}` in the table `#{database_name}.#{table_name}`."
       else
         err_msg  = "Please run `NoBrainer.sync_indexes' or `rake nobrainer:sync_indexes' to create the index `#{index_name}`"

data/lib/no_brainer/query_runner/run_options.rb

@@ -30,9 +30,6 @@ class NoBrainer::QueryRunner::RunOptions < NoBrainer::QueryRunner::Middleware
 
     env[:criteria] = env[:options].delete(:criteria)
 
-    env[:auto_create_tables] = env[:options].delete(:auto_create_tables)
-    env[:auto_create_databases] = env[:options].delete(:auto_create_databases)
-
     @runner.call(env)
   end
 end

data/lib/no_brainer/query_runner/table_on_demand.rb

@@ -10,15 +10,14 @@ class NoBrainer::QueryRunner::TableOnDemand < NoBrainer::QueryRunner::Middleware
   end
 
   def handle_table_on_demand_exception?(env, e)
-    (NoBrainer::Config.auto_create_tables || env[:auto_create_tables]) &&
     e.message =~ /^Table `(.+)\.(.+)` does not exist\.$/ && [$1, $2]
   end
 
   private
 
   def auto_create_table(env, database_name, table_name)
-    model = NoBrainer::Document::Index::MetaStore if table_name == 'nobrainer_index_meta'
-    model ||= NoBrainer::Document.all.select { |m| m.table_name == table_name }.first
+    model ||= NoBrainer::Document::Core._all.select { |m| m.table_name == table_name }.first
+    model ||= NoBrainer::Document::Core._all_nobrainer.select { |m| m.table_name == table_name }.first
 
     if model.nil?
       raise "Auto table creation is not working for `#{database_name}.#{table_name}` -- Can't find the corresponding model."

data/lib/no_brainer/rql.rb

@@ -27,8 +27,4 @@ module NoBrainer::RQL
       :read
     end
   end
-
-  def is_table?(rql)
-    rql.body.first == TABLE
-  end
 end

data/lib/nobrainer.rb

@@ -13,7 +13,7 @@ module NoBrainer
 
   # 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, :Geo
+  autoload :Document, :IndexManager, :Loader, :Fork, :Geo, :Lock
   eager_autoload :Config, :Connection, :ConnectionManager,  :Error,
                  :QueryRunner, :Criteria, :RQL
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: nobrainer
 version: !ruby/object:Gem::Version
-  version: 0.20.0
+  version: 0.22.0
 platform: ruby
 authors:
 - Nicolas Viennot
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-12-03 00:00:00.000000000 Z
+date: 2015-03-07 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rethinkdb
@@ -100,14 +100,15 @@ files:
 - lib/no_brainer/criteria/core.rb
 - lib/no_brainer/criteria/count.rb
 - lib/no_brainer/criteria/delete.rb
+- lib/no_brainer/criteria/eager_load.rb
 - lib/no_brainer/criteria/enumerable.rb
 - lib/no_brainer/criteria/extend.rb
+- lib/no_brainer/criteria/find.rb
 - lib/no_brainer/criteria/first.rb
 - lib/no_brainer/criteria/index.rb
 - lib/no_brainer/criteria/limit.rb
 - lib/no_brainer/criteria/order_by.rb
 - lib/no_brainer/criteria/pluck.rb
-- lib/no_brainer/criteria/preload.rb
 - lib/no_brainer/criteria/raw.rb
 - lib/no_brainer/criteria/scope.rb
 - lib/no_brainer/criteria/update.rb
@@ -149,13 +150,16 @@ files:
 - lib/no_brainer/document/types/boolean.rb
 - lib/no_brainer/document/types/date.rb
 - lib/no_brainer/document/types/float.rb
+- lib/no_brainer/document/types/geo.rb
 - lib/no_brainer/document/types/integer.rb
 - lib/no_brainer/document/types/set.rb
 - lib/no_brainer/document/types/string.rb
 - lib/no_brainer/document/types/symbol.rb
+- lib/no_brainer/document/types/text.rb
 - lib/no_brainer/document/types/time.rb
-- lib/no_brainer/document/uniqueness.rb
 - lib/no_brainer/document/validation.rb
+- lib/no_brainer/document/validation/not_null.rb
+- lib/no_brainer/document/validation/uniqueness.rb
 - lib/no_brainer/error.rb
 - lib/no_brainer/fork.rb
 - lib/no_brainer/geo.rb
@@ -166,6 +170,7 @@ files:
 - lib/no_brainer/geo/polygon.rb
 - lib/no_brainer/loader.rb
 - lib/no_brainer/locale/en.yml
+- lib/no_brainer/lock.rb
 - lib/no_brainer/query_runner.rb
 - lib/no_brainer/query_runner/connection_lock.rb
 - lib/no_brainer/query_runner/database_on_demand.rb

data/lib/no_brainer/criteria/preload.rb

@@ -1,44 +0,0 @@
-module NoBrainer::Criteria::Preload
-  extend ActiveSupport::Concern
-
-  included { criteria_option :preload, :merge_with => :append_array }
-
-  def preload(*values)
-    chain({:preload => values}, :copy_cache_from => self)
-  end
-
-  def merge!(criteria, options={})
-    super.tap do
-      # XXX Not pretty hack
-      if criteria.options[:preload].present? && criteria.cached?
-        perform_preloads(@cache)
-      end
-    end
-  end
-
-  def each(options={}, &block)
-    return super unless should_preloads? && !options[:no_preloading] && block
-
-    docs = []
-    super(options.merge(:no_preloading => true)) { |doc| docs << doc }
-    perform_preloads(docs)
-    docs.each(&block)
-    self
-  end
-
-  private
-
-  def should_preloads?
-    @options[:preload].present? && !raw?
-  end
-
-  def get_one(criteria)
-    super.tap { |doc| perform_preloads([doc]) }
-  end
-
-  def perform_preloads(docs)
-    if should_preloads? && docs.present?
-      NoBrainer::Document::Association::EagerLoader.new.eager_load(docs, @options[:preload])
-    end
-  end
-end