nobrainer 0.18.1 → 0.19.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 1d6a500e008eff372e800b011e917d121c07e00a
-  data.tar.gz: e43be89ac4963422c26559727c9a68011ee25f8a
+  metadata.gz: 5dc33c00dc3aa418ae3bd36b0ccb2618a8c0e47f
+  data.tar.gz: 3a4c171e4c41341d14a3c4b6103b463be1b12701
 SHA512:
-  metadata.gz: 56015e819aba3537ab60ea5f039d4b391ec803cc61b5bf246e44da642787e62606e9c02339b17f05976d5428ec3e4fa0e335cb51694b840bd2ba7821b6d66b20
-  data.tar.gz: d4b78185fed14f5baa28165462a4088096da640d93c0dfb3f20c851e968deceb1f48f13602850075a7eea2408fa23e52c2694d140bea1c9a937d7d49d5084f53
+  metadata.gz: 70af56ece8a93103f310a729c338631e0bc56b52d4725ea2a304dfdb389e04fb530fda2b3d8039ec36e4f175ae9d510f3eb765fdf2d7a6f155ea37b822f0f464
+  data.tar.gz: 58371614f47e835c11b183fd2b004271b7c0031f27de8b17a9f8b0d3d2c4ee185a4e32efb5e495f5f6cf0b53fa9f64e4510150cfff3305d237431ec195733b13

data/lib/no_brainer/connection.rb

@@ -50,7 +50,7 @@ class NoBrainer::Connection
 
   # Note that truncating each table (purge) is much faster than dropping the
   # database (drop)
-  def purge!(options={})
+  def purge!
     table_list.each do |table_name|
       next if table_name =~ /^nobrainer_/
       NoBrainer.run { |r| r.table(table_name).delete }

data/lib/no_brainer/criteria/core.rb

@@ -57,7 +57,7 @@ module NoBrainer::Criteria::Core
 
   private
 
-  def chain(options={}, merge_options={}, &block)
+  def chain(options={}, merge_options={})
     merge(self.class.new(options), merge_options)
   end
 

data/lib/no_brainer/criteria/delete.rb

@@ -6,6 +6,6 @@ module NoBrainer::Criteria::Delete
   end
 
   def destroy_all
-    to_a.each { |doc| doc.destroy }
+    to_a.each(&:destroy)
   end
 end

data/lib/no_brainer/criteria/order_by.rb

@@ -65,7 +65,9 @@ module NoBrainer::Criteria::OrderBy
     end
 
     def first_key_indexable?
-      (first_key.is_a?(Symbol) || first_key.is_a?(String)) && criteria.model.has_index?(first_key)
+      return false unless first_key.is_a?(Symbol) || first_key.is_a?(String)
+      return false unless index = criteria.model.indexes[first_key.to_sym]
+      return !index.multi && !index.geo
     end
 
     def find_index
@@ -87,7 +89,7 @@ module NoBrainer::Criteria::OrderBy
 
   def order_by_index_finder
     return finalized_criteria.__send__(:order_by_index_finder) unless finalized?
-    @order_by_index_finder ||= IndexFinder.new(self).tap { |index_finder| index_finder.find_index }
+    @order_by_index_finder ||= IndexFinder.new(self).tap(&:find_index)
   end
 
   def compile_rql_pass1

data/lib/no_brainer/criteria/where.rb

@@ -1,4 +1,12 @@
 module NoBrainer::Criteria::Where
+  NON_CHAINABLE_OPERATORS = %w(in nin eq ne not gt ge gte lt le lte defined).map(&:to_sym)
+  CHAINABLE_OPERATORS = %w(any all).map(&:to_sym)
+  OPERATORS = CHAINABLE_OPERATORS + NON_CHAINABLE_OPERATORS
+
+  require 'symbol_decoration'
+  Symbol::Decoration.register(*NON_CHAINABLE_OPERATORS)
+  Symbol::Decoration.register(*CHAINABLE_OPERATORS, :chainable => true)
+
   extend ActiveSupport::Concern
 
   included do
@@ -18,15 +26,16 @@ module NoBrainer::Criteria::Where
   end
 
   def where_indexed?
-    !!where_index_name
+    where_index_name.present?
   end
 
   def where_index_name
-    where_index_finder.index_name
+    index = where_index_finder.strategy.try(:index)
+    index.is_a?(Array) ? index.map(&:name) : index.try(:name)
   end
 
   def where_index_type
-    where_index_finder.index_type
+    where_index_finder.strategy.try(:rql_op)
   end
 
   private
@@ -34,7 +43,7 @@ module NoBrainer::Criteria::Where
   class MultiOperator < Struct.new(:op, :clauses)
     def simplify
       clauses = self.clauses.map(&:simplify)
