mongoid-geospatial 5.0.0 → 7.0.0

data/lib/mongoid/geospatial/config.rb

@@ -0,0 +1,29 @@
+module Mongoid
+  module Geospatial
+    module Config
+      autoload :Point, 'mongoid/geospatial/config/point'
+
+      extend self
+
+      def reset!
+        Mongoid::Geospatial::Config::Point.reset!
+      end
+
+      def point
+        Mongoid::Geospatial::Config::Point
+      end
+
+      reset!
+    end
+
+    class << self
+      def configure
+        block_given? ? yield(Config) : Config
+      end
+
+      def config
+        Config
+      end
+    end
+  end
+end

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

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

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

@@ -18,10 +18,11 @@ module Mongoid
       # @return (Array)
       def mongoize
         return nil unless x && y
+
         [x, y]
       end
-      alias_method :to_a,  :mongoize
-      alias_method :to_xy, :mongoize
+      alias to_a mongoize
+      alias to_xy mongoize
 
       def [](args)
         mongoize[args]
@@ -40,7 +41,7 @@ module Mongoid
       def to_hsh(xl = :x, yl = :y)
         { xl => x, yl => y }
       end
-      alias_method :to_hash, :to_hsh
+      alias to_hash to_hsh
 
       #
       # Helper for [self, radius]
@@ -48,7 +49,7 @@ module Mongoid
       # @return [Array] with [self, radius]
       #
       def radius(r = 1)
-        [mongoize, r]
+        [ mongoize, r ]
       end
 
       #
@@ -84,6 +85,18 @@ module Mongoid
         "#{x}, #{y}"
       end
 
+      #
+      # Point definition as GeoJSON
+      #
+      # "x, y"
+      #
+      # @return [String] Point as comma separated String
+      #
+      def to_geo_json
+        # Return a GeoJSON point hash that MongoDB can use
+        { type: "Point", coordinates: [x, y] }
+      end
+
       #
       # Point inverse/reverse
       #
@@ -144,7 +157,8 @@ module Mongoid
           when NilClass then nil
           else
             return obj.to_xy if obj.respond_to?(:to_xy)
-            fail 'Invalid Point'
+
+            raise 'Invalid Point'
           end
         end
 
@@ -171,6 +185,7 @@ module Mongoid
         #
         def from_string(str)
           return nil if str.empty?
+
           str.split(/,|\s/).reject(&:empty?).map(&:to_f)
         end
 
@@ -185,6 +200,7 @@ module Mongoid
         #
         def from_array(array)
           return nil if array.empty?
+
           array.flatten[0..1].map(&:to_f)
         end
 
@@ -203,20 +219,23 @@ module Mongoid
         # @return (Array)
         #
         def from_hash(hsh)
-          fail 'Hash must have at least 2 items' if hsh.size < 2
+          raise '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
+          v = (Mongoid::Geospatial::Config::Point.y & hsh.keys).first
           return hsh[v].to_f if !v.nil? && hsh[v]
-          fail "Hash must contain #{Mongoid::Geospatial.lat_symbols.inspect}"
+
+          raise "Hash must contain #{Mongoid::Geospatial::Config::Point.y.inspect}"
         end
 
         def from_hash_x(hsh)
-          v = (Mongoid::Geospatial.lng_symbols & hsh.keys).first
+          v = (Mongoid::Geospatial::Config::Point.x & hsh.keys).first
           return hsh[v].to_f if !v.nil? && hsh[v]
-          fail "Hash must contain #{Mongoid::Geospatial.lng_symbols.inspect}"
+
+          raise "Hash must contain #{Mongoid::Geospatial::Config::Point.x.inspect}"
         end
       end # << self
     end # Point

data/lib/mongoid/geospatial/geometry_field.rb

@@ -17,8 +17,10 @@ module Mongoid
       # @return [Array] containing 2 points
       #
       def bounding_box
-        max_x, min_x = -Float::MAX, Float::MAX
-        max_y, min_y = -Float::MAX, Float::MAX
+        max_x = -Float::MAX
+        min_x = Float::MAX
+        max_y = -Float::MAX
+        min_y = Float::MAX
         each do |point|
           max_y = point[1] if point[1] > max_y
           min_y = point[1] if point[1] < min_y
