sig_mongoid_spacial 0.2.17

data/lib/mongoid_spacial/criterion/inclusion.rb

@@ -0,0 +1,14 @@
+# encoding: utf-8
+module Mongoid #:nodoc:
+  module Criterion #:nodoc:
+    module Inclusion
+      def near(attributes = {})
+        update_selector(attributes, "$near")
+      end
+
+      def near_sphere(attributes = {})
+        update_selector(attributes, "$near")
+      end
+    end
+  end
+end

data/lib/mongoid_spacial/criterion/near_spacial.rb

@@ -0,0 +1,50 @@
+# encoding: utf-8
+module Mongoid #:nodoc:
+  module Criterion #:nodoc:
+
+    # NearSpecial criterion is used when performing #near with symbols to get
+    # get a shorthand syntax for where clauses.
+    #
+    # @example Coninputersion of a simple to complex criterion.
+    #   { :field => { "$nearSphere" => => [20,30]}, '$maxDistance' => 5 }
+    #   becomes:
+    #   { :field.near(:sphere) => {:point => [20,30], :max => 5, :unit => :km} }
+    class NearSpacial < Complex
+
+      # Coninputert input to query for near or nearSphere
+      #
+      # @example
+      #   near = NearSpacial.new(:key => :field, :operator => "near")
+      #   near.to_mongo_query({:point => [:50,50], :max => 5, :unit => :km}) => { '$near : [50,50]' , '$maxDistance' : 5 }
+      #
+      # @param [Hash,Array] input input to coninputer to query
+      def to_mongo_query(input)
+        if input.kind_of?(Hash)
+          raise ':point required to make valid query' unless input[:point]
+          input[:point] = input[:point].to_lng_lat if input[:point].respond_to?(:to_lng_lat)
+          query = {"$#{operator}" => input[:point] }
+          if input[:max]
+            query['$maxDistance'] = input[:max].to_f
+
+            if unit = Mongoid::Spacial.earth_radius[input[:unit]]
+              unit *= Mongoid::Spacial::RAD_PER_DEG unless operator =~ /sphere/i
+              input[:unit] = unit
+            end
+
+            query['$maxDistance'] = query['$maxDistance']/input[:unit].to_f if input[:unit]
+          end
+          query
+        elsif input.kind_of? Array
+          if input.first.kind_of? Numeric
+            {"$#{operator}" => input }
+          else
+            input[0] = input[0].to_lng_lat if input[0].respond_to?(:to_lng_lat)
+            {"$#{operator}" => input[0], '$maxDistance' => input[1] }
+          end
+        end
+      end
+
+    end
+  end
+end
+

data/lib/mongoid_spacial/criterion/within_spacial.rb

@@ -0,0 +1,60 @@
+# encoding: utf-8
+module Mongoid #:nodoc:
+  module Criterion #:nodoc:
+
+    # WithinSpecial criterion is used when performing #within with symbols to get
+    # get a shorthand syntax for where clauses.
+    #
+    # @example Conversion of a simple to complex criterion.
+    #   { :field => { "$within" => {'$center' => [20,30]} } }
+    #   becomes:
+    #   { :field.within(:center) => [20,30] }
+    class WithinSpacial < Complex
+
+      # Convert input to query for box, polygon, center, and centerSphere
+      #
+      # @example
+      #   within = WithinSpacial.new(opts[:key] => 'point', :operator => 'center')
+      #   within.to_mongo_query({:point => [20,30], :max => 5, :unit => :km}) #=>
+      #
+      # @param [Hash,Array] input Variable to conver to query
+      def to_mongo_query(input)
+        if ['box','polygon'].index(@operator)
+          input = input.values if input.kind_of?(Hash)
+          if input.respond_to?(:map)
+            input.map!{ |v| (v.respond_to?(:to_lng_lat)) ? v.to_lng_lat : v }
+          else
+            input
+          end
+        elsif ['center','centerSphere'].index(@operator)
+
+          if input.kind_of?(Hash) || input.kind_of?(ActiveSupport::OrderedHash)
+            raise ':point required to make valid query' unless input[:point]
+            input[:point] = input[:point].to_lng_lat if input[:point].respond_to?(:to_lng_lat)
+            if input[:max]
+              input[:max] = input[:max].to_f
+
+              if unit = Mongoid::Spacial.earth_radius[input[:unit]]
+                unit *= Mongoid::Spacial::RAD_PER_DEG unless operator =~ /sphere/i
+                input[:unit] = unit
+              end
+
+              input[:max] = input[:max]/input[:unit].to_f if input[:unit]
+
+              input = [input[:point],input[:max]]
+            else
+              input = input[:point]
+            end
+          end
+
+          if input.kind_of? Array
+            input[0] = input[0].to_lng_lat if input[0].respond_to?(:to_lng_lat)
+          end
+
+        end
+        {'$within' => {"$#{@operator}"=>input} }
+      end
+    end
+  end
+end
+

data/lib/mongoid_spacial/extentions/hash/criteria_helpers.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_spacial/extentions/symbol/inflections.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::NearSpacial]
+
+        def near(calc = :flat)
+          Criterion::NearSpacial.new(:operator => get_op('near',calc), :key => self)          
+        end
+
+        # alias for self.near(:sphere)
+        #
+        # @return [Criterion::NearSpacial]
+        def near_sphere
+          self.near(:sphere)
+        end
+        
+        # @param [Symbol] shape :box,:polygon,:center,:center_sphere
+        #
+        # @return [Criterion::WithinSpacial]
+        def within(shape)
+          shape = get_op(:center,:sphere) if shape == :center_sphere
+          Criterion::WithinSpacial.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_spacial/field_option.rb