-      if self.clauses.size == 1 && self.clauses.first.is_a?(self.class)
+      if clauses.size == 1 && clauses.first.is_a?(self.class)
         return clauses.first
       end
 
@@ -42,19 +51,19 @@ module NoBrainer::Criteria::Where
         v.is_a?(self.class) && (v.clauses.size == 1 || v.op == self.op)
       end
       simplified_clauses = other_clauses + same_op_clauses.map(&:clauses).flatten(1)
-      simplified_clauses =  BinaryOperator.simplify_clauses(op, simplified_clauses.uniq)
+      simplified_clauses = BinaryOperator.simplify_clauses(op, simplified_clauses.uniq)
       self.class.new(op, simplified_clauses)
     end
 
     def to_rql(doc)
       case op
-      when :and then clauses.map { |c| c.to_rql(doc) }.reduce { |a,b| a & b }
-      when :or  then clauses.map { |c| c.to_rql(doc) }.reduce { |a,b| a | b }
+      when :and then clauses.map { |c| c.to_rql(doc) }.reduce(:&)
+      when :or  then clauses.map { |c| c.to_rql(doc) }.reduce(:|)
       end
     end
   end
 
-  class BinaryOperator < Struct.new(:key, :op, :value, :model, :casted_values)
+  class BinaryOperator < Struct.new(:key, :key_modifier, :op, :value, :model, :casted_values)
     def self.get_candidate_clauses(clauses, *types)
       clauses.select { |c| c.is_a?(self) && types.include?(c.op) }
     end
@@ -63,14 +72,14 @@ module NoBrainer::Criteria::Where
       # This code assumes that simplfy() has already been called on all clauses.
       if op == :or
         eq_clauses = get_candidate_clauses(ast_clauses, :in, :eq)
-        new_clauses = eq_clauses.group_by(&:key).map do |key, clauses|
-          case clauses.size
-          when 1 then clauses.first
-          else
+        new_clauses = eq_clauses.group_by { |c| [c.key, c.key_modifier] }.map do |(key, key_modifier), clauses|
+          if key_modifier.in?([:scalar, :any]) && clauses.size > 1
             values = clauses.map { |c| c.op == :in ? c.value : [c.value] }.flatten(1).uniq
-            BinaryOperator.new(key, :in, values, clauses.first.model, true)
+            [BinaryOperator.new(key, key_modifier, :in, values, clauses.first.model, true)]
+          else
+            clauses
           end
-        end
+        end.flatten(1)
 
         if new_clauses.size != eq_clauses.size
           ast_clauses = ast_clauses - eq_clauses + new_clauses
@@ -81,29 +90,49 @@ module NoBrainer::Criteria::Where
     end
 
     def simplify
-      key = cast_key(self.key)
-      case op
-      when :in then
-        case value
-        when Range then BinaryOperator.new(key, :between, (cast_value(value.min)..cast_value(value.max)), model, true)
-        when Array then BinaryOperator.new(key, :in, value.map(&method(:cast_value)).uniq, model, true)
-        else raise ArgumentError.new ":in takes an array/range, not #{value}"
-        end
-      when :between then BinaryOperator.new(key, :between, (cast_value(value.min)..cast_value(value.max)), model, true)
-      else BinaryOperator.new(key, op, cast_value(value), model, true)
+      new_key = cast_key(key)
+      new_op, new_value = case op
+        when :in then
+          case value
+          when Range then [:between, (cast_value(value.min)..cast_value(value.max))]
+          when Array then [:in, value.map(&method(:cast_value)).uniq]
+          else raise ArgumentError.new ":in takes an array/range, not #{value}"
+          end
+        when :between then [op, (cast_value(value.min)..cast_value(value.max))]
+        when :defined
+          raise "Incorrect use of `#{op}' and `#{key_modifier}'" if key_modifier != :scalar
+          [op, cast_value(value)]
+        else [op, cast_value(value)]
       end
+      BinaryOperator.new(new_key, key_modifier, new_op, new_value, model, true)
     end
 
     def to_rql(doc)
       key = model.lookup_field_alias(self.key)
+
+      case key_modifier
+      when :scalar then
+        case op
+        when :defined then value ? doc.has_fields(key) : doc.has_fields(key).not
+        else to_rql_scalar(doc[key])
+        end
+      when :any then doc[key].map { |lvalue| to_rql_scalar(lvalue) }.contains(true)
+      when :all then doc[key].map { |lvalue| to_rql_scalar(lvalue) }.contains(false).not
+      end
+    end
+
+    def to_rql_scalar(lvalue)
       case op
