mongoid_geospatial 1.0.0rc0

data/lib/mongoid_geospatial/extensions/hash.rb

@@ -0,0 +1,22 @@
+# encoding: utf-8
+module Mongoid #:nodoc:
+  module Extensions #:nodoc:
+    module Hash #:nodoc:
+      module CriteriaHelpers #:nodoc:
+        def expand_complex_criteria
+          hsh = {}
+          each_pair do |k,v|
+            if k.respond_to?(:key) && k.respond_to?(:to_mongo_query)
+              hsh[k.key] ||= {}
+              hsh[k.key].merge!(k.to_mongo_query(v))
+            else
+              hsh[k] = v
+            end
+          end
+          hsh
+        end
+      end
+    end
+  end
+end
+

data/lib/mongoid_geospatial/extensions/symbol.rb

@@ -0,0 +1,46 @@
+# encoding: utf-8
+module Mongoid #:nodoc:
+  module Extensions #:nodoc:
+    module Symbol #:nodoc:
+      module Inflections #:nodoc:
+
+        # return a class that will accept a value to convert the query correctly for near
+        #
+        # @param [Symbol] calc This accepts :sphere
+        #
+        # @return [Criterion::NearSpatial]
+
+        def near(calc = :flat)
+          Criterion::NearSpatial.new(:operator => get_op('near',calc), :key => self)
+        end
+
+        # alias for self.near(:sphere)
+        #
+        # @return [Criterion::NearSpatial]
+        def near_sphere
+          self.near(:sphere)
+        end
+
+        # @param [Symbol] shape :box,:polygon,:center,:center_sphere
+        #
+        # @return [Criterion::WithinSpatial]
+        def within(shape)
+          shape = get_op(:center,:sphere) if shape == :center_sphere
+          Criterion::WithinSpatial.new(:operator => shape.to_s , :key => self)
+        end
+
+        private
+
+        def get_op operator, calc
+          if calc.to_sym == :sphere && Mongoid.master.connection.server_version >= '1.7'
+            "#{operator}Sphere"
+          elsif calc.to_sym == :sphere
+            raise "MongoDB Server version #{Mongoid.master.connection.server_version} does not have Spherical Calculation"
+          else
+            operator.to_s
+          end
+        end
+      end
+    end
+  end
+end

data/lib/mongoid_geospatial/field_option.rb

@@ -0,0 +1,16 @@
+#require 'ostruct'
+
+Mongoid::Fields.option :spatial do |model,field,options|
+  options = {} unless options.kind_of?(Hash)
+  lat_meth = options[:lat] || :lat
+  lng_meth = options[:lng] || :lng
+  model.class_eval do
+    self.spatial_fields ||= []
+    self.spatial_fields << field.name.to_sym if self.spatial_fields.kind_of? Array
+
+    define_method "distance_from_#{field.name}" do |*args|
+      self.distance_from(field.name, *args)
+    end
+
+  end
+end

data/lib/mongoid_geospatial/fields/line_string.rb

@@ -0,0 +1,18 @@
+module Mongoid
+  module Geospatial
+    class LineString
+
+      include Mongoid::Fields::Serializable
+
+      def deserialize(object)
+        RGeo::Geographic.spherical_factory.line_string *object
+      end
+
+      def serialize(object)
+        object.to_a
+      end
+
+
+    end
+  end
+end

data/lib/mongoid_geospatial/fields/point.rb

