nobrainer 0.9.0 → 0.11.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: ea32475119089388850bb55326aab70d4a3dbc16
-  data.tar.gz: dfbef7c1a239b75cb3b45d32b593026ef4d8df93
+  metadata.gz: 56f5bfdef46fb94e140efe80af84031e02238d07
+  data.tar.gz: aa5965b806a43a8727be98ef2a7a9c370fe94cfc
 SHA512:
-  metadata.gz: d83f20ced889fba1ba1048e6ad41f4c7a6a1ae02562c8bf230580a66e64306d9a064eb179a500b61b230f026bbc93a8bf8876f4b4edbf2e21c1a2140decb743d
-  data.tar.gz: a9a671db853f43d369550c7b1031a3a9ad17b9d5307aee6aea659e3808364c6d3d77b0ecfe9d2354a08efb99df7f44f085566d36d2f787a3e1d7469ec915ba52
+  metadata.gz: 0285cc6834d21a4e973fe293adf54ada0bcce15424a605719a32db2445a909793ebab766549a9d8b31b42ced44e6d3ef5f1cfecd980b33b4c4c1792af94a74c4
+  data.tar.gz: 3ed81e4508bc4528142b7049db0e1464927f7dfcad9c459853593c70a9ebbed95c47b3bd634d03f0bc2e9ebcc358a2d72cbcd7b7c73b4c46ca37a518a23c7c56

data/lib/no_brainer/autoload.rb

@@ -1,14 +1,25 @@
 module NoBrainer::Autoload
   include ActiveSupport::Autoload
 
-  def autoload(*args)
-    args.each { |mod| super mod }
+  def self.extended(base)
+    ActiveSupport::Autoload.extended(base)
   end
 
-  def autoload_and_include(*mods)
-    mods.each do |mod|
-      autoload mod
-      include const_get mod
-    end
+  def autoload(*constants)
+    constants.each { |constant| super(constant) }
+  end
+
+  def eager_autoload(*constants)
+    super() { autoload(*constants) }
+  end
+
+  def autoload_and_include(*constants)
+    constants.each { |constant| autoload constant }
+    constants.each { |constant| include const_get constant }
+  end
+
+  def eager_autoload_and_include(*constants)
+    eager_autoload(*constants)
+    constants.each { |constant| include const_get constant }
   end
 end

data/lib/no_brainer/config.rb

@@ -1,3 +1,5 @@
+require 'logger'
+
 module NoBrainer::Config
   class << self
     mattr_accessor :rethinkdb_url, :logger, :warn_on_active_record,

data/lib/no_brainer/criteria/chainable/where.rb

@@ -56,14 +56,21 @@ module NoBrainer::Criteria::Chainable::Where
 
   class BinaryOperator < Struct.new(:key, :op, :value)
     def simplify
-      # TODO Simplify the in uniq
-      self
+      case op
+      when :in then
+        case value
+        when Range then BinaryOperator.new(key, :between, value)
+        when Array then BinaryOperator.new(key, :in, value.uniq)
+        else raise ArgumentError.new ":in takes an array/range, not #{value}"
+        end
+      else self
+      end
     end
 
     def to_rql(doc)
       case op
       when :between then (doc[key] >= value.min) & (doc[key] <= value.max)
-      when :in then value.map { |v| doc[key].eq(v) }.reduce { |a,b| a | b }
+      when :in then RethinkDB::RQL.new.expr(value).contains(doc[key])
       else doc[key].__send__(op, value)
       end
     end
@@ -130,7 +137,7 @@ module NoBrainer::Criteria::Chainable::Where
     self.with_index_name == false
   end
 
-  class IndexFinder < Struct.new(:criteria, :index_name, :indexed_values, :ast)
+  class IndexFinder < Struct.new(:criteria, :index_name, :rql_proc, :ast)
     def initialize(*args)
       super
       find_index
@@ -143,9 +150,7 @@ module NoBrainer::Criteria::Chainable::Where
     private
 
     def get_candidate_clauses(*types)
-      Hash[criteria.where_ast.clauses
-        .select { |c| c.is_a?(BinaryOperator) && types.include?(c.op) }
-        .map { |c| [c.key, c] }]
+      criteria.where_ast.clauses.select { |c| c.is_a?(BinaryOperator) && types.include?(c.op) }
     end
 
     def get_usable_indexes(*types)
@@ -156,19 +161,24 @@ module NoBrainer::Criteria::Chainable::Where
     end
 
     def find_index_canonical
-      clauses = get_candidate_clauses(:eq, :in)
+      clauses = Hash[get_candidate_clauses(:eq, :in, :between).map { |c| [c.key, c] }]
       return unless clauses.present?
 
       if index_name = (get_usable_indexes.keys & clauses.keys).first
         clause = clauses[index_name]
         self.index_name = index_name
-        self.indexed_values = clause.op == :in ? clause.value : [clause.value]
         self.ast = MultiOperator.new(:and, criteria.where_ast.clauses - [clause])
+        self.rql_proc = case clause.op
+          when :eq      then ->(rql){ rql.get_all(clause.value, :index => index_name) }
+          when :in      then ->(rql){ rql.get_all(*clause.value, :index => index_name) }
+          when :between then ->(rql){ rql.between(clause.value.min, clause.value.max, :index => index_name,
+                                                  :left_bound => :closed, :right_bound => :closed) }
+        end
       end
     end
 
     def find_index_compound
