nobrainer 0.18.0 → 0.22.0

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

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

data/lib/no_brainer/error.rb

@@ -5,24 +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
@@ -36,19 +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
-      "#{attr_name} should be used with a #{human_type_name}. Got `#{value}` (#{value.class})"
+      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/geo/base.rb

@@ -0,0 +1,16 @@
+module NoBrainer::Geo::Base
+  extend ActiveSupport::Concern
+
+  def self.normalize_geo_options(options)
+    options = options.symbolize_keys
+
+    geo_system  = options.delete(:geo_system) || NoBrainer::Config.geo_options[:geo_system]
+    unit        = options.delete(:unit) || NoBrainer::Config.geo_options[:unit]
+
+    options[:unit] = unit if unit && unit.to_s != 'm'
+    options[:geo_system] = geo_system if geo_system && geo_system.to_s != 'WGS84'
+    options[:max_dist] = options.delete(:max_distance) if options[:max_distance]
+
+    options
+  end
+end

data/lib/no_brainer/geo/circle.rb

@@ -0,0 +1,25 @@
+class NoBrainer::Geo::Circle < Struct.new(:center, :radius, :options)
+  include NoBrainer::Geo::Base
+
+  def initialize(*args)
+    options = args.extract_options!
+    options = NoBrainer::Geo::Base.normalize_geo_options(options)
+
+    raise NoBrainer::Error::InvalidType if args.size > 2
+    center = args[0] || options.delete(:center)
+    radius = args[1] || options.delete(:radius)
+
+    center = NoBrainer::Geo::Point.nobrainer_cast_user_to_model(center)
+    radius = Float.nobrainer_cast_user_to_model(radius)
+
+    self.center = center
+    self.radius = radius
+    self.options = options
+  end
+
+  def to_rql
+    RethinkDB::RQL.new.circle(center.to_rql, radius, options)
+  end
+
+  # No DB serialization, can't store circles.
+end

data/lib/no_brainer/geo/line_string.rb

@@ -0,0 +1,11 @@
+class NoBrainer::Geo::LineString < Struct.new(:points)
+  include NoBrainer::Geo::Base
+
+  def initialize(*points)
+    self.points = points.map { |p| NoBrainer::Geo::Point.nobrainer_cast_user_to_model(p) }
+  end
+
+  def to_rql
+    RethinkDB::RQL.new.line(points.map(&:to_rql))
+  end
+end

data/lib/no_brainer/geo/point.rb

@@ -0,0 +1,49 @@
+require 'no_brainer/document/types/float'
+
+class NoBrainer::Geo::Point < Struct.new(:longitude, :latitude)
+  include NoBrainer::Geo::Base
+
+  def initialize(*args)
+    if args.size == 2
+      longitude, latitude = args
+    elsif args.size == 1 && args.first.is_a?(self.class)
+      longitude, latitude = args.first.longitude, args.first.latitude
+    elsif args.size == 1 && args.first.is_a?(Hash)
+      opt = args.first.symbolize_keys
+      longitude, latitude = opt[:longitude] || opt[:long], opt[:latitude] || opt[:lat]
+    else
+      raise NoBrainer::Error::InvalidType
+    end
+
+    longitude = Float.nobrainer_cast_user_to_model(longitude)
+    latitude  = Float.nobrainer_cast_user_to_model(latitude)
+
+    raise NoBrainer::Error::InvalidType unless (-180..180).include?(longitude)
+    raise NoBrainer::Error::InvalidType unless (-90..90).include?(latitude)
+
+    self.longitude = longitude
+    self.latitude = latitude
+  end
+
+  def to_rql
+    RethinkDB::RQL.new.point(longitude, latitude)
+  end
+
+  def to_s
+    [longitude, latitude].inspect
+  end
+  alias_method :inspect, :to_s
+
+  def self.nobrainer_cast_user_to_model(value)
+    value.is_a?(Array) ? new(*value) : new(value)
+  end
+
+  def self.nobrainer_cast_db_to_model(value)
+    return value unless value.is_a?(Hash) && value['coordinates'].is_a?(Array) && value['coordinates'].size == 2
+    new(value['coordinates'][0], value['coordinates'][1])
+  end
+
+  def self.nobrainer_cast_model_to_db(value)
+    value.is_a?(self) ? value.to_rql : value
+  end
+end

data/lib/no_brainer/geo/polygon.rb

@@ -0,0 +1,11 @@
+class NoBrainer::Geo::Polygon < Struct.new(:points)
+  include NoBrainer::Geo::Base
+
+  def initialize(*points)
+    self.points = points.map { |p| NoBrainer::Geo::Point.nobrainer_cast_user_to_model(p) }
+  end
+
+  def to_rql
+    RethinkDB::RQL.new.polygon(points.map(&:to_rql))
+  end
+end

