nobrainer 0.14.0 → 0.15.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 43783bcf0d625af679de685ab771782ce9b141f3
-  data.tar.gz: 4b5e4ff205f55adb754133b681b6e71c71772790
+  metadata.gz: e97dd4f563340a2c8551ffefb21f22fc628954b2
+  data.tar.gz: 1fca054e8f966be9e7518f8245c39987d40068c7
 SHA512:
-  metadata.gz: 1c182d056390dd2c7b51bac68999d79c72cfaca49837239c4eead56ce8d0ff474630cc7b24e9fa12a4ff8d36641a5f6cc46fb7c588c45e975af42e8d4b5dbebc
-  data.tar.gz: 5226adb01498de4e82f8b3a4729c818ed1a40dc07e3596061d64956407b9a62129108046e0625bbe60bcac1804f0b8111cab4ec3a736151b6cfdc3d5799f2d88
+  metadata.gz: 1cbfebfa6ac2922e733d157522eda4e6c9edf9de9e51601f6892ac2ac2814593ed20807c68441a2ff7391398cf37896eeb739eaf2cdafa0da8e9fe91bb02fce2
+  data.tar.gz: ace1719ae85c7593145e81818fb1b93f715ad65d4634130c664b0fdd134c637aba0395066163b9fd3aee91f7ec0b27a53338e857ec2c089a4b425e02f2eba00b

data/lib/no_brainer/config.rb

@@ -4,7 +4,8 @@ module NoBrainer::Config
   class << self
     mattr_accessor :rethinkdb_url, :logger, :warn_on_active_record,
                    :auto_create_databases, :auto_create_tables,
-                   :max_reconnection_tries, :durability, :colorize_logger,
+                   :max_reconnection_tries, :durability,
+                   :user_timezone, :db_timezone, :colorize_logger,
                    :distributed_lock_class
 
     def apply_defaults
@@ -15,6 +16,8 @@ module NoBrainer::Config
       self.auto_create_tables      = true
       self.max_reconnection_tries  = 10
       self.durability              = default_durability
+      self.user_timezone           = :local
+      self.db_timezone             = :utc
       self.colorize_logger         = true
       self.distributed_lock_class  = nil
     end
@@ -27,6 +30,7 @@ module NoBrainer::Config
     def configure(&block)
       apply_defaults unless configured?
       block.call(self) if block
+      assert_valid_options!
       @configured = true
 
       NoBrainer.disconnect_if_url_changed
@@ -36,6 +40,18 @@ module NoBrainer::Config
       !!@configured
     end
 
+    def assert_valid_options!
+      assert_array_in :durability,    [:hard, :soft]
+      assert_array_in :user_timezone, [:unchanged, :utc, :local]
+      assert_array_in :db_timezone,   [:unchanged, :utc, :local]
+    end
+
+    def assert_array_in(name, values)
+      unless __send__(name).in?(values)
+        raise ArgumentError.new("Unknown configuration for #{name}: #{__send__(name)}. Valid values are: #{values.inspect}")
+      end
+    end
+
     def default_rethinkdb_url
       db = ENV['RETHINKDB_DB'] || ENV['RDB_DB']
       db ||= "#{Rails.application.class.parent_name.underscore}_#{Rails.env}" rescue nil

data/lib/no_brainer/criteria/count.rb

@@ -2,7 +2,7 @@ module NoBrainer::Criteria::Count
   extend ActiveSupport::Concern
 
   def count
-    run(to_rql.count)
+    run(without_ordering.to_rql.count)
   end
 
   def empty?

data/lib/no_brainer/criteria/first.rb

@@ -17,6 +17,12 @@ module NoBrainer::Criteria::First
     last.tap { |doc| raise NoBrainer::Error::DocumentNotFound unless doc }
   end
 
+  def sample(n=nil)
+    result = NoBrainer.run { self.without_ordering.to_rql.sample(n.nil? ? 1 : n) }
+    result = result.map(&method(:instantiate_doc))
+    n.nil? ? result.first : result
+  end
+
   private
 
   def get_one(criteria)

data/lib/no_brainer/criteria/where.rb

@@ -54,24 +54,26 @@ module NoBrainer::Criteria::Where
     end
   end
 
-  class BinaryOperator < Struct.new(:key, :op, :value, :criteria)
+  class BinaryOperator < Struct.new(:key, :op, :value, :criteria, :casted_values)
     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)), criteria)