-      clauses = get_candidate_clauses(:eq)
+      clauses = Hash[get_candidate_clauses(:eq).map { |c| [c.key, c] }]
       return unless clauses.present?
 
       index_name, index_values = get_usable_indexes(:compound)
@@ -179,14 +189,33 @@ module NoBrainer::Criteria::Chainable::Where
       if index_name
         indexed_clauses = index_values.map { |field| clauses[field] }
         self.index_name = index_name
-        self.indexed_values = [indexed_clauses.map { |c| c.value }]
         self.ast = MultiOperator.new(:and, criteria.where_ast.clauses - indexed_clauses)
+        self.rql_proc = ->(rql){ rql.get_all(indexed_clauses.map { |c| c.value }, :index => index_name) }
+      end
+    end
+
+    def find_index_hidden_between
+      clauses = get_candidate_clauses(:gt, :ge, :lt, :le).group_by(&:key)
+      return unless clauses.present?
+
+      if index_name = (get_usable_indexes.keys & clauses.keys).first
+        op_clauses = Hash[clauses[index_name].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 = MultiOperator.new(:and, criteria.where_ast.clauses - [left_bound, right_bound].compact)
+
+        options = {:index => index_name}
+        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.rql_proc = ->(rql){ rql.between(left_bound.try(:value), right_bound.try(:value), options) }
       end
     end
 
     def find_index
       return if criteria.__send__(:without_index?)
-      find_index_canonical || find_index_compound
+      find_index_canonical || find_index_compound || find_index_hidden_between
       if criteria.with_index_name && !could_find_index?
         raise NoBrainer::Error::CannotUseIndex.new("Cannot use index #{criteria.with_index_name}")
       end
@@ -200,9 +229,7 @@ module NoBrainer::Criteria::Chainable::Where
 
   def compile_rql_pass1
     rql = super
-    if index_finder.could_find_index?
-      rql = rql.get_all(*index_finder.indexed_values, :index => index_finder.index_name)
-    end
+    rql = index_finder.rql_proc.call(rql) if index_finder.could_find_index?
     rql
   end
 

data/lib/no_brainer/criteria/termination/cache.rb

@@ -45,7 +45,7 @@ module NoBrainer::Criteria::Termination::Cache
       block.call(instance)
       cache << instance
     end
-    @cache = cache.freeze
+    @cache = cache
     self
   end
 

data/lib/no_brainer/criteria/termination/preload.rb

@@ -0,0 +1,55 @@
+module NoBrainer::Criteria::Termination::Preload
+  extend ActiveSupport::Concern
+
+  included { attr_accessor :_preloads }
+
+  def initialize(options={})
+    super
+    self._preloads = []
+  end
+
+  def preload(*values)
+    chain(:keep_cache => true) { |criteria| criteria._preloads = values }
+  end
+
+  def includes(*values)
+    NoBrainer.logger.warn "[NoBrainer] includes() is deprecated and will be removed, use preload() instead."
+    preload(*values)
+  end
+
+  def merge!(criteria, options={})
+    super
+    self._preloads = self._preloads + criteria._preloads
+
+    # XXX Not pretty hack
+    if criteria._preloads.present? && cached?
+      perform_preloads(@cache)
+    end
+  end
+
+  def each(options={}, &block)
+    return super unless should_preloads? && !options[:no_preloadsing] && block
+
+    docs = []
+    super(options.merge(:no_preloadsing => true)) { |doc| docs << doc }
+    perform_preloads(docs)
+    docs.each(&block)
+    self
+  end
+
+  private
+
+  def should_preloads?
+    self._preloads.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, self._preloads)
+    end
+  end
+end

data/lib/no_brainer/criteria.rb

@@ -11,7 +11,7 @@ class NoBrainer::Criteria
   module Termination
     extend NoBrainer::Autoload
     extend ActiveSupport::Concern
-    autoload_and_include :Count, :Delete, :Enumerable, :First, :EagerLoading,
+    autoload_and_include :Count, :Delete, :Enumerable, :First, :Preload,
                          :Inc, :Update, :Cache
   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 = [:foreign_key, :class_name, :index]
+    VALID_OPTIONS = [:foreign_key, :class_name, :index, :validates]
     include NoBrainer::Document::Association::Core::Metadata
     extend NoBrainer::Document::Association::EagerLoader::Generic
 
@@ -19,7 +19,9 @@ class NoBrainer::Document::Association::BelongsTo
     def hook
       super
 
-      owner_klass.field foreign_key, :index => options[:index]
+      owner_klass.field(foreign_key, :index => options[:index])
+      owner_klass.validates(target_name, options[:validates]) if options[:validates]
+
       delegate("#{foreign_key}=", :assign_foreign_key, :call_super => true)
       add_callback_for(:after_validation)
       # TODO test if we are not overstepping on another foreign_key

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

@@ -33,24 +33,26 @@ class NoBrainer::Document::Association::EagerLoader
   def eager_load_association(docs, association_name, criteria=nil)
     docs = docs.compact
     return [] if docs.empty?
-    association = docs.first.root_class.association_metadata[association_name.to_sym]
+    meta = docs.first.root_class.association_metadata
+    # TODO test the singularize thingy.
+    association = meta[association_name.to_sym] || meta[association_name.to_s.singularize.to_sym]
     raise "Unknown association #{association_name}" unless association
     association.eager_load(docs, criteria)
   end
 