@@ -0,0 +1,51 @@
+module Mongoid
+  module Geospatial
+    class Point
+
+      include Mongoid::Fields::Serializable
+
+      def deserialize(object)
+        return unless object && !object.empty?
+        RGeo::Geographic.spherical_factory.point *object
+        #["x"], object["y"]
+      end
+
+      def serialize(object)
+        object.respond_to?(:x) ? [object.x, object.y] : object
+        # if object.respond_to? :x
+        #   { "x" => object.x, "y" => object.y }
+        # else
+        #   { "x" => object[0], "y" => object[1] }
+        # end
+      end
+
+#       -    self.spacial_fields ||= []
+# -    self.spacial_fields << field.name.to_sym if self.spacial_fields.kind_of? Array
+# -
+# -    define_method "distance_from_#{field.name}" do |*args|
+# -      self.distance_from(field.name, *args)
+# -    end
+# -
+# -    define_method field.name do
+# -      output = self[field.name] || [nil,nil]
+# -      output = {lng_meth => output[0], lat_meth => output[1]} unless options[:return_array]
+# -      return options[:class].new(output) if options[:class]
+# -      output
+# -    end
+# -
+# -    define_method "#{field.name}=" do |arg|
+# -      if arg.kind_of?(Hash) && arg[lng_meth] && arg[lat_meth]
+# -        arg = [arg[lng_meth].to_f, arg[lat_meth].to_f]
+# -      elsif arg.respond_to?(:to_lng_lat)
+# -        arg = arg.to_lng_lat
+# -      end
+# -      self[field.name]=arg
+# -      arg = [nil,nil] if arg.nil?
+# -      return arg[0..1] if options[:return_array]
+# -      h = {lng_meth => arg[0], lat_meth => arg[1]}
+# -      return h if options[:class].blank?
+# -      options[:class].new(h)
+
+    end
+  end
+end

data/lib/mongoid_geospatial/fields/polygon.rb

@@ -0,0 +1,22 @@
+module Mongoid
+  module Geospatial
+    class Polygon
+
+      include Mongoid::Fields::Serializable
+
+      def deserialize(object)
+        points = object.map do |pair|
+          RGeo::Geographic.spherical_factory.point *pair
+        end
+        ring = RGeo::Geographic.spherical_factory.linear_ring points
+        RGeo::Geographic.spherical_factory.polygon ring
+      end
+
+      def serialize(object)
+        object #.flatten
+      end
+
+
+    end
+  end
+end

data/lib/mongoid_geospatial/finders.rb

@@ -0,0 +1,5 @@
+module Mongoid #:nodoc:
+  module Finders
+    delegate :geo_near, :to => :criteria 
+  end
+end

data/lib/mongoid_geospatial/geospatial/core_ext.rb

@@ -0,0 +1,27 @@
+class Array
+  def to_lng_lat
+    self[0..1].map(&:to_f)
+  end
+end
+
+class Hash
+  def to_lng_lat
+    raise "Hash must have at least 2 items" if self.size < 2
+    [to_lng, to_lat]
+  end
+
+  def to_lat
+    v = (Mongoid::Geospatial.lat_symbols & self.keys).first
+    return self[v].to_f if !v.nil? && self[v]
+    raise "Hash must contain #{Mongoid::Geospatial.lat_symbols.inspect} if ruby version is less than 1.9" if RUBY_VERSION.to_f < 1.9
+    raise "Hash cannot contain #{Mongoid::Geospatial.lng_symbols.inspect} as the second item if there is no #{Mongoid::Geospatial.lat_symbols.inspect}" if Mongoid::Geospatial.lng_symbols.index(self.keys[1])
+    self.values[1].to_f
+  end
+
+  def to_lng
+    v = (Mongoid::Geospatial.lng_symbols & self.keys).first
+    return self[v].to_f if !v.nil? && self[v]
+    raise "Hash cannot contain #{Mongoid::Geospatial.lat_symbols.inspect} as the first item if there is no #{Mongoid::Geospatial.lng_symbols.inspect}" if Mongoid::Geospatial.lat_symbols.index(self.keys[0])
+    self.values[0].to_f
+  end
+end

data/lib/mongoid_geospatial/geospatial/geo_near_results.rb