@@ -27,7 +29,7 @@ module Mongoid
         end
         [[min_x, min_y], [max_x, max_y]]
       end
-      alias_method :bbox, :bounding_box
+      alias bbox bounding_box
 
       #
       # Determines the 5 points geometry bounding box.
@@ -53,7 +55,7 @@ module Mongoid
         min, max = *bbox
         [(min[0] + max[0]) / 2.0, (min[1] + max[1]) / 2.0]
       end
-      alias_method :center, :center_point
+      alias center center_point
 
       #
       # Generates a radius from the point

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

@@ -11,6 +11,6 @@ Mongoid::Fields.option :sphere do |model, field, _options|
     spatial_fields_indexed << field.name.to_sym
 
     # Create 2Dsphere index
-    sphere_index field.name
+    spherical_index field.name
   end
 end

data/lib/mongoid/geospatial/version.rb

@@ -1,6 +1,6 @@
 module Mongoid
   # Mongoid Geospatial version
   module Geospatial
-    VERSION = '5.0.0'
+    VERSION = '7.0.0'.freeze
   end
 end

data/lib/mongoid/geospatial/wrappers/georuby.rb

@@ -16,6 +16,7 @@ module Mongoid
       # @return (GeoRuby::SimpleFeatures::Point)
       def to_geo
         return unless valid?
+
         GeoRuby::SimpleFeatures::Point.xy(x, y)
       end
 

data/lib/mongoid/geospatial.rb

@@ -1,6 +1,5 @@
 require 'mongoid'
-# require 'active_support/core_ext/string/inflections'
-# require 'active_support/concern'
+require 'active_support/concern' # Explicitly require for `extend ActiveSupport::Concern`
 require 'mongoid/geospatial/helpers/spatial'
 require 'mongoid/geospatial/helpers/sphere'
 require 'mongoid/geospatial/helpers/delegate'
@@ -27,10 +26,10 @@ module Mongoid
 
     # Symbols accepted as 'longitude', 'x'...
     LNG_SYMBOLS = [:x, :lon, :long, :lng, :longitude,
-                   'x', 'lon', 'long', 'lng', 'longitude']
+                   'x', 'lon', 'long', 'lng', 'longitude'].freeze
 
     # Symbols accepted as 'latitude', 'y'...
-    LAT_SYMBOLS = [:y, :lat, :latitude, 'y', 'lat', 'latitude']
+    LAT_SYMBOLS = [:y, :lat, :latitude, 'y', 'lat', 'latitude'].freeze
 
     # For distance spherical calculations
     EARTH_RADIUS_KM = 6371 # taken directly from mongodb
@@ -38,12 +37,12 @@ module Mongoid
 
     # Earth radius in multiple units
     EARTH_RADIUS = {
-      m:  EARTH_RADIUS_KM * 1000,
+      m: EARTH_RADIUS_KM * 1000,
       km: EARTH_RADIUS_KM,
       mi: EARTH_RADIUS_KM * 0.621371192,
       ft: EARTH_RADIUS_KM * 5280 * 0.621371192,
       sm: EARTH_RADIUS_KM * 0.53995680345572 # sea mile
-    }
+    }.freeze
 
     mattr_accessor :lng_symbols
     mattr_accessor :lat_symbols
@@ -55,7 +54,6 @@ module Mongoid
     @@earth_radius = EARTH_RADIUS.dup
 
     included do
-      # attr_accessor :geo
       cattr_accessor :spatial_fields, :spatial_fields_indexed
       self.spatial_fields = []
       self.spatial_fields_indexed = []
@@ -72,14 +70,10 @@ module Mongoid
     # Methods applied to Document's class
     module ClassMethods
       #
-      # Create Spatial index for given field
+      # Creates a 2d spatial index for the given field.
       #
-      #
-      # @param [String,Symbol] name
-      # @param [Hash] options options for spatial_index
-      #
-      # http://www.mongodb.org/display/DOCS/Geospatial+Indexing
-      # #GeospatialIndexing-geoNearCommand
+      # @param name [String, Symbol] The name of the field to index.
+      # @param options [Hash] Additional options for the index.
       #
       def spatial_index(name, options = {})
         spatial_fields_indexed << name