-      when :defined then value ? doc.has_fields(key) : doc.has_fields(key).not
-      when :between then (doc[key] >= value.min) & (doc[key] <= value.max)
-      when :in      then RethinkDB::RQL.new.expr(value).contains(doc[key])
-      else doc[key].__send__(op, value)
+      when :between then (lvalue >= value.min) & (lvalue <= value.max)
+      when :in      then RethinkDB::RQL.new.expr(value).contains(lvalue)
+      else lvalue.__send__(op, value)
       end
     end
 
+    def compatible_with_index?(index)
+      [key_modifier, index.multi].in?([[:any, true], [:scalar, false]])
+    end
+
     private
 
     def association
@@ -120,11 +149,14 @@ module NoBrainer::Criteria::Where
       case association
       when NoBrainer::Document::Association::BelongsTo::Metadata
         target_model = association.target_model
-        opts = { :attr_name => key, :value => value, :type => target_model}
+        opts = { :attr_name => key, :value => value, :type => target_model }
         raise NoBrainer::Error::InvalidType.new(opts) unless value.is_a?(target_model)
         value.pk_value
       else
-        model.cast_user_to_db_for(key, value)
+        case key_modifier
+        when :scalar    then model.cast_user_to_db_for(key, value)
+        when :any, :all then model.cast_user_to_db_for(key, [value]).first
+        end
       end
     end
 
@@ -133,9 +165,14 @@ module NoBrainer::Criteria::Where
 
       case association
       when NoBrainer::Document::Association::BelongsTo::Metadata then association.foreign_key
-      else key
+      else ensure_valid_key!(key); key
       end
     end
+
+    def ensure_valid_key!(key)
+      return if model.has_field?(key) || model.has_index?(key) || model < NoBrainer::Document::DynamicAttributes
+      raise NoBrainer::Error::UnknownAttribute, "`#{key}' is not a declared attribute of #{model}"
+    end
   end
 
   class UnaryOperator < Struct.new(:op, :value)
@@ -165,7 +202,7 @@ module NoBrainer::Criteria::Where
     when Array then MultiOperator.new(:and, clause.map { |c| parse_clause(c) })
     when Hash  then MultiOperator.new(:and, clause.map { |k,v| parse_clause_stub(k,v) })
     when Proc  then Lambda.new(clause)
-    when NoBrainer::DecoratedSymbol
+    when Symbol::Decoration
       case clause.args.size
       when 1 then parse_clause_stub(clause, clause.args.first)
       else raise "Invalid argument: #{clause}"
@@ -180,12 +217,15 @@ module NoBrainer::Criteria::Where
     when :or  then MultiOperator.new(:or,  value.map { |v| parse_clause(v) })
     when :not then UnaryOperator.new(:not, parse_clause(value))
     when String, Symbol then parse_clause_stub_eq(key, value)
-    when NoBrainer::DecoratedSymbol then
-      case key.modifier
+    when Symbol::Decoration then
+      case key.decorator
+      when :any, :all then parse_clause_stub_eq(key, value)
+      when :not, :ne  then parse_clause(:not => { key.symbol.eq => value })
       when :nin then parse_clause(:not => { key.symbol.in => value })
-      when :ne  then parse_clause(:not => { key.symbol.eq => value })
+      when :gte then parse_clause(key.symbol.ge => value)
+      when :lte then parse_clause(key.symbol.le => value)
       when :eq  then parse_clause_stub_eq(key.symbol, value)
-      else BinaryOperator.new(key.symbol, key.modifier, value, self.model)
+      else instantiate_binary_op(key.symbol, key.decorator, value)
       end
     else raise "Invalid key: #{key}"
     end
@@ -193,137 +233,154 @@ module NoBrainer::Criteria::Where
 
   def parse_clause_stub_eq(key, value)
     case value
-    when Range  then BinaryOperator.new(key, :between, value, self.model)
-    when Regexp then BinaryOperator.new(key, :match, value.inspect[1..-2], self.model)
-    else BinaryOperator.new(key, :eq, value, self.model)
+    when Range  then instantiate_binary_op(key, :between, value)
+    when Regexp then instantiate_binary_op(key, :match, value.inspect[1..-2])
+    else instantiate_binary_op(key, :eq, value)
     end
   end
 
-  class IndexFinder < Struct.new(:criteria, :ast, :index_name, :index_type, :rql_proc)
-    def initialize(*args)
-      super
+  def instantiate_binary_op(key, op, value)
+    case key
+    when Symbol::Decoration then BinaryOperator.new(key.symbol, key.decorator, op, value, self.model)
+    else BinaryOperator.new(key, :scalar, op, value, self.model)
     end
+  end
 