-        when Array then BinaryOperator.new(key, :in, value.map(&method(:cast_value)).uniq, criteria)
+        when Range then BinaryOperator.new(key, :between, (cast_value(value.min)..cast_value(value.max)), criteria, true)
+        when Array then BinaryOperator.new(key, :in, value.map(&method(:cast_value)).uniq, criteria, true)
         else raise ArgumentError.new ":in takes an array/range, not #{value}"
         end
-      else BinaryOperator.new(key, op, cast_value(value), criteria)
+      when :between then BinaryOperator.new(key, :between, (cast_value(value.min)..cast_value(value.max)), criteria, true)
+      else BinaryOperator.new(key, op, cast_value(value), criteria, true)
       end
     end
 
     def to_rql(doc)
       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])
+      when :in      then RethinkDB::RQL.new.expr(value).contains(doc[key])
       else doc[key].__send__(op, value)
       end
     end
@@ -87,6 +89,8 @@ module NoBrainer::Criteria::Where
     end
 
     def cast_value(value)
+      return value if casted_values
+
       case association
       when NoBrainer::Document::Association::BelongsTo::Metadata
         target_klass = association.target_klass
@@ -99,6 +103,8 @@ module NoBrainer::Criteria::Where
     end
 
     def cast_key(key)
+      return key if casted_values
+
       case association
       when NoBrainer::Document::Association::BelongsTo::Metadata
         association.foreign_key

data/lib/no_brainer/decorated_symbol.rb

@@ -2,7 +2,8 @@ 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}
+                :lt => :lt, :le => :le, :lte => :le,
+                :defined => :defined }
 
   def self.hook
     Symbol.class_eval do

data/lib/no_brainer/document/attributes.rb

@@ -1,7 +1,5 @@
 module NoBrainer::Document::Attributes
-  VALID_FIELD_OPTIONS = [:index, :default, :type, :cast_user_to_db,
-                         :cast_db_to_user, :validates, :required, :unique,
-                         :readonly, :primary_key]
+  VALID_FIELD_OPTIONS = [:index, :default, :type, :validates, :required, :unique, :in, :readonly, :primary_key]
   RESERVED_FIELD_NAMES = [:index, :default, :and, :or, :selector, :associations, :pk_value] \
                           + NoBrainer::DecoratedSymbol::MODIFIERS.keys
   extend ActiveSupport::Concern
@@ -64,6 +62,10 @@ module NoBrainer::Document::Attributes
     Hash[@_attributes.sort_by { |k,v| self.class.fields.keys.index(k.to_sym) || 2**10 }]
   end
 
+  def to_s
+    "#<#{self.class} #{self.class.pk_name}: #{self.pk_value.inspect}>"
+  end
+
   def inspect
     "#<#{self.class} #{inspectable_attributes.map { |k,v| "#{k}: #{v.inspect}" }.join(', ')}>"
   end

data/lib/no_brainer/document/criteria.rb

@@ -10,7 +10,7 @@ module NoBrainer::Document::Criteria
   module ClassMethods
     delegate :to_rql,                        # Core
              :limit, :offset, :skip,         # Limit
-             :order_by, :reverse_order,      # OrderBy
+             :order_by, :reverse_order, :without_ordering, # OrderBy
              :scoped, :unscoped,             # Scope
              :where, :with_index, :without_index, :used_index, :indexed?, # Where
              :with_cache, :without_cache,    # Cache
@@ -18,7 +18,7 @@ module NoBrainer::Document::Criteria
              :delete_all, :destroy_all,      # Delete
              :includes, :preload,            # Preload
              :each, :to_a,                   # Enumerable
-             :first, :last, :first!, :last!, # First
+             :first, :last, :first!, :last!, :sample, # First
              :update_all, :replace_all,      # Update
              :to => :all
 

data/lib/no_brainer/document/persistance.rb

@@ -28,7 +28,7 @@ module NoBrainer::Document::Persistance
 
   def _create(options={})
     return false if options[:validate] && !valid?
-    keys = self.class.insert_all(@_attributes)
+    keys = self.class.insert_all(self.class.persistable_attributes(@_attributes))
     self.pk_value ||= keys.first
     @new_record = false
     true
