mongoid-geospatial 3.9.0

data/Rakefile

@@ -0,0 +1,17 @@
+#!/usr/bin/env rake
+require 'bundler/gem_tasks'
+
+require 'rspec/core'
+require 'rspec/core/rake_task'
+RSpec::Core::RakeTask.new(:spec) do |spec|
+  spec.pattern = FileList['spec/**/*_spec.rb']
+end
+
+RSpec::Core::RakeTask.new(:rcov) do |spec|
+  spec.pattern = 'spec/**/*_spec.rb'
+  spec.rcov = true
+end
+
+task default: :spec
+
+require 'yard'

data/lib/mongoid/geospatial.rb

@@ -0,0 +1,106 @@
+require 'mongoid'
+require 'active_support/core_ext/string/inflections'
+require 'active_support/concern'
+require 'mongoid/geospatial/helpers/spatial'
+require 'mongoid/geospatial/helpers/sphere'
+require 'mongoid/geospatial/helpers/delegate'
+
+require 'mongoid/geospatial/fields/geometry_field'
+
+%w(point circle box line polygon).each do |type|
+  require "mongoid/geospatial/fields/#{type}"
+end
+
+module Mongoid
+  #
+  # Main Geospatial module
+  #
+  # include Mongoid::Geospatial
+  #
+  module Geospatial
+    extend ActiveSupport::Concern
+
+    LNG_SYMBOLS = [:x, :lon, :long, :lng, :longitude, 'x', 'lon', 'long', 'longitude']
+    LAT_SYMBOLS = [:y, :lat, :latitude, 'y', 'lat', 'latitude']
+
+    EARTH_RADIUS_KM = 6371 # taken directly from mongodb
+    RAD_PER_DEG = Math::PI / 180
+
+    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
+    }
+
+    mattr_accessor :lng_symbols
+    mattr_accessor :lat_symbols
+    mattr_accessor :earth_radius
+    mattr_accessor :factory
+
+    @@lng_symbols  = LNG_SYMBOLS.dup
+    @@lat_symbols  = LAT_SYMBOLS.dup
+    @@earth_radius = EARTH_RADIUS.dup
+
+    included do
+      # attr_accessor :geo
+      cattr_accessor :spatial_fields, :spatial_fields_indexed
+      self.spatial_fields = []
+      self.spatial_fields_indexed = []
+    end
+
+    def self.with_rgeo!
+      require 'mongoid/geospatial/wrappers/rgeo'
+    end
+
+    def self.with_georuby!
+      require 'mongoid/geospatial/wrappers/georuby'
+    end
+
+    module ClassMethods #:nodoc:
+      def geo_field(name, options = {})
+        field name, { type: Mongoid::Geospatial::Point, spatial: true }.merge(options)
+      end
+
+      # create spatial index for given field
+      # @param [String,Symbol] name
+      # @param [Hash] options options for spatial_index
+      # http://www.mongodb.org/display/DOCS/Geospatial+Indexing#GeospatialIndexing-geoNearCommand
+      def spatial_index(name, options = {})
+        spatial_fields_indexed << name
+        index({ name => '2d' }, options)
+      end
+
+      def sphere_index(name, options = {})
+        spatial_fields_indexed << name
+        index({ name => '2dsphere' }, options)
+      end
+
+      def spatial_scope(field, _opts = {})
+        singleton_class.class_eval do
+          # define_method(:close) do |args|
+          define_method(:nearby) do |args|
+            queryable.where(field.near_sphere => args)
+          end
+        end
+      end
+    end
+  end
+end
+
+# model.instance_eval do # wont work
+# #   define_method "near_#{field.name}" do |*args|
+# #     self.where(field.name => args)
+# #   end
+# end
+
+# define_method "near_#{field.name}" do |*args|
+#   queryable.where(field.near_sphere => args)
+# end
+
+# model.class_eval do
+#   define_method "close_to" do |*args|
+#     queriable.where(field.name.near_sphere => *args)
+#   end
+# end

data/lib/mongoid/geospatial/ext/rgeo_spherical_point_impl.rb

@@ -0,0 +1,18 @@
+module RGeo
+  module Geographic
+    # RGeo Point
+    class SphericalPointImpl
+      def to_xy
+        [x, y]
+      end
+
+      def to_a
+        [x, y, z]
+      end
+
+      def [](index)
+        to_a[index]
+      end
+    end
+  end
+end

data/lib/mongoid/geospatial/fields/box.rb