-  def eager_load(docs, includes)
-    case includes
-    when Hash  then includes.each do |k,v|
+  def eager_load(docs, preloads)
+    case preloads
+    when Hash  then preloads.each do |k,v|
       if v.is_a?(NoBrainer::Criteria)
         v = v.dup
-        nested_includes, v._includes = v._includes, []
-        eager_load(eager_load_association(docs, k, v), nested_includes)
+        nested_preloads, v._preloads = v._preloads, []
+        eager_load(eager_load_association(docs, k, v), nested_preloads)
       else
         eager_load(eager_load_association(docs, k), v)
       end
     end
-    when Array then includes.each { |v| eager_load(docs, v) }
-    else eager_load_association(docs, includes)
+    when Array then preloads.each { |v| eager_load(docs, v) }
+    else eager_load_association(docs, preloads)
     end
     true
   end

data/lib/no_brainer/document/association.rb

@@ -1,6 +1,7 @@
 module NoBrainer::Document::Association
   extend NoBrainer::Autoload
   autoload :Core, :BelongsTo, :HasMany, :HasManyThrough, :HasOne, :HasOneThrough, :EagerLoader
+  METHODS = [:belongs_to, :has_many, :has_one]
 
   extend ActiveSupport::Concern
 
@@ -19,7 +20,7 @@ module NoBrainer::Document::Association
       subclass.association_metadata = self.association_metadata.dup
     end
 
-    [:belongs_to, :has_many, :has_one].each do |association|
+    METHODS.each do |association|
       define_method(association) do |target, options={}|
         target = target.to_sym
 

data/lib/no_brainer/document/attributes.rb

@@ -1,5 +1,5 @@
 module NoBrainer::Document::Attributes
-  VALID_FIELD_OPTIONS = [:index, :default]
+  VALID_FIELD_OPTIONS = [:index, :default, :type, :validates]
   RESERVED_FIELD_NAMES = [:index, :default, :and, :or, :selector, :associations] + NoBrainer::DecoratedSymbol::MODIFIERS.keys
   extend ActiveSupport::Concern
 
@@ -10,14 +10,13 @@ module NoBrainer::Document::Attributes
     self.fields = {}
   end
 
-  def initialize(attrs={}, options={})
-    super
-    @attributes = {}
+  def _initialize(attrs={}, options={})
+    @_attributes = {}.with_indifferent_access
     assign_attributes(attrs, options.reverse_merge(:pristine => true))
   end
 
   def attributes
-    @attributes.dup.freeze
+    @_attributes.dup.freeze
   end
 
   def read_attribute(name)
@@ -32,7 +31,7 @@ module NoBrainer::Document::Attributes
 
   def assign_defaults
     self.class.fields.each do |name, field_options|
-      if field_options.has_key?(:default) && !@attributes.has_key?(name.to_s)
+      if field_options.has_key?(:default) && !@_attributes.has_key?(name)
         default_value = field_options[:default]
         default_value = default_value.call if default_value.is_a?(Proc)
         self.write_attribute(name, default_value)
@@ -40,39 +39,31 @@ module NoBrainer::Document::Attributes
     end
   end
 
-  def assign_attributes(attrs, options={})
-    # XXX We don't save field that are not explicitly set. The row will
-    # therefore not contain nil for unset attributes.
-    @attributes.clear if options[:pristine]
-
-    if options[:from_db]
-      # TODO Should we reject undeclared fields ?
-      #
-      # TODO Not using the getter/setters, the dirty tracking won't notice it,
-      # also we should start thinking about custom serializer/deserializer.
-      @attributes.merge! attrs
-    else
-      attrs.each { |k,v| self.write_attribute(k, v) }
-    end
+  def _assign_attributes(attrs, options={})
+    attrs.each { |k,v| self.write_attribute(k,v) }
+  end
 
-    assign_defaults if options[:pristine] || options[:from_db]
+  def assign_attributes(attrs, options={})
+    @_attributes.clear if options[:pristine]
+    _assign_attributes(attrs, options)
+    assign_defaults if options[:pristine]
     self
   end
   def attributes=(*args); assign_attributes(*args); end
 
-  # TODO test that thing
-  def inspect
-    attrs = self.class.fields.keys.map { |f| "#{f}: #{@attributes[f.to_s].inspect}" }
-    "#<#{self.class} #{attrs.join(', ')}>"
+  def inspectable_attributes
+    # TODO test that thing
+    Hash[@_attributes.sort_by { |k,v| self.class.fields.keys.index(k.to_sym) || 2**10 }]
   end
 
-  def to_s
-    inspect
+  def inspect
+    "#<#{self.class} #{inspectable_attributes.map { |k,v| "#{k}: #{v.inspect}" }.join(', ')}>"
   end
 
   module ClassMethods
     def new_from_db(attrs, options={})
-      klass_from_attrs(attrs).new(attrs, options.reverse_merge(:from_db => true)) if attrs
+      options = options.reverse_merge(:pristine => true, :from_db => true)
+      klass_from_attrs(attrs).new(attrs, options) if attrs
     end
 
     def inherited(subclass)
@@ -96,11 +87,11 @@ module NoBrainer::Document::Attributes
       # Using a layer so the user can use super when overriding these methods
       inject_in_layer :attributes, <<-RUBY, __FILE__, __LINE__ + 1
         def #{name}=(value)
-          @attributes['#{name}'] = value
+          @_attributes['#{name}'] = value
         end
 
         def #{name}
-          @attributes['#{name}']
+          @_attributes['#{name}']
         end
       RUBY
     end

data/lib/no_brainer/document/callbacks.rb