@@ -50,7 +50,7 @@ module NoBrainer::Document::Persistance
       attr = RethinkDB::RQL.new.literal(attr) if attr.is_a?(Hash)
       [k, attr]
     end]
-    _update(attrs) if attrs.present?
+    _update(self.class.persistable_attributes(attrs)) if attrs.present?
     true
   end
 

data/lib/no_brainer/document/types.rb

@@ -1,102 +1,7 @@
 module NoBrainer::Document::Types
   extend ActiveSupport::Concern
 
-  module CastUserToDB
-    extend self
-    InvalidType = NoBrainer::Error::InvalidType
-
-    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)
-      public_method(type.to_s)
-    rescue NameError
-      proc { raise InvalidType }
-    end
-  end
-
-  module CastDBToUser
-    extend self
-
-    def Symbol(value)
-      value.to_sym rescue value
-    end
-
-    def lookup(type)
-      public_method(type.to_s)
-    rescue NameError
-      nil
-    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
-
-    # Fast access for db->user cast methods for performance when reading from
-    # the database.
-    singleton_class.send(:attr_accessor, :cast_db_to_user_fields)
-    self.cast_db_to_user_fields = Set.new
-  end
+  included { before_validation :add_type_errors }
 
   def add_type_errors
     return unless @pending_type_errors
@@ -108,49 +13,59 @@ module NoBrainer::Document::Types
   def assign_attributes(attrs, options={})
     super
     if options[:from_db]
-      self.class.cast_db_to_user_fields.each do |attr|
-        field_def = self.class.fields[attr]
-        type = field_def[:type]
-        value = @_attributes[attr.to_s]
-        unless value.nil? || value.is_a?(type)
-          @_attributes[attr.to_s] = field_def[:cast_db_to_user].call(value)
-        end
-      end
+      @_attributes = Hash[@_attributes.map do |k,v|
+        [k, self.class.cast_db_to_model_for(k, v)]
+      end].with_indifferent_access
     end
   end
 
   module ClassMethods
-    def cast_user_to_db_for(attr, value)
-      field_def = fields[attr.to_sym]
-      return value if !field_def
-      type = field_def[:type]
-      return value if value.nil? || type.nil? || value.is_a?(type)
-      field_def[:cast_user_to_db].call(value)
+    def cast_user_to_model_for(attr, value)
+      type = fields[attr.to_sym].try(:[], :type)
+      return value if type.nil? || value.nil?
+      if type.respond_to?(:nobrainer_cast_user_to_model)
+        type.nobrainer_cast_user_to_model(value)
+      else
+        raise NoBrainer::Error::InvalidType unless value.is_a?(type)
+        value
+      end
     rescue NoBrainer::Error::InvalidType => error
-      error.type = field_def[:type]
+      error.type = type
       error.value = value
       error.attr_name = attr
       raise error
     end
 
-    def inherited(subclass)
-      super
-      subclass.cast_db_to_user_fields = self.cast_db_to_user_fields.dup
+    def cast_model_to_db_for(attr, value)
+      type = fields[attr.to_sym].try(:[], :type)
+      return value if type.nil? || value.nil? || !type.respond_to?(:nobrainer_cast_model_to_db)
+      type.nobrainer_cast_model_to_db(value)
+    end
+
+    def cast_db_to_model_for(attr, value)
+      type = fields[attr.to_sym].try(:[], :type)
+      return value if type.nil? || value.nil? || !type.respond_to?(:nobrainer_cast_db_to_model)
+      type.nobrainer_cast_db_to_model(value)
+    end
+
+    def cast_user_to_db_for(attr, value)
+      value = cast_user_to_model_for(attr, value)
+      cast_model_to_db_for(attr, value)
+    end
+
+    def persistable_attributes(attrs)
+      Hash[attrs.map { |k,v| [k, cast_model_to_db_for(k, v)] }]
     end
 
     def _field(attr, options={})
       super
 
-      if options[:cast_db_to_user]
-        ([self] + descendants).each do |klass|
-          klass.cast_db_to_user_fields << attr
-        end
-      end
+      NoBrainer::Document::Types.load_type_extensions(options[:type]) if options[:type]
 
       inject_in_layer :types do
         define_method("#{attr}=") do |value|
           begin
-            value = self.class.cast_user_to_db_for(attr, value)
+            value = self.class.cast_user_to_model_for(attr, value)
             @pending_type_errors.try(:delete, attr)
           rescue NoBrainer::Error::InvalidType => error
             @pending_type_errors ||= {}