@@ -0,0 +1,140 @@
+module Mongoid
+  module Geospatial
+    class GeoNearResults < Array
+      attr_reader :stats, :document, :_original_array, :_original_opts
+      attr_accessor :opts
+
+      def initialize(document,results,opts = {})
+        raise "#{document.name} class must include Mongoid::Geospatial::Document" unless document.respond_to?(:spatial_fields_indexed)
+        @document = document
+        @opts = opts
+        @_original_opts = opts.clone
+        @stats = results['stats'] || {}
+        @opts[:skip] ||= 0
+
+        @_original_array = results['results'].collect do |result|
+          res = Mongoid::Factory.from_db(@document, result.delete('obj'))
+          res.geo = {}
+          # camel case is awkward in ruby when using variables...
+          if result['dis']
+            res.geo[:distance] = result.delete('dis').to_f
+          end
+          result.each do |key,value|
+            res.geo[key.snakecase.to_sym] = value
+          end
+          # dist_options[:formula] = opts[:formula] if opts[:formula]
+          @opts[:calculate] = @document.spatial_fields_indexed if @document.spatial_fields_indexed.kind_of?(Array) && @opts[:calculate] == true
+          if @opts[:calculate]
+            @opts[:calculate] = [@opts[:calculate]] unless @opts[:calculate].kind_of? Array
+            @opts[:calculate] = @opts[:calculate].map(&:to_sym) & geo_fields
+            if @document.spatial_fields_indexed.kind_of?(Array) && @document.spatial_fields_indexed.size == 1
+              primary = @document.spatial_fields_indexed.first
+            end
+            @opts[:calculate].each do |key|
+              res.geo[(key.to_s+'_distance').to_sym] = res.distance_from(key,center,{:unit =>@opts[:unit] || @opts[:distance_multiplier], :spherical => @opts[:spherical]} )
+              res.geo[:distance] = res.geo[key] if primary && key == primary
+            end
+          end
+          res
+        end
+        if @opts[:page]
+          start = (@opts[:page]-1)*@opts[:per_page] # assuming current_page is 1 based.
+          @_paginated_array = @_original_array.clone
+          super(@_paginated_array[@opts[:skip]+start, @opts[:per_page]] || [])
+        else
+          super(@_original_array[@opts[:skip]..-1] || [])
+        end
+      end
+
+      def page(*args)
+        new_collection = self.clone
+        new_collection.page!(*args)
+        new_collection
+      end
+
+      def page!(page, options = {})
+        original = options.delete(:original)
+        self.opts.merge!(options)
+        self.opts[:paginator] ||= Mongoid::Geospatial.paginator
+        self.opts[:page] = page
+        start = (self.current_page-1)*self.limit_value # assuming current_page is 1 based.
+
+        if original
+          @_paginated_array = @_original_array.clone
+          self.replace(@_paginated_array[self.opts[:skip]+start, self.limit_value] || [])
+        else
+          @_paginated_array ||= self.to_a
+          self.replace(@_paginated_array[self.opts[:skip]+start, self.limit_value])
+        end
+        true
+      end
+
+      def per(num)
+        self.page(current_page, :per_page => num)
+      end
+
+      def reset!
+        self.replace(@_original_array)
+        @opts = @_original_opts
+        @_paginated_array = nil
+        true
+      end
+
+      def reset
+        clone = self.clone
+        clone.reset!
+        clone
+      end
+
+      def total_entries
+        (@_paginated_array) ? @_paginated_array.count : @_original_array.count
+      end
+      alias_method :total_count, :total_entries
+
+      def current_page
+        page = (@opts[:page]) ? @opts[:page].to_i.abs : 1
+        (page < 1) ? 1 : page
+      end
+
+      def limit_value
+        if @opts[:per_page]
+          @opts[:per_page] = @opts[:per_page].to_i.abs
+        else
+          @opts[:per_page] = case self.opts[:paginator]
+                             when :will_paginate
+                               @document.per_page
+                             when :kaminari
+                               Kaminari.config.default_per_page
+                             else
+                               Mongoid::Geospatial.default_per_page
+                             end
+        end
+      end
+      alias_method :per_page, :limit_value
+
+      def num_pages
+        (self.total_entries && @opts[:per_page]) ? (total_entries.to_f / @opts[:per_page]).ceil : nil
+      end
+      alias_method :total_pages, :num_pages
+
+      def out_of_bounds?
+        self.current_page > self.total_pages
+      end
+
+      def offset
+        (self.current_page - 1) * self.per_page
+      end
+
+      # current_page - 1 or nil if there is no previous page
+      def previous_page
+        self.current_page > 1 ? (self.current_page - 1) : nil
+      end
+
+      # current_page + 1 or nil if there is no next page
+      def next_page
+        self.current_page < self.total_pages ? (self.current_page + 1) : nil
+      end
+
+    end
+  end
+end

