nobrainer 0.29.0 → 0.30.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 9fbf539d3fd47eeec38c4ae88843297a7462efb5
-  data.tar.gz: e02bde6490ffc0eb21bf3fde637dc6a4dea0350d
+  metadata.gz: ebe188d50e06d6ef907cdf043560143e3bd7d703
+  data.tar.gz: 15b1580f27a66b6670386cc117b4767f930e67c7
 SHA512:
-  metadata.gz: 586f87afabedec2bc9716949298255c6456b7cbf9846a6b9e3090fe009cf481d68fd3eb852368a2658f1e4b59e432388f690cd2fce24606460229dbad1daf633
-  data.tar.gz: d55889b76d3a1e6dd48338fca51eb1ad636baa00bc20c21a992cf8e5e6d02a4f958f535dc95398a89c3695ceab87cf5ededbd915ac3b0f07f041dda16148e913
+  metadata.gz: ff9b387f2045109c33efb88d36273325edf34573acb134bbb94d3d2e04c1efd6fdf65b761739eac61c185309cfa9deba5a07987fdf56becf3d78308b300838b9
+  data.tar.gz: acb0f33b44d27ac25599352b0d568dd563e13a81da91b0dfef6cf72596a1500026e739f2cc64c63e22edc72ddb57ee3b61a70acf72c139cd502f0b1d95e78c9b

data/lib/no_brainer/criteria.rb

@@ -2,8 +2,9 @@ require 'rethinkdb'
 
 class NoBrainer::Criteria
   extend NoBrainer::Autoload
-  autoload_and_include :Core, :Run, :Raw, :Scope, :AfterFind, :Where, :OrderBy,
-                       :Limit, :Pluck, :Count, :Delete, :Enumerable, :Find,
-                       :First, :FirstOrCreate, :Changes, :Aggregate, :EagerLoad,
-                       :Update, :Cache, :Index, :Extend, :Join
+  autoload_and_include :Core, :Run, :Raw, :VirtualAttributes, :Scope,
+                       :AfterFind, :Where, :OrderBy, :Limit, :Pluck, :Count,
+                       :Delete, :Enumerable, :Find, :First, :FirstOrCreate,
+                       :Changes, :Aggregate, :EagerLoad, :Update, :Cache,
+                       :Index, :Extend, :Join
 end

data/lib/no_brainer/criteria/first_or_create.rb

@@ -38,7 +38,11 @@ module NoBrainer::Criteria::FirstOrCreate
 
   def _first_or_create(create_params, save_options, &block)
     raise "Cannot use .raw() with .first_or_create()" if raw?
-    raise "Use first_or_create() on the root class `#{model.root_class}'" unless model.is_root_class?
+
+    if block && block.arity == 1
+      raise "When passing a block to first_or_create(), you must pass a block with no arguments.\n" +
+            "The passed block must return a hash of additional attributes for create()"
+    end
 
     save_method = save_options.delete(:save_method)
     should_update = save_options.delete(:update)
@@ -62,6 +66,25 @@ module NoBrainer::Criteria::FirstOrCreate
         "\nend"
     end
 
+    unless model.is_root_class? || (model.superclass.fields.keys & keys).empty?
+      # We can't allow the parent to share the keys we are matching on.
+      # Consider this case:
+      # - Base has the field :name, :uniq => true declared
+      # - A < Base
+      # - B < Base
+      # - A.create(:name => 'x'),
+      # - B.where(:name => 'x').first_or_create
+      # We are forced to return nil, or raise.
+      parent = model
+      parent = parent.superclass while parent.superclass < NoBrainer::Document &&
+                                      !(parent.superclass.fields.keys & keys).empty?
+      raise "A polymorphic problem has been detected: The fields `#{keys.inspect}' are defined on `#{parent}'.\n" +
+            "This is problematic as first_or_create() could return nil in some cases.\n" +
+            "Either 1) Only define `#{keys.inspect}' on `#{model}', \n" +
+            "or     2) Query the superclass, and pass :_type in first_or_create() as such:\n" +
+            "          `#{parent}.where(...).first_or_create(:_type => \"#{model}\")'."
+    end
+
     # We don't want to access create_params yet, because invoking the block
     # might be costly (the user might be doing some API call or w/e), and
     # so we want to invoke the block only if necessary.
