nobrainer 0.19.0 → 0.20.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 5dc33c00dc3aa418ae3bd36b0ccb2618a8c0e47f
-  data.tar.gz: 3a4c171e4c41341d14a3c4b6103b463be1b12701
+  metadata.gz: 745af373e58173ca12eaee6f9be89f13ab3f56dd
+  data.tar.gz: 97d1cd1c63e4385ce5088b388bdd6392209dbe2e
 SHA512:
-  metadata.gz: 70af56ece8a93103f310a729c338631e0bc56b52d4725ea2a304dfdb389e04fb530fda2b3d8039ec36e4f175ae9d510f3eb765fdf2d7a6f155ea37b822f0f464
-  data.tar.gz: 58371614f47e835c11b183fd2b004271b7c0031f27de8b17a9f8b0d3d2c4ee185a4e32efb5e495f5f6cf0b53fa9f64e4510150cfff3305d237431ec195733b13
+  metadata.gz: 68609237b83a8df18d129dc5732eb02e83ed03f362d78c605b092bb96f2e00527a33c6f498f41fe5544ee0b258e3ca3104ffab456d85ed2a33dfe26ac6869c24
+  data.tar.gz: e74bef453c44b4b3588e23756e8204d228c27a1cfe0868ae5a887f86fce37b8247956ebec9aca2f71f2fb3b06694dc8d3aed498482f60a5c3c16af8fe5629f07

data/lib/no_brainer/config.rb

@@ -16,6 +16,8 @@ module NoBrainer::Config
     :colorize_logger        => { :default => ->{ true }, :valid_values => [true, false] },
     :distributed_lock_class => { :default => ->{ nil } },
     :per_thread_connection  => { :default => ->{ false }, :valid_values => [true, false] },
+    :machine_id             => { :default => ->{ default_machine_id } },
+    :geo_options            => { :default => ->{ {:geo_system => 'WGS84', :unit => 'm'} } },
   }
 
   class << self
@@ -32,7 +34,11 @@ module NoBrainer::Config
       @applied_defaults_for.each { |k| __send__("#{k}=", SETTINGS[k][:default].call) }
     end
 
-    def assert_valid_options!
+    def geo_options=(value)
+      @geo_options = value.try(:symbolize_keys)
+    end
+
+    def assert_valid_options
       SETTINGS.each { |k,v| assert_array_in(k, v[:valid_values]) if v[:valid_values] }
     end
 
@@ -44,7 +50,7 @@ module NoBrainer::Config
       @applied_defaults_for.to_a.each { |k| remove_instance_variable("@#{k}") }
       block.call(self) if block
       apply_defaults
-      assert_valid_options!
+      assert_valid_options
       @configured = true
 
       NoBrainer::ConnectionManager.disconnect_if_url_changed
@@ -95,5 +101,30 @@ module NoBrainer::Config
     def default_max_retries_on_connection_failure
       dev_mode? ? 1 : 15
     end
+
+    def default_machine_id
+      require 'socket'
+      require 'digest/md5'
+
+      return ENV['MACHINE_ID'] if ENV['MACHINE_ID']
+
+      host = Socket.gethostname
+      if host.in? %w(127.0.0.1 localhost)
+        raise "Please configure NoBrainer::Config.machine_id due to lack of appropriate hostname (Socket.gethostname = #{host})"
+      end
+
+      Digest::MD5.digest(host).unpack("N")[0] & NoBrainer::Document::PrimaryKey::Generator::MACHINE_ID_MASK
+    end
+
+    def machine_id=(machine_id)
+      machine_id = case machine_id
+        when Integer    then machine_id
+        when /^[0-9]+$/ then machine_id.to_i
+        else raise "Invalid machine_id"
+      end
+      max_id = NoBrainer::Document::PrimaryKey::Generator::MACHINE_ID_MASK
+      raise "Invalid machine_id (must be between 0 and #{max_id})" unless machine_id.in?(0..max_id)
+      @machine_id = machine_id
+    end
   end
 end

data/lib/no_brainer/criteria/where.rb

@@ -1,5 +1,5 @@
 module NoBrainer::Criteria::Where
