mongoid-geospatial 7.0.0 → 7.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c175628dbf99da911bb81c3c25b2665b3547506f910366a53d43eaabea99e410
-  data.tar.gz: 8e38f228cc16e9a17cbe44dd2be01bd06e989d5e91d968a9b50a1885cc12eb8e
+  metadata.gz: 88d807a8e7011846e353f18fc6812fb55e578f371464c202fa726976c7fec6e6
+  data.tar.gz: 32f5124231bfe558a9a591520c90dda408f76995faa2030e67c39bee1e9f7b23
 SHA512:
-  metadata.gz: a09b65028e7d0b27a88383dac691372e6b456ad0d72b3ef0159e8e9e33d7f6da78cb250038c6d592bbb667d9a6f6f864ac1ae8278eaed41b69277d0290a47399
-  data.tar.gz: 843567a6bbe62c5551cd962c70a927e2dd8e19968c741ea014e384cf942b99aa75fa382969fe139cc07c835249fb7d864421713cb5e324e0495615fc14b7d30e
+  metadata.gz: f8beb1650724d7b54d7a2a35d2376597144d9290360f2571da28681ef11d3e3e0792bf562f0c904f762b0abaf09d43b9f8c8f1747cb4d7753a5f187a6c6d04c5
+  data.tar.gz: b457c28c88ab87968e76eeb00afca6e376e37cf2432df230fc88260ab44b9984c9cd11708deba53eb19fa4a19d27175d63042c5b142762707fe3bd1019107652

data/README.md

@@ -176,26 +176,6 @@ field :location,  type: Point, delegate: true
 
 Now instead of `instance.location.x` you may call `instance.x`.
 
-## Nearby
-
-You can add a `spatial_scope` on your models. So you can query:
-
-```ruby
-Bar.nearby(my.location)
-```
-
-instead of
-
-```ruby
-Bar.near(location: my.location)
-```
-
-Good when you're drunk. Just add to your model:
-
-```ruby
-spatial_scope :<field>
-```
-
 ## Geometry
 
 You can also store Circle, Box, Line (LineString) and Polygons.
@@ -219,30 +199,81 @@ polygon.radius_sphere(5) # [[1.0, 1.0], 0.00048..]
 
 ## Query
 
-Before you proceed, make sure you have read this:
-
-http://mongoid.github.io/old/en/origin/docs/selection.html#standard
-
-All MongoDB queries are handled by Mongoid/Origin.
-
-http://www.rubydoc.info/github/mongoid/origin/Origin/Selectable
-
 You can use Geometry instance directly on any query:
 
-- near
+### near
 
 ```ruby
 Bar.near(location: person.house)
 Bar.where(:location.near => person.house)
 ```
 
-- near_sphere
+### near_sphere
 
 ```ruby
 Bar.near_sphere(location: person.house)
 Bar.where(:location.near_sphere => person.house)
 ```
 