@@ -108,18 +131,22 @@ module NoBrainer::Criteria::FirstOrCreate
     where_clauses = finalized_criteria.options[:where_ast]
 
     unless where_clauses.is_a?(NoBrainer::Criteria::Where::MultiOperator) &&
-           where_clauses.op == :and && where_clauses.clauses.size > 0 &&
-           where_clauses.clauses.all? do |c|
-             c.is_a?(NoBrainer::Criteria::Where::BinaryOperator) &&
-             c.op == :eq && c.key_modifier == :scalar
-           end
+           where_clauses.op == :and
       raise "Please use a query of the form `.where(...).first_or_create(...)'"
     end
 
     Hash[where_clauses.clauses.map do |c|
+      unless c.is_a?(NoBrainer::Criteria::Where::BinaryOperator) &&
+             c.op == :eq && c.key_modifier == :scalar
+        # Ignore params on the subclass type, we are handling this case directly
+        # in _first_or_create()
+        next if c.key_path == [:_type]
+        raise "Please only use equal constraints in your where() query when using first_or_create()"
+      end
+
       raise "You may not use nested hash queries with first_or.create()" if c.key_path.size > 1
       [c.key_path.first.to_sym, c.value]
-    end]
+    end.compact].tap { |h| raise "Missing where() clauses for first_or_create()" if h.empty? }
   end
 
   def get_model_unique_fields

data/lib/no_brainer/criteria/join.rb

@@ -53,9 +53,10 @@ module NoBrainer::Criteria::Join
     join_ast.reduce(super) do |rql, (association, criteria)|
       rql.concat_map do |doc|
         key = doc[association.eager_load_owner_key]
-        criteria.where(association.eager_load_target_key => key).to_rql.map do |assoc_doc|
-          doc.merge(association.target_name => assoc_doc)
-        end
+        RethinkDB::RQL.new.branch(key.eq(nil), [],
+          criteria.where(association.eager_load_target_key => key).to_rql.map do |assoc_doc|
+            doc.merge(association.target_name => assoc_doc)
+        end)
       end
     end
   end

data/lib/no_brainer/criteria/virtual_attributes.rb

@@ -0,0 +1,18 @@
+module NoBrainer::Criteria::VirtualAttributes
+  extend ActiveSupport::Concern
+
+  def compile_rql_pass2
+    rql = super
+
+    if model.virtual_fields
+      rql = rql.map do |_doc|
+        model.virtual_fields.reduce(_doc) do |doc, field|
+          field_rql = model.fields[field][:virtual].call(doc, RethinkDB::RQL.new)
+          field_rql.nil? ? doc : doc.merge(field => field_rql)
+        end
+      end
+    end
+
+    rql
+  end
+end

data/lib/no_brainer/criteria/where.rb

@@ -195,11 +195,12 @@ module NoBrainer::Criteria::Where
         else
           # 1) Box value in array if we have an any/all modifier
           # 2) Box value in hash if we have a nested query.
-          value = [value] if key_modifier.in?([:any, :all])
+          box_value = key_modifier.in?([:any, :all]) || op == :include
+          value = [value] if box_value
           value_hash = key_path.reverse.reduce(value) { |v,k| {k => v} }
           value = model.cast_user_to_db_for(*value_hash.first)
           value = key_path[1..-1].reduce(value) { |h,k| h[k] }
-          value = value.first if key_modifier.in?([:any, :all])
+          value = value.first if box_value
           value
         end
       end

data/lib/no_brainer/document.rb

@@ -7,7 +7,7 @@ module NoBrainer::Document
   autoload_and_include :Core, :TableConfig, :InjectionLayer, :Attributes, :Readonly,
                        :Persistance, :Callbacks, :Validation, :Types, :Dirty, :PrimaryKey,
                        :Association, :Serialization, :Criteria, :Polymorphic, :Index, :Aliases,
-                       :MissingAttributes, :LazyFetch, :AtomicOps
+                       :MissingAttributes, :LazyFetch, :AtomicOps, :VirtualAttributes
 
   autoload :DynamicAttributes, :Timestamps
 

data/lib/no_brainer/document/attributes.rb

@@ -2,7 +2,7 @@ module NoBrainer::Document::Attributes
   VALID_FIELD_OPTIONS = [:index, :default, :type, :readonly, :primary_key,
                          :lazy_fetch, :store_as, :validates, :required, :unique,
                          :uniq, :format, :in, :length, :min_length, :max_length,
-                         :prefix, :suffix]
+                         :prefix, :suffix, :virtual]
   RESERVED_FIELD_NAMES = [:index, :default, :and, :or, :selector, :associations, :pk_value] +
                           NoBrainer::SymbolDecoration::OPERATORS
 