@@ -0,0 +1,6 @@
+module Mongoid
+  module Geospatial
+    class Box < GeometryField
+    end
+  end
+end

data/lib/mongoid/geospatial/fields/circle.rb

@@ -0,0 +1,18 @@
+module Mongoid
+  module Geospatial
+    # Circle
+    #
+    class Circle < GeometryField
+      attr_accessor :center, :radius
+
+      def point
+        Point.new(self[0])
+      end
+      alias_method :point, :center
+
+      def radius
+        self[1]
+      end
+    end
+  end
+end

data/lib/mongoid/geospatial/fields/geometry_field.rb

@@ -0,0 +1,41 @@
+module Mongoid
+  module Geospatial
+    # Main Geometry Array
+    # Holds Lines/Polygons....
+    class GeometryField < Array
+      def bounding_box
+        max_x, min_x = -Float::MAX, Float::MAX
+        max_y, min_y = -Float::MAX, Float::MAX
+        each do |point|
+          max_y = point[1] if point[1] > max_y
+          min_y = point[1] if point[1] < min_y
+          max_x = point[0] if point[0] > max_x
+          min_x = point[0] if point[0] < min_x
+        end
+        [[min_x, min_y], [max_x, max_y]]
+      end
+      alias_method :bbox, :bounding_box
+
+      def center_point
+        min, max = *bbox
+        [(min[0] + max[0]) / 2.0, (min[1] + max[1]) / 2.0]
+      end
+      alias_method :center, :center_point
+
+      def radius(r = 1)
+        [center, r]
+      end
+
+      def radius_sphere(r = 1, unit = :km)
+        radius r.to_f / Mongoid::Geospatial.earth_radius[unit]
+      end
+
+      class << self
+        # Database -> Object
+        def demongoize(o)
+          new(o)
+        end
+      end
+    end
+  end
+end

data/lib/mongoid/geospatial/fields/line.rb

@@ -0,0 +1,6 @@
+module Mongoid
+  module Geospatial
+    class Line < GeometryField
+    end
+  end
+end

data/lib/mongoid/geospatial/fields/point.rb

@@ -0,0 +1,143 @@
+module Mongoid
+  module Geospatial
+    # Point
+    #
+    class Point
+      include Enumerable
+      attr_reader :x, :y
+
+      def initialize(x = nil, y = nil)
+        return unless x && y
+        @x, @y = x, y
+      end
+
+      # Object -> Database
+      # Let's store NilClass if we are invalid.
+      def mongoize
+        return nil unless x && y
+        [x, y]
+      end
+      alias_method :to_a,  :mongoize
+      alias_method :to_xy, :mongoize
+
+      def [](args)
+        mongoize[args]
+      end
+
+      def each
+        yield x
+        yield y
+      end
+
+      def to_s
+        "#{x}, #{y}"
+      end
+
+      def to_hsh(xl = :x, yl = :y)
+        { xl => x, yl => y }
+      end
+      alias_method :to_hash, :to_hsh
+
+      def radius(r = 1)
+        [mongoize, r]
+      end
+
+      def radius_sphere(r = 1, unit = :km)
+        radius r.to_f / Mongoid::Geospatial.earth_radius[unit]
+      end
+
+      def valid?
+        x && y && x.is_a?(Numeric) && y.is_a?(Numeric)
+      end
+
+      #
+      # Distance calculation methods. Thinking about not using it
+      # One needs to choose and external lib. GeoRuby or RGeo
+      #
+      # Return the distance between the 2D points (ie taking care
+      # only of the x and y coordinates), assuming the points are
+      # in projected coordinates. Euclidian distance in whatever
+      # unit the x and y ordinates are.
+      # def euclidian_distance(point)
+      #   Math.sqrt((point.x - x)**2 + (point.y - y)**2)
+      # end
+
+      # # Spherical distance in meters, using 'Haversine' formula.
+      # # with a radius of 6471000m
+      # # Assumes x is the lon and y the lat, in degrees (Changed
+      # in version 1.1).
+      # # The user has to make sure using this distance makes sense
+      # (ie she should be in latlon coordinates)
+      # def spherical_distance(point,r=6370997.0)
+      #   dlat = (point.lat - lat) * DEG2RAD / 2
+      #   dlon = (point.lon - lon) * DEG2RAD / 2
+
+      #   a = Math.sin(dlat)**2 + Math.cos(lat * DEG2RAD) *
+      #         Math.cos(point.lat * DEG2RAD) * Math.sin(dlon)**2
+      #   c = 2 * Math.atan2(Math.sqrt(a), Math.sqrt(1-a))
+      #   r * c
+      # end
+
+      class << self
+        # Makes life easier:
+        # "" -> nil
+        def from_string(str)
+          return nil if str.empty?
+          str.split(/,|\s/).reject(&:empty?).map(&:to_f)
+        end
+
+        # Also makes life easier:
+        # [] -> nil
+        def from_array(ary)
+          return nil if ary.empty?
+          ary[0..1].map(&:to_f)
+        end
+
+        # Throw error on wrong hash, just for a change.
+        def from_hash(hsh)
+          fail 'Hash must have at least 2 items' if hsh.size < 2
+          [from_hash_x(hsh), from_hash_y(hsh)]
+        end
+
+        def from_hash_y(hsh)
+          v = (Mongoid::Geospatial.lat_symbols & hsh.keys).first
+          return hsh[v].to_f if !v.nil? && hsh[v]
+          fail "Hash must contain #{Mongoid::Geospatial.lat_symbols.inspect} if Ruby version is less than 1.9" if RUBY_VERSION.to_f < 1.9
+          fail "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(hsh.keys[1])
+          hsh.values[1].to_f
+        end
+
+        def from_hash_x(hsh)
+          v = (Mongoid::Geospatial.lng_symbols & hsh.keys).first
+          return hsh[v].to_f if !v.nil? && hsh[v]
+          fail "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(hsh.keys[0])
+          hsh.values[0].to_f
+        end
+
+        # Database -> Object
+        def demongoize(object)
+          Point.new(*object) if object
+        end
+
+        def mongoize(object)
+          case object
+          when Point  then object.mongoize
+          when String then from_string(object)
+          when Array  then from_array(object)
+          when Hash   then from_hash(object)
+          when NilClass then nil
+          else
+            return object.to_xy if object.respond_to?(:to_xy)
+            fail 'Invalid Point'
+          end
+        end
+
+        # Converts the object that was supplied to a criteria
+        # into a database friendly form.
+        def evolve(object)
+          object.respond_to?(:x) ? object.mongoize : object
+        end
+      end # << self
+    end # Point
+  end # Geospatial
+end # Mongoid