@@ -87,36 +81,119 @@ module Mongoid
       end
 
       #
-      # Creates Sphere index for given field
-      #
+      # Creates a 2dsphere index for the given field, suitable for spherical geometry calculations.
       #
-      # @param [String,Symbol] name
-      # @param [Hash] options options for spatial_index
+      # @param name [String, Symbol] The name of the field to index.
+      # @param options [Hash] Additional options for the index.
       #
-      # http://www.mongodb.org/display/DOCS/Geospatial+Indexing
-      # #GeospatialIndexing-geoNearCommand
-      def sphere_index(name, options = {})
+      def spherical_index(name, options = {})
         spatial_fields_indexed << name
         index({ name => '2dsphere' }, options)
       end
 
       #
-      # Creates Sphere index for given field
+      # Defines a class method to find the closest document to a given point
+      # using the specified spatial field via the `geoNear` command.
       #
+      # @param field_name [String, Symbol] The name of the spatial field to query.
+      # @param default_geo_near_options [Hash] Default options for the geoNear command
+      #        (e.g., `{ spherical: true, max_distance: 1000 }`).
+      #        The `key` option will be automatically set to `field_name`.
       #
-      # @param [String,Symbol] name
-      # @param [Hash] options options for spatial_index
+      # Example:
+      #   class Place
+      #     include Mongoid::Document
+      #     include Mongoid::Geospatial
+      #     field :location, type: Array
+      #     spherical_index :location # Assumes a 2dsphere index for spherical queries
+      #     spatial_scope :location, spherical: true # Default to spherical for this scope
+      #   end
       #
-      # http://www.mongodb.org/display/DOCS/Geospatial+Indexing
-      # #GeospatialIndexing-geoNearCommand
-      def spatial_scope(field, _opts = {})
+      #   Place.closest_to_location([lon, lat]) # Finds the single closest place
+      #   Place.closest_to_location([lon, lat], max_distance: 500) # Override/add options
+      #
+      def spatial_scope(field_name, default_geo_near_options = {})
+        method_name    = :"closest_to_#{field_name}"
+        field_name_sym = field_name.to_sym
+        # key_name       = field_name.to_s # Original geoNear used 'key' for field name
+
         singleton_class.class_eval do
-          # define_method(:close) do |args|
-          define_method(:nearby) do |args|
-            queryable.where(field.near_sphere => args)
+          define_method(method_name) do |coordinates, additional_options = {}|
+            # `coordinates` should be [lon, lat] or a GeoJSON Point hash
+            # `self` here is the class (e.g., Bar)
+
+            merged_options = default_geo_near_options.merge(additional_options)
+
+            # Determine if spherical based on options or field definition
+            is_spherical = if merged_options.key?(:spherical)
+                             merged_options[:spherical]
+                           else
+                             # self.fields uses string keys for field names
+                             field_def = self.fields[field_name.to_s]
+                             field_def && field_def.options[:sphere]
+                           end
+            query_operator = is_spherical ? :near_sphere : :near
+
+            # Prepare the value for the geospatial operator
+            # Mongoid::Geospatial::Point.mongoize ensures coordinates are in [lng, lat] array format
+            # from various input types (Point object, array, string, hash).
+            mongoized_coords = Mongoid::Geospatial::Point.mongoize(coordinates)
+
+            geo_query_value = if merged_options[:max_distance]
+                                {
+                                  # Using $geometry for clarity when $maxDistance is used,
+                                  # which is standard for $near/$nearSphere operators.
+                                  "$geometry"    => { type: "Point", coordinates: mongoized_coords },
+                                  "$maxDistance" => merged_options[:max_distance].to_f
+                                }
+                              else
+                                mongoized_coords # Simple array [lng, lat] for the operator
+                              end
+
+            # Start with a base criteria, applying an optional filter query
+            current_criteria = merged_options[:query] ? self.where(merged_options[:query]) : self.all
+
+            # Apply the geospatial query. $near and $nearSphere queries return sorted results.
+            current_criteria.where(field_name_sym.send(query_operator) => geo_query_value)
           end
         end
       end