-  NON_CHAINABLE_OPERATORS = %w(in nin eq ne not gt ge gte lt le lte defined).map(&:to_sym)
+  NON_CHAINABLE_OPERATORS = %w(in nin eq ne not gt ge gte lt le lte defined near intersects).map(&:to_sym)
   CHAINABLE_OPERATORS = %w(any all).map(&:to_sym)
   OPERATORS = CHAINABLE_OPERATORS + NON_CHAINABLE_OPERATORS
 
@@ -96,7 +96,7 @@ module NoBrainer::Criteria::Where
           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}"
+          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
@@ -123,8 +123,16 @@ module NoBrainer::Criteria::Where
 
     def to_rql_scalar(lvalue)
       case op
-      when :between then (lvalue >= value.min) & (lvalue <= value.max)
-      when :in      then RethinkDB::RQL.new.expr(value).contains(lvalue)
+      when :between    then (lvalue >= value.min) & (lvalue <= value.max)
+      when :in         then RethinkDB::RQL.new.expr(value).contains(lvalue)
+      when :intersects then lvalue.intersects(value.to_rql)
+      when :near
+        options = value.dup
+        point = options.delete(:point)
+        max_dist = options.delete(:max_dist)
+        # XXX max_results is not used, seems to be a workaround of rethinkdb index implemetnation.
+        _ = options.delete(:max_results)
+        RethinkDB::RQL.new.distance(lvalue, point.to_rql, options) <= max_dist
       else lvalue.__send__(op, value)
       end
     end
@@ -153,9 +161,28 @@ module NoBrainer::Criteria::Where
         raise NoBrainer::Error::InvalidType.new(opts) unless value.is_a?(target_model)
         value.pk_value
       else
-        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
+        case op
+        when :intersects
+          raise "Use a geo object with `intersects`" unless value.is_a?(NoBrainer::Geo::Base)
+          value
+        when :near
+          raise "Incorrect use of `near': rvalue must be a hash" unless value.is_a?(Hash)
+          options = NoBrainer::Geo::Base.normalize_geo_options(value)
+
+          unless options[:point] && options[:max_dist]
+            raise "`near' takes something like {:point => P, :max_distance => d}"
+          end
+
+          unless options[:point].is_a?(NoBrainer::Geo::Point)
+            options[:point] = NoBrainer::Geo::Point.nobrainer_cast_user_to_model(options[:point])
+          end
+
+          options
+        else
+          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
     end
@@ -257,9 +284,11 @@ module NoBrainer::Criteria::Where
         lambda do |rql|
           opt = (rql_options || {}).merge(:index => index.aliased_name)
           r = rql.__send__(rql_op, *rql_args, opt)
+          r = r.map { |i| i['doc'] } if rql_op == :get_nearest
           # TODO distinct: waiting for issue #3345
           # TODO coerce_to: waiting for issue #3346
-          index.multi ? r.coerce_to('array').distinct : r
+          r = r.coerce_to('array').distinct if index.multi
+          r
         end
       end
     end
@@ -278,29 +307,35 @@ module NoBrainer::Criteria::Where
     end
 
     def find_strategy_canonical
-      clauses = Hash[get_candidate_clauses(:eq, :in, :between).map { |c| [c.key, c] }]
+      clauses = get_candidate_clauses(:eq, :in, :between, :near, :intersects)
       return nil unless clauses.present?
 
-      get_usable_indexes.each do |index|
-        clause = clauses[index.name]
-        next unless clause.try(:compatible_with_index?, index)
+      usable_indexes = Hash[get_usable_indexes.map { |i| [i.name, i] }]
+      clauses.map do |clause|
+        index = usable_indexes[clause.key]
+        next unless index && clause.compatible_with_index?(index)
+        next unless index.geo == [:near, :intersects].include?(clause.op)
 
         args = case clause.op
+          when :intersects then [:get_intersecting, clause.value.to_rql]
+          when :near
+            options = clause.value.dup
+            point = options.delete(:point)
+            [:get_nearest, point.to_rql, options]
           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
+        IndexStrategy.new(ast, [clause], index, *args)
+      end.compact.sort_by { |strat| usable_indexes.values.index(strat.index) }.first
     end
 
     def find_strategy_compound
       clauses = Hash[get_candidate_clauses(:eq).map { |c| [c.key, c] }]
       return nil unless clauses.present?
 