data/lib/no_brainer/document/index.rb

@@ -15,6 +15,7 @@ module NoBrainer::Document::Index
       name = case name
         when String then name.to_sym
         when Symbol then name
+        when Array  then args.unshift(name); name.map(&:to_s).join('_').to_sym
         else raise ArgumentError, "Incorrect index specification"
       end
 

data/lib/no_brainer/document/persistance.rb

@@ -18,18 +18,13 @@ module NoBrainer::Document::Persistance
     !new_record? && !destroyed?
   end
 
-  def _reload_selector(options={})
-    rql = selector
+  def _reload(options={})
+    criteria = root_class.raw
     if opt = options[:missing_attributes]
-      rql = rql.pluck(self.class.with_fields_aliased(opt[:pluck])) if opt[:pluck]
-      rql = rql.without(self.class.with_fields_aliased(opt[:without])) if opt[:without]
+      criteria = criteria.pluck(opt[:pluck]) if opt[:pluck]
+      criteria = criteria.without(opt[:without]) if opt[:without]
     end
-    rql
-  end
-
-  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
+    attrs = criteria.find(pk_value)
 
     options = options.merge(:pristine => true, :from_db => true)
 
@@ -60,7 +55,7 @@ module NoBrainer::Document::Persistance
   end
 
   def _create(options={})
-    attrs = self.class.persistable_attributes(@_attributes, :instance => self)
+    attrs = self.class.persistable_attributes(@_attributes)
     result = NoBrainer.run(self.class.rql_table.insert(attrs))
     self.pk_value ||= result['generated_keys'].to_a.first
     @new_record = false
@@ -69,7 +64,7 @@ module NoBrainer::Document::Persistance
   end
 
   def _update(attrs)
-    rql = ->(doc){ self.class.persistable_attributes(attrs, :instance => self, :rql_doc => doc) }
+    rql = ->(doc){ self.class.persistable_attributes(attrs, :rql_doc => doc) }
     NoBrainer.run { selector.update(&rql) }
   end
 

data/lib/no_brainer/document/virtual_attributes.rb

@@ -0,0 +1,52 @@
+module NoBrainer::Document::VirtualAttributes
+  extend NoBrainer::Autoload
+  extend ActiveSupport::Concern
+
+  VALID_VIRTUAL_FIELD_OPTIONS = [:type, :lazy_fetch, :virtual]
+
+  included do
+    cattr_accessor :virtual_fields, :instance_accessor => false
+  end
+
+  module ClassMethods
+    def virtual_field(attr, rql=nil, options={}, &block)
+      rql, options = nil, rql if rql.is_a?(Hash)
+      rql ||= block
+      rql_proc = rql.is_a?(Proc) ? rql : proc { rql }
+      field(attr, options.merge(:virtual => rql_proc))
+    end
+
+    def field(attr, options={})
+      return super unless options.key?(:virtual)
+
+      raise "virtual attributes are limited to the root class `#{self.root_class}' for the moment.\n" +
+            "Ask on GitHub for polymorphic support." unless is_root_class?
+
+      raise "You cannot index a virtual attribute. Use an index with a lambda expression instead" if options[:index]
+      options.assert_valid_keys(*VALID_VIRTUAL_FIELD_OPTIONS)
+
+      self.virtual_fields ||= Set.new
+      virtual_fields << attr
+
+      inject_in_layer :virtual_attributes do
+        define_method("#{attr}=") do |value|
+          raise NoBrainer::Error::ReadonlyField.new("#{attr} is a virtual attribute and thus readonly.")
+        end
+      end
+
+      super
+    end
+
+    def remove_field(attr, options={})
+      super
+
+      if fields[:virtual]
+        virtual_fields.try(:delete, attr)
+
+        inject_in_layer :virtual_attributes do
+          remove_method("#{attr}=")
+        end
+      end
+    end
+  end
+end

data/lib/no_brainer/error.rb

@@ -11,6 +11,7 @@ module NoBrainer::Error
   class UnknownAttribute        < RuntimeError; end
   class AtomicBlock             < RuntimeError; end
   class LostLock                < RuntimeError; end