-    def could_find_index?
-      !!self.index_name
+  class IndexFinder < Struct.new(:criteria, :ast, :strategy)
+    class Strategy < Struct.new(:rql_op, :index, :ast, :rql_proc); end
+    class IndexStrategy < Struct.new(:criteria_ast, :optimized_clauses, :index, :rql_op, :rql_args, :rql_options)
+      def ast
+        MultiOperator.new(criteria_ast.op, criteria_ast.clauses - optimized_clauses)
+      end
+
+      def rql_proc
+        lambda do |rql|
+          opt = (rql_options || {}).merge(:index => index.aliased_name)
+          r = rql.__send__(rql_op, *rql_args, opt)
+          # TODO distinct: waiting for issue #3345
+          # TODO coerce_to: waiting for issue #3346
+          index.multi ? r.coerce_to('array').distinct : r
+        end
+      end
     end
 
     def get_candidate_clauses(*types)
       BinaryOperator.get_candidate_clauses(ast.clauses, *types)
     end
 
-    def get_usable_indexes(*types)
-      @usable_indexes = {}
-      @usable_indexes[types] ||= begin
-        indexes = criteria.model.indexes.values
-        indexes = indexes.select { |i| types.include?(i.kind) } if types.present?
-        if criteria.options[:use_index] && criteria.options[:use_index] != true
-          indexes = indexes.select { |i| i.name == criteria.options[:use_index].to_sym }
-        end
-        indexes
+    def get_usable_indexes(options={})
+      indexes = criteria.model.indexes.values
+      options.each { |k,v| indexes = indexes.select { |i| v == i.__send__(k) } }
+      if criteria.options[:use_index] && criteria.options[:use_index] != true
+        indexes = indexes.select { |i| i.name == criteria.options[:use_index].to_sym }
       end
+      indexes
     end
 
-    def remove_from_ast(clauses)
-      new_ast = MultiOperator.new(ast.op, ast.clauses - clauses)
-      return new_ast if new_ast.clauses.present?
-    end
-
-    def find_index_canonical
+    def find_strategy_canonical
       clauses = Hash[get_candidate_clauses(:eq, :in, :between).map { |c| [c.key, c] }]
-      return unless clauses.present?
+      return nil unless clauses.present?
 
-      if index = get_usable_indexes.select { |i| clauses[i.name] }.first
+      get_usable_indexes.each do |index|
         clause = clauses[index.name]
-        self.index_name = index.name
-        self.ast = remove_from_ast([clause])
-        self.index_type = clause.op == :between ? :between : :get_all
-        self.rql_proc = case clause.op
-          when :eq      then ->(rql){ rql.get_all(clause.value, :index => index.aliased_name) }
-          when :in      then ->(rql){ rql.get_all(*clause.value, :index => index.aliased_name) }
-          when :between then ->(rql){ rql.between(clause.value.min, clause.value.max, :index => index.aliased_name,
-                                                  :left_bound => :closed, :right_bound => :closed) }
+        next unless clause.try(:compatible_with_index?, index)
+
+        args = case clause.op
+          when :eq      then [:get_all, [clause.value]]
+          when :in      then [:get_all, clause.value]
+          when :between then [:between, [clause.value.min, clause.value.max],
+                              :left_bound => :closed, :right_bound => :closed]
         end
+        return IndexStrategy.new(ast, [clause], index, *args)
       end
+      return nil
     end
 
-    def find_index_compound
+    def find_strategy_compound
       clauses = Hash[get_candidate_clauses(:eq).map { |c| [c.key, c] }]
-      return unless clauses.present?
+      return nil unless clauses.present?
 
-      if index = get_usable_indexes(:compound).select { |i| i.what & clauses.keys == i.what }.first
+      get_usable_indexes(:kind => :compound, :multi => false).each do |index|
         indexed_clauses = index.what.map { |field| clauses[field] }
-        self.index_name = index.name
-        self.ast = remove_from_ast(indexed_clauses)
-        self.index_type = :get_all
-        self.rql_proc = ->(rql){ rql.get_all(indexed_clauses.map { |c| c.value }, :index => index.aliased_name) }
+        next unless indexed_clauses.all? { |c| c.try(:compatible_with_index?, index) }
+
+        return IndexStrategy.new(ast, indexed_clauses, index, :get_all, [indexed_clauses.map(&:value)])
       end
+      return nil
     end
 
-    def find_index_hidden_between
+    def find_strategy_hidden_between
       clauses = get_candidate_clauses(:gt, :ge, :lt, :le).group_by(&:key)
-      return unless clauses.present?
+      return nil unless clauses.present?
+
+      get_usable_indexes.each do |index|
+        matched_clauses = clauses[index.name].try(:select) { |c| c.compatible_with_index?(index) }
+        next unless matched_clauses.present?
 
-      if index = get_usable_indexes.select { |i| clauses[i.name] }.first
-        op_clauses = Hash[clauses[index.name].map { |c| [c.op, c] }]
-        left_bound = op_clauses[:gt] || op_clauses[:ge]
+        op_clauses = Hash[matched_clauses.map { |c| [c.op, c] }]
+        left_bound  = op_clauses[:gt] || op_clauses[:ge]
         right_bound = op_clauses[:lt] || op_clauses[:le]
 