-      get_usable_indexes(:kind => :compound, :multi => false).each do |index|
+      get_usable_indexes(:kind => :compound, :geo => false, :multi => false).each do |index|
         indexed_clauses = index.what.map { |field| clauses[field] }
         next unless indexed_clauses.all? { |c| c.try(:compatible_with_index?, index) }
 
@@ -313,7 +348,7 @@ module NoBrainer::Criteria::Where
       clauses = get_candidate_clauses(:gt, :ge, :lt, :le).group_by(&:key)
       return nil unless clauses.present?
 
-      get_usable_indexes.each do |index|
+      get_usable_indexes(:geo => false).each do |index|
         matched_clauses = clauses[index.name].try(:select) { |c| c.compatible_with_index?(index) }
         next unless matched_clauses.present?
 

data/lib/no_brainer/document.rb

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

data/lib/no_brainer/document/criteria.rb

@@ -51,17 +51,15 @@ module NoBrainer::Document::Criteria
       rql_table.get(pk)
     end
 
-    # XXX this doesn't have the same semantics as other ORMs. the equivalent is find!.
-    def find(pk)
+    def find?(pk)
       attrs = NoBrainer.run { selector_for(pk) }
       new_from_db(attrs).tap { |doc| doc.run_callbacks(:find) } if attrs
     end
 
-    def find!(pk)
-      find(pk).tap do |doc|
-        raise NoBrainer::Error::DocumentNotFound, "#{self} #{pk_name}: #{pk} not found" unless doc
-      end
+    def find(pk)
+      find?(pk).tap { |doc| raise NoBrainer::Error::DocumentNotFound, "#{self} #{pk_name}: #{pk} not found" unless doc }
     end
+    alias_method :find!, :find
 
     def disable_perf_warnings
       self.perf_warnings_disabled = true

data/lib/no_brainer/document/index/index.rb