@@ -0,0 +1,32 @@
+module NoBrainer::Document::Callbacks
+  extend ActiveSupport::Concern
+
+  included do
+    extend ActiveModel::Callbacks
+    define_model_callbacks :initialize, :create, :update, :save, :destroy, :terminator => 'false'
+  end
+
+  def initialize(*args)
+    run_callbacks(:initialize) { _initialize(*args); true }
+  end
+
+  def _create(*args)
+    run_callbacks(:create) { super }
+  end
+
+  def update(*args, &block)
+    run_callbacks(:update) { super }
+  end
+
+  def replace(*args, &block)
+    run_callbacks(:update) { super }
+  end
+
+  def save(*args)
+    run_callbacks(:save) { super }
+  end
+
+  def destroy(*args)
+    run_callbacks(:destroy) { super }
+  end
+end

data/lib/no_brainer/document/core.rb

@@ -15,6 +15,4 @@ module NoBrainer::Document::Core
 
     NoBrainer::Document::Core.all << self
   end
-
-  def initialize(attrs={}, options={}); end
 end

data/lib/no_brainer/document/criteria.rb

@@ -16,7 +16,7 @@ module NoBrainer::Document::Criteria
              :with_cache, :without_cache,    # Cache
              :count, :empty?, :any?,         # Count
              :delete_all, :destroy_all,      # Delete
-             :includes,                      # EagerLoading
+             :includes, :preload,            # Preload
              :each, :to_a,                   # Enumerable
              :first, :last, :first!, :last!, # First
              :inc_all, :dec_all,             # Inc

data/lib/no_brainer/document/dirty.rb

@@ -5,73 +5,87 @@ module NoBrainer::Document::Dirty
   # ActiveModel::AttributeMethods which gives pretty violent method_missing()
   # capabilities, such as giving a getter/setter method for any keys within the
   # attributes keys. We don't want that.
+  # Also it doesn't work properly with array and hashes
 
-  included do
-    attr_accessor :previous_changes
-    after_save { clear_dirtiness }
+  included { after_save { clear_dirtiness } }
+
+  def old_attributes_values
+    @old_attributes_values ||= {}.with_indifferent_access
   end
 
-  def changed_attributes
-    @changed_attributes ||= {}
+  def clear_dirtiness
+    @old_attributes_values.try(:clear)
   end
 
-  def assign_attributes(attrs, options={})
-    clear_dirtiness if options[:pristine] || options[:from_db]
-    super
+  def attributes
+    # If we leak all the attributes (rare), we perform a copy to ensure that we
+    # don't have issues with modified hashes/array. Devs are crazy.
+    super.tap { |attrs| @old_attributes_values = attrs.deep_dup }
   end
 
-  def clear_dirtiness
-    self.previous_changes = changes
-    self.changed_attributes.clear
+  def _assign_attributes(attrs, options={})
+    super
+    clear_dirtiness if options[:from_db]
   end
 
   def changed?
-    changed_attributes.present?
+    changes.present?
   end
 
   def changed
-    changed_attributes.keys
+    changes.keys
   end
 
   def changes
-    Hash[changed_attributes.map { |k,v| [k, [v, read_attribute(k)]] }]
+    result = {}.with_indifferent_access
+    old_attributes_values.each do |attr, old_value|
+      current_value = read_attribute(attr)
+      result[attr] = [old_value, current_value] if current_value != old_value
+    end
+    result
   end
 
-  def attribute_will_change!(attr, new_value)
-    return if changed_attributes.include?(attr)
-
-    # ActiveModel ignores TypeError and NoMethodError exception as if nothng
-    # happened. Why is that?
-    value = read_attribute(attr)
-    value = value.clone if value.duplicable?
-
-    return if value == new_value
-
-    changed_attributes[attr] = value
+  def attribute_may_change(attr, current_value)
+    unless old_attributes_values.has_key?(attr)
+      old_attributes_values[attr] = current_value.deep_dup
+    end
   end
 
   module ClassMethods
     def field(name, options={})
       super
 