-        self.index_name = index.name
-        self.ast = remove_from_ast([left_bound, right_bound].compact)
+        # XXX we must keep only one bound when using `any', otherwise we get different semantics.
+        right_bound = nil if index.multi && left_bound && right_bound
 
         options = {}
-        options[:index] = index.aliased_name
-        options[:left_bound]  = {:gt => :open, :ge => :closed}[left_bound.op] if left_bound
+        options[:left_bound]  = {:gt => :open, :ge => :closed}[left_bound.op]  if left_bound
         options[:right_bound] = {:lt => :open, :le => :closed}[right_bound.op] if right_bound
-        self.index_type = :between
-        self.rql_proc = ->(rql){ rql.between(left_bound.try(:value), right_bound.try(:value), options) }
+
+        return IndexStrategy.new(ast, [left_bound, right_bound].compact, index, :between,
+                                 [left_bound.try(:value), right_bound.try(:value)], options)
       end
+      return nil
     end
 
-    def find_union_index
-      indexes = []
-      index_finder = self
-
-      loop do
-        index_finder = index_finder.dup
-        break unless index_finder.find_index_canonical
-        # TODO To use a compound index, we'd have to add all permutations in the query
-        indexes << index_finder
-        break unless index_finder.ast
+    def find_strategy_union
+      strategies = ast.clauses.map do |inner_ast|
+        inner_ast = MultiOperator.new(:and, [inner_ast]) unless inner_ast.is_a?(MultiOperator)
+        raise 'fatal' unless inner_ast.op == :and
+        self.class.new(criteria, inner_ast).find_strategy
       end
 
-      if indexes.present? && !index_finder.ast
-        self.ast = nil
-        self.index_name = indexes.map(&:index_name)
-        self.index_type = indexes.map(&:index_type)
-        self.rql_proc = ->(rql){ indexes.map { |index| index.rql_proc.call(rql) }.reduce { |a,b| a.union(b) } }
+      return nil if strategies.any?(&:nil?)
+
+      rql_proc = lambda do |base_rql|
+        strategies.map do |strategy|
+          rql = strategy.rql_proc.call(base_rql)
+          rql = rql.filter { |doc| strategy.ast.to_rql(doc) } if strategy.ast.try(:clauses).present?
+          rql
+        end.reduce(:union).distinct
       end
+
+      Strategy.new(:union, strategies.map(&:index), nil, rql_proc)
     end
 
-    def find_index
-      return if ast.nil? || criteria.without_index?
+    def find_strategy
+      return nil unless ast.try(:clauses).present? && !criteria.without_index?
       case ast.op
-      when :and then find_index_compound || find_index_canonical || find_index_hidden_between
-      when :or  then find_union_index
+      when :and then find_strategy_compound || find_strategy_canonical || find_strategy_hidden_between
+      when :or  then find_strategy_union
       end
     end
+
+    def find_strategy!
+      self.strategy = find_strategy
+    end
   end
 
   def where_index_finder
     return finalized_criteria.__send__(:where_index_finder) unless finalized?
-    @where_index_finder ||= IndexFinder.new(self, @options[:where_ast]).tap { |index_finder| index_finder.find_index }
+    @where_index_finder ||= IndexFinder.new(self, @options[:where_ast]).tap(&:find_strategy!)
   end
 
   def compile_rql_pass1
     rql = super
-    rql = where_index_finder.rql_proc.call(rql) if where_index_finder.could_find_index?
+    rql = where_index_finder.strategy.rql_proc.call(rql) if where_indexed?
     rql
   end
 
   def compile_rql_pass2
     rql = super
-    ast = where_index_finder.could_find_index? ? where_index_finder.ast : @options[:where_ast]
+    ast = where_indexed? ? where_index_finder.strategy.ast : @options[:where_ast]
     rql = rql.filter { |doc| ast.to_rql(doc) } if ast.try(:clauses).present?
     rql
   end

data/lib/no_brainer/document/aliases.rb

@@ -12,9 +12,17 @@ module NoBrainer::Document::Aliases
 
   module ClassMethods
     def _field(attr, options={})
+      if options[:store_as]
+        self.alias_map[attr.to_s] = options[:store_as].to_s
+        self.alias_reverse_map[options[:store_as].to_s] = attr.to_s
+      end
+      super
+    end
+
+    def field(attr, options={})
       if options[:as]
-        self.alias_map[attr.to_s] = options[:as].to_s
-        self.alias_reverse_map[options[:as].to_s] = attr.to_s
+        STDERR.puts "[NoBrainer] `:as' is deprecated and will be removed. Please use `:store_as' instead (from the #{self} model)"
+        options[:store_as] = options.delete(:as)
       end
       super
     end