+
+      #
+      # Provides a convenient way to find documents near a given set of coordinates.
+      # It automatically uses the first spatial field defined in the model and
+      # determines whether to use a planar (.near) or spherical (.near_sphere)
+      # query based on the field's definition options (`spatial: true` vs `sphere: true`).
+      #
+      # @param coordinates [Array, Mongoid::Geospatial::Point] The coordinates (e.g., [lon, lat])
+      #   or a Point object to find documents near to.
+      # @param _options [Hash] Optional hash for future extensions (currently unused).
+      #
+      # @return [Mongoid::Criteria] A criteria object for the query.
+      #
+      # Example:
+      #   Bar.nearby([10, 20])
+      #   Alarm.nearby(my_point_object)
+      #
+      def nearby(coordinates, _options = {})
+        if self.spatial_fields.empty?
+          raise "No spatial fields defined for #{self.name} to use with .nearby. " \
+                "Mark a field with 'spatial: true' or 'sphere: true'."
+        end
+
+        field_name_sym = self.spatial_fields.first.to_sym
+        field_definition = self.fields[field_name_sym.to_s]
+
+        unless field_definition
+          raise "Could not find field definition for spatial field: #{field_name_sym}"
+        end
+
+        query_operator = field_definition.options[:sphere] ? :near_sphere : :near
+
+        criteria.where(field_name_sym.send(query_operator) => coordinates)
+      end
     end
   end
 end
+
+require 'mongoid/geospatial/config'

data/mongoid-geospatial.gemspec

@@ -1,12 +1,11 @@
-# -*- encoding: utf-8 -*-
-require File.expand_path('../lib/mongoid/geospatial/version', __FILE__)
+require File.expand_path('lib/mongoid/geospatial/version', __dir__)
 
 Gem::Specification.new do |gem|
   gem.authors       = ['Ryan Ong', 'Marcos Piccinini']
   gem.email         = ['use@git.hub.com']
   gem.summary       = 'Mongoid Extension that simplifies MongoDB Geospatial Operations.'
   gem.description   = 'Mongoid Extension that simplifies MongoDB casting and operations on spatial Ruby objects.'
-  gem.homepage      = 'https://github.com/nofxx/mongoid-geospatial'
+  gem.homepage      = 'https://github.com/mongoid/mongoid-geospatial'
 
   gem.files         = `git ls-files`.split("\n")
   gem.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
@@ -15,5 +14,5 @@ Gem::Specification.new do |gem|
   gem.version       = Mongoid::Geospatial::VERSION
   gem.license       = 'MIT'
 
-  gem.add_dependency('mongoid', ['>= 5.0.0.beta'])
+  gem.add_dependency('mongoid', ['>= 4.0.0'])
 end

data/{bench → spec}/bench

@@ -2,7 +2,7 @@
 #
 # Just for fun
 #
-$LOAD_PATH << File.expand_path('../../lib', __FILE__)
+$LOAD_PATH << File.expand_path('../lib', __dir__)
 
 require 'mongoid/geospatial'
 

data/spec/models/bar.rb

@@ -9,5 +9,6 @@ class Bar
 
   has_one :rating, as: :ratable
 
+  spherical_index :location
   spatial_scope :location
 end

data/spec/models/event.rb

@@ -10,7 +10,7 @@ class Event
 
   def self.each_day(start_date, end_date)
     groups = only(:date).asc(:date)
-             .where(:date.gte => start_date, :date.lte => end_date).group
+                        .where(:date.gte => start_date, :date.lte => end_date).group
     groups.each do |hash|
       yield(hash['date'], hash['group'])
     end

data/spec/models/farm.rb

@@ -6,7 +6,7 @@ class Farm
   field :name,         type: String
   field :geom,         type: Point,    sphere: true
   field :area,         type: Polygon,  spatial: true
-  field :m2,           type: Fixnum
+  field :m2,           type: Integer
 
   spatial_index :geom
   spatial_index :area

data/spec/models/person.rb