data/lib/mongoid_geospatial/geospatial.rb

@@ -0,0 +1,86 @@
+require 'mongoid_geospatial/geospatial/core_ext'
+require 'mongoid_geospatial/geospatial/geo_near_results'
+
+module Mongoid
+  module Geospatial
+    extend ActiveSupport::Concern
+
+    LNG_SYMBOLS = [:x, :lon, :long, :lng, :longitude]
+    LAT_SYMBOLS = [:y, :lat, :latitude]
+
+    EARTH_RADIUS_KM = 6371 # taken directly from mongodb
+
+    EARTH_RADIUS = {
+      :km => EARTH_RADIUS_KM,
+      :m  => EARTH_RADIUS_KM*1000,
+      :mi => EARTH_RADIUS_KM*0.621371192, # taken directly from mongodb
+      :ft => EARTH_RADIUS_KM*5280*0.621371192,
+      :sm => EARTH_RADIUS_KM*0.53995680345572 # sea mile
+    }
+
+    GEO_FACTORY = RGeo::Geographic.spherical_factory
+
+    included do
+      attr_accessor :geo
+      cattr_accessor :spatial_fields, :spatial_fields_indexed
+      @@spatial_fields = []
+      @@spatial_fields_indexed = []
+    end
+
+    module ClassMethods #:nodoc:
+      # create spatial index for given field
+      # @param [String,Symbol] name
+      # @param [Hash] options options for spatial_index
+
+      def spatial_index name, *options
+        self.spatial_fields_indexed << name
+        index [[ name, Mongo::GEO2D ]], *options
+      end
+    end
+
+    # def distance(p2, opts = {})
+    #   p1 = self.send(key)
+      #   Mongoid::Geospatial.distance(p1, p2, opts)
+      # end
+
+
+
+    # def self.distance(p1,p2,opts = {})
+    #   opts[:formula] ||= (opts[:spherical]) ? @@spherical_distance_formula : :pythagorean_theorem
+    #   p1 = p1.to_lng_lat if p1.respond_to?(:to_lng_lat)
+    #   p2 = p2.to_lng_lat if p2.respond_to?(:to_lng_lat)
+
+    #   rads = Formulas.send(opts[:formula], p1, p2)
+
+    #   if unit = earth_radius[opts[:unit]]
+    #     opts[:unit] = (rads.instance_variable_get("@radian")) ? unit : unit * RAD_PER_DEG
+    #   end
+
+    #   rads *= opts[:unit].to_f if opts[:unit]
+    #   rads
+
+    # end
+    RAD_PER_DEG = Math::PI/180
+    mattr_accessor :lng_symbols
+    @@lng_symbols = LNG_SYMBOLS.dup
+
+    mattr_accessor :lat_symbols
+    @@lat_symbols = LAT_SYMBOLS.dup
+
+    mattr_accessor :earth_radius
+    @@earth_radius = EARTH_RADIUS.dup
+
+    mattr_accessor :paginator
+    @@paginator = :array
+
+    mattr_accessor :default_per_page
+    @@default_per_page = 25
+
+    # mattr_accessor :spherical_distance_formula
+    # @@spherical_distance_formula = :n_vector
+    mattr_accessor :geo_factory
+    @@lng_symbols = GEO_FACTORY.dup
+
+
+  end
+end