+### nearby
+
+You can add a `spatial_scope` on your models. So you can query:
+
+```ruby
+Bar.nearby(my.location)
+```
+
+instead of
+
+```ruby
+Bar.near(location: my.location)
+```
+
+Good when you're drunk. Just add to your model:
+
+```ruby
+spatial_scope :<field>
+```
+
+### geo_near
+
+The `geo_near` class method provides a more powerful way to query for documents based on proximity,
+using MongoDB's `$geoNear` aggregation pipeline stage. This method allows for more complex
+options and returns the distance to each matched document.
+
+```ruby
+# Find places near [10, 20], using spherical calculations, up to 5km away,
+# and get the distance.
+# The :distanceField option specifies the name of the field that will contain the distance.
+# The :limit option is applied as a separate $limit stage in the aggregation.
+Place.geo_near(:location, [10, 20],
+               spherical: true,
+               maxDistance: 5000, # 5 kilometers in meters for spherical queries
+               distanceField: 'dist.calculated', # Default is 'distance'
+               query: { category: 'restaurant' }, # Optional: filter documents before geoNear
+               limit: 10)
+
+# Iterate over results
+Place.geo_near(:location, [10, 20], spherical: true).each do |place|
+  # 'place.distance' will be available if distanceField was 'distance' (the default)
+  # or 'place.dist_calculated' if distanceField was 'dist.calculated'
+  puts "#{place.name} is #{place.distance || place.dist_calculated} meters away."
+end
+```
+
+Key features and options for `geo_near`:
+
+- `:spherical` (Boolean): If `true`, calculates distances using spherical geometry. Defaults to `false`.
+- `:distanceField` (String): Name of the output field for the calculated distance. Defaults to `'distance'`.
+- `:maxDistance` (Numeric): Maximum distance from the center point. (Meters for spherical, units of coordinates for planar).
+- `:minDistance` (Numeric): Minimum distance from the center point.
+- `:query` (Hash): A query to filter documents _before_ the `$geoNear` stage.
+- `:limit` (Integer): Maximum number of documents to return (applied as a separate `$limit` stage).
+- `:distanceMultiplier` (Numeric): A factor to multiply all distances.
+- `:includeLocs` (String): Name of an output field that will contain the exact location on the document used for the distance calculation. Useful for multi-location fields or complex GeoJSON geometries.
+
+The `geo_near` method returns an array of instantiated Mongoid documents, with the `distanceField` and `includeLocs` field (if specified) available as dynamic attributes on each model instance.
+
 - within_polygon
 
 ```ruby

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

@@ -1,17 +1,20 @@
+# frozen_string_literal: true
+
 module Mongoid
   module Geospatial
     module Config
       module Point
         extend self
 
-        attr_accessor :x
-        attr_accessor :y
+        attr_accessor :x, :y
 
         def reset!
+          # Now self.x and self.y refer to the public module accessors
           self.x = Mongoid::Geospatial.lng_symbols
           self.y = Mongoid::Geospatial.lat_symbols
         end
 
+        # Initialize the configuration
         reset!
       end
     end

data/lib/mongoid/geospatial/config.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Mongoid
   module Geospatial
     module Config

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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module RGeo
   module Geographic
     # RGeo Point

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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Mongoid
   module Geospatial
     class Box < GeometryField

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

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

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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Mongoid
   module Geospatial
     class LineString < GeometryField

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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Mongoid
   module Geospatial
     # Point
@@ -6,10 +8,10 @@ module Mongoid
       include Enumerable
       attr_accessor :x, :y, :z
 
-      def initialize(x, y, z = nil)
-        @x = x
-        @y = y
-        @z = z
+      def initialize(lon, lat, alt = nil)
+        @x = lon
+        @y = lat
+        @z = alt
       end
 
       # Object -> Database
@@ -35,11 +37,12 @@ module Mongoid
 
       #
       # Point representation as a Hash
+      # Optional param: custom keys.
       #
-      # @return [Hash] with { xl => x, yl => y }
+      # @return [Hash] with { lng_key => x, lat_key => y }
       #
-      def to_hsh(xl = :x, yl = :y)
-        { xl => x, yl => y }
+      def to_hsh(xkey = :x, ykey = :y)
+        { xkey => x, ykey => y }
       end
       alias to_hash to_hsh
 
@@ -48,8 +51,8 @@ module Mongoid
       #
       # @return [Array] with [self, radius]
       #
-      def radius(r = 1)
-        [ mongoize, r ]
+      def radius(r = 1) # rubocop:disable Naming/MethodParameterName
+        [mongoize, r]
       end
 
       #
@@ -59,7 +62,7 @@ module Mongoid
       #
       # @return [Array] with [self, radius / earth radius]
       #
-      def radius_sphere(r = 1, unit = :km)
+      def radius_sphere(r = 1, unit = :km) # rubocop:disable Naming/MethodParameterName
         radius r.to_f / Mongoid::Geospatial.earth_radius[unit]
       end
 
@@ -94,7 +97,7 @@ module Mongoid
       #
       def to_geo_json
         # Return a GeoJSON point hash that MongoDB can use
-        { type: "Point", coordinates: [x, y] }
+        { type: 'Point', coordinates: [x, y] }
       end
 
       #
@@ -237,7 +240,7 @@ module Mongoid
 
           raise "Hash must contain #{Mongoid::Geospatial::Config::Point.x.inspect}"
         end
-      end # << self
-    end # Point
-  end # Geospatial
-end # Mongoid
+      end
+    end
+  end
+end

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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Mongoid
   module Geospatial
     class Polygon < GeometryField

data/lib/mongoid/geospatial/geometry_field.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Mongoid
   module Geospatial
     #
@@ -63,7 +65,7 @@ module Mongoid
       # @param [Numeric] r radius
       # @return [Array]  [point, r] point and radius in mongoid format
       #
-      def radius(r = 1)
+      def radius(r = 1) # rubocop:disable Naming/MethodParameterName
         [center, r]
       end
 
@@ -75,7 +77,7 @@ module Mongoid
       # @see Point#radius
       # @return [Array]
       #
-      def radius_sphere(r = 1, unit = :km)
+      def radius_sphere(r = 1, unit = :km) # rubocop:disable Naming/MethodParameterName
         radius r.to_f / Mongoid::Geospatial.earth_radius[unit]
       end
 

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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 #
 # Mongoid fields extension
 #

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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 #
 # Mongoid fields extension
 #

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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 #
 # Mongoid fields extension
 #

data/lib/mongoid/geospatial/version.rb

@@ -1,6 +1,8 @@
+# frozen_string_literal: true
+
 module Mongoid
   # Mongoid Geospatial version
   module Geospatial
-    VERSION = '7.0.0'.freeze
+    VERSION = '7.1.0'
   end
 end

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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'geo_ruby'
 
 module Mongoid

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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'rgeo'
 require 'mongoid/geospatial/ext/rgeo_spherical_point_impl'
 

data/lib/mongoid/geospatial.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'mongoid'
 require 'active_support/concern' # Explicitly require for `extend ActiveSupport::Concern`
 require 'mongoid/geospatial/helpers/spatial'
@@ -91,6 +93,38 @@ module Mongoid
         index({ name => '2dsphere' }, options)
       end
 
+      #
+      # # Queries
+      #
+      # MongoDB provides the following geospatial query operators.
+      #
+      # $geoIntersects
+      # Selects geometries that intersect with a GeoJSON geometry.
+      # The 2dsphere index supports $geoIntersects.
+      #
+      # $geoWithin
+      # Selects geometries within a bounding GeoJSON geometry.
+      # The 2dsphere and 2d indexes support $geoWithin.
+      #
+      # $near
+      # Returns geospatial objects in proximity to a point.
+      # Requires a geospatial index. The 2dsphere and 2d indexes support $near.
+      #
+      # $nearSphere
+      # Returns geospatial objects in proximity to a point on a sphere.
+      # Requires a geospatial index. The 2dsphere and 2d indexes support $nearSphere.
+      #
+      # # Aggregation
+      #
+      # MongoDB provides the following geospatial aggregation pipeline stage:
+      #
+      # $geoNear
+      # Returns an ordered stream of documents based on the proximity to a geospatial point.
+      # Incorporates the functionality of $match, $sort, and $limit for geospatial data.
+      # The output documents include an additional distance field and can include a location identifier field.
+      # $geoNear requires a geospatial index.
+      #
+
       #
       # Defines a class method to find the closest document to a given point
       # using the specified spatial field via the `geoNear` command.
@@ -129,7 +163,7 @@ module Mongoid
                              merged_options[:spherical]
                            else
                              # self.fields uses string keys for field names
-                             field_def = self.fields[field_name.to_s]
+                             field_def = fields[field_name.to_s]
                              field_def && field_def.options[:sphere]
                            end
             query_operator = is_spherical ? :near_sphere : :near
@@ -143,15 +177,15 @@ module Mongoid
                                 {
                                   # 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
+                                  '$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
+            current_criteria = merged_options[:query] ? where(merged_options[:query]) : all
 
             # Apply the geospatial query. $near and $nearSphere queries return sorted results.
             current_criteria.where(field_name_sym.send(query_operator) => geo_query_value)
@@ -176,24 +210,122 @@ module Mongoid
       #   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. " \
+        if spatial_fields.empty?
+          raise "No spatial fields defined for #{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]
+        field_name_sym = spatial_fields.first.to_sym
+        field_definition = fields[field_name_sym.to_s]
 
-        unless field_definition
-          raise "Could not find field definition for spatial field: #{field_name_sym}"
-        end
+        raise "Could not find field definition for spatial field: #{field_name_sym}" unless field_definition
 
         query_operator = field_definition.options[:sphere] ? :near_sphere : :near
 
         criteria.where(field_name_sym.send(query_operator) => coordinates)
       end
+
+      # Performs a $geoNear aggregation pipeline stage to find documents near a point,
+      # returning them sorted by distance and including the distance.
+      #
+      # This method is a wrapper around the MongoDB `$geoNear` aggregation stage,
+      # which allows for more complex queries and options than the simple `near` or `near_sphere` methods.
+      #
+      # * But it's not chainable like a standard Mongoid query *
+      #
+      # @param field_name [String, Symbol] The name of the geospatial field to query.
+      #   This field must be indexed with a geospatial index (2d or 2dsphere).
+      # @param coordinates [Array, Hash, Mongoid::Geospatial::Point] The point to search near.
+      #   Examples: `[lng, lat]`, `{ type: 'Point', coordinates: [lng, lat] }`, a `Mongoid::Geospatial::Point` object.
+      # @param options [Hash] Options for the $geoNear stage.
+      #   Key options include:
+      #   - `:spherical` [Boolean] If true, calculates distances using spherical geometry. Defaults to `false`.
+      #   - `:distanceField` [String] Name of the output field that will contain the distance. Defaults to `'distance'`.
+      #   - `:maxDistance` [Numeric] The maximum distance from the center point that documents can be.
+      #     For spherical queries, specify distance in meters. For 2d queries, in the same units as coordinates.
+      #   - `:minDistance` [Numeric] The minimum distance. (MongoDB 2.6+)
+      #   - `:query` [Hash] Limits the results to the documents that match the query.
+      #   - `:limit` [Integer] The maximum number of documents to return (applied as a separate `$limit` pipeline stage).
+      #   - `:distanceMultiplier` [Numeric] A factor to multiply all distances returned by the query.
+      #   - `:includeLocs` [String] Specifies the name of the output field that identifies the location used to calculate the distance.
+      #     This is useful when the queried field contains multiple locations (e.g., an array of points) or complex GeoJSON
+      #     geometries (e.g., a Polygon), as it shows which specific point was used for the distance calculation.
+      #     Example: `includeLocs: 'matchedPoint'` would add a `matchedPoint` field to each output document.
+      #
+      # @return [Array<Mongoid::Document>] An array of instantiated Mongoid documents.
+      #   Each document will include its original fields plus any fields added by the `$geoNear` stage,
+      #   such as the field specified by `:distanceField` (e.g., `document.distance`) and `:includeLocs`.
+      #   These additional fields are accessible as dynamic attributes on the model instances.
+      #
+      # @raise [ArgumentError] If coordinates cannot be mongoized.
+      #
+      # Example:
+      #   # Find places near [10, 20], using spherical calculations, up to 5km away
+      #   Place.geo_near(:location, [10, 20],
+      #                  spherical: true,
+      #                  maxDistance: 5000, # 5 kilometers in meters
+      #                  distanceField: 'dist.calculated',
+      #                  query: { category: 'restaurant' },
+      #                  limit: 10)
+      #
+      #   # Iterate over results
+      #   Place.geo_near(:location, [10, 20], spherical: true).each do |place|
+      #     puts "#{place.name} is #{place.distance} meters away." # Assumes distanceField is 'distance'
+      #   end
+      #
+      def geo_near(field_name, coordinates, options = {})
+        mongoized_coords = Mongoid::Geospatial::Point.mongoize(coordinates)
+
+        raise ArgumentError, "Invalid coordinates provided: #{coordinates.inspect}" unless mongoized_coords
+
+        # User-provided options. Work with a copy.
+        user_options = options.dup
+        limit_value = user_options.delete(:limit) # Handled by a separate pipeline stage
+
+        # Core $geoNear parameters derived from method arguments, these are not overrideable by user_options.
+        geo_near_core_params = {
+          key: field_name.to_s,
+          near: mongoized_coords
+        }
+
+        # Defaultable $geoNear parameters. User options will override these.
+        geo_near_defaultable_params = {
+          distanceField: 'distance',
+          spherical: false # Default to planar (2d) calculations
+        }
+
+        # Merge user options over defaults, then ensure core parameters are set.
+        geo_near_stage_options = geo_near_defaultable_params.merge(user_options).merge(geo_near_core_params)
+
+        # Ensure :spherical is a strict boolean (true/false).
+        # If user_options provided :spherical, it's already set. If not, the default is used.
+        # This line ensures the final value is strictly true or false, not just truthy/falsy.
+        geo_near_stage_options[:spherical] = !geo_near_stage_options[:spherical].nil?
+
+        # Note on performance:
+        # $geoNear is an aggregation pipeline stage. For simple proximity queries,
+        # it might exhibit slightly higher "real" time (wall-clock time) in benchmarks
+        # compared to direct query operators like $near or $nearSphere. This is often
+        # due to the inherent overhead of the aggregation framework versus a direct query.
+        # However, $geoNear offers more capabilities, such as returning the distance
+        # (distanceField), distanceMultiplier, includeLocs, and integrating with other
+        # aggregation stages, which are not available with $near/$nearSphere.
+        pipeline = [{ '$geoNear' => geo_near_stage_options }]
+
+        # Add $limit stage if limit_value was provided
+        pipeline << { '$limit' => limit_value.to_i } if limit_value
+
+        # Execute the aggregation pipeline
+        collection.aggregate(pipeline)
+
+        # Don't instantiate results here.
+        # aggregated_results = collection.aggregate(pipeline)
+        # Map the raw Hash results from aggregation to Mongoid model instances.
+        # Mongoid's #instantiate method correctly handles creating model objects
+        # and assigning attributes, including dynamic ones like the distanceField.
+        # aggregated_results.map { |attrs| instantiate(attrs) }
+      end
     end
   end
 end
-
 require 'mongoid/geospatial/config'

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: mongoid-geospatial
 version: !ruby/object:Gem::Version
-  version: 7.0.0
+  version: 7.1.0
 platform: ruby
 authors:
 - Ryan Ong
@@ -32,20 +32,8 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
-- ".coveralls.yml"
-- ".gitignore"
-- ".hound.yml"
-- ".rspec"
-- ".rubocop.yml"
-- ".travis.yml"
-- CHANGELOG.md
-- CONTRIBUTING.md
-- Gemfile
-- Guardfile
 - MIT-LICENSE
 - README.md
-- RELEASING.md
-- Rakefile
 - lib/mongoid/geospatial.rb
 - lib/mongoid/geospatial/config.rb
 - lib/mongoid/geospatial/config/point.rb
@@ -62,40 +50,11 @@ files:
 - lib/mongoid/geospatial/version.rb
 - lib/mongoid/geospatial/wrappers/georuby.rb
 - lib/mongoid/geospatial/wrappers/rgeo.rb
-- mongoid-geospatial.gemspec
-- spec/bench
-- spec/models/address.rb
-- spec/models/alarm.rb
-- spec/models/bar.rb
-- spec/models/bus.rb
-- spec/models/event.rb
-- spec/models/farm.rb
-- spec/models/person.rb
-- spec/models/phone.rb
-- spec/models/place.rb
-- spec/models/river.rb
-- spec/mongoid.yml
-- spec/mongoid/geospatial/config_spec.rb
-- spec/mongoid/geospatial/fields/box_spec.rb
-- spec/mongoid/geospatial/fields/circle_spec.rb
-- spec/mongoid/geospatial/fields/line_string_spec.rb
-- spec/mongoid/geospatial/fields/point_spec.rb
-- spec/mongoid/geospatial/fields/polygon_spec.rb
-- spec/mongoid/geospatial/geospatial_spec.rb
-- spec/mongoid/geospatial/helpers/core_spec.rb
-- spec/mongoid/geospatial/helpers/delegate_spec.rb
-- spec/mongoid/geospatial/helpers/spatial_spec.rb
-- spec/mongoid/geospatial/helpers/sphere_spec.rb
-- spec/mongoid/geospatial/wrappers/georuby_spec.rb
-- spec/mongoid/geospatial/wrappers/rgeo_spec.rb
-- spec/spec_helper.rb
-- spec/support/authentication.rb
-- spec/support/mongod.conf
-- spec/support/mongoid.yml
 homepage: https://github.com/mongoid/mongoid-geospatial
 licenses:
 - MIT
-metadata: {}
+metadata:
+  rubygems_mfa_required: 'true'
 rdoc_options: []
 require_paths:
 - lib
@@ -103,7 +62,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 3.1.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
@@ -113,33 +72,4 @@ requirements: []
 rubygems_version: 3.6.7
 specification_version: 4
 summary: Mongoid Extension that simplifies MongoDB Geospatial Operations.
-test_files:
-- spec/bench
-- spec/models/address.rb
-- spec/models/alarm.rb
-- spec/models/bar.rb
-- spec/models/bus.rb
-- spec/models/event.rb
-- spec/models/farm.rb
-- spec/models/person.rb
-- spec/models/phone.rb
-- spec/models/place.rb
-- spec/models/river.rb
-- spec/mongoid.yml
-- spec/mongoid/geospatial/config_spec.rb
-- spec/mongoid/geospatial/fields/box_spec.rb
-- spec/mongoid/geospatial/fields/circle_spec.rb
-- spec/mongoid/geospatial/fields/line_string_spec.rb
-- spec/mongoid/geospatial/fields/point_spec.rb
-- spec/mongoid/geospatial/fields/polygon_spec.rb
-- spec/mongoid/geospatial/geospatial_spec.rb
-- spec/mongoid/geospatial/helpers/core_spec.rb
-- spec/mongoid/geospatial/helpers/delegate_spec.rb
-- spec/mongoid/geospatial/helpers/spatial_spec.rb
-- spec/mongoid/geospatial/helpers/sphere_spec.rb
-- spec/mongoid/geospatial/wrappers/georuby_spec.rb
-- spec/mongoid/geospatial/wrappers/rgeo_spec.rb
-- spec/spec_helper.rb
-- spec/support/authentication.rb
-- spec/support/mongod.conf
-- spec/support/mongoid.yml
+test_files: []

data/.coveralls.yml

@@ -1 +0,0 @@
-service_name: travis-ci