@@ -27,7 +27,7 @@ class Person
   field :security_code
   field :blood_alcohol_content, type: Float, default: -> { 0.0 }
   field :last_drink_taken_at,   type: Date,
-        default: -> { 1.day.ago.in_time_zone('Alaska') }
+                                default: -> { 1.day.ago.in_time_zone('Alaska') }
 
   # Geo
   field :location, type: Point
@@ -58,14 +58,7 @@ class Person
   accepts_nested_attributes_for :addresses
 
   scope :minor, -> { where(:age.lt => 18) }
-  scope :without_ssn, -> {  without(:ssn) }
-
-  def score_with_rescoring=(score)
-    @rescored = score.to_i + 20
-    self.score_without_rescoring = score
-  end
-
-  alias_method_chain :score=, :rescoring
+  scope :without_ssn, -> { without(:ssn) }
 
   def update_addresses
     addresses.each do |address|

data/spec/models/river.rb

@@ -3,14 +3,14 @@ class River
   include Mongoid::Document
   include Mongoid::Geospatial
 
-  field :name,       type: String
-  field :length,     type: Integer
-  field :discharge,  type: Integer
-  field :course,     type: LineString,   spatial: true
+  field :name,        type: String
+  field :length,      type: Integer
+  field :discharge,   type: Integer
+  field :course,      type: LineString,   spatial: true
   # set return_array to true if you do not want a hash returned all the time
-  field :source,     type: Point,        spatial: true
-  field :mouth,      type: Point, spatial: { lat: 'latitude', lng: 'longitude' }
-  field :mouth_array, type: Array, spatial: { return_array: true }
+  field :source,      type: Point,        spatial: true
+  field :mouth,       type: Point,        spatial: { lat: 'latitude', lng: 'longitude' }
+  field :mouth_array, type: Array,        spatial: { return_array: true }
 
   # simplified spatial indexing
   # you can only index one field in mongodb < 1.9

data/spec/mongoid/geospatial/config_spec.rb

@@ -0,0 +1,22 @@
+require 'spec_helper'
+
+describe Mongoid::Geospatial::Config do
+  context 'point' do
+    it 'uses LonLat by default' do
+      expect(Mongoid::Geospatial.config.point.x).to eq Mongoid::Geospatial.lng_symbols
+      expect(Mongoid::Geospatial.config.point.y).to eq Mongoid::Geospatial.lat_symbols
+    end
+    context 'configured as latlon' do
+      before do
+        Mongoid::Geospatial.configure do |config|
+          config.point.x = Mongoid::Geospatial.lat_symbols
+          config.point.y = Mongoid::Geospatial.lng_symbols
+        end
+      end
+      it 'uses latlon' do
+        expect(Mongoid::Geospatial.config.point.x).to eq Mongoid::Geospatial.lat_symbols
+        expect(Mongoid::Geospatial.config.point.y).to eq Mongoid::Geospatial.lng_symbols
+      end
+    end
+  end
+end

data/spec/mongoid/geospatial/fields/line_string_spec.rb

@@ -22,12 +22,11 @@ describe Mongoid::Geospatial::LineString do
       expect(River.first.course).to eq([[1, 1], [9, 9], [10, 10]])
     end
 
-    it 'should parent.line_string << point nicely' do
-      pending 'Mongoid Issue #...'
+    it 'should NOT parent.line_string << point nicely (mongoid doesnt track <<)' do
       river = River.create!(name: 'Amazonas', course: [[1, 1], [9, 9]])
-      river.course.push [10, 10]
+      river.course << [10, 10]
       river.save
-      expect(River.first.course).to eq([[1, 1], [9, 9], [10, 10]])
+      expect(River.first.course).to eq([[1, 1], [9, 9]])
     end
 
     it 'should have same obj id' do

data/spec/mongoid/geospatial/fields/point_spec.rb

@@ -33,6 +33,46 @@ describe Mongoid::Geospatial::Point do
       bar.location = '2.99 ,  3.99'
       expect(bar.location.mongoize).to eq([2.99, 3.99])
     end