data/lib/no_brainer/document/association/belongs_to.rb

@@ -2,7 +2,7 @@ class NoBrainer::Document::Association::BelongsTo
   include NoBrainer::Document::Association::Core
 
   class Metadata
-    VALID_OPTIONS = [:primary_key, :foreign_key, :class_name, :foreign_key_as, :index, :validates, :required]
+    VALID_OPTIONS = [:primary_key, :foreign_key, :class_name, :foreign_key_store_as, :index, :validates, :required]
     include NoBrainer::Document::Association::Core::Metadata
     extend NoBrainer::Document::Association::EagerLoader::Generic
 
@@ -29,8 +29,8 @@ class NoBrainer::Document::Association::BelongsTo
       # This would have the effect of loading all the models because they
       # are likely to be related to each other. So we don't know the type
       # of the primary key of the target.
-      owner_model.field(foreign_key, :as => options[:foreign_key_as], :index => options[:index])
-      owner_model.validates(target_name, { :presence => true }) if options[:required]
+      owner_model.field(foreign_key, :store_as => options[:foreign_key_store_as], :index => options[:index])
+      owner_model.validates(target_name, :presence => options[:required]) if options[:required]
       owner_model.validates(target_name, options[:validates]) if options[:validates]
 
       delegate("#{foreign_key}=", :assign_foreign_key, :call_super => true)

data/lib/no_brainer/document/association/core.rb

@@ -37,7 +37,7 @@ module NoBrainer::Document::Association::Core
     end
 
     def add_callback_for(what)
-      instance_eval <<-RUBY, __FILE__, __LINE__+1
+      instance_eval <<-RUBY, __FILE__, __LINE__ + 1
         if !@added_#{what}
           metadata = self
           owner_model.#{what} { associations[metadata].#{what}_callback }

data/lib/no_brainer/document/association/eager_loader.rb

@@ -17,7 +17,7 @@ class NoBrainer::Document::Association::EagerLoader
         if owner_keys.present?
           targets = criteria.where(target_key.in => owner_keys)
                             .map { |target| [target.read_attribute(target_key), target] }
-                            .reduce(Hash.new { |k,v| k[v] = [] }) { |h,(k,v)| h[k] << v; h }
+                            .each_with_object(Hash.new { |k,v| k[v] = [] }) { |(k,v),h| h[k] << v }
 
           unloaded_docs.each do |doc|
             doc_targets = targets[doc.read_attribute(owner_key)]

data/lib/no_brainer/document/association/has_many.rb

@@ -53,7 +53,7 @@ class NoBrainer::Document::Association::HasMany
   end
 
   def write(new_children)
-    raise "You can't assign #{target_name}. " +
+    raise "You can't assign #{target_name}. " \
           "Instead, you must modify delete and create #{target_model} manually."
   end
 
@@ -80,7 +80,7 @@ class NoBrainer::Document::Association::HasMany
   end
 
   def set_inverse_proc
-    lambda { |target| set_inverses_of([target]) if target.is_a?(NoBrainer::Document) }
+    ->(target){ set_inverses_of([target]) if target.is_a?(NoBrainer::Document) }
   end
 
   def before_destroy_callback

data/lib/no_brainer/document/atomic_ops.rb

@@ -2,54 +2,53 @@ module NoBrainer::Document::AtomicOps
   extend ActiveSupport::Concern
 
   class PendingAtomic
-    def self._new(instance, field, value, is_user_value, options={})
-      model = case value
-              when Array then PendingAtomicArray
-              when Set   then PendingAtomicSet
-              else self
-              end
-      model.new(instance, field, value, is_user_value, options)
+    def self._new(instance, field, value, is_user_value)
+      case value
+      when Array then PendingAtomicArray
+      when Set   then PendingAtomicSet
+      else self
+      end.new(instance, field, value, is_user_value)
     end
 
-    def initialize(instance, field, value, is_user_value, options={})
+    def initialize(instance, field, value, is_user_value)
       @instance = instance
       @field = field.to_s
       @value = value
       @is_user_value = is_user_value
-      @options = options.dup
       @ops = []
     end
 
-    def write_access?
-      !!@options[:write_access]
-    end
-
-    def ensure_writeable!
-      unless write_access?
-        @options[:write_access] = true
-        @instance.write_attribute(@field, self)
-      end
+    def initialize_copy(other)
+      super
+      @ops = @ops.dup
     end
 
     def to_s
-      "<#{@field} with pending atomic operations>"
+      "<`#{@field}' with #{@ops.size} pending atomic operations>"
     end
-    alias inspect to_s
+    alias_method :inspect, :to_s
 
