mongoid_geo 0.1.0

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright 2011 YOURNAME
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.textile

@@ -0,0 +1,123 @@
+h1. Mongoid geo
+
+A Geo extension for Mongoid. 
+
+"MongoDB Geospatial Indexing":http://www.mongodb.org/display/DOCS/Geospatial+Indexing
+
+* Supports Mongoid 1.7 sphere distance calculations and 
+* Adds a set of geo related inflections
+* Adds nearSphere inclusion method
+
+h2. Status
+
+This gem has so far just the initial design and has not been tested. Feel free to help in the effort. Thanks!
+
+h2. Fields
+
+When setting a geo-location array, the setter should try to convert the value to an array of floats 
+
+Old/Manual style:
+
+<pre>
+  class Person
+    field :locations, :type => Array
+
+    def locations= args
+      @locations = args.kind_of?(String) ? args.split(",").map(&:to_f) : args
+    end
+  end  
+</pre>
+
+With _mongoid-geo_, becomes:
+
+<pre>
+  class Person
+    field :locations, :type => Array, :geo => true
+  end  
+  
+   p = Person.new
+   # set via String or Strings
+   p.locations = "45.1, -3.4"
+   p.locations = "45.1", "-3.4"   
+
+   assert([45.1, -3.4], p.locations)   
+</pre>
+
+h2. Extra Geo Inclusions
+
+Find all addresses near a point using spherical distance calculation
+
+h3. nearSphere
+
+<pre>
+  base.where(:locations.nearSphere => [ 72, -44 ])
+  # => :locations => { "$nearSphere" : [ 72, -44 ] }
+</pre>
+
+h2. Extra Geo Inflections
+
+h3. nearMax
+
+Find all addresses near a point using spherical distance calculation
+
+<pre>
+  base.where(:locations.nearMax => [[ 72, -44 ], 5])
+  # => { $near: [50, 40] , $maxDistance: 3 }
+
+  base.where(:locations.nearMax(:sphere) => [[ 72, -44 ], 5])
+  # => { $nearSphere: [50, 40] , $maxDistanceSphere: 3 }
+</pre>
+
+h3. withinBox
+
+<pre>
+  box = [[50, 40], [30,55]]
+  base.where(:locations.withinBox => box)
+  # => locations: {"$within" : {"$box" : box}
+
+  base.where(:locations.withinBox(:sphere) => box)
+  # => locations: {"$within" : {"$boxSphere" : box}
+</pre>
+
+You can also use a Hash to define the box
+
+<pre> 
+  places.where(:location.withinBox => {:lower_left => [50, 40], :upper_right => [30,55]})  
+</pre>
+
+Or use an Object (which must have the methods #lower_left and #upper_right that return the points of the bounding box)
+
+<pre>
+  box = (Struct.new :lower_left, :upper_right).new
+  box.lower_left = [50, 40]
+  box.upper_right = [30,55]  
+  places.where(:location.withinBox => box)  
+</pre>
+
+h3. withinCenter
+
+<pre>
+  center = [50, 40]
+  radius = 4
+  
+  # places: {"$within" : {"$centerSphere" : [center, radius]}  
+  places.where(:location.withinCenter(:sphere) => [center, radius])  
+
+  # places: {"$within" : {"$center" : [center, radius]}
+  places.where(:location.withinCenter => [center, radius])  
+</pre>
+
+You can also use a Hash to define the box
+
+<pre> 
+  places.where(:location.withinCenter => {:center => [50, 40], :radius => 4})  
+</pre>
+
+Or use an Object (which must have the methods #lower_left and #upper_right that return the points of the bounding box)
+
+<pre>
+  circle = (Struct.new :center, :radius).new
+  circle.center = [50, 40]
+  circle.radius = 4
+  places.where(:location.withinCenter => circle)  
+</pre>

data/Rakefile

@@ -0,0 +1,25 @@
+# encoding: UTF-8
+require 'rubygems'
+begin
+  require 'bundler/setup'
+rescue LoadError
+  puts 'You must `gem install bundler` and `bundle install` to run rake tasks'
+end
+
+require 'rake'
+require 'rake/rdoctask'
+
+require 'rspec/core'
+require 'rspec/core/rake_task'
+
+RSpec::Core::RakeTask.new(:spec)
+
+task :default => :spec
+
+Rake::RDocTask.new(:rdoc) do |rdoc|
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title    = 'Mongoid Geo'
+  rdoc.options << '--line-numbers' << '--inline-source'
+  rdoc.rdoc_files.include('README.rdoc')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end

data/lib/mongoid/geo/criteria.rb

@@ -0,0 +1,6 @@
+require 'mongoid/geo/criterion/complex'
+require 'mongoid/geo/criterion/inclusion'
+require 'mongoid/geo/criterion/outer_operator'
+require 'mongoid/geo/criterion/twin_operators'
+require 'mongoid/geo/inflections'
+require 'mongoid/geo/criteria_helpers'

data/lib/mongoid/geo/criteria_helpers.rb

@@ -0,0 +1,29 @@
+# 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|
+            case k
+            when Mongoid::Criterion::Complex
+              hsh[k.key] ||= {}
+              hsh[k.key].merge!(k.make_hash(v))
+            when Mongoid::Criterion::OuterOperator
+              hsh[k.key] ||= {}
+              hsh[k.key].merge!(k.make_hash(v))
+            when Mongoid::Criterion::TwinOperators
+              raise "TwinOperators expects an array with a value for each of the twin operators" if !v.kind_of?(Array) && !v.size == 2
+              hsh[k.key] ||= {}              
+              hsh[k.key].merge!(k.make_hash(v))
+            else
+              hsh[k] = v
+            end
+          end
+          hsh
+        end
+      end
+    end
+  end
+end

data/lib/mongoid/geo/criterion/complex.rb

@@ -0,0 +1,19 @@
+# encoding: utf-8
+module Mongoid #:nodoc:
+  module Criterion #:nodoc:
+    # Complex criterion are used when performing operations on symbols to get
+    # get a shorthand syntax for where clauses.
+    #
+    # Example:
+    #
+    # <tt>{ :field => { "$lt" => "value" } }</tt>
+    # becomes:
+    # <tt> { :field.lt => "value }</tt>
+    class Complex
+      
+      def make_hash v
+        {"$#{operator}" => v}
+      end
+    end
+  end
+end

data/lib/mongoid/geo/criterion/inclusion.rb

@@ -0,0 +1,19 @@
+# encoding: utf-8
+module Mongoid #:nodoc:
+  module Criterion #:nodoc:
+    module Inclusion
+      # Adds a criterion to the +Criteria+ that specifies values to do
+      # geospacial searches by. The field must be indexed with the "2d" option.
+      #
+      # @example Adding the criterion.
+      #   criteria.near(:field1 => [30, -44])
+      #
+      # @param [ Hash ] attributes The fields with lat/long values.
+      #
+      # @return [ Criteria ] A new criteria with the added selector.
+      def nearSphere(attributes = {})
+        update_selector(attributes, "$nearSphere")
+      end
+    end
+  end
+end

data/lib/mongoid/geo/criterion/outer_operator.rb

@@ -0,0 +1,61 @@
+# encoding: utf-8
+module Mongoid #:nodoc:
+  module Criterion #:nodoc:
+    # Complex criterion are used when performing operations on symbols to get
+    # get a shorthand syntax for where clauses.
+    #
+    # Example:
+    
+    # {:outer_operator => 'within', :operator => 'center' }
+    # { :location => { "$within" => { "$center" => [ [ 50, -40 ], 1 ] } } }
+    class OuterOperator
+      attr_accessor :key, :outer_op, :operator
+
+      # Create the new complex criterion.
+      def initialize(opts = {})
+        @key = opts[:key]
+        @operator = opts[:operator]
+        @outer_op = opts[:outer_op]        
+      end
+
+      def make_hash v
+        v = extract_box(v) if !v.kind_of?(Array) && operator =~ /box/
+        v = extract_circle(v) if !v.kind_of?(Array) && operator =~ /center/
+        {"$#{outer_op}" => {"$#{operator}" => v } }
+      end
+
+      def hash
+        [@outer_op, [@operator, @key]].hash
+      end
+
+      def eql?(other)
+        self == (other)
+      end
+
+      def ==(other)
+        return false unless other.is_a?(self.class)        
+        self.outer_op == other.outer_op && self.key == other.key && self.operator == other.operator
+      end
+      
+      protected
+
+      def extract_circle(v)
+        case v
+        when Hash
+          [v[:center], v[:radius]]
+        else
+          v.respond_to?(:center) ? [v.center, v.radius] : raise("Can't extract box from: #{v}, must have :center and :radius methods or hash keys")
+        end
+      end
+      
+      def extract_box v
+        case v
+        when Hash
+          [v[:lower_left], v[:upper_right]]
+        else
+          v.respond_to?(:lower_left) ? [v.lower_left, v.upper_right] : raise("Can't extract box from: #{v}, must have :lower_left and :upper_right methods or hash keys")
+        end
+      end
+    end
+  end
+end

data/lib/mongoid/geo/criterion/twin_operators.rb

@@ -0,0 +1,39 @@
+# encoding: utf-8
+module Mongoid #:nodoc:
+  module Criterion #:nodoc:
+    # Complex criterion are used when performing operations on symbols to get
+    # get a shorthand syntax for where clauses.
+    #
+    # Example:
+    
+    # {:opA => 'near', :opB => 'maxDistance' }
+    # :location => { $near => [50,50], $maxDistance => 5 }
+    class TwinOperators
+      attr_accessor :key, :op_a, :op_b
+
+      # Create the new complex criterion.
+      def initialize(opts = {})
+        @key = opts[:key]
+        @op_a = opts[:op_a]
+        @op_b = opts[:op_b]        
+      end
+
+      def make_hash v
+        {"$#{op_a}" => v.first, "$#{op_b}" => v.last }
+      end
+
+      def hash
+        [@op_a, @op_b, @key].hash
+      end
+
+      def eql?(other)
+        self == (other)
+      end
+
+      def ==(other)
+        return false unless other.is_a?(self.class)        
+        self.op_a == other.op_a && self.op_b == other.op_b && self.key == other.key 
+      end
+    end
+  end
+end

data/lib/mongoid/geo/fields.rb

@@ -0,0 +1,23 @@
+module Mongoid #:nodoc
+  # This module defines behaviour for fields.
+  module Fields
+    module ClassMethods #:nodoc
+      def create_accessors(name, meth, options = {})
+        generated_field_methods.module_eval do
+          define_method(meth) { read_attribute(name) }
+          options
+          define_method("#{meth}=") do |value| 
+            value = if options[:type] == Array && options[:geo]
+              value.kind_of?(String) ? value.split(",") : value
+            end.map(&:to_f)
+            write_attribute(name, value) 
+          end
+          define_method("#{meth}?") do
+            attr = read_attribute(name)
+            (options[:type] == Boolean) ? attr == true : attr.present?
+          end
+        end
+      end
+    end
+  end
+end

data/lib/mongoid/geo/inflections.rb

@@ -0,0 +1,39 @@
+# encoding: utf-8
+module Mongoid #:nodoc:
+  module Extensions #:nodoc:
+    module Symbol #:nodoc:
+      module Inflections #:nodoc:
+        
+        # $nearSphere $centerSphere        
+        # nearMax
+        # - { $near : [50,50] , $maxDistance : 5 }
+        # withinBox
+        # - {"$within" : {"$box" : box}
+        # withinCenter
+        # - {"$within" : {"$center" : [center, radius]}}})          
+
+        def nearSphere
+          Criterion::Complex.new(:operator => 'nearSphere', :key => self)          
+        end
+
+        def nearMax calc = :flat
+          Criterion::TwinOperators.new(:op_a => get_op(calc, 'near'), :op_b => get_op(calc, 'maxDistance'), :key => self)
+        end
+
+        def withinBox calc = :flat
+          Criterion::OuterOperator.new(:outer_op => 'within', :operator => get_op(calc, 'box'), :key => self)
+        end
+
+        def withinCenter calc = :flat
+          Criterion::OuterOperator.new(:outer_op => 'within', :operator => get_op(calc, 'center'), :key => self)
+        end 
+        
+        private
+        
+        def get_op calc, operator
+          calc.to_s == 'sphere' ? "#{operator}Sphere" : operator
+        end
+      end
+    end
+  end
+end

data/lib/mongoid/geo.rb

@@ -0,0 +1,2 @@
+require 'mongoid/geo/criteria'
+require 'mongoid/geo/fields'

data/lib/mongoid_geo.rb

@@ -0,0 +1 @@
+require 'mongoid/geo'

metadata

@@ -0,0 +1,80 @@
+--- !ruby/object:Gem::Specification
+name: mongoid_geo
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+  prerelease: !!null 
+platform: ruby
+authors: []
+autorequire: !!null 
+bindir: bin
+cert_chain: []
+date: 2011-02-05 00:00:00.000000000 +01:00
+default_executable: !!null 
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: mongoid
+  requirement: &2159951560 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 2.0.0.rc.6
+  type: :runtime
+  prerelease: false
+  version_requirements: *2159951560
+- !ruby/object:Gem::Dependency
+  name: bson_ext
+  requirement: &2159950420 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 1.1.6
+  type: :runtime
+  prerelease: false
+  version_requirements: *2159950420
+description: Geo spatial extension on Mongoid 2, to add more geo-spatial capabilities
+email: !!null 
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/mongoid/geo/criteria.rb
+- lib/mongoid/geo/criteria_helpers.rb
+- lib/mongoid/geo/criterion/complex.rb
+- lib/mongoid/geo/criterion/inclusion.rb
+- lib/mongoid/geo/criterion/outer_operator.rb
+- lib/mongoid/geo/criterion/twin_operators.rb
+- lib/mongoid/geo/fields.rb
+- lib/mongoid/geo/inflections.rb
+- lib/mongoid/geo.rb
+- lib/mongoid_geo.rb
+- MIT-LICENSE
+- Rakefile
+- README.textile
+has_rdoc: true
+homepage: https://github.com/kristianmandrup/mongoid-geo
+licenses: []
+post_install_message: !!null 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: !!null 
+rubygems_version: 1.5.0
+signing_key: !!null 
+specification_version: 3
+summary: Adds extra convenience methods for geo-spatial operations etc.
+test_files: []