@@ -9,7 +9,8 @@ class NoBrainer::Document::Index::Index < Struct.new(
     self.name = self.name.to_sym
     self.aliased_name = self.aliased_name.to_sym
     self.external = !!self.external
-    self.geo = !!self.geo
+    # geo defaults for true with geo types.
+    self.geo = !!model.fields[name].try(:[], :type).try(:<, NoBrainer::Geo::Base) if self.geo.nil?
     self.multi = !!self.multi
   end
 

data/lib/no_brainer/document/{id.rb → primary_key.rb}

@@ -1,8 +1,7 @@
-require 'thread'
-require 'socket'
-require 'digest/md5'
+module NoBrainer::Document::PrimaryKey
+  extend NoBrainer::Autoload
+  autoload :Generator
 
-module NoBrainer::Document::Id
   extend ActiveSupport::Concern
 
   DEFAULT_PK_NAME = :id
@@ -24,40 +23,10 @@ module NoBrainer::Document::Id
 
   delegate :hash, :to => :pk_value
 
-  # The following code is inspired by the mongo-ruby-driver
-
-  @machine_id = Digest::MD5.digest(Socket.gethostname)[0, 3]
-  @lock = Mutex.new
-  @index = 0
-
-  def self.get_inc
-    @lock.synchronize do
-      @index = (@index + 1) % 0xFFFFFF
-    end
-  end
-
-  # TODO Unit test that thing
-  def self.generate
-    oid = ''
-    # 4 bytes current time
-    oid += [Time.now.to_i].pack("N")
-
-    # 3 bytes machine
-    oid += @machine_id
-
-    # 2 bytes pid
-    oid += [Process.pid % 0xFFFF].pack("n")
-
-    # 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
-  end
-
   module ClassMethods
     def define_default_pk
       class_variable_set(:@@pk_name, nil)
-      field NoBrainer::Document::Id::DEFAULT_PK_NAME, :primary_key => :default
+      field NoBrainer::Document::PrimaryKey::DEFAULT_PK_NAME, :primary_key => :default
     end
 
     def define_pk(attr)
@@ -83,7 +52,7 @@ module NoBrainer::Document::Id
 
         if options[:type].in?([String, nil]) && options[:default].nil?
           options[:type] = String
-          options[:default] = ->{ NoBrainer::Document::Id.generate }
+          options[:default] = ->{ NoBrainer::Document::PrimaryKey::Generator.generate }
         end
       end
       super

data/lib/no_brainer/document/primary_key/generator.rb

@@ -0,0 +1,83 @@
+module NoBrainer::Document::PrimaryKey::Generator
+  class Retry < RuntimeError; end
+
+  BASE_TABLE = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz".freeze
+
+  TIME_OFFSET = Time.parse('2014-01-01').to_i
+
+  # 30 bits timestamp with 1s resolution -> We overflow in year 2048. Good enough.
+  # Math.log(Time.parse('2048-01-01').to_f - TIME_OFFSET)/Math.log(2) = 29.999
+  TIMESTAMP_BITS = 30
+
+  # 14 bits of sequence number. max 16k values per 1s slices.
+  # We want something >10k because we want to be able to do high speed inserts
+  # on a single process for future benchmarks.
+  SEQUENCE_BITS = 14
+
+  # 24 bits of machine id
+  # 0.1% of chance to have a collision with 183 servers:
+  # Math.sqrt(-2*(2**24)*Math.log(0.999)) = 183.2
+  # 1% of chance to have a collision with ~580 servers.
+  # When using more than 500 machines, it's therefore a good
+  # idea to set the machine_id manually to avoid collisions.
+  MACHINE_ID_BITS = 24
+
+  # 15 bits for the current pid. We wouldn't need it if the sequence number was
+  # on a piece of shared memory :)
+  PID_BITS = 15
+
+  # Total: 83 bits
+  # We need at most 14 digits in [A-Za-z0-9] to represent 83 bits:
+  # Math.log(62**14)/Math.log(2) = 83.35
+  ID_STR_LENGTH = 14
+
+  TIMESTAMP_MASK  = (1 <<  TIMESTAMP_BITS)-1
+  SEQUENCE_MASK   = (1 <<   SEQUENCE_BITS)-1
+  MACHINE_ID_MASK = (1 << MACHINE_ID_BITS)-1
+  PID_MASK        = (1 <<        PID_BITS)-1
+
+  PID_SHIFT        = 0
+  MACHINE_ID_SHIFT = PID_SHIFT + PID_BITS
+  SEQUENCE_SHIFT   = MACHINE_ID_SHIFT + MACHINE_ID_BITS
+  TIMESTAMP_SHIFT  = SEQUENCE_SHIFT + SEQUENCE_BITS
+
+  def self._generate
+    timestamp = (Time.now.to_i - TIME_OFFSET) & TIMESTAMP_MASK
+
+    unless @last_timestamp == timestamp
+      # more noise is better in the ID, but we prefer to avoid
+      # wrapping the sequences so that Model.last on a single
+      # machine returns the latest created document.
+      @first_sequence = sequence = rand(SEQUENCE_MASK/2)
+      @last_timestamp = timestamp
+    else
+      sequence = (@sequence + 1) & SEQUENCE_MASK
+      raise Retry if @first_sequence == sequence
+    end
+    @sequence = sequence
+
+    machine_id = NoBrainer::Config.machine_id & MACHINE_ID_MASK
+
+    pid = Process.pid & PID_MASK
+
+    (timestamp << TIMESTAMP_SHIFT) | (sequence << SEQUENCE_SHIFT) |
+      (machine_id << MACHINE_ID_SHIFT) | (pid << PID_SHIFT)
+  rescue Retry
+    sleep 0.1
+    retry
+  end
+
+  def self.convert_to_alphanum(id)
+    result = []
+    until id.zero?
+      id, r = id.divmod(BASE_TABLE.size)
+      result << BASE_TABLE[r]
+    end
+    result.reverse.join.rjust(ID_STR_LENGTH, BASE_TABLE[0])
+  end
+
+  @lock = Mutex.new
+  def self.generate
+    convert_to_alphanum(@lock.synchronize { _generate })
+  end
+end

data/lib/no_brainer/document/types.rb

@@ -64,6 +64,12 @@ module NoBrainer::Document::Types
 
       NoBrainer::Document::Types.load_type_extensions(options[:type]) if options[:type]
 
+      case options[:type].to_s
+      when "NoBrainer::Geo::Circle" then raise "Cannot store circles :("
+      when "NoBrainer::Geo::Polygon", "NoBrainer::Geo::LineString"
+        raise "Make a request on github if you'd like to store polygons/linestrings"
+      end
+
       inject_in_layer :types do
         define_method("#{attr}=") do |value|
           begin
@@ -94,6 +100,7 @@ module NoBrainer::Document::Types
   require File.join(File.dirname(__FILE__), 'types', 'boolean')
   Binary = NoBrainer::Binary
   Boolean = NoBrainer::Boolean
+  Geo = NoBrainer::Geo
 
   class << self
     mattr_accessor :loaded_extensions

data/lib/no_brainer/error.rb

@@ -49,7 +49,11 @@ module NoBrainer::Error
     end
 
     def message
-      "#{attr_name} should be used with a #{human_type_name}. Got `#{value}` (#{value.class})"
+      if attr_name && type && value
+        "#{attr_name} should be used with a #{human_type_name}. Got `#{value}` (#{value.class})"
+      else
+        super
+      end
     end
   end
 

data/lib/no_brainer/geo.rb

@@ -0,0 +1,4 @@
+module NoBrainer::Geo
+  extend NoBrainer::Autoload
+  autoload :Base, :Point, :Circle, :LineString, :Polygon
+end

data/lib/no_brainer/geo/base.rb

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

data/lib/no_brainer/geo/circle.rb

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

data/lib/no_brainer/geo/line_string.rb

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

data/lib/no_brainer/geo/point.rb

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

data/lib/no_brainer/geo/polygon.rb

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

data/lib/nobrainer.rb

@@ -1,5 +1,6 @@
 require 'set'
 require 'active_support'
+require 'thread'
 %w(module/delegation module/attribute_accessors module/introspection
    class/attribute object/blank object/inclusion object/deep_dup
    object/try hash/keys hash/indifferent_access hash/reverse_merge
@@ -12,7 +13,7 @@ module NoBrainer
 
   # We eager load things that could be loaded when handling the first web request.
   # Code that is loaded through the DSL of NoBrainer should not be eager loaded.
-  autoload :Document, :IndexManager, :Loader, :Fork
+  autoload :Document, :IndexManager, :Loader, :Fork, :Geo
   eager_autoload :Config, :Connection, :ConnectionManager,  :Error,
                  :QueryRunner, :Criteria, :RQL
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: nobrainer
 version: !ruby/object:Gem::Version
-  version: 0.19.0
+  version: 0.20.0
 platform: ruby
 authors:
 - Nicolas Viennot
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-11-17 00:00:00.000000000 Z
+date: 2014-12-03 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rethinkdb
@@ -129,7 +129,6 @@ files:
 - lib/no_brainer/document/criteria.rb
 - lib/no_brainer/document/dirty.rb
 - lib/no_brainer/document/dynamic_attributes.rb
-- lib/no_brainer/document/id.rb
 - lib/no_brainer/document/index.rb
 - lib/no_brainer/document/index/index.rb
 - lib/no_brainer/document/index/meta_store.rb
@@ -139,6 +138,8 @@ files:
 - lib/no_brainer/document/missing_attributes.rb
 - lib/no_brainer/document/persistance.rb
 - lib/no_brainer/document/polymorphic.rb
+- lib/no_brainer/document/primary_key.rb
+- lib/no_brainer/document/primary_key/generator.rb
 - lib/no_brainer/document/readonly.rb
 - lib/no_brainer/document/serialization.rb
 - lib/no_brainer/document/store_in.rb
@@ -157,6 +158,12 @@ files:
 - lib/no_brainer/document/validation.rb
 - lib/no_brainer/error.rb
 - lib/no_brainer/fork.rb
+- lib/no_brainer/geo.rb
+- lib/no_brainer/geo/base.rb
+- lib/no_brainer/geo/circle.rb
+- lib/no_brainer/geo/line_string.rb
+- lib/no_brainer/geo/point.rb
+- lib/no_brainer/geo/polygon.rb
 - lib/no_brainer/loader.rb
 - lib/no_brainer/locale/en.yml
 - lib/no_brainer/query_runner.rb
@@ -196,7 +203,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.4.2
+rubygems_version: 2.4.4
 signing_key: 
 specification_version: 4
 summary: ORM for RethinkDB