rpbertp13-dm-geokit 0.9.11

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2008 Foy Savas
+
+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

@@ -0,0 +1,49 @@
+dm-geokit
+=========
+
+A mixin for Datamapper models that enables geographic functionality.
+
+* Search for content via DataMapper-style query methods, e.g. Location.all(:address.near => {:origin => 'Portland, OR', :distance => 5.mi})
+* Sort by distance easily: Location.all(:address.near => {:origin => 'Portland, OR', :distance => 5.mi}, :order => [:address_distance.desc])
+* Ability to specify multiple fields that are geocodable (mostly)
+
+Usage
+=====
+
+Basic Class Definition:
+
+class Location
+  include DataMapper::Resource
+  property :id, Serial
+  has_geographic_location :address
+end
+
+This will automatically generate fields and methods for use with the DM Object, prefixed with the field name specified.
+Since the above example used the field :address, the following fields would be generated:
+
+* address_street_address
+* address_city
+* address_state
+* address_zip
+* address_country_code
+* address_full_address
+* address_lat
+* address_lng
+
+You can either reference those fields directly, or use the proxy object returned by calling .address on your object:
+
+l = Location.all(:address.near => {:origin => 'Portland, OR', :distance => 5.mi})
+
+l.each do |loc|
+  puts loc.address # .to_s yields string representation of full address, e.g. "12345 My St. Portland, OR USA"
+  puts loc.address.inspect # the proxy object, GeographicLocation, with matching methods for each property
+  puts loc.address.street_address # getting the street_address from the proxy object
+  puts loc.address_street_address # directly access the SQL column
+end
+
+The GeographicLocation proxy object is a convenience to allow you to compare and sort results in Ruby.
+
+Requirements
+===========
+
+Requires the GeoKit gem.

data/Rakefile

@@ -0,0 +1,20 @@
+begin 
+  require 'jeweler' 
+  Jeweler::Tasks.new do |s| 
+    s.name = 'rpbertp13-dm-geokit' 
+    s.summary = "DataMapper plugin for geokit stuff forked from Foy Savas's project. Now relies on the geokit gem rather than Foy's gem."
+    s.authors = ['Foy Savas', 'Daniel Higginbotham', 'Matt King', 'Roberto Thais']
+    s.email = 'roberto@robertothais.com'
+    s.homepage = "http://github.com/rpbertp13/dm-geokit/tree/master" 
+    s.description = "Simple and opinionated helper for creating Rubygem projects on GitHub" 
+    s.files =  FileList["[A-Z]*", "{bin,generators,lib,test}/**/*", 'lib/jeweler/templates/.gitignore'] 
+    s.require_path     = 'lib'
+    s.has_rdoc         = true
+    s.platform         = Gem::Platform::RUBY
+    s.extra_rdoc_files = %w[ README LICENSE TODO ]
+    s.add_dependency 'dm-core'
+    s.add_dependency 'geokit'
+  end 
+rescue LoadError 
+  puts "Jeweler, or one of its dependencies, is not available. Install it with: sudo gem install technicalpickles-jeweler -s http://gems.github.com" 
+end

data/TODO

@@ -0,0 +1,8 @@
+TODO
+====
+
+
+
+---
+TODO tickets may also be found in the DataMapper Issue Tracker:
+http://wm.lighthouseapp.com/projects/4819-datamapper/overview

data/VERSION.yml

@@ -0,0 +1,4 @@
+--- 
+:major: 0
+:minor: 9
+:patch: 11

data/lib/dm-geokit.rb

@@ -0,0 +1,8 @@
+require 'rubygems'
+require 'geokit'
+require 'dm-core'
+
+%w(distance_measurement distance_support symbol integer float).each{|f|
+  require File.join(File.dirname(__FILE__),'dm-geokit','support',f)
+}
+require File.join(File.dirname(__FILE__),'dm-geokit','resource')

data/lib/dm-geokit/acts_as_mappable.rb