@@ -0,0 +1,38 @@
+require 'ostruct'
+# Field changes to Fields from mongoid 2.0 to mongoid 2.1
+field = (defined?(Mongoid::Field)) ? Mongoid::Field : Mongoid::Fields
+
+field.option :spacial 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.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_spacial/finders.rb

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

data/lib/mongoid_spacial/spacial.rb

@@ -0,0 +1,56 @@
+require 'mongoid_spacial/spacial/core_ext'
+require 'mongoid_spacial/spacial/formulas'
+require 'mongoid_spacial/spacial/document'
+require 'mongoid_spacial/spacial/geo_near_results'
+module Mongoid
+  module Spacial
+
+    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,
+    }
+
+    RAD_PER_DEG = Math::PI/180
+
+    LNG_SYMBOLS = [:x, :lon, :long, :lng, :longitude]
+    LAT_SYMBOLS = [:y, :lat, :latitude]
+
+    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
+
+    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
+
+  end
+end

data/lib/mongoid_spacial/spacial/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::Spacial.lat_symbols & self.keys).first
+    return self[v].to_f if !v.nil? && self[v]
+    raise "Hash must contain #{Mongoid::Spacial.lat_symbols.inspect} if ruby version is less than 1.9" if RUBY_VERSION.to_f < 1.9
+    raise "Hash cannot contain #{Mongoid::Spacial.lng_symbols.inspect} as the second item if there is no #{Mongoid::Spacial.lat_symbols.inspect}" if Mongoid::Spacial.lng_symbols.index(self.keys[1])
+    self.values[1].to_f
+  end
+
+  def to_lng
+    v = (Mongoid::Spacial.lng_symbols & self.keys).first
+    return self[v].to_f if !v.nil? && self[v]
+    raise "Hash cannot contain #{Mongoid::Spacial.lat_symbols.inspect} as the first item if there is no #{Mongoid::Spacial.lng_symbols.inspect}" if Mongoid::Spacial.lat_symbols.index(self.keys[0])
+    self.values[0].to_f
+  end
+end

data/lib/mongoid_spacial/spacial/document.rb

@@ -0,0 +1,29 @@
+module Mongoid
+  module Spacial
+    module Document
+      extend ActiveSupport::Concern
+
+      included do
+        attr_accessor :geo
+        cattr_accessor :spacial_fields, :spacial_fields_indexed
+        @@spacial_fields = []
+        @@spacial_fields_indexed = []
+      end
+
+      module ClassMethods #:nodoc:
+        # create spacial index for given field
+        # @param [String,Symbol] name
+        # @param [Hash] options options for spacial_index
+        def spacial_index name, *options
+          self.spacial_fields_indexed << name
+          index [[ name, Mongo::GEO2D ]], *options
+        end
+      end
+
+      def distance_from(key,p2, opts = {})
+        p1 = self.send(key)
+        Mongoid::Spacial.distance(p1, p2, opts)
+      end
+    end
+  end
+end

data/lib/mongoid_spacial/spacial/formulas.rb

@@ -0,0 +1,52 @@
+module Mongoid
+  module Spacial
+    module Formulas
+      class << self
+        def n_vector(point1,point2)
+          p1 = point1.map{|deg| deg * RAD_PER_DEG}
+          p2 = point2.map{|deg| deg * RAD_PER_DEG}
+
+          sin_x1 = Math.sin(p1[0])
+          cos_x1 = Math.cos(p1[0])
+
+          sin_y1 = Math.sin(p1[1])
+          cos_y1 = Math.cos(p1[1])
+
+          sin_x2 = Math.sin(p2[0])
+          cos_x2 = Math.cos(p2[0])
+
+          sin_y2 = Math.sin(p2[1])
+          cos_y2 = Math.cos(p2[1])
+
+          cross_prod =  (cos_y1*cos_x1 * cos_y2*cos_x2) +
+            (cos_y1*sin_x1 * cos_y2*sin_x2) +
+            (sin_y1        * sin_y2)
+
+          return cross_prod > 0 ? 0 : Math::PI if (cross_prod >= 1 || cross_prod <= -1)
+
+          d = Math.acos(cross_prod)
+          d.instance_variable_set("@radian", true)
+          d
+        end
+
+        def haversine(point1,point2)
+          p1 = point1.map{|deg| deg * RAD_PER_DEG}
+          p2 = point2.map{|deg| deg * RAD_PER_DEG}
+
+          dlon = p2[0] - p1[0]
+          dlat = p2[1] - p1[1]
+
+          a = (Math.sin(dlat/2))**2 + Math.cos(p1[1]) * Math.cos(p2[1]) * (Math.sin(dlon/2))**2
+
+          d = 2 * Math.atan2( Math.sqrt(a), Math.sqrt(1-a))
+          d.instance_variable_set("@radian", true)
+          d
+        end
+
+        def pythagorean_theorem(p1, p2)
+          Math.sqrt(((p2[0] - p1[0]) ** 2) + ((p2[1] - p1[1]) ** 2))
+        end
+      end
+    end
+  end
+end

data/lib/mongoid_spacial/spacial/geo_near_results.rb

@@ -0,0 +1,140 @@
+module Mongoid
+  module Spacial
+    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::Spacial::Document" unless document.respond_to?(:spacial_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.spacial_fields_indexed if @document.spacial_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.spacial_fields_indexed.kind_of?(Array) && @document.spacial_fields_indexed.size == 1
+              primary = @document.spacial_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::Spacial.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::Spacial.default_per_page
+                             end
+        end
+      end
+      alias_method :per_page, :limit_value
+
+      def num_pages
+        (self.total_entries && @opts[:per_page]) ? self.total_entries/@opts[:per_page] : 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