data/lib/no_brainer/geo.rb

@@ -0,0 +1,4 @@
+module NoBrainer::Geo
+  extend NoBrainer::Autoload
+  autoload :Base, :Point, :Circle, :LineString, :Polygon
+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/connection_lock.rb

@@ -3,7 +3,7 @@ class NoBrainer::QueryRunner::ConnectionLock < NoBrainer::QueryRunner::Middlewar
 
   def call(env)
     if NoBrainer::Config.per_thread_connection
-      @runner.call(env) 
+      @runner.call(env)
     else
       @@lock.synchronize { @runner.call(env) }
     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/reconnect.rb

@@ -18,18 +18,16 @@ class NoBrainer::QueryRunner::Reconnect < NoBrainer::QueryRunner::Middleware
   private
 
   def reconnect(e, context)
-    begin
-      return false if context[:retries].zero?
-      context[:retries] -= 1
+    return false if context[:retries].zero?
+    context[:retries] -= 1
 
-      warn_reconnect(e)
-      sleep 1
-      NoBrainer.connection.reconnect(:noreply_wait => false)
-      return true
-    rescue StandardError => e
-      retry if is_connection_error_exception?(e)
-      raise
-    end
+    warn_reconnect(e)
+    sleep 1
+    NoBrainer.connection.reconnect(:noreply_wait => false)
+    true
+  rescue StandardError => e
+    retry if is_connection_error_exception?(e)
+    raise
   end
 
   def is_connection_error_exception?(e)

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."
@@ -30,7 +29,7 @@ class NoBrainer::QueryRunner::TableOnDemand < NoBrainer::QueryRunner::Middleware
     env[:last_auto_create_table] = [database_name, table_name]
 
     NoBrainer.with_database(database_name) do
-      NoBrainer.table_create(table_name, :primary_key => model.pk_name)
+      NoBrainer.table_create(table_name, :primary_key => model.lookup_field_alias(model.pk_name))
     end
   rescue RuntimeError => e
     # We might have raced with another table create

data/lib/no_brainer/railtie/database.rake

@@ -19,10 +19,10 @@ namespace :nobrainer do
   end
 
   desc 'Equivalent to :sync_indexes_quiet + :seed'
-  task :setup => [ :sync_indexes_quiet, :seed ]
+  task :setup => [:sync_indexes_quiet, :seed]
 
   desc 'Equivalent to :drop + :setup'
-  task :reset => [ :drop, :setup ]
+  task :reset => [:drop, :setup]
 
   task :create => :environment do
     # noop

data/lib/no_brainer/rql.rb

@@ -19,7 +19,7 @@ module NoBrainer::RQL
     case rql_query.body.first
     when UPDATE, DELETE, REPLACE, INSERT
       :write
-    when DB_CREATE,DB_DROP, DB_LIST, TABLE_CREATE, TABLE_DROP, TABLE_LIST, SYNC,
+    when DB_CREATE, DB_DROP, DB_LIST, TABLE_CREATE, TABLE_DROP, TABLE_LIST, SYNC,
          INDEX_CREATE, INDEX_DROP, INDEX_LIST, INDEX_STATUS, INDEX_WAIT
       :management
     else
@@ -27,8 +27,4 @@ module NoBrainer::RQL
       :read
     end
   end
-
-  def is_table?(rql)
-    rql.body.first == TABLE
-  end
 end

data/lib/nobrainer.rb

@@ -1,5 +1,6 @@
 require 'set'
 require 'active_support'
+require 'thread'
 %w(module/delegation module/attribute_accessors module/introspection
    class/attribute object/blank object/inclusion object/deep_dup
    object/try hash/keys hash/indifferent_access hash/reverse_merge
@@ -12,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, :DecoratedSymbol
+  autoload :Document, :IndexManager, :Loader, :Fork, :Geo, :Lock
   eager_autoload :Config, :Connection, :ConnectionManager,  :Error,
                  :QueryRunner, :Criteria, :RQL
 
@@ -31,13 +32,8 @@ module NoBrainer
     def jruby?
       RUBY_PLATFORM == 'java'
     end
-
-    def user_caller
-      caller.reject { |s| s =~ /\/no_brainer\// }.first
-    end
   end
 
-  DecoratedSymbol.hook
   Fork.hook unless jruby?
 end
 

data/lib/rails/generators/nobrainer.rb

@@ -12,7 +12,7 @@ module NoBrainer::Generators
     end
 
     def self.namespace
-      super.gsub(/no_brainer/,'nobrainer')
+      super.gsub(/no_brainer/, 'nobrainer')
     end
   end
 end