data/lib/mongoid/geospatial/fields/polygon.rb

@@ -0,0 +1,6 @@
+module Mongoid
+  module Geospatial
+    class Polygon < GeometryField
+    end
+  end
+end

data/lib/mongoid/geospatial/helpers/delegate.rb

@@ -0,0 +1,30 @@
+#
+# Mongoid fields extension
+#
+# field :foo, :delegate => {opts
+#
+Mongoid::Fields.option :delegate do |model, field, options|
+  options = {} unless options.is_a?(Hash)
+  x_meth = options[:x] || :x
+  y_meth = options[:y] || :y
+
+  model.instance_eval do
+
+    define_method x_meth do
+      self[field.name][0]
+    end
+
+    define_method y_meth do
+      self[field.name][1]
+    end
+
+    define_method "#{x_meth}=" do |arg|
+      self[field.name][0] = arg
+    end
+
+    define_method "#{y_meth}=" do |arg|
+      self[field.name][1] = arg
+    end
+
+  end
+end

data/lib/mongoid/geospatial/helpers/spatial.rb

@@ -0,0 +1,19 @@
+#
+# Mongoid fields extension
+#
+# field :foo, :spatial => true
+#
+Mongoid::Fields.option :spatial do |model, field, _options|
+  # options = {} unless options.kind_of?(Hash)
+
+  model.class_eval do
+
+    spatial_fields << field.name.to_sym
+    spatial_fields_indexed << field.name.to_sym
+
+    # Create 2D index
+    spatial_index field.name
+
+  end
+
+end

data/lib/mongoid/geospatial/helpers/sphere.rb

@@ -0,0 +1,18 @@
+#
+# Mongoid fields extension
+#
+# field :foo, :sphere => true
+#
+Mongoid::Fields.option :sphere do |model, field, _options|
+  # options = {} unless options.kind_of?(Hash)
+
+  model.class_eval do
+
+    spatial_fields << field.name.to_sym
+    spatial_fields_indexed << field.name.to_sym
+
+    # Create 2Dsphere index
+    sphere_index field.name
+
+  end
+end

data/lib/mongoid/geospatial/version.rb

@@ -0,0 +1,6 @@
+module Mongoid
+  # Gem version
+  module Geospatial
+    VERSION = '3.9.0'
+  end
+end