-    def method_missing(method_name, *a, &b)
-      @ops << [method_name, a, b]
+    def method_missing(method, *a, &b)
+      @ops << [method, a, b]
       self
     end
 
     def compile_rql_value(rql_doc)
       field = @instance.class.lookup_field_alias(@field)
       value = @is_user_value ? RethinkDB::RQL.new.expr(@value) : rql_doc[field]
-      @ops.each { |method_name, a, b| value = value.__send__(method_name, *a, &b) }
-      value
+      @ops.reduce(value) { |v, (method, a, b)| v.__send__(method, *a, &b) }
+    end
+  end
+
+  class PendingAtomicContainer < PendingAtomic
+    def modify_source!
+      unless @instance._is_attribute_touched?(@field)
+        @instance.write_attribute(@field, self)
+      end
     end
   end
 
-  class PendingAtomicArray < PendingAtomic
+  class PendingAtomicArray < PendingAtomicContainer
     def -(value)
       @ops << [:difference, [value.to_a]]
       self
@@ -80,12 +79,12 @@ module NoBrainer::Document::AtomicOps
 
     def <<(value)
       @ops << [:append, [value]]
-      ensure_writeable!
+      modify_source!
       self
     end
   end
 
-  class PendingAtomicSet < PendingAtomicArray
+  class PendingAtomicSet < PendingAtomicContainer
     def -(value)
       @ops << [:set_difference, [value.to_a]]
       self
@@ -98,7 +97,7 @@ module NoBrainer::Document::AtomicOps
 
     def <<(value)
       @ops << [:set_union, [[value]]]
-      ensure_writeable!
+      modify_source!
       self
     end
   end
@@ -145,9 +144,9 @@ module NoBrainer::Document::AtomicOps
     value = super
 
     case [in_atomic?, value.is_a?(PendingAtomic)]
-    when [true, true]   then value
     when [true, false]  then PendingAtomic._new(self, name, value, _is_attribute_touched?(name))
     when [false, true]  then raise NoBrainer::Error::CannotReadAtomic.new(self, name, value)
+    when [true, true]   then value.is_a?(PendingAtomicContainer) ? value : value.dup
     when [false, false] then value
     end
   end
@@ -156,9 +155,9 @@ module NoBrainer::Document::AtomicOps
     ensure_exclusive_atomic!
 
     case [in_atomic?, value.is_a?(PendingAtomic)]
-    when [true, true]   then super
     when [true, false]  then raise NoBrainer::Error::AtomicBlock.new('Avoid the use of atomic blocks for non atomic operations')
     when [false, true]  then raise NoBrainer::Error::AtomicBlock.new('Use atomic blocks for atomic operations')
+    when [true, true]   then super.tap { _touch_attribute(name) }
     when [false, false] then super.tap { _touch_attribute(name) }
     end
   end

data/lib/no_brainer/document/attributes.rb

@@ -1,14 +1,11 @@
 module NoBrainer::Document::Attributes
-  VALID_FIELD_OPTIONS = [:index, :default, :type, :real_type,
-                         :validates, :required, :unique, :uniq, :format, :in,
-                         :readonly, :primary_key, :as, :lazy_fetch]
+  VALID_FIELD_OPTIONS = [:index, :default, :type, :readonly, :primary_key, :lazy_fetch, :store_as,
+                         :validates, :required, :unique, :uniq, :format, :in]
   RESERVED_FIELD_NAMES = [:index, :default, :and, :or, :selector, :associations, :pk_value] \
-                          + NoBrainer::DecoratedSymbol::MODIFIERS.keys
+                          + NoBrainer::Criteria::Where::OPERATORS
   extend ActiveSupport::Concern
 
   included do
-    # Not using class_attribute because we want to
-    # use our custom logic
     singleton_class.send(:attr_accessor, :fields)
     self.fields = {}
   end
@@ -46,20 +43,19 @@ module NoBrainer::Document::Attributes
 
   def assign_defaults(options)
     self.class.fields.each do |name, field_options|
-      if field_options.has_key?(:default) &&
-         !@_attributes.has_key?(name)
-
-         if opt = options[:missing_attributes]
-           if (opt[:pluck] && !opt[:pluck][name]) ||
-              (opt[:without] && opt[:without][name])
-             next
-           end
-         end
-
-        default_value = field_options[:default]
-        default_value = default_value.call if default_value.is_a?(Proc)
-        self.write_attribute(name, default_value)
+      next unless field_options.has_key?(:default) &&
+                  !@_attributes.has_key?(name)
+
+      if opt = options[:missing_attributes]
+        if (opt[:pluck] && !opt[:pluck][name]) ||
+           (opt[:without] && opt[:without][name])
+          next
+        end
       end
+
+      default_value = field_options[:default]
+      default_value = default_value.call if default_value.is_a?(Proc)
+      self.write_attribute(name, default_value)
     end
   end
 