+
+    it 'should set point from hash' do
+      bar.location = { latitude: 2.99, longitude: 3.99 }
+      expect(bar.location.mongoize).to eq([3.99, 2.99])
+    end
+
+    context 'configured as latlon' do
+      before do
+        Mongoid::Geospatial.configure do |config|
+          config.point.x = Mongoid::Geospatial.lat_symbols
+          config.point.y = Mongoid::Geospatial.lng_symbols
+        end
+      end
+      it 'should set point from hash' do
+        bar.location = { latitude: 2.99, longitude: 3.99 }
+        expect(bar.location.mongoize).to eq([2.99, 3.99])
+      end
+    end
+  end
+
+  it "should have a to_s method" do
+    bar = Bar.create!(name: "Moe's", location: [1, 2])
+    expect(bar.location.to_s).to eq('1.0, 2.0')
+  end
+
+  it "should have a to_s method" do
+    bar = Bar.create!(name: "Moe's", location: [1.0009, 21.009])
+    expect(bar.location.to_s).to eq('1.0009, 21.009')
+  end
+
+  it "should have a to_geo_json method" do
+    bar = Bar.create!(name: "Moe's", location: [1.0009, 21.009])
+    expect(bar.location.to_geo_json).to eq({
+      type: "Point", coordinates: [1.0009, 21.009]
+    })
+  end
+
+  it "should have a to_json method" do
+    bar = Bar.create!(name: "Moe's", location: [1.0009, 21.009])
+    expect(bar.location.to_json).to eq("[1.0009,21.009]")
   end
 
   it 'should have #reverse to get lat, lon' do
@@ -83,7 +123,7 @@ describe Mongoid::Geospatial::Point do
     end
 
     it 'should have an ActiveModel symbol accessor' do
-      expect(bar[:location]).to eq([3, 2])
+      expect(bar[:location].to_a).to eq([3, 2])
     end
 
     it 'should have a radius helper' do
@@ -129,7 +169,12 @@ describe Mongoid::Geospatial::Point do
       end
 
       it 'returns the documents sorted closest to furthest' do
-        expect(Bar.where(:location.near => jim.location))
+        expect(Bar.closest_to_location(jim.location).to_a)
+          .to eq([paris, prague, berlin])
+      end
+
+      it 'returns the documents sorted closest to furthest' do
+        expect(Bar.where(:location.near => jim.location).to_a)
           .to eq([paris, prague, berlin])
       end
 
@@ -198,7 +243,8 @@ describe Mongoid::Geospatial::Point do
       it 'returns the documents within a box' do
         poly = Mongoid::Geospatial::LineString.new(
           [elvis.location.map { |c| c + 1 },
-           elvis.location.map { |c| c - 1 }])
+           elvis.location.map { |c| c - 1 }]
+        )
         expect(Bar.where(:location.within_polygon => [poly.geom_box]).to_a)
           .to include(mile3)
       end
@@ -239,7 +285,7 @@ describe Mongoid::Geospatial::Point do
 
     describe 'with rgeo' do
       describe 'instantiated' do
-        let(:bar) { Bar.create!(name: 'Vitinho', location: [10, 10]) }
+        let(:bar) { Bar.new(name: 'Vitinho', location: [10, 10]) }
 
         it 'should demongoize to rgeo' do
           expect(bar.location.class).to eql(Mongoid::Geospatial::Point)

data/spec/mongoid/geospatial/fields/polygon_spec.rb

@@ -49,20 +49,20 @@ describe Mongoid::Geospatial::Polygon do
         Farm.create_indexes
       end
 
-      let!(:ranch) do
+      let(:ranch) do
         Farm.create!(name: 'Ranch',
                      area: [[1, 1], [3, 3], [3, 1], [1, 1]],
                      geom: [2, 2])
       end
 
-      let!(:farm) do
+      let(:farm) do
         Farm.create!(name: 'Farm',
                      area: [[47, 1], [48, 1.5], [49, 3], [49, 1], [47, 1]],
                      geom: [48, 1.28])
       end
 
       it 'returns the documents within a box' do
-        query = Farm.geo_spacial(:geom.within_polygon => [ranch.area])
+        query = Farm.geo_spatial(:geom.within_polygon => [ranch.area])
         expect(query.to_a).to eq([ranch])
       end