@@ -0,0 +1,436 @@
+module DataMapper::GeoKit
+  # Contains the class method acts_as_mappable targeted to be mixed into DataMapper.
+  # When mixed in, augments find services such that they provide distance calculation
+  # query services.  The find method accepts additional options:
+  #
+  # * :origin - can be 
+  #   1. a two-element array of latititude/longitude -- :origin=>[37.792,-122.393]
+  #   2. a geocodeable string -- :origin=>'100 Spear st, San Francisco, CA'
+  #   3. an object which responds to lat and lng methods, or latitude and longitude methods,
+  #      or whatever methods you have specified for lng_column_name and lat_column_name
+  #
+  # Other finder methods are provided for specific queries.  These are:
+  #
+  # * find_within (alias: find_inside)
+  # * find_beyond (alias: find_outside)
+  # * find_closest (alias: find_nearest)
+  # * find_farthest
+  #
+  # Counter methods are available and work similarly to finders.  
+  #
+  # If raw SQL is desired, the distance_sql method can be used to obtain SQL appropriate
+  # to use in a find_by_sql call.
+  module ActsAsMappable 
+    # Mix below class methods into DataMapper.
+    def self.included(base) # :nodoc:
+      base.extend ClassMethods
+    end
+    
+    # Class method to mix into active record.
+    module ClassMethods # :nodoc:
+      # Class method to bring distance query support into ActiveRecord models.  By default
+      # uses :miles for distance units and performs calculations based upon the Haversine
+      # (sphere) formula.  These can be changed by setting GeoKit::default_units and
+      # GeoKit::default_formula.  Also, by default, uses lat, lng, and distance for respective
+      # column names.  All of these can be overridden using the :default_units, :default_formula,
+      # :lat_column_name, :lng_column_name, and :distance_column_name hash keys.
+      # 
+      # Can also use to auto-geocode a specific column on create. Syntax;
+      #   
+      #   acts_as_mappable :auto_geocode=>true
+      # 
+      # By default, it tries to geocode the "address" field. Or, for more customized behavior:
+      #   
+      #   acts_as_mappable :auto_geocode=>{:field=>:address,:error_message=>'bad address'}
+      #   
+      # In both cases, it creates a before_validation_on_create callback to geocode the given column.
+      # For anything more customized, we recommend you forgo the auto_geocode option
+      # and create your own AR callback to handle geocoding.
+      def acts_as_mappable(options = {})
+        # Mix in the module, but ensure to do so just once.
+        return if self.included_modules.include?(GeoKit::ActsAsMappable::InstanceMethods)
+        send :include, GeoKit::ActsAsMappable::InstanceMethods
+        # include the Mappable module.
+        send :include, Mappable
+        
+        # Handle class variables.
+        cattr_accessor :distance_column_name, :default_units, :default_formula, :lat_column_name, :lng_column_name, :qualified_lat_column_name, :qualified_lng_column_name
+        self.distance_column_name = options[:distance_column_name]  || 'distance'
+        self.default_units = options[:default_units] || GeoKit::default_units
+        self.default_formula = options[:default_formula] || GeoKit::default_formula
+        self.lat_column_name = options[:lat_column_name] || 'lat'
+        self.lng_column_name = options[:lng_column_name] || 'lng'
+        self.qualified_lat_column_name = "#{table_name}.#{lat_column_name}"
+        self.qualified_lng_column_name = "#{table_name}.#{lng_column_name}"
+        if options.include?(:auto_geocode) && options[:auto_geocode]
+          # if the form auto_geocode=>true is used, let the defaults take over by suppling an empty hash
+          options[:auto_geocode] = {} if options[:auto_geocode] == true 
+          cattr_accessor :auto_geocode_field, :auto_geocode_error_message
+          self.auto_geocode_field = options[:auto_geocode][:field] || 'address'
+          self.auto_geocode_error_message = options[:auto_geocode][:error_message] || 'could not locate address'
+          
+          # set the actual callback here
+          before_validation_on_create :auto_geocode_address        
+        end
+      end
+    end
+    
+    # this is the callback for auto_geocoding
+    def auto_geocode_address
+      address=self.send(auto_geocode_field)
+      geo=GeoKit::Geocoders::MultiGeocoder.geocode(address)
+  
+      if geo.success
+        self.send("#{lat_column_name}=", geo.lat)
+        self.send("#{lng_column_name}=", geo.lng)
+      else
+        errors.add(auto_geocode_field, auto_geocode_error_message) 
+      end
+      
+      geo.success
+    end
+    
+    # Instance methods to mix into ActiveRecord.
+    module InstanceMethods #:nodoc:    
+      # Mix class methods into module.
+      def self.included(base) # :nodoc:
+        base.extend SingletonMethods
+      end
+      
+      # Class singleton methods to mix into ActiveRecord.
+      module SingletonMethods # :nodoc:
+        # Extends the existing find method in potentially two ways:
+        # - If a mappable instance exists in the options, adds a distance column.
+        # - If a mappable instance exists in the options and the distance column exists in the
+        #   conditions, substitutes the distance sql for the distance column -- this saves
+        #   having to write the gory SQL.
+        def find(*args)
+          prepare_for_find_or_count(:find, args)
+          super(*args)
+        end     
+        
+        # Extends the existing count method by:
+        # - If a mappable instance exists in the options and the distance column exists in the
+        #   conditions, substitutes the distance sql for the distance column -- this saves
+        #   having to write the gory SQL.
+        def count(*args)
+          prepare_for_find_or_count(:count, args)
+          super(*args)
+        end
+        
+        # Finds within a distance radius.
+        def find_within(distance, options={})
+          options[:within] = distance
+          find(:all, options)
+        end
+        alias find_inside find_within
+                
+        # Finds beyond a distance radius.
+        def find_beyond(distance, options={})
+          options[:beyond] = distance
+          find(:all, options)
+        end
+        alias find_outside find_beyond
+        
+        # Finds according to a range.  Accepts inclusive or exclusive ranges.
+        def find_by_range(range, options={})
+          options[:range] = range
+          find(:all, options)
+        end
+        
+        # Finds the closest to the origin.
+        def find_closest(options={})
+          find(:nearest, options)
+        end
+        alias find_nearest find_closest
+        
+        # Finds the farthest from the origin.
+        def find_farthest(options={})
+          find(:farthest, options)
+        end
+
+        # Finds within rectangular bounds (sw,ne).
+        def find_within_bounds(bounds, options={})
+          options[:bounds] = bounds
+          find(:all, options)
+        end
+        
+        # counts within a distance radius.
+        def count_within(distance, options={})
+          options[:within] = distance
+          count(options)
+        end
+        alias count_inside count_within
+
+        # Counts beyond a distance radius.
+        def count_beyond(distance, options={})
+          options[:beyond] = distance
+          count(options)
+        end
+        alias count_outside count_beyond
+        
+        # Counts according to a range.  Accepts inclusive or exclusive ranges.
+        def count_by_range(range, options={})
+          options[:range] = range
+          count(options)
+        end
+
+        # Finds within rectangular bounds (sw,ne).
+        def count_within_bounds(bounds, options={})
+          options[:bounds] = bounds
+          count(options)
+        end
+                
+        # Returns the distance calculation to be used as a display column or a condition.  This
+        # is provide for anyone wanting access to the raw SQL.
+        def distance_sql(origin, units=default_units, formula=default_formula)
+          case formula
+          when :sphere
+            sql = sphere_distance_sql(origin, units)
+          when :flat
+            sql = flat_distance_sql(origin, units)
+          end
+          sql
+        end   
+
+        private
+        
+        # Prepares either a find or a count action by parsing through the options and
+        # conditionally adding to the select clause for finders.
+        def prepare_for_find_or_count(action, args)
+          options = defined?(args.extract_options!) ? args.extract_options! : extract_options_from_args!(args)
+          # Obtain items affecting distance condition.
+          origin = extract_origin_from_options(options)
+          units = extract_units_from_options(options)
+          formula = extract_formula_from_options(options)
+          bounds = extract_bounds_from_options(options)
+          # if no explicit bounds were given, try formulating them from the point and distance given
+          bounds = formulate_bounds_from_distance(options, origin, units) unless bounds
+          # Apply select adjustments based upon action.
+          add_distance_to_select(options, origin, units, formula) if origin && action == :find
+          # Apply the conditions for a bounding rectangle if applicable
+          apply_bounds_conditions(options,bounds) if bounds
+          # Apply distance scoping and perform substitutions.
+          apply_distance_scope(options)
+          substitute_distance_in_conditions(options, origin, units, formula) if origin && options.has_key?(:conditions)
+          # Order by scoping for find action.
+          apply_find_scope(args, options) if action == :find
+          # Unfortunatley, we need to do extra work if you use an :include. See the method for more info.
+          handle_order_with_include(options,origin,units,formula) if options.include?(:include) && options.include?(:order) && origin
+          # Restore options minus the extra options that we used for the
+          # GeoKit API.
+          args.push(options)   
+        end
+        
+        # If we're here, it means that 1) an origin argument, 2) an :include, 3) an :order clause were supplied.
+        # Now we have to sub some SQL into the :order clause. The reason is that when you do an :include,
+        # ActiveRecord drops the psuedo-column (specificically, distance) which we supplied for :select. 
+        # So, the 'distance' column isn't available for the :order clause to reference when we use :include.
+        def handle_order_with_include(options, origin, units, formula)
+          # replace the distance_column_name with the distance sql in order clause
+          options[:order].sub!(distance_column_name, distance_sql(origin, units, formula))
+        end
+        
+        # Looks for mapping-specific tokens and makes appropriate translations so that the 
+        # original finder has its expected arguments.  Resets the the scope argument to 
+        # :first and ensures the limit is set to one.
+        def apply_find_scope(args, options)
+          case args.first
+            when :nearest, :closest
+              args[0] = :first
+              options[:limit] = 1
+              options[:order] = "#{distance_column_name} ASC"
+            when :farthest
+              args[0] = :first
+              options[:limit] = 1
+              options[:order] = "#{distance_column_name} DESC"
+          end
+        end
+        
+        # If it's a :within query, add a bounding box to improve performance.
+        # This only gets called if a :bounds argument is not otherwise supplied. 
+        def formulate_bounds_from_distance(options, origin, units)
+          distance = options[:within] if options.has_key?(:within)
+          distance = options[:range].last-(options[:range].exclude_end?? 1 : 0) if options.has_key?(:range)
+          if distance
+            res=GeoKit::Bounds.from_point_and_radius(origin,distance,:units=>units)
+          else 
+            nil
+          end
+        end
+        
+        # Replace :within, :beyond and :range distance tokens with the appropriate distance 
+        # where clauses.  Removes these tokens from the options hash.
+        def apply_distance_scope(options)
+          distance_condition = "#{distance_column_name} <= #{options[:within]}" if options.has_key?(:within)
+          distance_condition = "#{distance_column_name} > #{options[:beyond]}" if options.has_key?(:beyond)
+          distance_condition = "#{distance_column_name} >= #{options[:range].first} AND #{distance_column_name} <#{'=' unless options[:range].exclude_end?} #{options[:range].last}" if options.has_key?(:range)
+          [:within, :beyond, :range].each { |option| options.delete(option) } if distance_condition
+          
+          options[:conditions]=augment_conditions(options[:conditions],distance_condition) if distance_condition
+        end
+
+        # This method lets you transparently add a new condition to a query without
+        # worrying about whether it currently has conditions, or what kind of conditions they are
+        # (string or array).
+        # 
+        # Takes the current conditions (which can be an array or a string, or can be nil/false), 
+        # and a SQL string. It inserts the sql into the existing conditions, and returns new conditions
+        # (which can be a string or an array
+        def augment_conditions(current_conditions,sql)
+          if current_conditions && current_conditions.is_a?(String)
+            res="#{current_conditions} AND #{sql}"  
+          elsif current_conditions && current_conditions.is_a?(Array)
+            current_conditions[0]="#{current_conditions[0]} AND #{sql}"
+            res=current_conditions
+          else
+            res=sql
+          end
+          res
+        end
+
+        # Alters the conditions to include rectangular bounds conditions.
+        def apply_bounds_conditions(options,bounds)
+          sw,ne=bounds.sw,bounds.ne
+          lng_sql= bounds.crosses_meridian? ? "(#{qualified_lng_column_name}<#{sw.lng} OR #{qualified_lng_column_name}>#{ne.lng})" : "#{qualified_lng_column_name}>#{sw.lng} AND #{qualified_lng_column_name}<#{ne.lng}"
+          bounds_sql="#{qualified_lat_column_name}>#{sw.lat} AND #{qualified_lat_column_name}<#{ne.lat} AND #{lng_sql}"
+          options[:conditions]=augment_conditions(options[:conditions],bounds_sql)          
+        end
+
+        # Extracts the origin instance out of the options if it exists and returns
+        # it.  If there is no origin, looks for latitude and longitude values to 
+        # create an origin.  The side-effect of the method is to remove these 
+        # option keys from the hash.
+        def extract_origin_from_options(options)
+          origin = options.delete(:origin)
+          res = normalize_point_to_lat_lng(origin) if origin
+          res
+        end
+        
+        # Extract the units out of the options if it exists and returns it.  If
+        # there is no :units key, it uses the default.  The side effect of the 
+        # method is to remove the :units key from the options hash.
+        def extract_units_from_options(options)
+          units = options[:units] || default_units
+          options.delete(:units)
+          units
+        end
+        
+        # Extract the formula out of the options if it exists and returns it.  If
+        # there is no :formula key, it uses the default.  The side effect of the 
+        # method is to remove the :formula key from the options hash.
+        def extract_formula_from_options(options)
+          formula = options[:formula] || default_formula
+          options.delete(:formula)
+          formula
+        end
+        
+        def extract_bounds_from_options(options)
+          bounds = options.delete(:bounds)
+          bounds = GeoKit::Bounds.normalize(bounds) if bounds
+        end
+       
+        # Geocode IP address.
+        def geocode_ip_address(origin)
+          geo_location = GeoKit::Geocoders::IpGeocoder.geocode(origin)
+          return geo_location if geo_location.success
+          raise GeoKit::Geocoders::GeocodeError
+        end
+        
+
+        # Given a point in a variety of (an address to geocode,
+        # an array of [lat,lng], or an object with appropriate lat/lng methods, an IP addres)
+        # this method will normalize it into a GeoKit::LatLng instance. The only thing this
+        # method adds on top of LatLng#normalize is handling of IP addresses
+        def normalize_point_to_lat_lng(point)
+          res = geocode_ip_address(point) if point.is_a?(String) && /^(\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3})?$/.match(point)
+          res = GeoKit::LatLng.normalize(point) unless res
+          res       
+        end
+
+        # Augments the select with the distance SQL.
+        def add_distance_to_select(options, origin, units=default_units, formula=default_formula)
+          if origin
+            distance_selector = distance_sql(origin, units, formula) + " AS #{distance_column_name}"
+            selector = options.has_key?(:select) && options[:select] ? options[:select] : "*"
+            options[:select] = "#{selector}, #{distance_selector}"  
+          end   
+        end
+
+        # Looks for the distance column and replaces it with the distance sql. If an origin was not 
+        # passed in and the distance column exists, we leave it to be flagged as bad SQL by the database.
+        # Conditions are either a string or an array.  In the case of an array, the first entry contains
+        # the condition.
+        def substitute_distance_in_conditions(options, origin, units=default_units, formula=default_formula)
+          original_conditions = options[:conditions]
+          condition = original_conditions.is_a?(String) ? original_conditions : original_conditions.first
+          pattern = Regexp.new("\s*#{distance_column_name}(\s<>=)*")
+          condition = condition.gsub(pattern, distance_sql(origin, units, formula))
+          original_conditions = condition if original_conditions.is_a?(String)
+          original_conditions[0] = condition if original_conditions.is_a?(Array)
+          options[:conditions] = original_conditions
+        end
+        
+        # Returns the distance SQL using the spherical world formula (Haversine).  The SQL is tuned
+        # to the database in use.
+        def sphere_distance_sql(origin, units)
+          lat = deg2rad(origin.lat)
+          lng = deg2rad(origin.lng)
+          multiplier = units_sphere_multiplier(units)
+          case connection.adapter_name.downcase
+          when "mysql"
+            sql=<<-SQL_END 
+                  (ACOS(least(1,COS(#{lat})*COS(#{lng})*COS(RADIANS(#{qualified_lat_column_name}))*COS(RADIANS(#{qualified_lng_column_name}))+
+                  COS(#{lat})*SIN(#{lng})*COS(RADIANS(#{qualified_lat_column_name}))*SIN(RADIANS(#{qualified_lng_column_name}))+
+                  SIN(#{lat})*SIN(RADIANS(#{qualified_lat_column_name}))))*#{multiplier})
+                  SQL_END
+          when "postgresql"
+            sql=<<-SQL_END 
+                  (ACOS(least(1,COS(#{lat})*COS(#{lng})*COS(RADIANS(#{qualified_lat_column_name}))*COS(RADIANS(#{qualified_lng_column_name}))+
+                  COS(#{lat})*SIN(#{lng})*COS(RADIANS(#{qualified_lat_column_name}))*SIN(RADIANS(#{qualified_lng_column_name}))+
+                  SIN(#{lat})*SIN(RADIANS(#{qualified_lat_column_name}))))*#{multiplier})
+                  SQL_END
+          else
+            sql = "unhandled #{connection.adapter_name.downcase} adapter"
+          end        
+        end
+        
+        # Returns the distance SQL using the flat-world formula (Phythagorean Theory).  The SQL is tuned
+        # to the database in use.
+        def flat_distance_sql(origin, units)
+          lat_degree_units = units_per_latitude_degree(units)
+          lng_degree_units = units_per_longitude_degree(origin.lat, units)
+          case connection.adapter_name.downcase
+          when "mysql"
+            sql=<<-SQL_END
+                  SQRT(POW(#{lat_degree_units}*(#{origin.lat}-#{qualified_lat_column_name}),2)+
+                  POW(#{lng_degree_units}*(#{origin.lng}-#{qualified_lng_column_name}),2))
+                  SQL_END
+          when "postgresql"
+            sql=<<-SQL_END
+                  SQRT(POW(#{lat_degree_units}*(#{origin.lat}-#{qualified_lat_column_name}),2)+
+                  POW(#{lng_degree_units}*(#{origin.lng}-#{qualified_lng_column_name}),2))
+                  SQL_END
+          else
+            sql = "unhandled #{connection.adapter_name.downcase} adapter"
+          end
+        end
+      end
+    end
+  end
+end
+
+# Extend Array with a sort_by_distance method.
+# This method creates a "distance" attribute on each object, 
+# calculates the distance from the passed origin,
+# and finally sorts the array by the resulting distance.
+class Array
+  def sort_by_distance_from(origin, opts={})
+    distance_attribute_name = opts.delete(:distance_attribute_name) || 'distance'    
+    self.each do |e|
+      e.class.send(:attr_accessor, distance_attribute_name) if !e.respond_to? "#{distance_attribute_name}="
+      e.send("#{distance_attribute_name}=", origin.distance_to(e,opts))
+    end
+    self.sort!{|a,b|a.send(distance_attribute_name) <=> b.send(distance_attribute_name)}
+  end
+end

data/lib/dm-geokit/ip_geocode_lookup.rb

@@ -0,0 +1,35 @@
+require 'yaml'
+
+module GeoKit 
+  # Contains a class method geocode_ip_address which can be used to enable automatic geocoding
+  # for request IP addresses.  The geocoded information is stored in a cookie and in the 
+  # session to minimize web service calls.  The point of the helper is to enable location-based
+  # websites to have a best-guess for new visitors.
+  module IpGeocodeLookup
+ 
+    private   
+         
+    # Places the IP address' geocode location into the session if it 
+    # can be found.  Otherwise, looks for a geo location cookie and
+    # uses that value.  The last resort is to call the web service to
+    # get the value.
+    def store_ip_location
+      session[:geo_location] ||= retrieve_location_from_cookie_or_service
+      cookies[:geo_location] = { :value => session[:geo_location].to_yaml, :expires => 30.days.from_now } if session[:geo_location]
+    end    
+    
+    # Uses the stored location value from the cookie if it exists.  If
+    # no cookie exists, calls out to the web service to get the location. 
+    def retrieve_location_from_cookie_or_service
+      return YAML.load(cookies[:geo_location]) if cookies[:geo_location]
+      location = Geocoders::IpGeocoder.geocode(get_ip_address)
+      return location.success ? location : nil
+    end
+    
+    # Returns the real ip address, though this could be the localhost ip
+    # address.  No special handling here anymore.
+    def get_ip_address
+      request.remote_ip
+    end
+  end
+end

data/lib/dm-geokit/merbtasks.rb

@@ -0,0 +1,33 @@
+namespace :geo do
+  
+  desc "Look up an address using the failover"
+  task :multi do
+    puts GeoKit::Geocoders::MultiGeocoder.geocode(ENV["ADDR"])
+  end
+  
+  desc "Look up an address on google"
+  task :google do
+    puts GeoKit::Geocoders::GoogleGeocoder.geocode(ENV["ADDR"])
+  end
+  
+  desc "Look up an address on yahoo"
+  task :yahoo do
+    puts GeoKit::Geocoders::YahooGeocoder.geocode(ENV["ADDR"])
+  end
+  
+  desc "Look up an address on us_geocoder"
+  task :us do
+    puts GeoKit::Geocoders::UsGeocoder.geocode(ENV["ADDR"])
+  end
+  
+  desc "Look up an address on ca_geocoder"
+  task :ca do
+    puts GeoKit::Geocoders::CaGeocoder.geocode(ENV["ADDR"])
+  end
+  
+  desc "Lookup up the address of an IP"
+  task :ip do
+    puts GeoKit::Geocoders::IpGeocoder.geocode(ENV["ADDR"])
+  end
+    
+end

data/lib/dm-geokit/resource.rb

@@ -0,0 +1,169 @@
+module DataMapper
+  module GeoKit
+    PROPERTY_NAMES = %w(lat lng street_address city state zip country_code full_address)
+
+    def self.included(base)
+      base.extend ClassMethods
+    end
+
+    module ClassMethods
+      def has_geographic_location(name, options = {})
+        return if self.included_modules.include?(DataMapper::GeoKit::InstanceMethods)
+        send :include, InstanceMethods
+        send :include, ::GeoKit::Mappable
+
+        property name.to_sym, String, :size => 255
+        property "#{name}_distance".to_sym, Float
+
+        PROPERTY_NAMES.each do |p|
+          if p.match(/l(at|ng)/)
+            property "#{name}_#{p}".to_sym, Float, :precision => 15, :scale => 12, :index => true
+          else
+            property "#{name}_#{p}".to_sym, String, :size => 255
+          end
+        end
+
+        DataMapper.auto_upgrade!
+
+        define_method "#{name}" do
+          if(value = attribute_get(name.to_sym)).nil?
+            nil
+          else
+            GeographicLocation.new(name, self)
+          end
+        end
+
+        define_method "#{name}=" do |value|
+          if value.nil?
+            nil
+          else value.is_a?(String)
+            geo = ::GeoKit::Geocoders::MultiGeocoder.geocode(value)
+            if geo.success?
+              attribute_set(name.to_sym, geo.full_address)
+              PROPERTY_NAMES.each do |p|
+                attribute_set("#{name}_#{p}".to_sym, geo.send(p.to_sym))
+              end
+            end
+          end
+        end
+      end
+      alias acts_as_mappable has_geographic_location
+    end
+
+    module InstanceMethods
+      def self.included(base) # :nodoc:
+        base.extend SingletonMethods
+      end
+      
+      module SingletonMethods # :nodoc:
+        def all(query = {})
+          super(prepare_query(query))
+        end
+
+        # Required dm-aggregates to work
+        def count(query = {})
+          super(prepare_query(query))
+        end
+
+        private
+
+        # Looks in the query for keys that are a DistanceOperator, then extracts the keys/values and turns them into conditions
+        def prepare_query(query)
+          query.each_pair do |k,v|
+            next if not k.is_a?(DistanceOperator)
+            field = k.target
+            origin = v[:origin].is_a?(String) ? ::GeoKit::Geocoders::MultiGeocoder.geocode(v[:origin]) : v[:origin]
+            distance = v[:distance]
+            query[:conditions] = expand_conditions(query[:conditions], "#{sphere_distance_sql(field, origin, distance.measurement)}", distance.to_f)
+            query[:fields] = expand_fields(query[:fields], field, "#{sphere_distance_sql(field, origin, distance.measurement)}")
+            query.delete(k)
+          end
+          query
+        end
+
+        # Spherical distance sql
+        def sphere_distance_sql(field, origin, units)
+          lat = deg2rad(origin.lat)
+          lng = deg2rad(origin.lng)
+          qualified_lat_column = "`#{storage_name}`.`#{field}_lat`"
+          qualified_lng_column = "`#{storage_name}`.`#{field}_lng`"
+          "(ACOS(least(1,COS(#{lat})*COS(#{lng})*COS(RADIANS(#{qualified_lat_column}))*COS(RADIANS(#{qualified_lng_column}))+COS(#{lat})*SIN(#{lng})*COS(RADIANS(#{qualified_lat_column}))*SIN(RADIANS(#{qualified_lng_column}))+SIN(#{lat})*SIN(RADIANS(#{qualified_lat_column}))))*#{units_sphere_multiplier(units)})"
+        end
+
+        # in case conditions were altered by other means
+        def expand_conditions(conditions, sql, value)
+          if conditions.is_a?(Hash)
+            [conditions.keys.inject(''){|m,k|
+              m << "#{k} = ?"
+            } << " AND #{sql} < ?"] + ([conditions.values] << value)
+          elsif conditions.is_a?(Array)
+            if conditions.size == 1
+              ["#{conditions[0]} AND #{sql} < ?", value]
+            else
+              conditions[0] = ["#{conditions[0]} AND #{sql} < ?"]
+              conditions << value
+              conditions
+            end
+          else
+            ["#{sql} < ?", value]
+          end
+        end
+
+        # Hack in the distance field by adding the :fields option to the query
+        def expand_fields(fields, distance_field, sql)
+          f = DataMapper::Property.new(self, "#{distance_field}_distance".to_sym, DataMapper::Types::Distance, :field => "#{sql} as #{distance_field}_distance")
+          if fields.is_a?(Array) # user specified fields, just tack this onto the end
+            fields + [f]
+          else # otherwise since we specify :fields, we have to add back in the original fields it would have selected
+            self.properties(repository.name).defaults + [f]
+          end
+        end
+
+      end
+    end
+
+    class GeographicLocation
+      attr_accessor :full_address, :lat, :lng, :street_address, :city, :state, :zip, :country_code, :distance
+      def initialize(field, obj)
+        PROPERTY_NAMES.each do |p|
+          instance_variable_set("@#{p}",obj.send("#{field}_#{p}"))
+        end
+        @distance = obj.send("#{field}_distance") if obj.respond_to?("#{field}_distance".to_sym)
+      end
+      def to_s
+        @full_address
+      end
+      def to_lat_lng
+        ::GeoKit::LatLng.new(@lat,@lng)
+      end
+    end
+
+    class DistanceOperator < DataMapper::Query::Operator
+    end
+
+  end
+
+  module Adapters
+    class DataObjectsAdapter
+      module SQL
+        alias old_property_to_column_name property_to_column_name
+        
+        def property_to_column_name(repository, property, qualify)
+          if property.respond_to?(:type) and property.type == DataMapper::Types::Distance
+            property.field
+          else
+            old_property_to_column_name(repository, property, qualify)
+          end
+        end
+
+      end
+      include SQL
+    end
+  end
+
+  module Types
+    class Distance < DataMapper::Type
+      primitive Float
+    end
+  end
+end

data/lib/dm-geokit/support/distance_measurement.rb

@@ -0,0 +1,16 @@
+class DistanceMeasurement
+  attr_accessor :measurement
+  def initialize(value,measurement)
+    @value = value.to_f
+    @measurement = measurement
+  end
+  def to_s
+    @value.to_s
+  end
+  def to_i
+    @value.to_i
+  end
+  def to_f
+    @value.to_f
+  end
+end

data/lib/dm-geokit/support/distance_support.rb

@@ -0,0 +1,11 @@
+module DistanceSupport
+
+  def mi
+    DistanceMeasurement.new(self, :miles)
+  end
+
+  def km
+    DistanceMeasurement.new(self, :kms)
+  end
+
+end

data/lib/dm-geokit/support/float.rb

@@ -0,0 +1 @@
+Float.send(:include, DistanceSupport)

data/lib/dm-geokit/support/integer.rb

@@ -0,0 +1 @@
+Integer.send(:include, DistanceSupport)

data/lib/dm-geokit/support/symbol.rb

@@ -0,0 +1,11 @@
+class Symbol
+  
+  def near
+    DataMapper::GeoKit::DistanceOperator.new(self, :near)
+  end
+
+  def outside
+    DataMapper::GeoKit::DistanceOperator.new(self, :outside)
+  end
+
+end

data/lib/skeleton/api_keys_template

@@ -0,0 +1,50 @@
+# These defaults are used in GeoKit::Mappable.distance_to and in acts_as_mappable
+GeoKit::default_units = :miles
+GeoKit::default_formula = :sphere
+
+# This is the timeout value in seconds to be used for calls to the geocoder web
+# services.  For no timeout at all, comment out the setting.  The timeout unit
+# is in seconds. 
+GeoKit::Geocoders::timeout = 3
+
+# These settings are used if web service calls must be routed through a proxy.
+# These setting can be nil if not needed, otherwise, addr and port must be 
+# filled in at a minimum.  If the proxy requires authentication, the username
+# and password can be provided as well.
+GeoKit::Geocoders::proxy_addr = nil
+GeoKit::Geocoders::proxy_port = nil
+GeoKit::Geocoders::proxy_user = nil
+GeoKit::Geocoders::proxy_pass = nil
+
+# This is your yahoo application key for the Yahoo Geocoder.
+# See http://developer.yahoo.com/faq/index.html#appid
+# and http://developer.yahoo.com/maps/rest/V1/geocode.html
+GeoKit::Geocoders::yahoo = 'REPLACE_WITH_YOUR_YAHOO_KEY'
+    
+# This is your Google Maps geocoder key. 
+# See http://www.google.com/apis/maps/signup.html
+# and http://www.google.com/apis/maps/documentation/#Geocoding_Examples
+GeoKit::Geocoders::google = 'REPLACE_WITH_YOUR_GOOGLE_KEY'
+    
+# This is your username and password for geocoder.us.
+# To use the free service, the value can be set to nil or false.  For 
+# usage tied to an account, the value should be set to username:password.
+# See http://geocoder.us
+# and http://geocoder.us/user/signup
+GeoKit::Geocoders::geocoder_us = false 
+
+# This is your authorization key for geocoder.ca.
+# To use the free service, the value can be set to nil or false.  For 
+# usage tied to an account, set the value to the key obtained from
+# Geocoder.ca.
+# See http://geocoder.ca
+# and http://geocoder.ca/?register=1
+GeoKit::Geocoders::geocoder_ca = false
+
+# This is the order in which the geocoders are called in a failover scenario
+# If you only want to use a single geocoder, put a single symbol in the array.
+# Valid symbols are :google, :yahoo, :us, and :ca.
+# Be aware that there are Terms of Use restrictions on how you can use the 
+# various geocoders.  Make sure you read up on relevant Terms of Use for each
+# geocoder you are going to use.
+GeoKit::Geocoders::provider_order = [:google,:us]

data/spec/dm_geokit_spec.rb

@@ -0,0 +1,116 @@
+require File.dirname(__FILE__) + '/spec_helper'
+
+describe "dm-geokit" do
+  it "should add address fields after calling has_geographic_location" do
+    u = UninitializedLocation.new
+    u.should_not respond_to(:address)
+    DataMapper::GeoKit::PROPERTY_NAMES.each do |p|
+      u.should_not respond_to("address_#{p}".to_sym)
+    end
+    UninitializedLocation.send(:has_geographic_location, :address)
+    u = UninitializedLocation.new
+    u.should respond_to(:address)
+    DataMapper::GeoKit::PROPERTY_NAMES.each do |p|
+      u.should respond_to("address_#{p}".to_sym)
+    end
+  end
+
+  it "should respond to acts_as_mappable" do
+    Location.should respond_to(:acts_as_mappable)
+  end
+
+  it "should have a geocode method" do
+    Location.should respond_to(:geocode)    
+  end
+
+  it "should have the address field return a GeographicLocation object" do
+    l = Location.create(:address => "5119 NE 27th ave portland, or 97211")
+    l.address.should be_a(DataMapper::GeoKit::GeographicLocation)
+    DataMapper::GeoKit::PROPERTY_NAMES.each do |p|
+      l.address.should respond_to("#{p}".to_sym)
+    end
+    l.address.should respond_to(:distance)
+  end
+
+  it "should set address fields on geocode" do
+    l = Location.new
+    l.address.should be(nil)
+    DataMapper::GeoKit::PROPERTY_NAMES.each do |p|
+      l.send("address_#{p}").should be(nil)
+    end
+    l.address = '5119 NE 27th ave portland, or 97211'
+    DataMapper::GeoKit::PROPERTY_NAMES.each do |p|
+      l.send("address_#{p}").should_not be(nil)
+    end
+  end
+
+  it "should convert to LatLng" do
+    l = Location.create(:address => "5119 NE 27th ave portland, or 97211")
+    l.address.should respond_to(:to_lat_lng)
+    l.address.to_lat_lng.should be_a(::GeoKit::LatLng)
+    l.address.to_lat_lng.lat.should == l.address.lat
+    l.address.to_lat_lng.lng.should == l.address.lng
+  end
+
+  it "should find a location with LatLng Object" do
+    Location.all(:address.near => {:origin => ::GeoKit::LatLng.new(45.5767359,-122.670399), :distance => 3.mi}).size.should == 2
+  end
+
+  it "should find a location with a String" do
+    Location.all(:address.near => {:origin => 'portland, or', :distance => 3.mi}).size.should == 2
+  end
+
+  it "should find a location with LatLng Object in KM" do
+    Location.all(:address.near => {:origin => ::GeoKit::LatLng.new(45.5767359,-122.670399), :distance => 4.km}).size.should == 2
+  end
+
+  it "should find a location with a String in KM" do
+    Location.all(:address.near => {:origin => 'portland, or', :distance => 5.km}).size.should == 2
+  end
+
+  it "should respect other conditions (array)" do
+    Location.all(:conditions => ["id > 1000000000"], :address.near => {:origin => 'portland, or', :distance => 5.mi}).size.should == 0
+  end
+
+  it "should respect other conditions (hash)" do
+    Location.all(:conditions => {:id => 33}, :address.near => {:origin => 'portland, or', :distance => 5.mi}).size.should == 0
+  end
+
+  it "should respect other conditions (array with placeholders)" do
+    Location.all(:conditions => ["id = ?", 33], :address.near => {:origin => 'portland, or', :distance => 5.mi}).size.should == 0
+  end
+
+  it "should count locations" do
+    Location.count(:address.near => {:origin => 'portland, or', :distance => 5.mi}).should == 2
+  end
+
+  it "should include distance field and have a float value" do
+    Location.all(:address.near => {:origin => 'portland, or', :distance => 5.mi}).first.should respond_to(:address_distance)
+    Location.all(:address.near => {:origin => 'portland, or', :distance => 5.mi}).first.address_distance.should be_a(Float)
+    Location.all(:address.near => {:origin => 'portland, or', :distance => 5.mi}).first.address.should respond_to(:distance)
+    Location.all(:address.near => {:origin => 'portland, or', :distance => 5.mi}).first.address.distance.should be_a(Float)
+  end
+
+  it "should include distance field that changes with distance" do
+    Location.all(:address.near => {:origin => '97211', :distance => 5.mi}).first.address_distance.should_not == Location.all(:address.near => {:origin => 'portland, or', :distance => 5.mi}).first.address_distance
+  end
+
+  it "should order by distance desc" do
+    seattle = Location.create(:address => "Seattle, WA USA")
+    tacoma = Location.create(:address => "Tacoma, WA USA")
+    locations = Location.all(:address.near => {:origin => '97211', :distance => 500.mi}, :order => [:address_distance.desc])
+    locations.first.address_distance.should > locations.last.address_distance
+  end
+
+  it "should order by distance asc" do
+    locations = Location.all(:address.near => {:origin => '97211', :distance => 500.mi}, :order => [:address_distance.asc])
+    locations.first.address_distance.should < locations.last.address_distance
+  end
+
+  it "should filter on association search" do
+    Comment.create(:location_id => Location.first.id, :name => 'Example')
+    locations = Location.all(:address.near => {:origin => '97211', :distance => 500.mi}, :order => [:address_distance.asc], 'comments.name' => 'Example')
+    locations.size.should == 1
+  end
+
+end

data/spec/spec_helper.rb

@@ -0,0 +1,31 @@
+$TESTING=true
+$:.push File.join(File.dirname(__FILE__), '..', 'lib')
+%w(dm-geokit dm-aggregates).each{|l| require l}
+
+DataMapper::Logger.new(STDOUT, :debug)
+DataMapper.setup(:default, "mysql://root@localhost/dm_geokit_test")
+
+class Location
+  include DataMapper::Resource
+  include DataMapper::GeoKit
+  property :id, Serial
+  has_geographic_location :address
+  has n, :comments
+end
+
+class Comment
+  include DataMapper::Resource
+  property :id, Serial
+  property :name, String
+  property :location_id, Integer
+  belongs_to :location
+end
+
+class UninitializedLocation
+  include DataMapper::Resource
+  include DataMapper::GeoKit
+  property :id, Serial
+end
+
+DataMapper.auto_migrate!
+

metadata

@@ -0,0 +1,96 @@
+--- !ruby/object:Gem::Specification 
+name: rpbertp13-dm-geokit
+version: !ruby/object:Gem::Version 
+  version: 0.9.11
+platform: ruby
+authors: 
+- Foy Savas
+- Daniel Higginbotham
+- Matt King
+- Roberto Thais
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-10-24 00:00:00 -04:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: dm-core
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: geokit
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+    version: 
+description: Simple and opinionated helper for creating Rubygem projects on GitHub
+email: roberto@robertothais.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- LICENSE
+- README
+- TODO
+files: 
+- LICENSE
+- README
+- Rakefile
+- TODO
+- VERSION.yml
+- lib/dm-geokit.rb
+- lib/dm-geokit/acts_as_mappable.rb
+- lib/dm-geokit/ip_geocode_lookup.rb
+- lib/dm-geokit/merbtasks.rb
+- lib/dm-geokit/resource.rb
+- lib/dm-geokit/support/distance_measurement.rb
+- lib/dm-geokit/support/distance_support.rb
+- lib/dm-geokit/support/float.rb
+- lib/dm-geokit/support/integer.rb
+- lib/dm-geokit/support/symbol.rb
+- lib/jeweler/templates/.gitignore
+- lib/skeleton/api_keys_template
+has_rdoc: true
+homepage: http://github.com/rpbertp13/dm-geokit/tree/master
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --charset=UTF-8
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.5
+signing_key: 
+specification_version: 3
+summary: DataMapper plugin for geokit stuff forked from Foy Savas's project. Now relies on the geokit gem rather than Foy's gem.
+test_files: 
+- spec/dm_geokit_spec.rb
+- spec/spec_helper.rb