data/lib/no_brainer/document/callbacks.rb

@@ -9,7 +9,7 @@ module NoBrainer::Document::Callbacks
   end
 
   def initialize(*args, &block)
-    run_callbacks(:initialize) { _initialize(*args); true }
+    run_callbacks(:initialize) { _initialize(*args, &block); true }
   end
 
   def _create(*args, &block)

data/lib/no_brainer/document/id.rb

@@ -51,14 +51,13 @@ module NoBrainer::Document::Id
     # 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
+    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::Id::DEFAULT_PK_NAME, :primary_key => :default
     end
 
     def define_pk(attr)
@@ -81,6 +80,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::Id.generate }
+        end
       end
       super
     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
 
@@ -14,6 +14,12 @@ module NoBrainer::Document::Index
     def index(name, *args)
       name = name.to_sym
       options = args.extract_options!
+
+      if options[:as]
+        STDERR.puts "[NoBrainer] `:as' is deprecated and will be removed. Please use `:store_as' instead (from the #{self} model)"
+        options[:store_as] = options.delete(:as)
+      end
+
       options.assert_valid_keys(*VALID_INDEX_OPTIONS)
 
       raise "Too many arguments: #{args}" if args.size > 1
@@ -33,12 +39,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 +67,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

@@ -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
@@ -144,6 +144,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/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.rb

@@ -88,15 +88,6 @@ 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')

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

@@ -20,4 +20,3 @@ class NoBrainer::Binary
   end
   extend NoBrainerExtentions
 end
-

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

@@ -23,4 +23,3 @@ class NoBrainer::Boolean
   end
   extend NoBrainerExtentions
 end
-

data/lib/no_brainer/document/uniqueness.rb

@@ -58,7 +58,6 @@ module NoBrainer::Document::Uniqueness
       subclass.unique_validators = self.unique_validators.dup
       super
     end
-
   end
 
   class UniquenessValidator < ActiveModel::EachValidator

data/lib/no_brainer/document/validation.rb

@@ -23,11 +23,11 @@ module NoBrainer::Document::Validation
   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)
+      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)
       validates(attr, options[:validates]) if options[:validates]
     end
   end

data/lib/no_brainer/error.rb

@@ -9,6 +9,7 @@ module NoBrainer::Error
   class AssociationNotPersisted < RuntimeError; end
   class ReadonlyField           < RuntimeError; end
   class MissingAttribute        < RuntimeError; end
+  class UnknownAttribute        < RuntimeError; end
   class AtomicBlock             < RuntimeError; end
 
   class CannotReadAtomic < RuntimeError

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/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/table_on_demand.rb

@@ -30,7 +30,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

data/lib/nobrainer.rb

@@ -12,7 +12,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
   eager_autoload :Config, :Connection, :ConnectionManager,  :Error,
                  :QueryRunner, :Criteria, :RQL
 
@@ -31,13 +31,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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: nobrainer
 version: !ruby/object:Gem::Version
-  version: 0.18.1
+  version: 0.19.0
 platform: ruby
 authors:
 - Nicolas Viennot
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-11-08 00:00:00.000000000 Z
+date: 2014-11-17 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rethinkdb
@@ -16,14 +16,14 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 1.14.0.0
+        version: 1.15.0.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 1.14.0.0
+        version: 1.15.0.0
 - !ruby/object:Gem::Dependency
   name: activesupport
   requirement: !ruby/object:Gem::Requirement
@@ -66,6 +66,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: 0.1.0
+- !ruby/object:Gem::Dependency
+  name: symbol_decoration
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.1'
 description: ORM for RethinkDB
 email:
 - nicolas@viennot.biz
@@ -98,7 +112,6 @@ files:
 - lib/no_brainer/criteria/scope.rb
 - lib/no_brainer/criteria/update.rb
 - lib/no_brainer/criteria/where.rb
-- lib/no_brainer/decorated_symbol.rb
 - lib/no_brainer/document.rb
 - lib/no_brainer/document/aliases.rb
 - lib/no_brainer/document/association.rb

data/lib/no_brainer/decorated_symbol.rb

@@ -1,17 +0,0 @@
-class NoBrainer::DecoratedSymbol < Struct.new(:symbol, :modifier, :args)
-  MODIFIERS = { :in => :in, :nin => :nin,
-                :eq => :eq, :ne => :ne, :not => :ne,
-                :gt => :gt, :ge => :ge, :gte => :ge,
-                :lt => :lt, :le => :le, :lte => :le,
-                :defined => :defined }
-
-  def self.hook
-    Symbol.class_eval do
-      MODIFIERS.each do |modifier_name, modifier|
-        define_method modifier_name do |*args|
-          NoBrainer::DecoratedSymbol.new(self, modifier, args)
-        end
-      end
-    end
-  end
-end