+  class LockInvalidOp           < RuntimeError; end
   class LockUnavailable         < RuntimeError; end
   class InvalidPolymorphicType  < RuntimeError; end
 

data/lib/no_brainer/lock.rb

@@ -7,27 +7,33 @@ class NoBrainer::Lock
 
   # 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 }
+  field :key_hash,       :type => String, :primary_key => true, :default => ->{ Digest::SHA1.base64digest(key.to_s) }
+  field :key,            :type => String
+  field :instance_token, :type => String, :default => ->{ get_new_instance_token }
+  field :expires_at,     :type => Time
 
   scope :expired, where(:expires_at.lt(RethinkDB::RQL.new.now))
 
-  def initialize(key, options={})
-    return super if options[:from_db]
+  def self.find(key)
+    super(Digest::SHA1.base64digest(key.to_s))
+  end
 
-    key = case key
-      when Symbol then key.to_s
-      when String then key
-      else raise ArgumentError
+  def initialize(key, options={})
+    if options[:from_db]
+      super
+      # We reset our instance_token to allow recoveries.
+      self.instance_token = get_new_instance_token
+    else
+      @default_options = options.slice(:expire, :timeout)
+      options.delete(:expire); options.delete(:timeout);
+
+      super(options.merge(:key => key))
+      raise ArgumentError unless valid?
     end
+  end
 
-    super(options.merge(:key => key))
+  def get_new_instance_token
+    NoBrainer::Document::PrimaryKey::Generator.generate
   end
 
   def synchronize(options={}, &block)
@@ -41,22 +47,21 @@ class NoBrainer::Lock
 
   def lock(options={})
     options.assert_valid_keys(:expire, :timeout)
-    timeout = NoBrainer::Config.lock_options.merge(options)[:timeout]
+    timeout = get_option_value(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 })
+    loop do
+      return if try_lock(options.slice(:expire))
+      raise_lock_unavailable! if Time.now - start_at + sleep_amount > timeout
       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
+    raise_if_locked!
 
     set_expiration(options)
 
@@ -71,28 +76,28 @@ class NoBrainer::Lock
   end
 
   def unlock
-    raise "Lock instance `#{key}' not locked" unless @locked
+    raise_unless_locked!
 
     result = NoBrainer.run do |r|
       selector.replace do |doc|