data/lib/mongoid_geospatial/version.rb

@@ -0,0 +1,5 @@
+module Mongoid
+  module Geospatial
+    VERSION = "1.0.0rc0"
+  end
+end

data/lib/mongoid_geospatial.rb

@@ -0,0 +1,16 @@
+require 'rgeo'
+require 'mongoid'
+require 'active_support/core_ext/string/inflections'
+require 'active_support/concern'
+require 'mongoid_geospatial/contexts/mongo'
+require 'mongoid_geospatial/criteria'
+require 'mongoid_geospatial/criterion'
+require 'mongoid_geospatial/extensions/hash'
+require 'mongoid_geospatial/extensions/symbol'
+require 'mongoid_geospatial/field_option'
+require 'mongoid_geospatial/fields/point'
+require 'mongoid_geospatial/fields/polygon'
+require 'mongoid_geospatial/fields/line_string'
+require 'mongoid_geospatial/finders'
+require 'mongoid_geospatial/geospatial'
+

data/mongoid_geospatial.gemspec

@@ -0,0 +1,28 @@
+# -*- encoding: utf-8 -*-
+require File.expand_path('../lib/mongoid_geospatial/version', __FILE__)
+
+Gem::Specification.new do |gem|
+  gem.authors       = ["Ryan Ong", "Marcos Piccinini"]
+  gem.email         = ["use@git.hub.com"]
+  gem.description   = %q{mongoid_geospatial simplifies spatial calculations. Adds integration into mongoid so pagination and other function continue to work. It adds symbol extentions to simplify query creation.}
+  gem.summary       = %q{A Mongoid Extention that simplifies and adds support for MongoDB Geo Spatial Calculations.}
+  gem.homepage      = "https://github.com/nofxx/mongoid_geospatial"
+
+  gem.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  gem.files         = `git ls-files`.split("\n")
+  gem.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  gem.name          = "mongoid_geospatial"
+  gem.require_paths = ["lib"]
+  gem.version       = Mongoid::Geospatial::VERSION
+
+
+  gem.add_dependency('rgeo', ['>= 0.3.5'])
+  gem.add_dependency('mongoid', ['>= 2.1.0'])
+  gem.add_dependency('activesupport', ["~> 3.0"])
+  gem.add_development_dependency('yard', ["~>0.6.0"])
+  gem.add_development_dependency('rspec', ['~>2.3'])
+  gem.add_development_dependency('rcov', ['>= 0'])
+  gem.add_development_dependency('mocha', ['>= 0'])
+  gem.add_development_dependency('will_paginate', ['>= 0'])
+  gem.add_development_dependency('kaminari', ['>= 0'])
+end

data/spec/config/mongod.conf

@@ -0,0 +1,3 @@
+dbpath = /usr/local/var/mongodb
+master = true
+bind_ip = 127.0.0.1

data/spec/config/mongoid.yml

@@ -0,0 +1,18 @@
+test:
+  database: mongoid_config_test
+  host: localhost
+  slaves:
+    # - host: localhost
+      # port: 27018
+    # - host: localhost
+      # port: 27019
+  allow_dynamic_fields: false
+  include_root_in_json: true
+  parameterize_keys: false
+  persist_in_safe_mode: false
+  raise_not_found_error: false
+  reconnect_time: 5
+  autocreate_indexes: false
+  persist_types: false
+  option_no_exist: false
+  skip_version_check: false

data/spec/functional/contexts/mongo_spec.rb