-      inject_in_layer :dirty_tracking, <<-RUBY, __FILE__, __LINE__ + 1
-        def #{name}_changed?
-          changed_attributes.include?(:#{name})
+      inject_in_layer :dirty_tracking do
+        define_method("#{name}_change") do
+          if old_attributes_values.has_key?(name)
+            result = [old_attributes_values[name], read_attribute(name)]
+            result = nil if result.first == result.last
+            result
+          end
         end
 
-        def #{name}_change
-          [changed_attributes[:#{name}], #{name}] if #{name}_changed?
+        define_method("#{name}_changed?") do
+          !!__send__("#{name}_change")
         end
 
-        def #{name}_was
-          #{name}_changed? ? changed_attributes[:#{name}] : #{name}
+        define_method("#{name}_was") do
+          old_attributes_values.has_key?(name) ?
+            old_attributes_values[name] : read_attribute(name)
         end
 
-        def #{name}=(value)
-          attribute_will_change!(:#{name}, value)
-          super
+        define_method("#{name}") do
+          super().tap do |value|
+            # This take care of string/arrays/hashes that could change without going
+            # through the setter.
+            attribute_may_change(name, value) if value.respond_to?(:size)
+          end
         end
-      RUBY
+
+        define_method("#{name}=") do |value|
+          attribute_may_change(name, read_attribute(name))
+          super(value)
+        end
+      end
     end
 
     def remove_field(name)
@@ -81,6 +95,7 @@ module NoBrainer::Document::Dirty
         undef #{name}_changed?
         undef #{name}_change
         undef #{name}_was
+        undef #{name}
         undef #{name}=
       RUBY
     end

data/lib/no_brainer/document/dynamic_attributes.rb

@@ -2,11 +2,19 @@ module NoBrainer::Document::DynamicAttributes
   extend ActiveSupport::Concern
 
   def read_attribute(name)
-    self.respond_to?("#{name}") ? super : @attributes[name.to_s]
+    if self.respond_to?("#{name}") 
+      super
+    else
+      @_attributes[name].tap { |value| attribute_may_change(name, value) if value.respond_to?(:size) }
+    end
   end
 
   def write_attribute(name, value)
-    attribute_will_change!(name, value)
-    self.respond_to?("#{name}=") ? super : @attributes[name.to_s] = value
+    if self.respond_to?("#{name}=")
+      super
+    else
+      attribute_may_change(name, read_attribute(name))
+      @_attributes[name] = value
+    end
   end
 end

data/lib/no_brainer/document/index.rb

@@ -23,7 +23,6 @@ module NoBrainer::Document::Index
         else raise "Index argument must be a lambda or a list of fields"
       end
 
-      # FIXME Primary key may not always be :id
       if name.in?(NoBrainer::Document::Attributes::RESERVED_FIELD_NAMES)
         raise "Cannot use a reserved field name: #{name}"
       end

data/lib/no_brainer/document/injection_layer.rb

@@ -3,7 +3,7 @@ module NoBrainer::Document::InjectionLayer
 
   module ClassMethods
     def inject_in_layer(name, code=nil, file=nil, line=nil, &block)
-      mod = class_eval "module NoBrainer; module #{name.to_s.camelize}; self; end; end"
+      mod = class_eval "module NoBrainerLayer; module #{name.to_s.camelize}; self; end; end"
       mod.module_eval(code, file, line) if code
       mod.module_exec(&block) if block
       include mod

data/lib/no_brainer/document/persistance.rb

@@ -6,8 +6,7 @@ module NoBrainer::Document::Persistance
     define_model_callbacks :create, :update, :save, :destroy, :terminator => 'false'
   end
 
-  # TODO after_initialize, after_find callback
-  def initialize(attrs={}, options={})
+  def _initialize(attrs={}, options={})
     super
     @new_record = !options[:from_db]
   end
@@ -25,56 +24,44 @@ module NoBrainer::Document::Persistance
   end
 
   def reload(options={})
-    unless options[:keep_ivars]
-      id = self.id
-      instance_variables.each { |ivar| remove_instance_variable(ivar) }
-      @attributes = {}
-      self.id = id
-    end
-    assign_attributes(selector.raw.first!, :pristine => true, :from_db => true)
+    attrs = selector.raw.first!
+    instance_variables.each { |ivar| remove_instance_variable(ivar) } unless options[:keep_ivars]
+    initialize(attrs, :pristine => true, :from_db => true)
     self
   end
 
   def _create(options={})
-    run_callbacks :create do
-      if options[:validate] && !valid?
-        false
-      else
-        keys = self.class.insert_all(attributes)
-        self.id ||= keys.first
-        @new_record = false
-        true
-      end
+    if options[:validate] && !valid?
+      false
+    else
+      keys = self.class.insert_all(attributes)
+      self.id ||= keys.first
+      @new_record = false
+      true
     end
   end
 
   def update(options={}, &block)
-    run_callbacks :update do
-      if options[:validate] && !valid?
-        false
-      else
-        selector.update_all(&block)
-        true
-      end
+    if options[:validate] && !valid?
+      false
+    else
+      selector.update_all(&block)
+      true
     end
   end
 
   def replace(options={}, &block)
-    run_callbacks :update do
-      if options[:validate] && !valid?
-        false
-      else
-        selector.replace_all(&block)
-        true
-      end
+    if options[:validate] && !valid?
+      false
+    else
+      selector.replace_all(&block)
+      true
     end
   end
 
   def save(options={})
     options = options.reverse_merge(:validate => true)
-    run_callbacks :save do
-      new_record? ? _create(options) : replace(options) { attributes }
-    end
+    new_record? ? _create(options) : replace(options) { attributes }
   end
 
   def save!(*args)
@@ -95,12 +82,12 @@ module NoBrainer::Document::Persistance
       selector.delete_all
       @destroyed = true
     end
-    # TODO freeze attributes
+    @_attributes.freeze
     true
   end
 
   def destroy
-    run_callbacks(:destroy) { delete }
+    delete
   end
 
   module ClassMethods

data/lib/no_brainer/document/timestamps.rb

@@ -2,15 +2,18 @@ module NoBrainer::Document::Timestamps
   extend ActiveSupport::Concern
 
   included do
-    self.field :created_at
-    self.field :updated_at
+    class_attribute :timestamps_disabled
 
-    before_create { self.created_at = Time.now if self.respond_to?(:created_at=) }
-    before_save   { self.updated_at = Time.now if self.respond_to?(:updated_at=) }
+    self.field :created_at, :type => Time
+    self.field :updated_at, :type => Time
+
+    before_create { self.created_at = Time.now unless self.timestamps_disabled }
+    before_save   { self.updated_at = Time.now unless self.timestamps_disabled }
   end
 
   module ClassMethods
     def disable_timestamps
+      self.timestamps_disabled = true
       self.remove_field :created_at
       self.remove_field :updated_at
     end

data/lib/no_brainer/document/types.rb

@@ -0,0 +1,137 @@
+module NoBrainer::Document::Types
+  extend ActiveSupport::Concern
+
+  module CastingRules
+    extend self
+
+    def String(value)
+      case value
+      when Symbol then value.to_s
+      else raise InvalidType
+      end
+    end
+
+    def Integer(value)
+      case value
+      when String
+        value = value.strip.gsub(/^\+/, '')
+        value.to_i.tap { |new_value| new_value.to_s == value or raise InvalidType }
+      when Float
+        value.to_i.tap { |new_value| new_value.to_f == value or raise InvalidType }
+      else raise InvalidType
+      end
+    end
+
+    def Float(value)
+      case value
+      when Integer then value.to_f
+      when String
+        value = value.strip.gsub(/^\+/, '')
+        value = value.gsub(/0+$/, '') if value['.']
+        value = value.gsub(/\.$/, '')
+        value = "#{value}.0" unless value['.']
+        value.to_f.tap { |new_value| new_value.to_s == value or raise InvalidType }
+      else raise InvalidType
+      end
+    end
+
+    def Boolean(value)
+      case value
+      when TrueClass  then true
+      when FalseClass then false
+      when String, Integer
+        value = value.to_s.strip.downcase
+        return true  if value.in? %w(true yes t 1)
+        return false if value.in? %w(false no f 0)
+        raise InvalidType
+      else raise InvalidType
+      end
+    end
+
+    def Symbol(value)
+      case value
+      when String
+        value = value.strip
+        raise InvalidType if value.empty?
+        value.to_sym
+      else raise InvalidType
+      end
+    end
+
+    def lookup(type)
+      CastingRules.method(type.to_s)
+    rescue NameError
+      proc { raise InvalidType }
+    end
+
+    def cast(value, type, cast_method)
+      return value if value.nil? || type.nil? || value.is_a?(type)
+      cast_method.call(value)
+    end
+  end
+
+  included do
+    # We namespace our fake Boolean class to avoid polluting the global namespace
+    class_exec do
+      class Boolean
+        def initialize; raise; end
+        def self.inspect; 'Boolean'; end
+        def self.to_s; inspect; end
+        def self.name; inspect; end
+      end
+    end
+    before_validation :add_type_errors
+  end
+
+  class InvalidType < RuntimeError
+    attr_accessor :type
+    def initialize(type=nil)
+      @type = type
+    end
+
+    def validation_error_args
+      [:invalid_type, :type => type.to_s.underscore.humanize.downcase]
+    end
+  end
+
+  def add_type_errors
+    return unless @pending_type_errors
+    @pending_type_errors.each do |name, error|
+      errors.add(name, *error.validation_error_args)
+    end
+  end
+
+  module ClassMethods
+    def field(name, options={})
+      super
+      return unless options.has_key?(:type)
+      name = name.to_sym
+      type = options[:type]
+      cast_method = NoBrainer::Document::Types::CastingRules.lookup(type)
+
+      inject_in_layer :types do
+        define_method("#{name}=") do |value|
+          begin
+            value = NoBrainer::Document::Types::CastingRules.cast(value, type, cast_method)
+            @pending_type_errors.try(:delete, name)
+          rescue NoBrainer::Document::Types::InvalidType => error
+            error.type ||= type
+            @pending_type_errors ||= {}
+            @pending_type_errors[name] = error
+          end
+          super(value)
+        end
+
+        define_method("#{name}?") { !!read_attribute(name) } if type == Boolean
+      end
+    end
+
+    def remove_field(name)
+      super
+      # TODO remove the name? if we added it. Low priority though.
+      inject_in_layer :types, <<-RUBY, __FILE__, __LINE__ + 1
+        undef #{name}=
+      RUBY
+    end
+  end
+end

data/lib/no_brainer/document/validation.rb

@@ -3,12 +3,16 @@ module NoBrainer::Document::Validation
   include ActiveModel::Validations
   include ActiveModel::Validations::Callbacks
 
-  # TODO Test that thing
   def valid?(context=nil)
     super(context || (new_record? ? :create : :update))
   end
 
   module ClassMethods
+    def field(name, options={})
+      super
+      validates(name.to_sym, options[:validates]) if options[:validates]
+    end
+
     def validates_uniqueness_of(*attr_names)
       validates_with UniquenessValidator, _merge_attributes(attr_names)
     end

data/lib/no_brainer/document.rb

@@ -4,9 +4,9 @@ module NoBrainer::Document
   extend ActiveSupport::Concern
   extend NoBrainer::Autoload
 
-  autoload_and_include :Core, :StoreIn, :InjectionLayer, :Attributes, :Persistance, :Dirty,
-                       :Id, :Association, :Serialization, :Criteria, :Validation,
-                       :Polymorphic, :Index, :Timestamps
+  autoload_and_include :Core, :StoreIn, :InjectionLayer, :Attributes, :Validation, :Types,
+                       :Persistance, :Callbacks, :Dirty, :Id, :Association, :Serialization,
+                       :Criteria, :Polymorphic, :Index, :Timestamps
 
   autoload :DynamicAttributes
 

data/lib/no_brainer/locale/en.yml

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

data/lib/no_brainer/railtie.rb

@@ -1,7 +1,9 @@
-require "nobrainer"
-require "rails"
+require 'nobrainer'
 
 class NoBrainer::Railtie < Rails::Railtie
+  config.app_generators.orm :nobrainer
+  config.eager_load_namespaces << NoBrainer
+
   config.action_dispatch.rescue_responses.merge!(
     "NoBrainer::Errors::DocumentNotFound" => :not_found,
     "NoBrainer::Errors::DocumentInvalid"  => :unprocessable_entity,
@@ -16,7 +18,7 @@ class NoBrainer::Railtie < Rails::Railtie
 
     if defined?(ActiveRecord) && NoBrainer::Config.warn_on_active_record
       STDERR.puts "[NoBrainer] WARNING: ActiveRecord is loaded which is probably not what you want."
-      STDERR.puts "[NoBrainer] Follow the instructions on http://todo/ to learn how to remove ActiveRecord."
+      STDERR.puts "[NoBrainer] Follow the instructions on http://nobrainer.io/docs/configuration/#removing_activerecord"
       STDERR.puts "[NoBrainer] Configure NoBrainer with 'config.warn_on_active_record = false' to disable with warning."
     end
 
@@ -30,6 +32,4 @@ class NoBrainer::Railtie < Rails::Railtie
       NoBrainer::Loader.cleanup
     end
   end
-
-  #config.eager_load_namespaces << NoBrainer
 end

data/lib/nobrainer.rb

@@ -1,15 +1,19 @@
-require 'active_support/core_ext'
-
 if Gem::Version.new(RUBY_VERSION.dup) < Gem::Version.new('1.9')
   raise 'Please use Ruby 1.9 or later'
 end
 
+require 'active_support'
+%w(module/delegation module/attribute_accessors class/attribute object/blank object/inclusion
+   object/deep_dup object/try hash/keys hash/indifferent_access hash/reverse_merge array/extract_options)
+    .each { |dep| require "active_support/core_ext/#{dep}" }
+
 module NoBrainer
   require 'no_brainer/autoload'
   extend NoBrainer::Autoload
 
-  autoload :Config, :Document, :Connection, :Database, :Error, :QueryRunner,
-           :Criteria, :DecoratedSymbol, :IndexManager, :Loader, :Logging, :Util, :Fork
+  # We eager load things that could be loaded for the first time during the web request
+  autoload :Document, :IndexManager, :Loader, :Fork, :DecoratedSymbol
+  eager_autoload :Config, :Connection, :Error, :QueryRunner, :Criteria, :Util
 
   class << self
     # Note: we always access the connection explicitly, so that in the future,
@@ -34,14 +38,14 @@ module NoBrainer
       end
     end
 
-    # Not using modules to extend, it's nicer to see the NoBrainer module API here.
     delegate :db_create, :db_drop, :db_list,
              :table_create, :table_drop, :table_list,
              :drop!, :purge!, :to => :connection
-    delegate :run, :to => 'NoBrainer::QueryRunner'
-    delegate :update_indexes, :to => 'NoBrainer::IndexManager'
+
+    delegate :configure, :logger,   :to => 'NoBrainer::Config'
+    delegate :run,                  :to => 'NoBrainer::QueryRunner'
+    delegate :update_indexes,       :to => 'NoBrainer::IndexManager'
     delegate :with, :with_database, :to => 'NoBrainer::QueryRunner::RunOptions'
-    delegate :configure, :logger, :to => 'NoBrainer::Config'
 
     def jruby?
       RUBY_PLATFORM == 'java'

data/lib/rails/generators/nobrainer/model/model_generator.rb

@@ -0,0 +1,17 @@
+require "rails/generators/nobrainer"
+
+module NoBrainer::Generators
+  class ModelGenerator < Base
+    argument :attributes, :type => :array, default: [], banner: "field ... field"
+
+    check_class_collision
+
+    class_option :parent, :type => :string, :desc => "The parent class for the generated model"
+
+    def create_model_file
+      template "model.rb.tt", File.join("app/models", class_path, "#{file_name}.rb")
+    end
+
+    hook_for :test_framework
+  end
+end

data/lib/rails/generators/nobrainer/model/templates/model.rb.tt

@@ -0,0 +1,13 @@
+<% module_namespacing do -%>
+class <%= class_name %><%= " < #{options[:parent].classify}" if options[:parent] %>
+<% unless options[:parent] -%>
+  include NoBrainer::Document
+<% end -%>
+<% attributes.reject(&:reference?).each do |attribute| -%>
+  field :<%= attribute.name %>
+<% end -%>
+<% attributes.select(&:reference?).each do |attribute| -%>
+  belongs_to :<%= attribute.name %>
+<% end -%>
+end
+<% end -%>

data/lib/rails/generators/nobrainer.rb

@@ -0,0 +1,18 @@
+require 'rails/generators/named_base'
+require 'nobrainer'
+
+module NoBrainer::Generators
+  class Base < Rails::Generators::NamedBase
+    def self.base_name
+      'nobrainer'
+    end
+
+    def self.base_root
+      File.dirname(__FILE__)
+    end
+
+    def self.namespace
+      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.9.0
+  version: 0.11.0
 platform: ruby
 authors:
 - Nicolas Viennot
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-01-05 00:00:00.000000000 Z
+date: 2014-01-08 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rethinkdb
@@ -66,35 +66,37 @@ extensions: []
 extra_rdoc_files: []
 files:
 - lib/no_brainer/document/id.rb
-- lib/no_brainer/document/injection_layer.rb
-- lib/no_brainer/document/timestamps.rb
-- lib/no_brainer/document/association/belongs_to.rb
-- lib/no_brainer/document/association/core.rb
-- lib/no_brainer/document/association/eager_loader.rb
-- lib/no_brainer/document/association/has_many_through.rb
 - lib/no_brainer/document/association/has_many.rb
 - lib/no_brainer/document/association/has_one.rb
 - lib/no_brainer/document/association/has_one_through.rb
+- lib/no_brainer/document/association/has_many_through.rb
+- lib/no_brainer/document/association/core.rb
+- lib/no_brainer/document/association/belongs_to.rb
+- lib/no_brainer/document/association/eager_loader.rb
+- lib/no_brainer/document/polymorphic.rb
+- lib/no_brainer/document/store_in.rb
+- lib/no_brainer/document/injection_layer.rb
+- lib/no_brainer/document/index.rb
+- lib/no_brainer/document/serialization.rb
+- lib/no_brainer/document/association.rb
+- lib/no_brainer/document/timestamps.rb
+- lib/no_brainer/document/core.rb
+- lib/no_brainer/document/callbacks.rb
+- lib/no_brainer/document/validation.rb
 - lib/no_brainer/document/dirty.rb
+- lib/no_brainer/document/attributes.rb
 - lib/no_brainer/document/dynamic_attributes.rb
 - lib/no_brainer/document/persistance.rb
-- lib/no_brainer/document/validation.rb
-- lib/no_brainer/document/serialization.rb
 - lib/no_brainer/document/criteria.rb
-- lib/no_brainer/document/index.rb
-- lib/no_brainer/document/polymorphic.rb
-- lib/no_brainer/document/store_in.rb
-- lib/no_brainer/document/attributes.rb
-- lib/no_brainer/document/core.rb
-- lib/no_brainer/document/association.rb
+- lib/no_brainer/document/types.rb
 - lib/no_brainer/query_runner/connection.rb
 - lib/no_brainer/query_runner/database_on_demand.rb
-- lib/no_brainer/query_runner/logger.rb
 - lib/no_brainer/query_runner/table_on_demand.rb
 - lib/no_brainer/query_runner/write_error.rb
 - lib/no_brainer/query_runner/driver.rb
 - lib/no_brainer/query_runner/missing_index.rb
 - lib/no_brainer/query_runner/run_options.rb
+- lib/no_brainer/query_runner/logger.rb
 - lib/no_brainer/railtie/database.rake
 - lib/no_brainer/criteria/chainable/limit.rb
 - lib/no_brainer/criteria/chainable/order_by.rb
@@ -108,23 +110,25 @@ files:
 - lib/no_brainer/criteria/termination/enumerable.rb
 - lib/no_brainer/criteria/termination/update.rb
 - lib/no_brainer/criteria/termination/delete.rb
-- lib/no_brainer/criteria/termination/eager_loading.rb
 - lib/no_brainer/criteria/termination/cache.rb
+- lib/no_brainer/criteria/termination/preload.rb
 - lib/no_brainer/decorated_symbol.rb
 - lib/no_brainer/index_manager.rb
 - lib/no_brainer/loader.rb
 - lib/no_brainer/locale/en.yml
-- lib/no_brainer/util.rb
 - lib/no_brainer/fork.rb
-- lib/no_brainer/criteria.rb
 - lib/no_brainer/connection.rb
 - lib/no_brainer/query_runner.rb
 - lib/no_brainer/error.rb
-- lib/no_brainer/document.rb
-- lib/no_brainer/config.rb
 - lib/no_brainer/railtie.rb
+- lib/no_brainer/config.rb
 - lib/no_brainer/autoload.rb
-- lib/no_brainer/version.rb
+- lib/no_brainer/document.rb
+- lib/no_brainer/util.rb
+- lib/no_brainer/criteria.rb
+- lib/rails/generators/nobrainer.rb
+- lib/rails/generators/nobrainer/model/model_generator.rb
+- lib/rails/generators/nobrainer/model/templates/model.rb.tt
 - lib/nobrainer.rb
 - README.md
 - LICENSE.md

data/lib/no_brainer/criteria/termination/eager_loading.rb

@@ -1,50 +0,0 @@
-module NoBrainer::Criteria::Termination::EagerLoading
-  extend ActiveSupport::Concern
-
-  included { attr_accessor :_includes }
-
-  def initialize(options={})
-    super
-    self._includes = []
-  end
-
-  def includes(*values)
-    chain(:keep_cache => true) { |criteria| criteria._includes = values }
-  end
-
-  def merge!(criteria, options={})
-    super
-    self._includes = self._includes + criteria._includes
-
-    # XXX Not pretty hack
-    if criteria._includes.present? && cached?
-      perform_eager_loading(@cache)
-    end
-  end
-
-  def each(options={}, &block)
-    return super unless should_eager_load? && !options[:no_eager_loading] && block
-
-    docs = []
-    super(options.merge(:no_eager_loading => true)) { |doc| docs << doc }
-    perform_eager_loading(docs)
-    docs.each(&block)
-    self
-  end
-
-  private
-
-  def should_eager_load?
-    self._includes.present? && !raw?
-  end
-
-  def get_one(criteria)
-    super.tap { |doc| perform_eager_loading([doc]) }
-  end
-
-  def perform_eager_loading(docs)
-    if should_eager_load? && docs.present?
-      NoBrainer::Document::Association::EagerLoader.new.eager_load(docs, self._includes)
-    end
-  end
-end

data/lib/no_brainer/version.rb

@@ -1,3 +0,0 @@
-module NoBrainer
-  VERSION = '0.9.0'
-end