-        r.branch(doc[:token].eq(self.token),
+        r.branch(doc[:instance_token].default(nil).eq(self.instance_token),
                  nil, doc)
       end
     end
 
     @locked = false
-    raise NoBrainer::Error::LostLock.new("Lost lock on `#{key}'") unless result['deleted'] == 1
+    raise_lost_lock! unless result['deleted'] == 1
   end
 
   def refresh(options={})
     options.assert_valid_keys(:expire)
-    raise "Lock instance `#{key}' not locked" unless @locked
+    raise_unless_locked!
 
-    set_expiration(options)
+    set_expiration(options.merge(:use_previous_expire => true))
 
     result = NoBrainer.run do |r|
       selector.update do |doc|
-        r.branch(doc[:token].eq(self.token),
+        r.branch(doc[:instance_token].eq(self.instance_token),
                  { :expires_at => self.expires_at }, nil)
       end
     end
@@ -102,7 +107,7 @@ class NoBrainer::Lock
     # unlikely to happen and should not harmful.
     unless result['replaced'] == 1
       @locked = false
-      raise NoBrainer::Error::LostLock.new("Lost lock on `#{key}'")
+      raise_lost_lock!
     end
   end
 
@@ -112,7 +117,29 @@ class NoBrainer::Lock
   private
 
   def set_expiration(options)
-    expire = NoBrainer::Config.lock_options.merge(options)[:expire]
+    expire = @previous_expire if options[:use_previous_expire] && !options[:expire]
+    expire ||= get_option_value(options, :expire)
+    @previous_expire = expire
     self.expires_at = RethinkDB::RQL.new.now + expire
   end
+
+  def get_option_value(options, key)
+    NoBrainer::Config.lock_options.merge(@default_options || {}).merge(options)[key]
+  end
+
+  def raise_if_locked!
+    raise NoBrainer::Error::LockInvalidOp.new("Lock instance `#{key}' already locked") if @locked
+  end
+
+  def raise_unless_locked!
+    raise NoBrainer::Error::LockInvalidOp.new("Lock instance `#{key}' not locked") unless @locked
+  end
+
+  def raise_lost_lock!
+    raise NoBrainer::Error::LostLock.new("Lost lock on `#{key}'")
+  end
+
+  def raise_lock_unavailable!
+    raise NoBrainer::Error::LockUnavailable.new("Lock on `#{key}' unavailable")
+  end
 end

data/lib/no_brainer/profiler/controller_runtime.rb

@@ -47,6 +47,8 @@ module NoBrainer::Profiler::ControllerRuntime
   end
 
   def cleanup_view_runtime
+    return super unless Profiler.current
+
     time_spent_in_db_before_views = Profiler.current.total_duration
     runtime = super
     time_spent_in_db_after_views = Profiler.current.total_duration

data/lib/no_brainer/reentrant_lock.rb

@@ -0,0 +1,36 @@
+class NoBrainer::ReentrantLock < NoBrainer::Lock
+  field :lock_count, :type => Integer
+
+  def try_lock(options={})
+    options.assert_valid_keys(:expire)
+    set_expiration(options)
+
+    result = NoBrainer.run do |r|
+      selector.replace do |doc|
+        r.branch(doc[:instance_token].default(nil).eq(self.instance_token),
+                 doc.merge(:expires_at => self.expires_at,
+                           :lock_count => doc[:lock_count] + 1),
+                 r.branch(doc.eq(nil).or(doc[:expires_at] < r.now),
+                          self.attributes.merge(:lock_count => 1), doc))
+      end
+    end
+
+    @locked = true # to make refresh() and synchronize() happy, somewhat hacky
+    return (result['inserted'] + result['replaced']) == 1
+  end
+
+  def unlock
+    set_expiration(:use_previous_expire => true)
+
+    result = NoBrainer.run do |r|
+      selector.replace do |doc|
+        r.branch(doc[:instance_token].default(nil).eq(self.instance_token),
+                 r.branch(doc[:lock_count] > 1,
+                          doc.merge(:expires_at => self.expires_at,
+                                    :lock_count => doc[:lock_count] - 1), nil), doc)
+      end
+    end
+
+    raise_lost_lock! unless (result['deleted'] + result['replaced']) == 1
+  end
+end

data/lib/nobrainer.rb

@@ -16,7 +16,7 @@ module NoBrainer
   # Code that is loaded through the DSL of NoBrainer should not be eager loaded.
   autoload :Document, :IndexManager, :Loader, :Fork, :Geo, :SymbolDecoration
   eager_autoload :Config, :Connection, :ConnectionManager, :Error,
-                 :QueryRunner, :Criteria, :RQL, :Lock, :Profiler, :System
+                 :QueryRunner, :Criteria, :RQL, :Lock, :ReentrantLock, :Profiler, :System
 
   class << self
     delegate :connection, :disconnect, :to => 'NoBrainer::ConnectionManager'

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: nobrainer
 version: !ruby/object:Gem::Version
-  version: 0.29.0
+  version: 0.30.0
 platform: ruby
 authors:
 - Nicolas Viennot
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-08-19 00:00:00.000000000 Z
+date: 2015-10-03 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rethinkdb
@@ -116,6 +116,7 @@ files:
 - lib/no_brainer/criteria/run.rb
 - lib/no_brainer/criteria/scope.rb
 - lib/no_brainer/criteria/update.rb
+- lib/no_brainer/criteria/virtual_attributes.rb
 - lib/no_brainer/criteria/where.rb
 - lib/no_brainer/document.rb
 - lib/no_brainer/document/aliases.rb
@@ -167,6 +168,7 @@ files:
 - lib/no_brainer/document/validation/core.rb
 - lib/no_brainer/document/validation/not_null.rb
 - lib/no_brainer/document/validation/uniqueness.rb
+- lib/no_brainer/document/virtual_attributes.rb
 - lib/no_brainer/error.rb
 - lib/no_brainer/fork.rb
 - lib/no_brainer/geo.rb
@@ -194,6 +196,7 @@ files:
 - lib/no_brainer/query_runner/write_error.rb
 - lib/no_brainer/railtie.rb
 - lib/no_brainer/railtie/database.rake
+- lib/no_brainer/reentrant_lock.rb
 - lib/no_brainer/rql.rb
 - lib/no_brainer/symbol_decoration.rb
 - lib/no_brainer/system.rb