@@ -0,0 +1,127 @@
+require "spec_helper"
+
+describe Mongoid::Contexts::Mongo do
+  describe "#geo_near" do
+
+    before do
+      Bar.delete_all
+      Bar.create_indexes
+    end
+
+    let!(:jfk) do
+      Bar.create(:name => 'jfk', :location => [-73.77694444, 40.63861111 ])
+    end
+
+    let!(:lax) do
+      Bar.create(:name => 'lax', :location => [-118.40, 33.94])
+    end
+
+    it "should work with specifying specific center and different location attribute on collction" do
+      Bar.geo_near(lax.location, :spherical => true).should == [lax, jfk]
+      Bar.geo_near(jfk.location, :spherical => true).should == [jfk, lax]
+    end
+    context 'option' do
+      context ':num' do
+        it "should limit number of results to 1" do
+          Bar.geo_near(jfk.location, :num => 1).size.should == 1
+        end
+      end
+
+      context ':maxDistance' do
+        it "should get 1 item" do
+          Bar.geo_near(lax.location, :spherical => true, :max_distance => 2465/Mongoid::Geospatial.earth_radius[:mi]).size.should == 1
+        end
+        it "should get 2 items" do
+          Bar.geo_near(lax.location, :spherical => true, :max_distance => 2480/Mongoid::Geospatial.earth_radius[:mi]).size.should == 2
+        end
+
+      end
+
+      context ':distance_multiplier' do
+        it "should multiply returned distance with multiplier" do
+          Bar.geo_near(lax.location, :spherical => true, :distance_multiplier=> Mongoid::Geospatial.earth_radius[:mi]).second.geo[:distance].to_i.should be_within(1).of(2469)
+        end
+      end
+
+      context ':unit' do
+        it "should multiply returned distance with multiplier" do
+          pending
+          Bar.geo_near(lax.location, :spherical => true, :unit => :mi).second.geo[:distance].to_i.should be_within(1).of(2469)
+        end
+
+        it "should convert max_distance to radians with unit" do
+          Bar.geo_near(lax.location, :spherical => true, :max_distance => 2465, :unit => :mi).size.should == 1
+        end
+
+      end
+
+      context ':query' do
+        it "should filter using extra query option" do
+          # two record in the collection, only one's name is Munich
+          Bar.geo_near(jfk.location, :query => {:name => jfk.name}).should == [jfk]
+        end
+      end
+
+    end
+
+    context 'criteria chaining' do
+      it "should filter by where" do
+        Bar.where(:name => jfk.name).geo_near(jfk.location).should == [jfk]
+        Bar.any_of({:name => jfk.name},{:name => lax.name}).geo_near(jfk.location).should == [jfk,lax]
+      end
+
+      it 'should skip 1' do
+        Bar.skip(1).geo_near(jfk.location).size.should == 1
+      end
+
+      it 'should limit 1' do
+        Bar.limit(1).geo_near(jfk.location).size.should == 1
+      end
+
+    end
+
+  end
+
+  context ':page' do
+    before do
+      Bar.delete_all
+      Bar.create_indexes
+
+      50.times do
+        Bar.create({:location => [rand(360)-180,rand(360)-180]})
+      end
+    end
+
+    context ":paginator :array" do
+      [nil,1,2].each do |page|
+        it "page=#{page} should have 25" do
+          Bar.geo_near([1,1], :page => page).size.should == 25
+        end
+      end
+
+      it "page=3 should have 0" do
+        Bar.geo_near([1,1], :page => 20).size.should == 0
+      end
+
+      it "per_page=5" do
+        Bar.geo_near([1,1], :page => 1, :per_page => 5).size.should == 5
+      end
+    end
+
+    context ":paginator :kaminari" do
+      let(:near) {Bar.geo_near([1,1], :page => 1)}
+      it "should have current_page" do
+        near.current_page.should == 1
+      end
+
+      it "should have num_pages" do
+        near.num_pages.should == 2
+      end
+
+      it "should have limit_value" do
+        near.limit_value.should == 25
+      end
+    end
+  end
+
+end