@@ -163,21 +78,38 @@ module NoBrainer::Document::Types
       end
     end
 
-    def field(attr, options={})
-      if options[:type]
-        options = options.merge(
-          :cast_user_to_db => NoBrainer::Document::Types::CastUserToDB.lookup(options[:type]),
-          :cast_db_to_user => NoBrainer::Document::Types::CastDBToUser.lookup(options[:type]))
-      end
-      super
-    end
-
     def _remove_field(attr, options={})
       super
+
       inject_in_layer :types do
         remove_method("#{attr}=")
         remove_method("#{attr}?") if method_defined?("#{attr}?")
       end
     end
+
+    def field(attr, options={})
+      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', 'boolean')
+  Boolean = NoBrainer::Boolean
+
+  class << self
+    mattr_accessor :loaded_extensions
+    self.loaded_extensions = Set.new
+    def load_type_extensions(klass)
+      unless loaded_extensions.include?(klass)
+        begin
+          require File.join(File.dirname(__FILE__), 'types', klass.name.underscore)
+        rescue LoadError
+        end
+        loaded_extensions << klass
+      end
+    end
   end
 end

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

@@ -0,0 +1,26 @@
+# We namespace our fake Boolean class to avoid polluting the global namespace
+class NoBrainer::Boolean
+  def initialize; raise; end
+  def self.inspect; 'Boolean'; end
+  def self.to_s; inspect; end
+  def self.name; inspect; end
+
+  module NoBrainerExtentions
+    InvalidType = NoBrainer::Error::InvalidType
+
+    def nobrainer_cast_user_to_model(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
+  end
+  extend NoBrainerExtentions
+end
+

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

@@ -0,0 +1,26 @@
+class Date
+  module NoBrainerExtentions
+    InvalidType = NoBrainer::Error::InvalidType
+
+    def nobrainer_cast_user_to_model(value)
+      case value
+      when Date then value
+      when String
+        value = value.strip
+        date = Date.parse(value) rescue (raise InvalidType)
+        raise InvalidType unless date.iso8601 == value
+        date
+      else raise InvalidType
+      end
+    end
+
+    def nobrainer_cast_db_to_model(value)
+      value.is_a?(Time) ? value.to_date : value
+    end
+
+    def nobrainer_cast_model_to_db(value)
+      value.is_a?(Date) ? Time.utc(value.year, value.month, value.day) : value
+    end
+  end
+  extend NoBrainerExtentions
+end

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

@@ -0,0 +1,20 @@
+class Float
+  module NoBrainerExtentions
+    InvalidType = NoBrainer::Error::InvalidType
+
+    def nobrainer_cast_user_to_model(value)
+      case value
+      when Float   then 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
+  end
+  extend NoBrainerExtentions
+end

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

@@ -0,0 +1,18 @@
+class Integer
+  module NoBrainerExtentions
+    InvalidType = NoBrainer::Error::InvalidType
+
+    def nobrainer_cast_user_to_model(value)
+      case value
+      when Integer then 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
+  end
+  extend NoBrainerExtentions
+end

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

@@ -0,0 +1,14 @@
+class String
+  module NoBrainerExtentions
+    InvalidType = NoBrainer::Error::InvalidType
+
+    def nobrainer_cast_user_to_model(value)
+      case value
+      when String then value
+      when Symbol then value.to_s
+      else raise InvalidType
+      end
+    end
+  end
+  extend NoBrainerExtentions
+end

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

@@ -0,0 +1,21 @@
+class Symbol
+  module NoBrainerExtentions
+    InvalidType = NoBrainer::Error::InvalidType
+
+    def nobrainer_cast_user_to_model(value)
+      case value
+      when Symbol then value
+      when String
+        value = value.strip
+        raise InvalidType if value.empty?
+        value.to_sym
+      else raise InvalidType
+      end
+    end
+
+    def nobrainer_cast_db_to_model(value)
+      value.to_sym rescue (value.to_s.to_sym rescue value)
+    end
+  end
+  extend NoBrainerExtentions
+end

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

@@ -0,0 +1,41 @@
+require 'time'
+
+class Time
+  module NoBrainerExtentions
+    InvalidType = NoBrainer::Error::InvalidType
+
+    def nobrainer_cast_user_to_model(value)
+      case value
+      when Time then time = value
+      when String
+        value = value.strip.sub(/Z$/, '+00:00')
+        # Using DateTime to preserve the timezone offset
+        dt = DateTime.parse(value) rescue (raise InvalidType)
+        time = Time.new(dt.year, dt.month, dt.day, dt.hour, dt.minute, dt.second, dt.zone)
+        raise InvalidType unless time.iso8601 == value
+      else raise InvalidType
+      end
+
+      nobrainer_timezoned(NoBrainer::Config.user_timezone, time)
+    end
+
+    def nobrainer_cast_db_to_model(value)
+      return value unless value.is_a?(Time)
+      nobrainer_timezoned(NoBrainer::Config.user_timezone, value)
+    end
+
+    def nobrainer_cast_model_to_db(value)
+      return value unless value.is_a?(Time)
+      nobrainer_timezoned(NoBrainer::Config.db_timezone, value)
+    end
+
+    def nobrainer_timezoned(tz, value)
+      case tz
+      when :local     then value.getlocal
+      when :utc       then value.getutc
+      when :unchanged then value
+      end
+    end
+  end
+  extend NoBrainerExtentions
+end

data/lib/no_brainer/document/validation.rb

@@ -18,6 +18,7 @@ module NoBrainer::Document::Validation
       super
       validates(attr, { :presence => options[:required] }) if options.has_key?(:required)
       validates(attr, { :uniqueness => options[:unique] }) if options.has_key?(:unique)
+      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

@@ -33,7 +33,7 @@ module NoBrainer::Error
     end
 
     def message
-      "#{attr_name} should be used with a #{human_type_name}. Got `#{value}`"
+      "#{attr_name} should be used with a #{human_type_name}. Got `#{value}` (#{value.class})"
     end
   end
 end

data/lib/nobrainer.rb

@@ -45,6 +45,10 @@ module NoBrainer
     def jruby?
       RUBY_PLATFORM == 'java'
     end
+
+    def user_caller
+      caller.reject { |s| s =~ /\/no_brainer\// }.first
+    end
   end
 
   DecoratedSymbol.hook

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

@@ -2,7 +2,8 @@ require "rails/generators/nobrainer"
 
 module NoBrainer::Generators
   class ModelGenerator < Base
-    argument :attributes, :type => :array, default: [], banner: "field ... field"
+    argument(:attributes, :type => :array, default: [],
+             banner: "field[:type][:index] ... field[:type][:index]")
 
     check_class_collision
 

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

@@ -2,12 +2,17 @@
 class <%= class_name %><%= " < #{options[:parent].classify}" if options[:parent] %>
 <% unless options[:parent] -%>
   include NoBrainer::Document
+  include NoBrainer::Document::Timestamps
+
 <% end -%>
 <% attributes.reject(&:reference?).each do |attribute| -%>
-  field :<%= attribute.name %>
+  field :<%= attribute.name -%>
+<%= puts attribute; ", :type => #{attribute.type.to_s.classify}" if attribute.type != :object -%>
+<%= ", :index => true" if attribute.has_index? %>
 <% end -%>
 <% attributes.select(&:reference?).each do |attribute| -%>
-  belongs_to :<%= attribute.name %>
+  belongs_to :<%= attribute.name -%>
+<%= ", :index => true" if attribute.has_index? %>
 <% end -%>
 end
 <% end -%>

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: nobrainer
 version: !ruby/object:Gem::Version
-  version: 0.14.0
+  version: 0.15.0
 platform: ruby
 authors:
 - Nicolas Viennot
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-06-17 00:00:00.000000000 Z
+date: 2014-07-27 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rethinkdb
@@ -119,6 +119,13 @@ files:
 - lib/no_brainer/document/store_in.rb
 - lib/no_brainer/document/timestamps.rb
 - lib/no_brainer/document/types.rb
+- lib/no_brainer/document/types/boolean.rb
+- lib/no_brainer/document/types/date.rb
+- lib/no_brainer/document/types/float.rb
+- lib/no_brainer/document/types/integer.rb
+- lib/no_brainer/document/types/string.rb
+- lib/no_brainer/document/types/symbol.rb
+- lib/no_brainer/document/types/time.rb
 - lib/no_brainer/document/uniqueness.rb
 - lib/no_brainer/document/validation.rb
 - lib/no_brainer/error.rb