Remove geokit, as finding by location is done by solr

Rafael Martins
1 parent 83b2a192
Showing 36 changed files with 0 additions and 3374 deletions Show diff stats
test/unit/product_test.rb
test/unit/profile_test.rb
vendor/plugins/geokit/MIT-LICENSE
vendor/plugins/geokit/README
vendor/plugins/geokit/Rakefile
vendor/plugins/geokit/VERSION_HISTORY.txt
vendor/plugins/geokit/about.yml
vendor/plugins/geokit/assets/api_keys_template
vendor/plugins/geokit/init.rb
vendor/plugins/geokit/install.rb
vendor/plugins/geokit/lib/geo_kit/acts_as_mappable.rb
vendor/plugins/geokit/lib/geo_kit/defaults.rb
vendor/plugins/geokit/lib/geo_kit/geocoders.rb
vendor/plugins/geokit/lib/geo_kit/ip_geocode_lookup.rb
vendor/plugins/geokit/lib/geo_kit/mappable.rb
vendor/plugins/geokit/lib/geo_kit/sqlite_extension.rb
vendor/plugins/geokit/test/acts_as_mappable_test.rb
vendor/plugins/geokit/test/base_geocoder_test.rb
vendor/plugins/geokit/test/bounds_test.rb
vendor/plugins/geokit/test/ca_geocoder_test.rb
@@ -126,16 +126,6 @@ class ProductTest &lt; ActiveSupport::TestCase
     assert_in_delta 45.0, prod.lng, 0.0001
   end
  
-  should 'be searched by radius and distance' do
-    prod1 = fast_create(Product, :name => 'prod test 1', :lat => 30.0, :lng => 30.0, :product_category_id => @product_category.id)
-    prod2 = fast_create(Product, :name => 'prod test 2', :lat => 45.0, :lng => 45.0, :product_category_id => @product_category.id)
-
-    prods = Product.find(:all, :within => 10, :origin => [30.0, 30.0])
-
-    assert_includes prods, prod1
-    assert_not_includes prods, prod2
-  end
-
   should 'provide url' do
     product = Product.new
  
@@ -439,12 +439,6 @@ class ProfileTest &lt; ActiveSupport::TestCase
     assert_includes Enterprise.find_within(2, :origin => [45, 45]), e    
   end
  
-  should 'have latitude and longitude and find' do
-    e = fast_create(Enterprise, :lat => 45, :lng => 45)
-
-    assert_includes Enterprise.find(:all, :within => 2, :origin => [45, 45]), e    
-  end
-
   should 'have a public profile by default' do
     assert_equal true, Profile.new.public_profile
   end
@@ -1,20 +0,0 @@
-Copyright (c) 2007 Bill Eisenhauer & Andre Lewis
-
-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.
 \ No newline at end of file
@@ -1,451 +0,0 @@
-## FEATURE SUMMARY
-
-This plugin provides key functionality for location-oriented Rails applications:
-
-- Distance calculations, for both flat and spherical environments. For example, 
-  given the location of two points on the earth, you can calculate the miles/KM 
-  between them.
-- ActiveRecord distance-based finders. For example, you can find all the points 
-  in your database within a 50-mile radius.
-- Geocoding from multiple providers. It currently supports Google, Yahoo, 
-  Geocoder.us, and Geocoder.ca geocoders, and it provides a uniform response 
-  structure from all of them. It also provides a fail-over mechanism, in case 
-  your input fails to geocode in one service.
-- IP-based location lookup utilizing hostip.info. Provide an IP address, and get
-  city name and latitude/longitude in return
-- A before_filter helper to geocoder the user's location based on IP address, 
-  and retain the location in a cookie.
-  
-The goal of this plugin is to provide the common functionality for location-oriented 
-applications (geocoding, location lookup, distance calculation) in an easy-to-use 
-package.
-
-## A NOTE ON TERMINOLOGY
-
-Throughout the code and API of this, latitude and longitude are referred to as lat 
-and lng.  We've found over the long term the abbreviation saves lots of typing time.
-
-## DISTANCE CALCULATIONS AND QUERIES
-
-If you want only distance calculation services, you need only mix in the Mappable 
-module like so:
-
-    class Location
-    	include GeoKit::Mappable
-    end
-
-After doing so, you can do things like:
-
-    Location.distance_between(from, to) 
-
-with optional parameters :units and :formula.  Values for :units can be :miles or 
-:kms with :miles as the default.  Values for :formula can be :sphere or :flat with
-:sphere as the default.  :sphere gives you Haversine calculations, while :flat 
-gives the Pythagoreum Theory.  These defaults persist through out the plug-in.
-
-You can also do:
-
-    location.distance_to(other)
-
-The real power and utility of the plug-in is in its query support.  This is 
-achieved through mixing into an ActiveRecord model object:
-
-    class Location < ActiveRecord::Base
-    	acts_as_mappable
-    end
-
-The plug-in uses the above-mentioned defaults, but can be modified to use 
-different units and a different formulae.  This is done through the :default_units
-and :default_formula keys which accept the same values as mentioned above.
-
-The plug-in creates a calculated column and potentially a calculated condition.  
-By default, these are known as "distance" but this can be changed through the
-:distance_field_name key.  
-
-So, an alternative invocation would look as below:
-
-    class Location < ActiveRecord::Base
-       acts_as_mappable :default_units => :kms, 
-                        :default_formula => :flat, 
-                        :distance_field_name => :distance
-    end
-
-You can also define alternative column names for latitude and longitude using
-the :lat_column_name and :lng_column_name keys.  The defaults are 'lat' and
-'lng' respectively.
-
-Thereafter, a set of finder methods are made available.  Below are the 
-different combinations:
-
-Origin as a two-element array of latititude/longitude:
-
-		find(:all, :origin => [37.792,-122.393])
-
-Origin as a geocodeable string:
-
-		find(:all, :origin => '100 Spear st, San Francisco, CA')
-
-Origin as 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:
-
-		find(:all, :origin=>my_store) # my_store.lat and my_store.lng methods exist
-
-Often you will need to find within a certain distance. The prefered syntax is:
-
-    find(:all, :origin => @somewhere, :within => 5)
-    
-. . . however these syntaxes will also work:
-
-    find_within(5, :origin => @somewhere)
-    find(:all, :origin => @somewhere, :conditions => "distance < 5")
-    
-Note however that the third form should be avoided. With either of the first two,
-GeoKit automatically adds a bounding box to speed up the radial query in the database.
-With the third form, it does not.
-
-If you need to combine distance conditions with other conditions, you should do
-so like this:
-
-    find(:all, :origin => @somewhere, :within => 5, :conditions=>['state=?',state])
-
-If :origin is not provided in the finder call, the find method 
-works as normal.  Further, the key is removed
-from the :options hash prior to invoking the superclass behavior.
-
-Other convenience methods work intuitively and are as follows:
-
-    find_within(distance, :origin => @somewhere)
-    find_beyond(distance, :origin => @somewhere)
-    find_closest(:origin => @somewhere)
-    find_farthest(:origin => @somewhere)
-
-where the options respect the defaults, but can be overridden if 
-desired.  
-
-Lastly, if all that is desired is the raw SQL for distance 
-calculations, you can use the following:
-
-    distance_sql(origin, units=default_units, formula=default_formula)
-
-Thereafter, you are free to use it in find_by_sql as you wish.
-
-There are methods available to enable you to get the count based upon
-the find condition that you have provided.  These all work similarly to
-the finders.  So for instance:
-
-    count(:origin, :conditions => "distance < 5")
-    count_within(distance, :origin => @somewhere)
-    count_beyond(distance, :origin => @somewhere)
-
-## FINDING WITHIN A BOUNDING BOX
- 
-If you are displaying points on a map, you probably need to query for whatever falls within the rectangular bounds of the map:
-
-    Store.find :all, :bounds=>[sw_point,ne_point]
-
-The input to :bounds can be array with the two points or a Bounds object. However you provide them, the order should always be the southwest corner, northeast corner of the rectangle. Typically, you will be getting the sw_point and ne_point from a map that is displayed on a web page.
-
-If you need to calculate the bounding box from a point and radius, you can do that:
-
-    bounds=Bounds.from_point_and_radius(home,5)
-    Store.find :all, :bounds=>bounds
-
-## USING INCLUDES
-
-You can use includes along with your distance finders:
-
-    stores=Store.find :all, :origin=>home, :include=>[:reviews,:cities] :within=>5, :order=>'distance'
-
-*However*, ActiveRecord drops the calculated distance column when you use include. So, if you need to
-use the distance column, you'll have to re-calculate it post-query in Ruby:
-
-    stores.sort_by_distance_from(home)
-
-In this case, you may want to just use the bounding box
-condition alone in your SQL (there's no use calculating the distance twice):
-
-    bounds=Bounds.from_point_and_radius(home,5)
-    stores=Store.find :all, :include=>[:reviews,:cities] :bounds=>bounds
-    stores.sort_by_distance_from(home)
-
-## IP GEOCODING
-
-You can obtain the location for an IP at any time using the geocoder
-as in the following example:
-
-    location = IpGeocoder.geocode('12.215.42.19')
-
-where Location is a GeoLoc instance containing the latitude, 
-longitude, city, state, and country code.  Also, the success 
-value is true.
-
-If the IP cannot be geocoded, a GeoLoc instance is returned with a
-success value of false.  
-
-It should be noted that the IP address needs to be visible to the
-Rails application.  In other words, you need to ensure that the 
-requesting IP address is forwarded by any front-end servers that
-are out in front of the Rails app.  Otherwise, the IP will always
-be that of the front-end server.
-
-## IP GEOCODING HELPER
-
-A class method called geocode_ip_address has been mixed into the 
-ActionController::Base.  This enables before_filter style lookup of
-the IP address.  Since it is a filter, it can accept any of the 
-available filter options.
-
-Usage is as below:
-
-    class LocationAwareController < ActionController::Base
-      geocode_ip_address
-    end
-
-A first-time lookup will result in the GeoLoc class being stored
-in the session as :geo_location as well as in a cookie called
-:geo_session.  Subsequent lookups will use the session value if it
-exists or the cookie value if it doesn't exist.  The last resort is
-to make a call to the web service.  Clients are free to manage the
-cookie as they wish.
-
-The intent of this feature is to be able to provide a good guess as
-to a new visitor's location.
-
-## INTEGRATED FIND AND GEOCODING
-
-Geocoding has been integrated with the finders enabling you to pass
-a physical address or an IP address.  This would look the following:
-
-    Location.find_farthest(:origin => '217.15.10.9')
-    Location.find_farthest(:origin => 'Irving, TX')
-
-where the IP or physical address would be geocoded to a location and
-then the resulting latitude and longitude coordinates would be used 
-in the find.  This is not expected to be common usage, but it can be
-done nevertheless.
-
-## ADDRESS GEOCODING
-
-GeoKit can geocode addresses using multiple geocodeing web services.
-Currently, GeoKit supports Google, Yahoo, and Geocoder.us geocoding 
-services. 
-
-These geocoder services are made available through three classes: 
-GoogleGeocoder, YahooGeocoder, and UsGeocoder.  Further, an additional
-geocoder class called MultiGeocoder incorporates an ordered failover
-sequence to increase the probability of successful geocoding.
-
-All classes are called using the following signature:
-
-    include GeoKit::Geocoders
-    location = XxxGeocoder.geocode(address)
-
-where you replace Xxx Geocoder with the appropriate class.  A GeoLoc
-instance is the result of the call.  This class has a "success"
-attribute which will be true if a successful geocoding occurred.  
-If successful, the lat and lng properties will be populated.
-
-Geocoders are named with the naming convention NameGeocoder.  This
-naming convention enables Geocoder to auto-detect its sub-classes
-in order to create methods called name_geocoder(address) so that
-all geocoders are called through the base class.  This is done 
-purely for convenience; the individual geocoder classes are expected
-to be used independently.
-
-The MultiGeocoder class requires the configuration of a provider
-order which dictates what order to use the various geocoders.  Ordering
-is done through the PROVIDER_ORDER constant found in environment.rb.
-
-On installation, this plugin appends a template for your API keys to 
-your environment.rb. 
-
-Make sure your failover configuration matches the usage characteristics 
-of your application -- for example, if you routinely get bogus input to 
-geocode, your code will be much slower if you have to failover among 
-multiple geocoders before determining that the input was in fact bogus. 
-
-The Geocoder.geocode method returns a GeoLoc object. Basic usage:
-
-    loc=Geocoder.geocode('100 Spear St, San Francisco, CA')
-    if loc.success
-      puts loc.lat
-      puts loc.lng
-      puts loc.full_address
-    end
-
-## INTEGRATED FIND WITH ADDRESS GEOCODING
-
-Just has you can pass an IP address directly into an ActiveRecord finder
-as the origin, you can also pass a physical address as the origin:
-
-    Location.find_closest(:origin => '100 Spear st, San Francisco, CA')
-
-where the physical address would be geocoded to a location and then the 
-resulting latitude and longitude coordinates would be used in the 
-find. 
-
-Note that if the address fails to geocode, the find method will raise an 
-ActiveRecord::GeocodeError you must be prepared to catch. Alternatively,
-You can geocoder the address beforehand, and pass the resulting lat/lng
-into the finder if successful.
-
-## Auto Geocoding
-
-If your geocoding needs are simple, you can tell your model to automatically
-geocode itself on create:
-
-    class Store < ActiveRecord::Base
-      acts_as_mappable :auto_geocode=>true
-    end
-
-It takes two optional params:
-
-    class Store < ActiveRecord::Base
-      acts_as_mappable :auto_geocode=>{:field=>:address, :error_message=>'Could not geocode address'}
-    end
-
-. . . which is equivilent to:
-
-    class Store << ActiveRecord::Base
-      acts_as_mappable
-      before_validation_on_create :geocode_address
-
-      private
-      def geocode_address
-        geo=GeoKit::Geocoders::MultiGeocoder.geocode (address)
-        errors.add(:address, "Could not Geocode address") if !geo.success
-        self.lat, self.lng = geo.lat,geo.lng if geo.success
-      end
-    end
-    
-If you need any more complicated geocoding behavior for your model, you should roll your own 
-before_validate callback.
-
-
-## Distances, headings, endpoints, and midpoints
-
-    distance=home.distance_from(work, :units=>:miles)
-    heading=home.heading_to(work) # result is in degrees, 0 is north
-    endpoint=home.endpoint(90,2)  # two miles due east
-    midpoing=home.midpoint_to(work)
-
-## Cool stuff you can do with bounds
-    
-    bounds=Bounds.new(sw_point,ne_point)
-    bounds.contains?(home)
-    puts bounds.center
-    
-
-HOW TO . . .
-=================================================================================
-
-## How to install the GeoKit plugin 
-    cd [APP_ROOT]
-    ruby script/plugin install svn://rubyforge.org/var/svn/geokit/trunk
-      or, to install as an external (your project must be version controlled):
-    ruby script/plugin install -x svn://rubyforge.org/var/svn/geokit/trunk
-
-## How to find all stores within a 10-mile radius of a given lat/lng
-1. ensure your stores table has lat and lng columns with numeric or float 
-   datatypes to store your latitude/longitude
-
-3. use acts_as_mappable on your store model:
-    class Store < ActiveRecord::Base
-       acts_as_mappable
-       ...
-    end
-3. finders now have extra capabilities:
-    Store.find(:all, :origin =>[32.951613,-96.958444], :within=>10)
-
-## How to geocode an address
-
-1. configure your geocoder key(s) in environment.rb
-
-2. also in environment.rb, make sure that PROVIDER_ORDER reflects the 
-   geocoder(s). If you only want to use one geocoder, there should
-   be only one symbol in the array. For example:
-    PROVIDER_ORDER=[:google]
-   
-3. Test it out in script/console
-    include GeoKit::Geocoders
-    res = MultiGeocoder.geocode('100 Spear St, San Francisco, CA')
-    puts res.lat
-    puts res.lng
-    puts res.full_address 
-    ... etc. The return type is GeoLoc, see the API for 
-    all the methods you can call on it.
-
-## How to find all stores within 10 miles of a given address
-
-1. as above, ensure your table has the lat/lng columns, and you've
-   applied acts_as_mappable to the Store model.
-
-2. configure and test out your geocoder, as above
-
-3. pass the address in under the :origin key
-		Store.find(:all, :origin=>'100 Spear st, San Francisco, CA', 
-		           :within=>10)
-
-4. you can also use a zipcode, or anything else that's geocodable:
-		Store.find(:all, :origin=>'94117', 
-		           :conditions=>'distance<10')
-
-## How to sort a query by distance from an origin
-
-You now have access to a 'distance' column, and you can use it
-as you would any other column. For example:
-		Store.find(:all, :origin=>'94117', :order=>'distance')
-
-## How to elements of an array according to distance from a common point
-
-Usually, you can do your sorting in the database as part of your find call.
-If you need to sort things post-query, you can do so:
-
-    stores=Store.find :all
-    stores.sort_by_distance_from(home)
-    puts stores.first.distance
-    
-Obviously, each of the items in the array must have a latitude/longitude so
-they can be sorted by distance.
-
-Database Compatability
-=================================================================================
-GeoKit does *not* work with SQLite, as it lacks the necessary geometry functions. 
-GeoKit works with MySQL (tested with version 5.0.41) or PostgreSQL (tested with version 8.2.6)
-GeoKit is known to *not* work with Postgres <8.1 -- it uses the least() funciton.
-
-
-HIGH-LEVEL NOTES ON WHAT'S WHERE
-=================================================================================
-
-acts_as_mappable.rb, as you'd expect, contains the ActsAsMappable
-module which gets mixed into your models to provide the 
-location-based finder goodness.
-
-mappable.rb contains the Mappable module, which provides basic
-distance calculation methods, i.e., calculating the distance
-between two points. 
-
-mappable.rb also contains LatLng, GeoLoc, and Bounds.
-LatLng is a simple container for latitude and longitude, but 
-it's made more powerful by mixing in the above-mentioned Mappable
-module -- therefore, you can calculate easily the distance between two
-LatLng ojbects with distance = first.distance_to(other)
-
-GeoLoc (also in mappable.rb) represents an address or location which
-has been geocoded. You can get the city, zipcode, street address, etc.
-from a GeoLoc object. GeoLoc extends LatLng, so you also get lat/lng
-AND the Mappable modeule goodness for free.
-
-geocoders.rb contains the geocoder classes.
-
-ip_geocode_lookup.rb contains the before_filter helper method which
-enables auto lookup of the requesting IP address.
-
-## IMPORTANT NOTE: We have appended to your environment.rb file
-
-Installation of this plugin has appended an API key template 
-to your environment.rb file. You *must* add your own keys for the various
-geocoding services if you want to use geocoding. If you need to refer to the original
-template again, see the api_keys_template file in the root of the plugin.
@@ -1,22 +0,0 @@
-require 'rake'
-require 'rake/testtask'
-require 'rake/rdoctask'
-
-desc 'Default: run unit tests.'
-task :default => :test
-
-desc 'Test the GeoKit plugin.'
-Rake::TestTask.new(:test) do |t|
-  t.libs << 'lib'
-  t.pattern = 'test/**/*_test.rb'
-  t.verbose = true
-end
-
-desc 'Generate documentation for the GeoKit plugin.'
-Rake::RDocTask.new(:rdoc) do |rdoc|
-  rdoc.rdoc_dir = 'rdoc'
-  rdoc.title    = 'GeoKit'
-  rdoc.options << '--line-numbers' << '--inline-source'
-  rdoc.rdoc_files.include('README')
-  rdoc.rdoc_files.include('lib/**/*.rb')
-end
 \ No newline at end of file
@@ -1,4 +0,0 @@
-01/20/08	Version 1.0.1. Further fix of distance calculation, this time in SQL. Now uses least() function, which is available in MySQL version 3.22.5+ and postgres versions 8.1+
-01/16/08  fixed the "zero-distance" bug (calculating between two points that are the same)
-12/11/07	fixed a small but with queries crossing meridian, and also fixed find(:closest)
-10/11/07	Fixed Rails2/Edge compatability
 \ No newline at end of file
@@ -1,9 +0,0 @@
-author:
-  name_1: Bill Eisenhauer
-  homepage_1: http://blog.billeisenhauer.com
-  name_2: Andre Lewis
-  homepage_2: http://www.earthcode.com
-summary: Geo distance calculations, distance calculation query support, geocoding for physical and ip addresses.
-version: 1.0.1
-rails_version: 1.0+
-license: MIT
 \ No newline at end of file
@@ -1,50 +0,0 @@
-# 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]
 \ No newline at end of file
@@ -1,14 +0,0 @@
-# Load modules and classes needed to automatically mix in ActiveRecord and 
-# ActionController helpers.  All other functionality must be explicitly 
-# required.
-require 'geo_kit/defaults'
-require 'geo_kit/mappable'
-require 'geo_kit/acts_as_mappable'
-require 'geo_kit/ip_geocode_lookup'
-require 'geo_kit/sqlite_extension'
-
-# Automatically mix in distance finder support into ActiveRecord classes.
-ActiveRecord::Base.send :include, GeoKit::ActsAsMappable
-
-# Automatically mix in ip geocoding helpers into ActionController classes.
-ActionController::Base.send :include, GeoKit::IpGeocodeLookup
@@ -1,7 +0,0 @@
-# Display to the console the contents of the README file.
-puts IO.read(File.join(File.dirname(__FILE__), 'README'))
-
-# Append the contents of api_keys_template to the application's environment.rb file
-environment_rb = File.open(File.expand_path(File.join(File.dirname(__FILE__), '../../../config/environment.rb')), "a")
-environment_rb.puts IO.read(File.join(File.dirname(__FILE__), '/assets/api_keys_template'))
-environment_rb.close
@@ -1,446 +0,0 @@
-module GeoKit
-  # Contains the class method acts_as_mappable targeted to be mixed into ActiveRecord.
-  # 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 ActiveRecord.
-    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
-	  when "sqlite"
-		  # The /1.0 in the end is to force the convertion to float
-            sql=<<-SQL_END
-	          (SPHERIC_DISTANCE(#{lat},#{lng},RADIANS(#{qualified_lat_column_name}),RADIANS(#{qualified_lng_column_name}),#{multiplier})/1.0)
-                  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
-	  when "sqlite"
-            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))/1.0)
-                  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
@@ -1,21 +0,0 @@
-module GeoKit
-  # These defaults are used in GeoKit::Mappable.distance_to and in acts_as_mappable
-  @@default_units = :miles
-  @@default_formula = :sphere
-
-  [:default_units, :default_formula].each do |sym|
-    class_eval <<-EOS, __FILE__, __LINE__
-      def self.#{sym}
-        if defined?(#{sym.to_s.upcase})
-          #{sym.to_s.upcase}
-        else
-          @@#{sym}
-        end
-      end
-
-      def self.#{sym}=(obj)
-        @@#{sym} = obj
-      end
-    EOS
-  end
-end
@@ -1,348 +0,0 @@
-require 'net/http'
-require 'rexml/document'
-require 'yaml'
-require 'timeout'
-
-module GeoKit
-  # Contains a set of geocoders which can be used independently if desired.  The list contains:
-  # 
-  # * Google Geocoder - requires an API key.
-  # * Yahoo Geocoder - requires an API key.
-  # * Geocoder.us - may require authentication if performing more than the free request limit.
-  # * Geocoder.ca - for Canada; may require authentication as well.
-  # * IP Geocoder - geocodes an IP address using hostip.info's web service.
-  # * Multi Geocoder - provides failover for the physical location geocoders.
-  # 
-  # Some configuration is required for these geocoders and can be located in the environment
-  # configuration files.
-  module Geocoders
-    @@proxy_addr = nil
-    @@proxy_port = nil
-    @@proxy_user = nil
-    @@proxy_pass = nil
-    @@timeout = nil    
-    @@yahoo = 'REPLACE_WITH_YOUR_YAHOO_KEY'
-    @@google = 'REPLACE_WITH_YOUR_GOOGLE_KEY'
-    @@geocoder_us = false
-    @@geocoder_ca = false
-    @@provider_order = [:google,:us]
-    
-    [:yahoo, :google, :geocoder_us, :geocoder_ca, :provider_order, :timeout, 
-     :proxy_addr, :proxy_port, :proxy_user, :proxy_pass].each do |sym|
-      class_eval <<-EOS, __FILE__, __LINE__
-        def self.#{sym}
-          if defined?(#{sym.to_s.upcase})
-            #{sym.to_s.upcase}
-          else
-            @@#{sym}
-          end
-        end
-
-        def self.#{sym}=(obj)
-          @@#{sym} = obj
-        end
-      EOS
-    end
-    
-    # Error which is thrown in the event a geocoding error occurs.
-    class GeocodeError < StandardError; end
-    
-    # The Geocoder base class which defines the interface to be used by all
-    # other geocoders.
-    class Geocoder   
-      # Main method which calls the do_geocode template method which subclasses
-      # are responsible for implementing.  Returns a populated GeoLoc or an
-      # empty one with a failed success code.
-      def self.geocode(address)  
-        res = do_geocode(address)
-        return res.success ? res : GeoLoc.new
-      end  
-      
-      # Call the geocoder service using the timeout if configured.
-      def self.call_geocoder_service(url)
-        timeout(GeoKit::Geocoders::timeout) { return self.do_get(url) } if GeoKit::Geocoders::timeout        
-        return self.do_get(url)
-      rescue TimeoutError
-        return nil  
-      end
-
-      protected
-
-      def self.logger() RAILS_DEFAULT_LOGGER; end
-      
-      private
-      
-      # Wraps the geocoder call around a proxy if necessary.
-      def self.do_get(url)     
-        return Net::HTTP::Proxy(GeoKit::Geocoders::proxy_addr, GeoKit::Geocoders::proxy_port,
-            GeoKit::Geocoders::proxy_user, GeoKit::Geocoders::proxy_pass).get_response(URI.parse(url))          
-      end
-      
-      # Adds subclass' geocode method making it conveniently available through 
-      # the base class.
-      def self.inherited(clazz)
-        class_name = clazz.name.split('::').last
-        src = <<-END_SRC
-          def self.#{class_name.underscore}(address)
-            #{class_name}.geocode(address)
-          end
-        END_SRC
-        class_eval(src)
-      end
-    end
-    
-    # Geocoder CA geocoder implementation.  Requires the GeoKit::Geocoders::GEOCODER_CA variable to
-    # contain true or false based upon whether authentication is to occur.  Conforms to the 
-    # interface set by the Geocoder class.
-    #
-    # Returns a response like:
-    # <?xml version="1.0" encoding="UTF-8" ?>
-    # <geodata>
-    #   <latt>49.243086</latt>
-    #   <longt>-123.153684</longt>
-    # </geodata>
-    class CaGeocoder < Geocoder
-
-      private
-
-      # Template method which does the geocode lookup.
-      def self.do_geocode(address)
-        raise ArgumentError('Geocoder.ca requires a GeoLoc argument') unless address.is_a?(GeoLoc)
-        url = construct_request(address)
-        res = self.call_geocoder_service(url)
-        return GeoLoc.new if !res.is_a?(Net::HTTPSuccess)
-        xml = res.body
-        logger.debug "Geocoder.ca geocoding. Address: #{address}. Result: #{xml}"
-        # Parse the document.
-        doc = REXML::Document.new(xml)    
-        address.lat = doc.elements['//latt'].text
-        address.lng = doc.elements['//longt'].text
-        address.success = true
-        return address
-      rescue
-        logger.error "Caught an error during Geocoder.ca geocoding call: "+$!
-        return GeoLoc.new  
-      end  
-
-      # Formats the request in the format acceptable by the CA geocoder.
-      def self.construct_request(location)
-        url = ""
-        url += add_ampersand(url) + "stno=#{location.street_number}" if location.street_address
-        url += add_ampersand(url) + "addresst=#{CGI.escape(location.street_name)}" if location.street_address
-        url += add_ampersand(url) + "city=#{CGI.escape(location.city)}" if location.city
-        url += add_ampersand(url) + "prov=#{location.state}" if location.state
-        url += add_ampersand(url) + "postal=#{location.zip}" if location.zip
-        url += add_ampersand(url) + "auth=#{GeoKit::Geocoders::geocoder_ca}" if GeoKit::Geocoders::geocoder_ca
-        url += add_ampersand(url) + "geoit=xml"
-        'http://geocoder.ca/?' + url
-      end
-
-      def self.add_ampersand(url)
-        url && url.length > 0 ? "&" : ""
-      end
-    end    
-    
-    # Google geocoder implementation.  Requires the GeoKit::Geocoders::GOOGLE variable to
-    # contain a Google API key.  Conforms to the interface set by the Geocoder class.
-    class GoogleGeocoder < Geocoder
-
-      private 
-
-      # Template method which does the geocode lookup.
-      def self.do_geocode(address)
-        address_str = address.is_a?(GeoLoc) ? address.to_geocodeable_s : address
-        res = self.call_geocoder_service("http://maps.google.com/maps/geo?q=#{CGI.escape(address_str)}&output=xml&key=#{GeoKit::Geocoders::google}&oe=utf-8")
-#        res = Net::HTTP.get_response(URI.parse("http://maps.google.com/maps/geo?q=#{CGI.escape(address_str)}&output=xml&key=#{GeoKit::Geocoders::google}&oe=utf-8"))
-        return GeoLoc.new if !res.is_a?(Net::HTTPSuccess)
-        xml=res.body
-        logger.debug "Google geocoding. Address: #{address}. Result: #{xml}"
-        doc=REXML::Document.new(xml)
-
-        if doc.elements['//kml/Response/Status/code'].text == '200'
-          res = GeoLoc.new
-          coordinates=doc.elements['//coordinates'].text.to_s.split(',')
-
-          #basics
-          res.lat=coordinates[1]
-          res.lng=coordinates[0]
-          res.country_code=doc.elements['//CountryNameCode'].text
-          res.provider='google'
-
-          #extended -- false if not not available
-          res.city = doc.elements['//LocalityName'].text if doc.elements['//LocalityName']
-          res.state = doc.elements['//AdministrativeAreaName'].text if doc.elements['//AdministrativeAreaName']
-          res.full_address = doc.elements['//address'].text if doc.elements['//address'] # google provides it
-          res.zip = doc.elements['//PostalCodeNumber'].text if doc.elements['//PostalCodeNumber']
-          res.street_address = doc.elements['//ThoroughfareName'].text if doc.elements['//ThoroughfareName']
-          # Translate accuracy into Yahoo-style token address, street, zip, zip+4, city, state, country
-          # For Google, 1=low accuracy, 8=high accuracy
-          # old way -- address_details=doc.elements['//AddressDetails','urn:oasis:names:tc:ciq:xsdschema:xAL:2.0']
-          address_details=doc.elements['//*[local-name() = "AddressDetails"]']
-          accuracy = address_details ? address_details.attributes['Accuracy'].to_i : 0
-          res.precision=%w{unknown country state state city zip zip+4 street address}[accuracy]
-          res.success=true
-          
-          return res
-        else 
-          logger.info "Google was unable to geocode address: "+address
-          return GeoLoc.new
-        end
-
-        rescue
-          logger.error "Caught an error during Google geocoding call: "+$!
-          return GeoLoc.new
-      end  
-    end
-    
-    # Provides geocoding based upon an IP address.  The underlying web service is a hostip.info
-    # which sources their data through a combination of publicly available information as well
-    # as community contributions.
-    class IpGeocoder < Geocoder 
-
-      private 
-
-      # Given an IP address, returns a GeoLoc instance which contains latitude,
-      # longitude, city, and country code.  Sets the success attribute to false if the ip 
-      # parameter does not match an ip address.  
-      def self.do_geocode(ip)
-        return GeoLoc.new unless /^(\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3})?$/.match(ip)
-        url = "http://api.hostip.info/get_html.php?ip=#{ip}&position=true"
-        response = self.call_geocoder_service(url)
-        response.is_a?(Net::HTTPSuccess) ? parse_body(response.body) : GeoLoc.new
-      rescue
-        logger.error "Caught an error during HostIp geocoding call: "+$!
-        return GeoLoc.new
-      end
-
-      # Converts the body to YAML since its in the form of:
-      #
-      # Country: UNITED STATES (US)
-      # City: Sugar Grove, IL
-      # Latitude: 41.7696
-      # Longitude: -88.4588
-      #
-      # then instantiates a GeoLoc instance to populate with location data.
-      def self.parse_body(body) # :nodoc:
-        yaml = YAML.load(body)
-        res = GeoLoc.new
-        res.provider = 'hostip'
-        res.city, res.state = yaml['City'].split(', ')
-        country, res.country_code = yaml['Country'].split(' (')
-        res.lat = yaml['Latitude'] 
-        res.lng = yaml['Longitude']
-        res.country_code.chop!
-        res.success = res.city != "(Private Address)"
-        res
-      end
-    end
-    
-    # Geocoder Us geocoder implementation.  Requires the GeoKit::Geocoders::GEOCODER_US variable to
-    # contain true or false based upon whether authentication is to occur.  Conforms to the 
-    # interface set by the Geocoder class.
-    class UsGeocoder < Geocoder
-
-      private
-
-      # For now, the geocoder_method will only geocode full addresses -- not zips or cities in isolation
-      def self.do_geocode(address)
-        address_str = address.is_a?(GeoLoc) ? address.to_geocodeable_s : address
-        url = "http://"+(GeoKit::Geocoders::geocoder_us || '')+"geocoder.us/service/csv/geocode?address=#{CGI.escape(address_str)}"
-        res = self.call_geocoder_service(url)
-        return GeoLoc.new if !res.is_a?(Net::HTTPSuccess)
-        data = res.body
-        logger.debug "Geocoder.us geocoding. Address: #{address}. Result: #{data}"
-        array = data.chomp.split(',')
-
-        if array.length == 6  
-          res=GeoLoc.new
-          res.lat,res.lng,res.street_address,res.city,res.state,res.zip=array
-          res.country_code='US'
-          res.success=true 
-          return res
-        else 
-          logger.info "geocoder.us was unable to geocode address: "+address
-          return GeoLoc.new      
-        end
-        rescue 
-          logger.error "Caught an error during geocoder.us geocoding call: "+$!
-          return GeoLoc.new
-      end
-    end
-    
-    # Yahoo geocoder implementation.  Requires the GeoKit::Geocoders::YAHOO variable to
-    # contain a Yahoo API key.  Conforms to the interface set by the Geocoder class.
-    class YahooGeocoder < Geocoder
-
-      private 
-
-      # Template method which does the geocode lookup.
-      def self.do_geocode(address)
-        address_str = address.is_a?(GeoLoc) ? address.to_geocodeable_s : address
-        url="http://api.local.yahoo.com/MapsService/V1/geocode?appid=#{GeoKit::Geocoders::yahoo}&location=#{CGI.escape(address_str)}"
-        res = self.call_geocoder_service(url)
-        return GeoLoc.new if !res.is_a?(Net::HTTPSuccess)
-        xml = res.body
-        doc = REXML::Document.new(xml)
-        logger.debug "Yahoo geocoding. Address: #{address}. Result: #{xml}"
-
-        if doc.elements['//ResultSet']
-          res=GeoLoc.new
-
-          #basic      
-          res.lat=doc.elements['//Latitude'].text
-          res.lng=doc.elements['//Longitude'].text
-          res.country_code=doc.elements['//Country'].text
-          res.provider='yahoo'  
-
-          #extended - false if not available
-          res.city=doc.elements['//City'].text if doc.elements['//City'] && doc.elements['//City'].text != nil
-          res.state=doc.elements['//State'].text if doc.elements['//State'] && doc.elements['//State'].text != nil
-          res.zip=doc.elements['//Zip'].text if doc.elements['//Zip'] && doc.elements['//Zip'].text != nil
-          res.street_address=doc.elements['//Address'].text if doc.elements['//Address'] && doc.elements['//Address'].text != nil
-          res.precision=doc.elements['//Result'].attributes['precision'] if doc.elements['//Result']
-          res.success=true
-          return res
-        else 
-          logger.info "Yahoo was unable to geocode address: "+address
-          return GeoLoc.new
-        end   
-
-        rescue 
-          logger.info "Caught an error during Yahoo geocoding call: "+$!
-          return GeoLoc.new
-      end
-    end
-    
-    # Provides methods to geocode with a variety of geocoding service providers, plus failover
-    # among providers in the order you configure.
-    # 
-    # Goal:
-    # - homogenize the results of multiple geocoders
-    # 
-    # Limitations:
-    # - currently only provides the first result. Sometimes geocoders will return multiple results.
-    # - currently discards the "accuracy" component of the geocoding calls
-    class MultiGeocoder < Geocoder 
-      private
-
-      # This method will call one or more geocoders in the order specified in the 
-      # configuration until one of the geocoders work.
-      # 
-      # The failover approach is crucial for production-grade apps, but is rarely used.
-      # 98% of your geocoding calls will be successful with the first call  
-      def self.do_geocode(address)
-        GeoKit::Geocoders::provider_order.each do |provider|
-          begin
-            klass = GeoKit::Geocoders.const_get "#{provider.to_s.capitalize}Geocoder"
-            res = klass.send :geocode, address
-            return res if res.success
-          rescue
-            logger.error("Something has gone very wrong during geocoding, OR you have configured an invalid class name in GeoKit::Geocoders::provider_order. Address: #{address}. Provider: #{provider}")
-          end
-        end
-        # If we get here, we failed completely.
-        GeoLoc.new
-      end
-    end   
-  end
-end
 \ No newline at end of file
@@ -1,46 +0,0 @@
-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
-    # Mix below class methods into ActionController.
-    def self.included(base) # :nodoc:
-      base.extend ClassMethods
-    end
-    
-    # Class method to mix into active record.
-    module ClassMethods # :nodoc:
-      def geocode_ip_address(filter_options = {})
-        before_filter :store_ip_location, filter_options
-      end
-    end
- 
-    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
 \ No newline at end of file
@@ -1,432 +0,0 @@
-require 'geo_kit/defaults'
-
-module GeoKit
-  # Contains class and instance methods providing distance calcuation services.  This
-  # module is meant to be mixed into classes containing lat and lng attributes where
-  # distance calculation is desired.  
-  # 
-  # At present, two forms of distance calculations are provided:
-  # 
-  # * Pythagorean Theory (flat Earth) - which assumes the world is flat and loses accuracy over long distances.
-  # * Haversine (sphere) - which is fairly accurate, but at a performance cost.
-  # 
-  # Distance units supported are :miles and :kms.
-  module Mappable
-    PI_DIV_RAD = 0.0174
-    KMS_PER_MILE = 1.609
-    EARTH_RADIUS_IN_MILES = 3963.19
-    EARTH_RADIUS_IN_KMS = EARTH_RADIUS_IN_MILES * KMS_PER_MILE
-    MILES_PER_LATITUDE_DEGREE = 69.1
-    KMS_PER_LATITUDE_DEGREE = MILES_PER_LATITUDE_DEGREE * KMS_PER_MILE
-    LATITUDE_DEGREES = EARTH_RADIUS_IN_MILES / MILES_PER_LATITUDE_DEGREE  
-    
-    # Mix below class methods into the includer.
-    def self.included(receiver) # :nodoc:
-      receiver.extend ClassMethods
-    end   
-    
-    module ClassMethods #:nodoc:
-      # Returns the distance between two points.  The from and to parameters are
-      # required to have lat and lng attributes.  Valid options are:
-      # :units - valid values are :miles or :kms (GeoKit::default_units is the default)
-      # :formula - valid values are :flat or :sphere (GeoKit::default_formula is the default)
-      def distance_between(from, to, options={})
-        from=GeoKit::LatLng.normalize(from)
-        to=GeoKit::LatLng.normalize(to)
-        return 0.0 if from == to # fixes a "zero-distance" bug
-        units = options[:units] || GeoKit::default_units
-        formula = options[:formula] || GeoKit::default_formula
-        case formula
-        when :sphere          
-          units_sphere_multiplier(units) * 
-              Math.acos( Math.sin(deg2rad(from.lat)) * Math.sin(deg2rad(to.lat)) + 
-              Math.cos(deg2rad(from.lat)) * Math.cos(deg2rad(to.lat)) * 
-              Math.cos(deg2rad(to.lng) - deg2rad(from.lng)))   
-        when :flat
-          Math.sqrt((units_per_latitude_degree(units)*(from.lat-to.lat))**2 + 
-              (units_per_longitude_degree(from.lat, units)*(from.lng-to.lng))**2)
-        end
-      end
-
-      # Returns heading in degrees (0 is north, 90 is east, 180 is south, etc)
-      # from the first point to the second point. Typicaly, the instance methods will be used 
-      # instead of this method.
-      def heading_between(from,to)
-        from=GeoKit::LatLng.normalize(from)
-        to=GeoKit::LatLng.normalize(to)
-
-        d_lng=deg2rad(to.lng-from.lng)
-        from_lat=deg2rad(from.lat)
-        to_lat=deg2rad(to.lat) 
-        y=Math.sin(d_lng) * Math.cos(to_lat)
-        x=Math.cos(from_lat)*Math.sin(to_lat)-Math.sin(from_lat)*Math.cos(to_lat)*Math.cos(d_lng)
-        heading=to_heading(Math.atan2(y,x))
-      end
-  
-      # Given a start point, distance, and heading (in degrees), provides
-      # an endpoint. Returns a LatLng instance. Typically, the instance method
-      # will be used instead of this method.
-      def endpoint(start,heading, distance, options={})
-        units = options[:units] || GeoKit::default_units
-        radius = units == :miles ? EARTH_RADIUS_IN_MILES : EARTH_RADIUS_IN_KMS
-        start=GeoKit::LatLng.normalize(start)        
-        lat=deg2rad(start.lat)
-        lng=deg2rad(start.lng)
-        heading=deg2rad(heading)
-        distance=distance.to_f
-        
-        end_lat=Math.asin(Math.sin(lat)*Math.cos(distance/radius) +
-                          Math.cos(lat)*Math.sin(distance/radius)*Math.cos(heading))
-
-        end_lng=lng+Math.atan2(Math.sin(heading)*Math.sin(distance/radius)*Math.cos(lat),
-                               Math.cos(distance/radius)-Math.sin(lat)*Math.sin(end_lat))
-
-        LatLng.new(rad2deg(end_lat),rad2deg(end_lng))
-      end
-
-      # Returns the midpoint, given two points. Returns a LatLng. 
-      # Typically, the instance method will be used instead of this method.
-      # Valid option:
-      #   :units - valid values are :miles or :kms (:miles is the default)
-      def midpoint_between(from,to,options={})
-        from=GeoKit::LatLng.normalize(from)
-
-        units = options[:units] || GeoKit::default_units
-        
-        heading=from.heading_to(to)
-        distance=from.distance_to(to,options)
-        midpoint=from.endpoint(heading,distance/2,options)
-      end
-  
-      # Geocodes a location using the multi geocoder.
-      def geocode(location)
-        res = Geocoders::MultiGeocoder.geocode(location)
-        return res if res.success
-        raise GeoKit::Geocoders::GeocodeError      
-      end
-    
-      protected
-    
-      def deg2rad(degrees)
-        degrees.to_f / 180.0 * Math::PI
-      end
-      
-      def rad2deg(rad)
-        rad.to_f * 180.0 / Math::PI 
-      end
-      
-      def to_heading(rad)
-        (rad2deg(rad)+360)%360
-      end
-
-      # Returns the multiplier used to obtain the correct distance units.
-      def units_sphere_multiplier(units)
-        units == :miles ? EARTH_RADIUS_IN_MILES : EARTH_RADIUS_IN_KMS
-      end
-
-      # Returns the number of units per latitude degree.
-      def units_per_latitude_degree(units)
-        units == :miles ? MILES_PER_LATITUDE_DEGREE : KMS_PER_LATITUDE_DEGREE
-      end
-    
-      # Returns the number units per longitude degree.
-      def units_per_longitude_degree(lat, units)
-        miles_per_longitude_degree = (LATITUDE_DEGREES * Math.cos(lat * PI_DIV_RAD)).abs
-        units == :miles ? miles_per_longitude_degree : miles_per_longitude_degree * KMS_PER_MILE
-      end  
-    end
-  
-    # -----------------------------------------------------------------------------------------------
-    # Instance methods below here
-    # -----------------------------------------------------------------------------------------------
-  
-    # Extracts a LatLng instance. Use with models that are acts_as_mappable
-    def to_lat_lng
-      return self if instance_of?(GeoKit::LatLng) || instance_of?(GeoKit::GeoLoc)
-      return LatLng.new(send(self.class.lat_column_name),send(self.class.lng_column_name)) if self.class.respond_to?(:acts_as_mappable)
-      return nil
-    end
-
-    # Returns the distance from another point.  The other point parameter is
-    # required to have lat and lng attributes.  Valid options are:
-    # :units - valid values are :miles or :kms (:miles is the default)
-    # :formula - valid values are :flat or :sphere (:sphere is the default)
-    def distance_to(other, options={})
-      self.class.distance_between(self, other, options)
-    end  
-    alias distance_from distance_to
-
-    # Returns heading in degrees (0 is north, 90 is east, 180 is south, etc)
-    # to the given point. The given point can be a LatLng or a string to be Geocoded 
-    def heading_to(other)
-      self.class.heading_between(self,other)
-    end
-
-    # Returns heading in degrees (0 is north, 90 is east, 180 is south, etc)
-    # FROM the given point. The given point can be a LatLng or a string to be Geocoded 
-    def heading_from(other)
-      self.class.heading_between(other,self)
-    end
- 
-    # Returns the endpoint, given a heading (in degrees) and distance.  
-    # Valid option:
-    # :units - valid values are :miles or :kms (:miles is the default)
-    def endpoint(heading,distance,options={})
-      self.class.endpoint(self,heading,distance,options)  
-    end
-
-    # Returns the midpoint, given another point on the map.  
-    # Valid option:
-    # :units - valid values are :miles or :kms (:miles is the default)    
-    def midpoint_to(other, options={})
-      self.class.midpoint_between(self,other,options)
-    end
-    
-  end
-
-  class LatLng 
-    include Mappable
-
-    attr_accessor :lat, :lng
-
-    # Accepts latitude and longitude or instantiates an empty instance
-    # if lat and lng are not provided. Converted to floats if provided
-    def initialize(lat=nil, lng=nil)
-      lat = lat.to_f if lat && !lat.is_a?(Numeric)
-      lng = lng.to_f if lng && !lng.is_a?(Numeric)
-      @lat = lat
-      @lng = lng
-    end 
-
-    # Latitude attribute setter; stored as a float.
-    def lat=(lat)
-      @lat = lat.to_f if lat
-    end
-
-    # Longitude attribute setter; stored as a float;
-    def lng=(lng)
-      @lng=lng.to_f if lng
-    end  
-
-    # Returns the lat and lng attributes as a comma-separated string.
-    def ll
-      "#{lat},#{lng}"
-    end
-    
-    #returns a string with comma-separated lat,lng values
-    def to_s
-      ll
-    end
-  
-    #returns a two-element array
-    def to_a
-      [lat,lng]
-    end
-    # Returns true if the candidate object is logically equal.  Logical equivalence
-    # is true if the lat and lng attributes are the same for both objects.
-    def ==(other)
-      other.is_a?(LatLng) ? self.lat == other.lat && self.lng == other.lng : false
-    end
-    
-    # A *class* method to take anything which can be inferred as a point and generate
-    # a LatLng from it. You should use this anything you're not sure what the input is,
-    # and want to deal with it as a LatLng if at all possible. Can take:
-    #  1) two arguments (lat,lng)
-    #  2) a string in the format "37.1234,-129.1234" or "37.1234 -129.1234"
-    #  3) a string which can be geocoded on the fly
-    #  4) an array in the format [37.1234,-129.1234]
-    #  5) a LatLng or GeoLoc (which is just passed through as-is)
-    #  6) anything which acts_as_mappable -- a LatLng will be extracted from it
-    def self.normalize(thing,other=nil)
-      # if an 'other' thing is supplied, normalize the input by creating an array of two elements
-      thing=[thing,other] if other
-      
-      if thing.is_a?(String)
-        thing.strip!
-        if match=thing.match(/(\-?\d+\.?\d*)[, ] ?(\-?\d+\.?\d*)$/)
-          return GeoKit::LatLng.new(match[1],match[2])
-        else
-          res = GeoKit::Geocoders::MultiGeocoder.geocode(thing)
-          return res if res.success
-          raise GeoKit::Geocoders::GeocodeError  
-        end
-      elsif thing.is_a?(Array) && thing.size==2
-        return GeoKit::LatLng.new(thing[0],thing[1])
-      elsif thing.is_a?(LatLng) # will also be true for GeoLocs
-        return thing
-      elsif thing.class.respond_to?(:acts_as_mappable) && thing.class.respond_to?(:distance_column_name)
-        return thing.to_lat_lng
-      end
-      
-      throw ArgumentError.new("#{thing} (#{thing.class}) cannot be normalized to a LatLng. We tried interpreting it as an array, string, Mappable, etc., but no dice.")
-    end
-    
-  end
-
-  # This class encapsulates the result of a geocoding call
-  # It's primary purpose is to homogenize the results of multiple
-  # geocoding providers. It also provides some additional functionality, such as 
-  # the "full address" method for geocoders that do not provide a 
-  # full address in their results (for example, Yahoo), and the "is_us" method.
-  class GeoLoc < LatLng
-    # Location attributes.  Full address is a concatenation of all values.  For example:
-    # 100 Spear St, San Francisco, CA, 94101, US
-    attr_accessor :street_address, :city, :state, :zip, :country_code, :full_address
-    # Attributes set upon return from geocoding.  Success will be true for successful
-    # geocode lookups.  The provider will be set to the name of the providing geocoder.
-    # Finally, precision is an indicator of the accuracy of the geocoding.
-    attr_accessor :success, :provider, :precision
-    # Street number and street name are extracted from the street address attribute.
-    attr_reader :street_number, :street_name
-
-    # Constructor expects a hash of symbols to correspond with attributes.
-    def initialize(h={})
-      @street_address=h[:street_address] 
-      @city=h[:city] 
-      @state=h[:state] 
-      @zip=h[:zip] 
-      @country_code=h[:country_code] 
-      @success=false
-      @precision='unknown'
-      super(h[:lat],h[:lng])
-    end
-
-    # Returns true if geocoded to the United States.
-    def is_us?
-      country_code == 'US'
-    end
-
-    # full_address is provided by google but not by yahoo. It is intended that the google
-    # geocoding method will provide the full address, whereas for yahoo it will be derived
-    # from the parts of the address we do have.
-    def full_address
-      @full_address ? @full_address : to_geocodeable_s
-    end
-
-    # Extracts the street number from the street address if the street address
-    # has a value.
-    def street_number
-      street_address[/(\d*)/] if street_address
-    end
-
-    # Returns the street name portion of the street address.
-    def street_name
-       street_address[street_number.length, street_address.length].strip if street_address
-    end
-
-    # gives you all the important fields as key-value pairs
-    def hash
-      res={}
-      [:success,:lat,:lng,:country_code,:city,:state,:zip,:street_address,:provider,:full_address,:is_us?,:ll,:precision].each { |s| res[s] = self.send(s.to_s) }
-      res
-    end
-    alias to_hash hash
-
-    # Sets the city after capitalizing each word within the city name.
-    def city=(city)
-      @city = city.titleize if city
-    end
-
-    # Sets the street address after capitalizing each word within the street address.
-    def street_address=(address)
-      @street_address = address.titleize if address
-    end  
-
-    # Returns a comma-delimited string consisting of the street address, city, state,
-    # zip, and country code.  Only includes those attributes that are non-blank.
-    def to_geocodeable_s
-      a=[street_address, city, state, zip, country_code].compact
-      a.delete_if { |e| !e || e == '' }
-      a.join(', ')      
-    end
-
-    # Returns a string representation of the instance.
-    def to_s
-      "Provider: #{provider}\n Street: #{street_address}\nCity: #{city}\nState: #{state}\nZip: #{zip}\nLatitude: #{lat}\nLongitude: #{lng}\nCountry: #{country_code}\nSuccess: #{success}"
-    end
-  end
-  
-  # Bounds represents a rectangular bounds, defined by the SW and NE corners
-  class Bounds
-    # sw and ne are LatLng objects
-    attr_accessor :sw, :ne
-    
-    # provide sw and ne to instantiate a new Bounds instance
-    def initialize(sw,ne)
-      raise ArguementError if !(sw.is_a?(GeoKit::LatLng) && ne.is_a?(GeoKit::LatLng))
-      @sw,@ne=sw,ne
-    end
-    
-    #returns the a single point which is the center of the rectangular bounds
-    def center
-      @sw.midpoint_to(@ne)
-    end
-  
-    # a simple string representation:sw,ne
-    def to_s
-      "#{@sw.to_s},#{@ne.to_s}"   
-    end
-    
-    # a two-element array of two-element arrays: sw,ne
-    def to_a
-      [@sw.to_a, @ne.to_a]
-    end
-    
-    # Returns true if the bounds contain the passed point.
-    # allows for bounds which cross the meridian
-    def contains?(point)
-      point=GeoKit::LatLng.normalize(point)
-      res = point.lat > @sw.lat && point.lat < @ne.lat
-      if crosses_meridian?
-        res &= point.lng < @ne.lng || point.lng > @sw.lng
-      else
-        res &= point.lng < @ne.lng && point.lng > @sw.lng
-      end
-      res
-    end
-    
-    # returns true if the bounds crosses the international dateline
-    def crosses_meridian?
-      @sw.lng > @ne.lng 
-    end
-
-    # Returns true if the candidate object is logically equal.  Logical equivalence
-    # is true if the lat and lng attributes are the same for both objects.
-    def ==(other)
-      other.is_a?(Bounds) ? self.sw == other.sw && self.ne == other.ne : false
-    end
-    
-    class <<self
-      
-      # returns an instance of bounds which completely encompases the given circle
-      def from_point_and_radius(point,radius,options={})
-        point=LatLng.normalize(point)
-        p0=point.endpoint(0,radius,options)
-        p90=point.endpoint(90,radius,options)
-        p180=point.endpoint(180,radius,options)
-        p270=point.endpoint(270,radius,options)
-        sw=GeoKit::LatLng.new(p180.lat,p270.lng)
-        ne=GeoKit::LatLng.new(p0.lat,p90.lng)
-        GeoKit::Bounds.new(sw,ne)
-      end
-      
-      # Takes two main combinations of arguements to create a bounds:
-      # point,point   (this is the only one which takes two arguments
-      # [point,point]
-      # . . . where a point is anything LatLng#normalize can handle (which is quite a lot)
-      #
-      # NOTE: everything combination is assumed to pass points in the order sw, ne
-      def normalize (thing,other=nil)   
-        # maybe this will be simple -- an actual bounds object is passed, and we can all go home
-        return thing if thing.is_a? Bounds
-        
-        # no? OK, if there's no "other," the thing better be a two-element array        
-        thing,other=thing if !other && thing.is_a?(Array) && thing.size==2
-
-        # Now that we're set with a thing and another thing, let LatLng do the heavy lifting.
-        # Exceptions may be thrown
-        Bounds.new(GeoKit::LatLng.normalize(thing),GeoKit::LatLng.normalize(other))
-      end
-    end
-  end
-end
 \ No newline at end of file
@@ -1,28 +0,0 @@
-if ActiveRecord::Base.connection.adapter_name =~ /^sqlite$/i
-
-  database = ActiveRecord::Base.connection.raw_connection
-
-  database.create_function('pow', 2, 1) do |func, base, exponent|
-    func.set_result(base.to_f ** exponent.to_f)
-  end
-  
-  database.create_function('sqrt', 1, 1) do |func, value|
-    func.set_result(Math.sqrt(value))
-  end
-
-  database.create_function('radians', 1, 1) do |func, value|
-    func.set_result(value.to_f * Math::PI / 180.0)
-  end
-
-  database.create_function('spheric_distance', 5, 1) do |func, lat1, long1, lat2, long2, radius|
-    func.set_result(
-      radius.to_f * Math.acos(
-	[1,
-        Math.cos(lat1.to_f) * Math.cos(long1.to_f) * Math.cos(lat2.to_f) * Math.cos(long2.to_f) + 
-         Math.cos(lat1.to_f) * Math.sin(long1.to_f) * Math.cos(lat2.to_f) * Math.sin(long2.to_f) + 
-         Math.sin(lat1.to_f) * Math.sin(lat2.to_f)
-        ].min
-      )
-    )
-  end
-end
@@ -1,481 +0,0 @@
-require 'rubygems'
-require 'mocha'
-require File.join(File.dirname(__FILE__), 'test_helper')
-
-GeoKit::Geocoders::provider_order=[:google,:us]
-
-# Uses defaults
-class Company < ActiveRecord::Base #:nodoc: all
-  has_many :locations
-end
-
-# Configures everything.
-class Location < ActiveRecord::Base #:nodoc: all
-  belongs_to :company
-  acts_as_mappable
-end
-
-# for auto_geocode
-class Store < ActiveRecord::Base
-  acts_as_mappable :auto_geocode=>true
-end
-
-# Uses deviations from conventions.
-class CustomLocation < ActiveRecord::Base #:nodoc: all
-  belongs_to :company
-  acts_as_mappable :distance_column_name => 'dist', 
-                   :default_units => :kms, 
-                   :default_formula => :flat, 
-                   :lat_column_name => 'latitude', 
-                   :lng_column_name => 'longitude'
-                   
-  def to_s
-    "lat: #{latitude} lng: #{longitude} dist: #{dist}"
-  end
-end
-
-class ActsAsMappableTest < Test::Unit::TestCase #:nodoc: all
-    
-  LOCATION_A_IP = "217.10.83.5"  
-    
-  #self.fixture_path = File.dirname(__FILE__) + '/fixtures'  
-  #self.fixture_path = RAILS_ROOT + '/test/fixtures/'
-  #puts "Rails Path #{RAILS_ROOT}"
-  #puts "Fixture Path: #{self.fixture_path}"
-  #self.fixture_path = ' /Users/bill_eisenhauer/Projects/geokit_test/test/fixtures/'
-  fixtures :companies, :locations, :custom_locations, :stores
-
-  def setup
-    @location_a = GeoKit::GeoLoc.new
-    @location_a.lat = 32.918593
-    @location_a.lng = -96.958444
-    @location_a.city = "Irving"
-    @location_a.state = "TX"
-    @location_a.country_code = "US"
-    @location_a.success = true
-    
-    @sw = GeoKit::LatLng.new(32.91663,-96.982841)
-    @ne = GeoKit::LatLng.new(32.96302,-96.919495)
-    @bounds_center=GeoKit::LatLng.new((@sw.lat+@ne.lat)/2,(@sw.lng+@ne.lng)/2)
-    
-    @starbucks = companies(:starbucks)
-    @loc_a = locations(:a)
-    @custom_loc_a = custom_locations(:a)
-    @loc_e = locations(:e)
-    @custom_loc_e = custom_locations(:e)    
-  end
-  
-  def test_override_default_units_the_hard_way
-    Location.default_units = :kms
-    locations = Location.find(:all, :origin => @loc_a, :conditions => "distance < 3.97")
-    assert_equal 5, locations.size   
-    locations = Location.count(:origin => @loc_a, :conditions => "distance < 3.97")
-    assert_equal 5, locations
-    Location.default_units = :miles
-  end
-  
-  def test_include
-    locations = Location.find(:all, :origin => @loc_a, :include => :company, :conditions => "company_id = 1")
-    assert !locations.empty?
-    assert_equal 1, locations[0].company.id
-    assert_equal 'Starbucks', locations[0].company.name
-  end
-  
-  def test_distance_between_geocoded
-    GeoKit::Geocoders::MultiGeocoder.expects(:geocode).with("Irving, TX").returns(@location_a)
-    GeoKit::Geocoders::MultiGeocoder.expects(:geocode).with("San Francisco, CA").returns(@location_a)
-    assert_equal 0, Location.distance_between("Irving, TX", "San Francisco, CA") 
-  end
-  
-  def test_distance_to_geocoded
-    GeoKit::Geocoders::MultiGeocoder.expects(:geocode).with("Irving, TX").returns(@location_a)
-    assert_equal 0, @custom_loc_a.distance_to("Irving, TX") 
-  end
-  
-  def test_distance_to_geocoded_error
-    GeoKit::Geocoders::MultiGeocoder.expects(:geocode).with("Irving, TX").returns(GeoKit::GeoLoc.new)
-    assert_raise(GeoKit::Geocoders::GeocodeError) { @custom_loc_a.distance_to("Irving, TX")  }
-  end
-  
-  def test_custom_attributes_distance_calculations
-    assert_equal 0, @custom_loc_a.distance_to(@loc_a)
-    assert_equal 0, CustomLocation.distance_between(@custom_loc_a, @loc_a)
-  end
-  
-  def test_distance_column_in_select
-    locations = Location.find(:all, :origin => @loc_a, :order => "distance ASC")
-    assert_equal 6, locations.size
-    assert_equal 0, @loc_a.distance_to(locations.first)
-    assert_in_delta 3.97, @loc_a.distance_to(locations.last, :units => :miles, :formula => :sphere), 0.01
-  end
-  
-  def test_find_with_distance_condition
-    locations = Location.find(:all, :origin => @loc_a, :conditions => "distance < 3.97")
-    assert_equal 5, locations.size
-    locations = Location.count(:origin => @loc_a, :conditions => "distance < 3.97")
-    assert_equal 5, locations
-  end 
-  
-  def test_find_with_distance_condition_with_units_override
-    locations = Location.find(:all, :origin => @loc_a, :units => :kms, :conditions => "distance < 6.387")
-    assert_equal 5, locations.size
-    locations = Location.count(:origin => @loc_a, :units => :kms, :conditions => "distance < 6.387")
-    assert_equal 5, locations
-  end
-  
-  def test_find_with_distance_condition_with_formula_override
-    locations = Location.find(:all, :origin => @loc_a, :formula => :flat, :conditions => "distance < 6.387")
-    assert_equal 6, locations.size
-    locations = Location.count(:origin => @loc_a, :formula => :flat, :conditions => "distance < 6.387")
-    assert_equal 6, locations
-  end
-  
-  def test_find_within
-    locations = Location.find_within(3.97, :origin => @loc_a)
-    assert_equal 5, locations.size 
-    locations = Location.count_within(3.97, :origin => @loc_a)
-    assert_equal 5, locations   
-  end
-  
-  def test_find_within_with_token
-    locations = Location.find(:all, :within => 3.97, :origin => @loc_a)
-    assert_equal 5, locations.size    
-    locations = Location.count(:within => 3.97, :origin => @loc_a)
-    assert_equal 5, locations
-  end
-  
-  def test_find_within_with_coordinates
-    locations = Location.find_within(3.97, :origin =>[@loc_a.lat,@loc_a.lng])
-    assert_equal 5, locations.size    
-    locations = Location.count_within(3.97, :origin =>[@loc_a.lat,@loc_a.lng])
-    assert_equal 5, locations
-  end
-  
-  def test_find_with_compound_condition
-    locations = Location.find(:all, :origin => @loc_a, :conditions => "distance < 5 and city = 'Coppell'")
-    assert_equal 2, locations.size
-    locations = Location.count(:origin => @loc_a, :conditions => "distance < 5 and city = 'Coppell'")
-    assert_equal 2, locations
-  end
-  
-  def test_find_with_secure_compound_condition
-    locations = Location.find(:all, :origin => @loc_a, :conditions => ["distance < ? and city = ?", 5, 'Coppell'])
-    assert_equal 2, locations.size
-    locations = Location.count(:origin => @loc_a, :conditions => ["distance < ? and city = ?", 5, 'Coppell'])
-    assert_equal 2, locations
-  end
-  
-  def test_find_beyond
-    locations = Location.find_beyond(3.95, :origin => @loc_a)
-    assert_equal 1, locations.size    
-    locations = Location.count_beyond(3.95, :origin => @loc_a)
-    assert_equal 1, locations
-  end
-  
-  def test_find_beyond_with_token
-    locations = Location.find(:all, :beyond => 3.95, :origin => @loc_a)
-    assert_equal 1, locations.size    
-    locations = Location.count(:beyond => 3.95, :origin => @loc_a)
-    assert_equal 1, locations
-  end
-  
-  def test_find_beyond_with_coordinates
-    locations = Location.find_beyond(3.95, :origin =>[@loc_a.lat, @loc_a.lng])
-    assert_equal 1, locations.size    
-    locations = Location.count_beyond(3.95, :origin =>[@loc_a.lat, @loc_a.lng])
-    assert_equal 1, locations
-  end
-  
-  def test_find_range_with_token
-    locations = Location.find(:all, :range => 0..10, :origin => @loc_a)
-    assert_equal 6, locations.size
-    locations = Location.count(:range => 0..10, :origin => @loc_a)
-    assert_equal 6, locations
-  end
-  
-  def test_find_range_with_token_with_conditions
-    locations = Location.find(:all, :origin => @loc_a, :range => 0..10, :conditions => ["city = ?", 'Coppell'])
-    assert_equal 2, locations.size
-    locations = Location.count(:origin => @loc_a, :range => 0..10, :conditions => ["city = ?", 'Coppell'])
-    assert_equal 2, locations
-  end
-  
-  def test_find_range_with_token_excluding_end
-    locations = Location.find(:all, :range => 0...10, :origin => @loc_a)
-    assert_equal 6, locations.size
-    locations = Location.count(:range => 0...10, :origin => @loc_a)
-    assert_equal 6, locations
-  end
-  
-  def test_find_nearest
-    assert_equal @loc_a, Location.find_nearest(:origin => @loc_a)
-  end
-  
-  def test_find_nearest_through_find
-     assert_equal @loc_a, Location.find(:nearest, :origin => @loc_a)
-  end
-  
-  def test_find_nearest_with_coordinates
-    assert_equal @loc_a, Location.find_nearest(:origin =>[@loc_a.lat, @loc_a.lng])
-  end
-  
-  def test_find_farthest
-    assert_equal @loc_e, Location.find_farthest(:origin => @loc_a)
-  end
-  
-  def test_find_farthest_through_find
-    assert_equal @loc_e, Location.find(:farthest, :origin => @loc_a)
-  end
-  
-  def test_find_farthest_with_coordinates
-    assert_equal @loc_e, Location.find_farthest(:origin =>[@loc_a.lat, @loc_a.lng])
-  end
-  
-  def test_scoped_distance_column_in_select
-    locations = @starbucks.locations.find(:all, :origin => @loc_a, :order => "distance ASC")
-    assert_equal 5, locations.size
-    assert_equal 0, @loc_a.distance_to(locations.first)
-    assert_in_delta 3.97, @loc_a.distance_to(locations.last, :units => :miles, :formula => :sphere), 0.01
-  end
-  
-  def test_scoped_find_with_distance_condition
-    locations = @starbucks.locations.find(:all, :origin => @loc_a, :conditions => "distance < 3.97")
-    assert_equal 4, locations.size
-    locations = @starbucks.locations.count(:origin => @loc_a, :conditions => "distance < 3.97")
-    assert_equal 4, locations
-  end 
-  
-  def test_scoped_find_within
-    locations = @starbucks.locations.find_within(3.97, :origin => @loc_a)
-    assert_equal 4, locations.size    
-    locations = @starbucks.locations.count_within(3.97, :origin => @loc_a)
-    assert_equal 4, locations
-  end
-  
-  def test_scoped_find_with_compound_condition
-    locations = @starbucks.locations.find(:all, :origin => @loc_a, :conditions => "distance < 5 and city = 'Coppell'")
-    assert_equal 2, locations.size
-    locations = @starbucks.locations.count( :origin => @loc_a, :conditions => "distance < 5 and city = 'Coppell'")
-    assert_equal 2, locations
-  end
-  
-  def test_scoped_find_beyond
-    locations = @starbucks.locations.find_beyond(3.95, :origin => @loc_a)
-    assert_equal 1, locations.size 
-    locations = @starbucks.locations.count_beyond(3.95, :origin => @loc_a)
-    assert_equal 1, locations   
-  end
-  
-  def test_scoped_find_nearest
-    assert_equal @loc_a, @starbucks.locations.find_nearest(:origin => @loc_a)
-  end
-  
-  def test_scoped_find_farthest
-    assert_equal @loc_e, @starbucks.locations.find_farthest(:origin => @loc_a)
-  end  
-  
-  def test_ip_geocoded_distance_column_in_select
-    GeoKit::Geocoders::IpGeocoder.expects(:geocode).with(LOCATION_A_IP).returns(@location_a)
-    locations = Location.find(:all, :origin => LOCATION_A_IP, :order => "distance ASC")
-    assert_equal 6, locations.size
-    assert_equal 0, @loc_a.distance_to(locations.first)
-    assert_in_delta 3.97, @loc_a.distance_to(locations.last, :units => :miles, :formula => :sphere), 0.01
-  end
-  
-  def test_ip_geocoded_find_with_distance_condition
-    GeoKit::Geocoders::IpGeocoder.expects(:geocode).with(LOCATION_A_IP).returns(@location_a)
-    locations = Location.find(:all, :origin => LOCATION_A_IP, :conditions => "distance < 3.97")
-    assert_equal 5, locations.size
-    GeoKit::Geocoders::IpGeocoder.expects(:geocode).with(LOCATION_A_IP).returns(@location_a)
-    locations = Location.count(:origin => LOCATION_A_IP, :conditions => "distance < 3.97")
-    assert_equal 5, locations
-  end 
-  
-  def test_ip_geocoded_find_within
-    GeoKit::Geocoders::IpGeocoder.expects(:geocode).with(LOCATION_A_IP).returns(@location_a)
-    locations = Location.find_within(3.97, :origin => LOCATION_A_IP)
-    assert_equal 5, locations.size    
-    GeoKit::Geocoders::IpGeocoder.expects(:geocode).with(LOCATION_A_IP).returns(@location_a)
-    locations = Location.count_within(3.97, :origin => LOCATION_A_IP)
-    assert_equal 5, locations
-  end
-  
-  def test_ip_geocoded_find_with_compound_condition
-    GeoKit::Geocoders::IpGeocoder.expects(:geocode).with(LOCATION_A_IP).returns(@location_a)
-    locations = Location.find(:all, :origin => LOCATION_A_IP, :conditions => "distance < 5 and city = 'Coppell'")
-    assert_equal 2, locations.size
-    GeoKit::Geocoders::IpGeocoder.expects(:geocode).with(LOCATION_A_IP).returns(@location_a)
-    locations = Location.count(:origin => LOCATION_A_IP, :conditions => "distance < 5 and city = 'Coppell'")
-    assert_equal 2, locations
-  end
-  
-  def test_ip_geocoded_find_with_secure_compound_condition
-    GeoKit::Geocoders::IpGeocoder.expects(:geocode).with(LOCATION_A_IP).returns(@location_a)
-    locations = Location.find(:all, :origin => LOCATION_A_IP, :conditions => ["distance < ? and city = ?", 5, 'Coppell'])
-    assert_equal 2, locations.size
-    GeoKit::Geocoders::IpGeocoder.expects(:geocode).with(LOCATION_A_IP).returns(@location_a)
-    locations = Location.count(:origin => LOCATION_A_IP, :conditions => ["distance < ? and city = ?", 5, 'Coppell'])
-    assert_equal 2, locations
-  end
-  
-  def test_ip_geocoded_find_beyond
-    GeoKit::Geocoders::IpGeocoder.expects(:geocode).with(LOCATION_A_IP).returns(@location_a)
-    locations = Location.find_beyond(3.95, :origin => LOCATION_A_IP)
-    assert_equal 1, locations.size    
-    GeoKit::Geocoders::IpGeocoder.expects(:geocode).with(LOCATION_A_IP).returns(@location_a)
-    locations = Location.count_beyond(3.95, :origin => LOCATION_A_IP)
-    assert_equal 1, locations
-  end
-  
-  def test_ip_geocoded_find_nearest
-    GeoKit::Geocoders::IpGeocoder.expects(:geocode).with(LOCATION_A_IP).returns(@location_a)
-    assert_equal @loc_a, Location.find_nearest(:origin => LOCATION_A_IP)
-  end
-  
-  def test_ip_geocoded_find_farthest
-    GeoKit::Geocoders::IpGeocoder.expects(:geocode).with(LOCATION_A_IP).returns(@location_a)
-    assert_equal @loc_e, Location.find_farthest(:origin => LOCATION_A_IP)
-  end
-  
-  def test_ip_geocoder_exception
-    GeoKit::Geocoders::IpGeocoder.expects(:geocode).with('127.0.0.1').returns(GeoKit::GeoLoc.new)
-    assert_raises GeoKit::Geocoders::GeocodeError do
-      Location.find_farthest(:origin => '127.0.0.1')
-    end
-  end
-  
-  def test_address_geocode
-    GeoKit::Geocoders::MultiGeocoder.expects(:geocode).with('Irving, TX').returns(@location_a)  
-    locations = Location.find(:all, :origin => 'Irving, TX', :conditions => ["distance < ? and city = ?", 5, 'Coppell'])
-    assert_equal 2, locations.size
-  end
-  
-  def test_find_with_custom_distance_condition
-    locations = CustomLocation.find(:all, :origin => @loc_a, :conditions => "dist < 3.97")
-    assert_equal 5, locations.size 
-    locations = CustomLocation.count(:origin => @loc_a, :conditions => "dist < 3.97")
-    assert_equal 5, locations
-  end  
-  
-  def test_find_with_custom_distance_condition_using_custom_origin
-    locations = CustomLocation.find(:all, :origin => @custom_loc_a, :conditions => "dist < 3.97")
-    assert_equal 5, locations.size 
-    locations = CustomLocation.count(:origin => @custom_loc_a, :conditions => "dist < 3.97")
-    assert_equal 5, locations
-  end
-  
-  def test_find_within_with_custom
-    locations = CustomLocation.find_within(3.97, :origin => @loc_a)
-    assert_equal 5, locations.size    
-    locations = CustomLocation.count_within(3.97, :origin => @loc_a)
-    assert_equal 5, locations
-  end
-  
-  def test_find_within_with_coordinates_with_custom
-    locations = CustomLocation.find_within(3.97, :origin =>[@loc_a.lat, @loc_a.lng])
-    assert_equal 5, locations.size    
-    locations = CustomLocation.count_within(3.97, :origin =>[@loc_a.lat, @loc_a.lng])
-    assert_equal 5, locations
-  end
-  
-  def test_find_with_compound_condition_with_custom
-    locations = CustomLocation.find(:all, :origin => @loc_a, :conditions => "dist < 5 and city = 'Coppell'")
-    assert_equal 1, locations.size
-    locations = CustomLocation.count(:origin => @loc_a, :conditions => "dist < 5 and city = 'Coppell'")
-    assert_equal 1, locations
-  end
-  
-  def test_find_with_secure_compound_condition_with_custom
-    locations = CustomLocation.find(:all, :origin => @loc_a, :conditions => ["dist < ? and city = ?", 5, 'Coppell'])
-    assert_equal 1, locations.size
-    locations = CustomLocation.count(:origin => @loc_a, :conditions => ["dist < ? and city = ?", 5, 'Coppell'])
-    assert_equal 1, locations
-  end
-  
-  def test_find_beyond_with_custom
-    locations = CustomLocation.find_beyond(3.95, :origin => @loc_a)
-    assert_equal 1, locations.size  
-    locations = CustomLocation.count_beyond(3.95, :origin => @loc_a)
-    assert_equal 1, locations  
-  end
-  
-  def test_find_beyond_with_coordinates_with_custom
-    locations = CustomLocation.find_beyond(3.95, :origin =>[@loc_a.lat, @loc_a.lng])
-    assert_equal 1, locations.size    
-    locations = CustomLocation.count_beyond(3.95, :origin =>[@loc_a.lat, @loc_a.lng])
-    assert_equal 1, locations
-  end
-  
-  def test_find_nearest_with_custom
-    assert_equal @custom_loc_a, CustomLocation.find_nearest(:origin => @loc_a)
-  end
-  
-  def test_find_nearest_with_coordinates_with_custom
-    assert_equal @custom_loc_a, CustomLocation.find_nearest(:origin =>[@loc_a.lat, @loc_a.lng])
-  end
-  
-  def test_find_farthest_with_custom
-    assert_equal @custom_loc_e, CustomLocation.find_farthest(:origin => @loc_a)
-  end
-  
-  def test_find_farthest_with_coordinates_with_custom
-    assert_equal @custom_loc_e, CustomLocation.find_farthest(:origin =>[@loc_a.lat, @loc_a.lng])
-  end
-  
-  def test_find_with_array_origin
-    locations = Location.find(:all, :origin =>[@loc_a.lat,@loc_a.lng], :conditions => "distance < 3.97")
-    assert_equal 5, locations.size
-    locations = Location.count(:origin =>[@loc_a.lat,@loc_a.lng], :conditions => "distance < 3.97")
-    assert_equal 5, locations
-  end
-
-
-  # Bounding box tests
-
-  def test_find_within_bounds
-    locations = Location.find_within_bounds([@sw,@ne])
-    assert_equal 2, locations.size
-    locations = Location.count_within_bounds([@sw,@ne])
-    assert_equal 2, locations
-  end
-
-  def test_find_within_bounds_ordered_by_distance
-    locations = Location.find_within_bounds([@sw,@ne], :origin=>@bounds_center, :order=>'distance asc')
-    assert_equal locations[0], locations(:d)
-    assert_equal locations[1], locations(:a)
-  end
-  
-  def test_find_within_bounds_with_token
-    locations = Location.find(:all, :bounds=>[@sw,@ne])
-    assert_equal 2, locations.size
-    locations = Location.count(:bounds=>[@sw,@ne])
-    assert_equal 2, locations  
-  end
-
-  def test_find_within_bounds_with_string_conditions
-    locations = Location.find(:all, :bounds=>[@sw,@ne], :conditions=>"id !=#{locations(:a).id}")
-    assert_equal 1, locations.size
-  end
-
-  def test_find_within_bounds_with_array_conditions
-    locations = Location.find(:all, :bounds=>[@sw,@ne], :conditions=>["id != ?", locations(:a).id])
-    assert_equal 1, locations.size
-  end
-
-  def test_auto_geocode
-    GeoKit::Geocoders::MultiGeocoder.expects(:geocode).with("Irving, TX").returns(@location_a)
-    store=Store.new(:address=>'Irving, TX')
-    store.save
-    assert_equal store.lat,@location_a.lat  
-    assert_equal store.lng,@location_a.lng
-    assert_equal 0, store.errors.size
-  end
-
-  def test_auto_geocode_failure
-    GeoKit::Geocoders::MultiGeocoder.expects(:geocode).with("BOGUS").returns(GeoKit::GeoLoc.new)
-    store=Store.new(:address=>'BOGUS')
-    store.save
-    assert store.new_record?
-    assert_equal 1, store.errors.size
-  end
-end
@@ -1,57 +0,0 @@
-require 'test/unit'
-require 'net/http'
-require 'rubygems'
-require 'mocha'
-require File.join(File.dirname(__FILE__), '../../../../config/environment')
-
-
-class MockSuccess < Net::HTTPSuccess #:nodoc: all
-  def initialize
-  end
-end
-
-class MockFailure < Net::HTTPServiceUnavailable #:nodoc: all
-  def initialize
-  end
-end
-
-# Base class for testing geocoders.
-class BaseGeocoderTest < Test::Unit::TestCase #:nodoc: all
-
-  # Defines common test fixtures.
-  def setup
-    @address = 'San Francisco, CA'    
-    @full_address = '100 Spear St, San Francisco, CA, 94105-1522, US'   
-    @full_address_short_zip = '100 Spear St, San Francisco, CA, 94105, US' 
-    
-    @success = GeoKit::GeoLoc.new({:city=>"SAN FRANCISCO", :state=>"CA", :country_code=>"US", :lat=>37.7742, :lng=>-122.417068})
-    @success.success = true    
-  end  
-  
-  def test_timeout_call_web_service
-    GeoKit::Geocoders::Geocoder.class_eval do
-      def self.do_get(url)
-        sleep(2)
-      end
-    end
-    url = "http://www.anything.com"
-    GeoKit::Geocoders::timeout = 1
-    assert_nil GeoKit::Geocoders::Geocoder.call_geocoder_service(url)    
-  end
-  
-  def test_successful_call_web_service
-    url = "http://www.anything.com"
-    GeoKit::Geocoders::Geocoder.expects(:do_get).with(url).returns("SUCCESS")
-    assert_equal "SUCCESS", GeoKit::Geocoders::Geocoder.call_geocoder_service(url)
-  end
-  
-  def test_find_geocoder_methods
-    public_methods = GeoKit::Geocoders::Geocoder.public_methods
-    assert public_methods.include?("yahoo_geocoder")
-    assert public_methods.include?("google_geocoder")
-    assert public_methods.include?("ca_geocoder")
-    assert public_methods.include?("us_geocoder")
-    assert public_methods.include?("multi_geocoder")
-    assert public_methods.include?("ip_geocoder")
-  end
-end
 \ No newline at end of file
@@ -1,75 +0,0 @@
-$LOAD_PATH.unshift File.join('..', 'lib')
-require 'geo_kit/mappable'
-require 'test/unit'
-
-class BoundsTest < Test::Unit::TestCase #:nodoc: all
-  
-  def setup
-    # This is the area in Texas
-    @sw = GeoKit::LatLng.new(32.91663,-96.982841)
-    @ne = GeoKit::LatLng.new(32.96302,-96.919495)
-    @bounds=GeoKit::Bounds.new(@sw,@ne) 
-    @loc_a=GeoKit::LatLng.new(32.918593,-96.958444) # inside bounds    
-    @loc_b=GeoKit::LatLng.new(32.914144,-96.958444) # outside bouds
-    
-    # this is a cross-meridan area
-    @cross_meridian=GeoKit::Bounds.normalize([30,170],[40,-170])
-    @inside_cm=GeoKit::LatLng.new(35,175)
-    @inside_cm_2=GeoKit::LatLng.new(35,-175)
-    @east_of_cm=GeoKit::LatLng.new(35,-165)
-    @west_of_cm=GeoKit::LatLng.new(35,165)
-
-  end  
-
-  def test_equality
-    assert_equal GeoKit::Bounds.new(@sw,@ne), GeoKit::Bounds.new(@sw,@ne)
-  end  
-  
-  def test_normalize
-    res=GeoKit::Bounds.normalize(@sw,@ne)
-    assert_equal res,GeoKit::Bounds.new(@sw,@ne)     
-    res=GeoKit::Bounds.normalize([@sw,@ne])
-    assert_equal res,GeoKit::Bounds.new(@sw,@ne)
-    res=GeoKit::Bounds.normalize([@sw.lat,@sw.lng],[@ne.lat,@ne.lng])
-    assert_equal res,GeoKit::Bounds.new(@sw,@ne)
-    res=GeoKit::Bounds.normalize([[@sw.lat,@sw.lng],[@ne.lat,@ne.lng]])
-    assert_equal res,GeoKit::Bounds.new(@sw,@ne)
-  end
-  
-  def test_point_inside_bounds
-    assert @bounds.contains?(@loc_a)
-  end
-
-  def test_point_outside_bounds
-    assert !@bounds.contains?(@loc_b) 
-  end  
-
-  def test_point_inside_bounds_cross_meridian
-    assert @cross_meridian.contains?(@inside_cm)
-    assert @cross_meridian.contains?(@inside_cm_2)
-  end
-
-  def test_point_outside_bounds_cross_meridian
-    assert !@cross_meridian.contains?(@east_of_cm)
-    assert !@cross_meridian.contains?(@west_of_cm)
-  end    
-  
-  def test_center
-    assert_in_delta 32.939828,@bounds.center.lat,0.00005
-    assert_in_delta -96.9511763,@bounds.center.lng,0.00005
-  end
-
-  def test_center_cross_meridian
-    assert_in_delta 35.41160, @cross_meridian.center.lat,0.00005
-    assert_in_delta 179.38112, @cross_meridian.center.lng,0.00005
-  end  
-  
-  def test_creation_from_circle
-    bounds=GeoKit::Bounds.from_point_and_radius([32.939829, -96.951176],2.5)
-    inside=GeoKit::LatLng.new 32.9695270000,-96.9901590000
-    outside=GeoKit::LatLng.new 32.8951550000,-96.9584440000
-    assert bounds.contains?(inside)
-    assert !bounds.contains?(outside)
-  end
-  
-end
 \ No newline at end of file
@@ -1,41 +0,0 @@
-require File.join(File.dirname(__FILE__), 'base_geocoder_test')
-
-GeoKit::Geocoders::geocoder_ca = "SOMEKEYVALUE"
-
-class CaGeocoderTest < BaseGeocoderTest #:nodoc: all
-  
-  CA_SUCCESS=<<-EOF
-  <?xml version="1.0" encoding="UTF-8" ?>
-  <geodata><latt>49.243086</latt><longt>-123.153684</longt></geodata>  
-  EOF
-  
-  def setup
-    @ca_full_hash = {:street_address=>"2105 West 32nd Avenue",:city=>"Vancouver", :state=>"BC"}
-    @ca_full_loc = GeoKit::GeoLoc.new(@ca_full_hash)
-  end  
-  
-  def test_geocoder_with_geo_loc_with_account
-    response = MockSuccess.new
-    response.expects(:body).returns(CA_SUCCESS)
-    url = "http://geocoder.ca/?stno=2105&addresst=West+32nd+Avenue&city=Vancouver&prov=BC&auth=SOMEKEYVALUE&geoit=xml"
-    GeoKit::Geocoders::CaGeocoder.expects(:call_geocoder_service).with(url).returns(response)
-    verify(GeoKit::Geocoders::CaGeocoder.geocode(@ca_full_loc))    
-  end
-  
-  def test_service_unavailable
-    response = MockFailure.new
-    #Net::HTTP.expects(:get_response).with(URI.parse("http://geocoder.ca/?stno=2105&addresst=West+32nd+Avenue&city=Vancouver&prov=BC&auth=SOMEKEYVALUE&geoit=xml")).returns(response)  
-    url = "http://geocoder.ca/?stno=2105&addresst=West+32nd+Avenue&city=Vancouver&prov=BC&auth=SOMEKEYVALUE&geoit=xml" 
-    GeoKit::Geocoders::CaGeocoder.expects(:call_geocoder_service).with(url).returns(response)
-    assert !GeoKit::Geocoders::CaGeocoder.geocode(@ca_full_loc).success   
-  end  
-  
-  private
-  
-  def verify(location)
-    assert_equal "BC", location.state
-    assert_equal "Vancouver", location.city 
-    assert_equal "49.243086,-123.153684", location.ll 
-    assert !location.is_us? 
-  end
-end
 \ No newline at end of file
@@ -1,15 +0,0 @@
-mysql:
-  adapter: mysql
-  host: localhost
-  username: root
-  password:
-  database: geokit_plugin_test
-postgresql:
-  adapter: postgresql
-  host: localhost
-  username: root
-  password: 
-  database: geokit_plugin_test
-sqlite:
-  adapter: sqlite3
-  database: tmp/geokit_plugin_test.sqlite3
@@ -1,7 +0,0 @@
-starbucks:
-  id: 1
-  name: Starbucks
-
-barnes_and_noble:
-  id: 2
-  name: Barnes & Noble
 \ No newline at end of file
@@ -1,54 +0,0 @@
-a:
-  id: 1
-  company_id: 1
-  street: 7979 N MacArthur Blvd
-  city: Irving
-  state: TX
-  postal_code: 75063
-  latitude: 32.918593
-  longitude: -96.958444
-b:
-  id: 2
-  company_id: 1
-  street: 7750 N Macarthur Blvd # 160
-  city: Irving
-  state: TX
-  postal_code: 75063
-  latitude: 32.914144
-  longitude: -96.958444
-c:
-  id: 3
-  company_id: 1
-  street: 5904 N Macarthur Blvd # 160
-  city: Irving
-  state: TX
-  postal_code: 75039
-  latitude: 32.895155
-  longitude: -96.958444
-d:
-  id: 4
-  company_id: 1
-  street: 817 S Macarthur Blvd # 145
-  city: Coppell
-  state: TX
-  postal_code: 75019
-  latitude: 32.951613
-  longitude: -96.958444
-e:
-  id: 5
-  company_id: 1
-  street: 106 N Denton Tap Rd # 350
-  city: Coppell
-  state: TX
-  postal_code: 75019
-  latitude: 32.969527
-  longitude: -96.990159
-f:
-  id: 6
-  company_id: 2
-  street: 5904 N Macarthur Blvd # 160
-  city: Irving
-  state: TX
-  postal_code: 75039
-  latitude: 32.895155
-  longitude: -96.958444
 \ No newline at end of file
@@ -1,54 +0,0 @@
-a:
-  id: 1
-  company_id: 1
-  street: 7979 N MacArthur Blvd
-  city: Irving
-  state: TX
-  postal_code: 75063
-  lat: 32.918593
-  lng: -96.958444
-b:
-  id: 2
-  company_id: 1
-  street: 7750 N Macarthur Blvd # 160
-  city: Irving
-  state: TX
-  postal_code: 75063
-  lat: 32.914144
-  lng: -96.958444
-c:
-  id: 3
-  company_id: 1
-  street: 5904 N Macarthur Blvd # 160
-  city: Irving
-  state: TX
-  postal_code: 75039
-  lat: 32.895155
-  lng: -96.958444
-d:
-  id: 4
-  company_id: 1
-  street: 817 S Macarthur Blvd # 145
-  city: Coppell
-  state: TX
-  postal_code: 75019
-  lat: 32.951613
-  lng: -96.958444
-e:
-  id: 5
-  company_id: 1
-  street: 106 N Denton Tap Rd # 350
-  city: Coppell
-  state: TX
-  postal_code: 75019
-  lat: 32.969527
-  lng: -96.990159
-f:
-  id: 6
-  company_id: 2
-  street: 5904 N Macarthur Blvd # 160
-  city: Irving
-  state: TX
-  postal_code: 75039
-  lat: 32.895155
-  lng: -96.958444
 \ No newline at end of file
@@ -1,49 +0,0 @@
-require 'test/unit'
-require File.join(File.dirname(__FILE__), '../../../../config/environment')
-
-class GeoLocTest < Test::Unit::TestCase #:nodoc: all
-  
-  def setup
-    @loc = GeoKit::GeoLoc.new
-  end
-  
-  def test_is_us
-    assert !@loc.is_us?
-    @loc.country_code = 'US'
-    assert @loc.is_us?
-  end
-  
-  def test_street_number
-    @loc.street_address = '123 Spear St.'
-    assert_equal '123', @loc.street_number
-  end
-  
-  def test_street_name
-    @loc.street_address = '123 Spear St.'
-    assert_equal 'Spear St.', @loc.street_name
-  end
-  
-  def test_city
-    @loc.city = "san francisco"
-    assert_equal 'San Francisco', @loc.city
-  end
-  
-  def test_full_address
-    @loc.city = 'San Francisco'
-    @loc.state = 'CA'
-    @loc.zip = '94105'
-    @loc.country_code = 'US'
-    assert_equal 'San Francisco, CA, 94105, US', @loc.full_address
-    @loc.full_address = 'Irving, TX, 75063, US'
-    assert_equal 'Irving, TX, 75063, US', @loc.full_address
-  end
-  
-  def test_hash
-    @loc.city = 'San Francisco'
-    @loc.state = 'CA'
-    @loc.zip = '94105'
-    @loc.country_code = 'US'
-    @another = GeoKit::GeoLoc.new @loc.to_hash    
-    assert_equal @loc, @another
-  end
-end
 \ No newline at end of file
@@ -1,88 +0,0 @@
-require File.join(File.dirname(__FILE__), 'base_geocoder_test')
-
-GeoKit::Geocoders::google = 'Google'
-
-class GoogleGeocoderTest < BaseGeocoderTest #:nodoc: all
-  
-  GOOGLE_FULL=<<-EOF.strip
-  <?xml version="1.0" encoding="UTF-8"?><kml xmlns="http://earth.google.com/kml/2.0"><Response><name>100 spear st, san francisco, ca</name><Status><code>200</code><request>geocode</request></Status><Placemark><address>100 Spear St, San Francisco, CA 94105, USA</address><AddressDetails Accuracy="8" xmlns="urn:oasis:names:tc:ciq:xsdschema:xAL:2.0"><Country><CountryNameCode>US</CountryNameCode><AdministrativeArea><AdministrativeAreaName>CA</AdministrativeAreaName><SubAdministrativeArea><SubAdministrativeAreaName>San Francisco</SubAdministrativeAreaName><Locality><LocalityName>San Francisco</LocalityName><Thoroughfare><ThoroughfareName>100 Spear St</ThoroughfareName></Thoroughfare><PostalCode><PostalCodeNumber>94105</PostalCodeNumber></PostalCode></Locality></SubAdministrativeArea></AdministrativeArea></Country></AddressDetails><Point><coordinates>-122.393985,37.792501,0</coordinates></Point></Placemark></Response></kml>
-  EOF
-
-  GOOGLE_CITY=<<-EOF.strip
-  <?xml version="1.0" encoding="UTF-8"?><kml xmlns="http://earth.google.com/kml/2.0"><Response><name>San Francisco</name><Status><code>200</code><request>geocode</request></Status><Placemark><address>San Francisco, CA, USA</address><AddressDetails Accuracy="4" xmlns="urn:oasis:names:tc:ciq:xsdschema:xAL:2.0"><Country><CountryNameCode>US</CountryNameCode><AdministrativeArea><AdministrativeAreaName>CA</AdministrativeAreaName><Locality><LocalityName>San Francisco</LocalityName></Locality></AdministrativeArea></Country></AddressDetails><Point><coordinates>-122.418333,37.775000,0</coordinates></Point></Placemark></Response></kml>
-  EOF
-  
-  def setup
-    super
-    @google_full_hash = {:street_address=>"100 Spear St", :city=>"San Francisco", :state=>"CA", :zip=>"94105", :country_code=>"US"}
-    @google_city_hash = {:city=>"San Francisco", :state=>"CA"}
-
-    @google_full_loc = GeoKit::GeoLoc.new(@google_full_hash)
-    @google_city_loc = GeoKit::GeoLoc.new(@google_city_hash)
-  end  
-
-  def test_google_full_address
-    response = MockSuccess.new
-    response.expects(:body).returns(GOOGLE_FULL)
-    url = "http://maps.google.com/maps/geo?q=#{CGI.escape(@address)}&output=xml&key=Google&oe=utf-8"
-    GeoKit::Geocoders::GoogleGeocoder.expects(:call_geocoder_service).with(url).returns(response)
-    res=GeoKit::Geocoders::GoogleGeocoder.geocode(@address)
-    assert_equal "CA", res.state
-    assert_equal "San Francisco", res.city 
-    assert_equal "37.792501,-122.393985", res.ll # slightly dif from yahoo
-    assert res.is_us?
-    assert_equal "100 Spear St, San Francisco, CA 94105, USA", res.full_address #slightly different from yahoo
-    assert_equal "google", res.provider
-  end
-  
-  def test_google_full_address_with_geo_loc
-    response = MockSuccess.new
-    response.expects(:body).returns(GOOGLE_FULL)
-    url = "http://maps.google.com/maps/geo?q=#{CGI.escape(@full_address_short_zip)}&output=xml&key=Google&oe=utf-8"
-    GeoKit::Geocoders::GoogleGeocoder.expects(:call_geocoder_service).with(url).returns(response)
-    res=GeoKit::Geocoders::GoogleGeocoder.geocode(@google_full_loc)
-    assert_equal "CA", res.state
-    assert_equal "San Francisco", res.city 
-    assert_equal "37.792501,-122.393985", res.ll # slightly dif from yahoo
-    assert res.is_us?
-    assert_equal "100 Spear St, San Francisco, CA 94105, USA", res.full_address #slightly different from yahoo
-    assert_equal "google", res.provider
-  end  
-
-  def test_google_city
-    response = MockSuccess.new
-    response.expects(:body).returns(GOOGLE_CITY)
-    url = "http://maps.google.com/maps/geo?q=#{CGI.escape(@address)}&output=xml&key=Google&oe=utf-8"
-    GeoKit::Geocoders::GoogleGeocoder.expects(:call_geocoder_service).with(url).returns(response)
-    res=GeoKit::Geocoders::GoogleGeocoder.geocode(@address)
-    assert_equal "CA", res.state
-    assert_equal "San Francisco", res.city
-    assert_equal "37.775,-122.418333", res.ll
-    assert res.is_us?
-    assert_equal "San Francisco, CA, USA", res.full_address
-    assert_nil res.street_address
-    assert_equal "google", res.provider
-  end  
-  
-  def test_google_city_with_geo_loc
-    response = MockSuccess.new
-    response.expects(:body).returns(GOOGLE_CITY)
-    url = "http://maps.google.com/maps/geo?q=#{CGI.escape(@address)}&output=xml&key=Google&oe=utf-8"
-    GeoKit::Geocoders::GoogleGeocoder.expects(:call_geocoder_service).with(url).returns(response)
-    res=GeoKit::Geocoders::GoogleGeocoder.geocode(@google_city_loc)
-    assert_equal "CA", res.state
-    assert_equal "San Francisco", res.city
-    assert_equal "37.775,-122.418333", res.ll
-    assert res.is_us?
-    assert_equal "San Francisco, CA, USA", res.full_address
-    assert_nil res.street_address
-    assert_equal "google", res.provider
-  end  
-  
-  def test_service_unavailable
-    response = MockFailure.new
-    url = "http://maps.google.com/maps/geo?q=#{CGI.escape(@address)}&output=xml&key=Google&oe=utf-8"
-    GeoKit::Geocoders::GoogleGeocoder.expects(:call_geocoder_service).with(url).returns(response)
-    assert !GeoKit::Geocoders::GoogleGeocoder.geocode(@google_city_loc).success
-  end 
-end
 \ No newline at end of file
@@ -1,84 +0,0 @@
-require File.join(File.dirname(__FILE__), '../../../../config/environment')
-require 'action_controller/test_process'
-require 'test/unit'
-require 'rubygems'
-require 'mocha'
-
-
-class LocationAwareController < ActionController::Base #:nodoc: all
-  geocode_ip_address
-  
-  def index
-    render :nothing => true
-  end
-end
-
-class ActionController::TestRequest #:nodoc: all
-  attr_accessor :remote_ip
-end
-
-# Re-raise errors caught by the controller.
-class LocationAwareController #:nodoc: all
-  def rescue_action(e) raise e end; 
-end
-
-class IpGeocodeLookupTest < Test::Unit::TestCase #:nodoc: all
-  
-  def setup
-    @success = GeoKit::GeoLoc.new
-    @success.provider = "hostip"
-    @success.lat = 41.7696
-    @success.lng = -88.4588
-    @success.city = "Sugar Grove"
-    @success.state = "IL"
-    @success.country_code = "US"
-    @success.success = true
-    
-    @failure = GeoKit::GeoLoc.new
-    @failure.provider = "hostip"
-    @failure.city = "(Private Address)"
-    @failure.success = false
-    
-    @controller = LocationAwareController.new
-    @request = ActionController::TestRequest.new
-    @response = ActionController::TestResponse.new
-  end
-
-  def test_no_location_in_cookie_or_session
-    GeoKit::Geocoders::IpGeocoder.expects(:geocode).with("good ip").returns(@success)
-    @request.remote_ip = "good ip"
-    get :index
-    verify
-  end
-  
-  def test_location_in_cookie
-    @request.remote_ip = "good ip"
-    @request.cookies['geo_location'] = CGI::Cookie.new('geo_location', @success.to_yaml)
-    get :index
-    verify
-  end
-  
-  def test_location_in_session
-    @request.remote_ip = "good ip"
-    @request.session[:geo_location] = @success
-    @request.cookies['geo_location'] = CGI::Cookie.new('geo_location', @success.to_yaml)
-    get :index
-    verify
-  end
-  
-  def test_ip_not_located
-    GeoKit::Geocoders::IpGeocoder.expects(:geocode).with("bad ip").returns(@failure)
-    @request.remote_ip = "bad ip"
-    get :index
-    assert_nil @request.session[:geo_location]
-  end
-  
-  private
-  
-  def verify
-    assert_response :success    
-    assert_equal @success, @request.session[:geo_location]
-    assert_not_nil cookies['geo_location']
-    assert_equal @success, YAML.load(cookies['geo_location'].join)
-  end
-end
 \ No newline at end of file
@@ -1,87 +0,0 @@
-require File.join(File.dirname(__FILE__), 'base_geocoder_test')
-
-class IpGeocoderTest < BaseGeocoderTest #:nodoc: all
-    
-  IP_FAILURE=<<-EOF
-    Country: (Private Address) (XX)
-    City: (Private Address)
-    Latitude: 
-    Longitude:
-    EOF
-    
-  IP_SUCCESS=<<-EOF
-    Country: UNITED STATES (US)
-    City: Sugar Grove, IL
-    Latitude: 41.7696
-    Longitude: -88.4588
-    EOF
-    
-  IP_UNICODED=<<-EOF
-    Country: SWEDEN (SE)
-    City: Borås
-    Latitude: 57.7167
-    Longitude: 12.9167
-    EOF
-    
-    def setup
-      super
-      @success.provider = "hostip"
-    end    
-  
-  def test_successful_lookup
-    success = MockSuccess.new
-    success.expects(:body).returns(IP_SUCCESS)
-    url = 'http://api.hostip.info/get_html.php?ip=12.215.42.19&position=true'
-    GeoKit::Geocoders::IpGeocoder.expects(:call_geocoder_service).with(url).returns(success)
-    location = GeoKit::Geocoders::IpGeocoder.geocode('12.215.42.19')
-    assert_not_nil location
-    assert_equal 41.7696, location.lat
-    assert_equal -88.4588, location.lng
-    assert_equal "Sugar Grove", location.city
-    assert_equal "IL", location.state
-    assert_equal "US", location.country_code
-    assert_equal "hostip", location.provider
-    assert location.success
-  end
-  
-  def test_unicoded_lookup
-    success = MockSuccess.new
-    success.expects(:body).returns(IP_UNICODED)
-    url = 'http://api.hostip.info/get_html.php?ip=12.215.42.19&position=true'
-    GeoKit::Geocoders::IpGeocoder.expects(:call_geocoder_service).with(url).returns(success)
-    location = GeoKit::Geocoders::IpGeocoder.geocode('12.215.42.19')
-    assert_not_nil location
-    assert_equal 57.7167, location.lat
-    assert_equal 12.9167, location.lng
-    assert_equal "Borås", location.city
-    assert_nil location.state
-    assert_equal "SE", location.country_code
-    assert_equal "hostip", location.provider
-    assert location.success
-  end
-  
-  def test_failed_lookup
-    failure = MockSuccess.new
-    failure.expects(:body).returns(IP_FAILURE)
-    url = 'http://api.hostip.info/get_html.php?ip=0.0.0.0&position=true'
-    GeoKit::Geocoders::IpGeocoder.expects(:call_geocoder_service).with(url).returns(failure)
-    location = GeoKit::Geocoders::IpGeocoder.geocode("0.0.0.0")
-    assert_not_nil location
-    assert !location.success
-  end
-  
-  def test_invalid_ip
-    location = GeoKit::Geocoders::IpGeocoder.geocode("blah")
-    assert_not_nil location
-    assert !location.success
-  end
-  
-  def test_service_unavailable
-    failure = MockFailure.new
-    url = 'http://api.hostip.info/get_html.php?ip=0.0.0.0&position=true'
-    GeoKit::Geocoders::IpGeocoder.expects(:call_geocoder_service).with(url).returns(failure)
-    location = GeoKit::Geocoders::IpGeocoder.geocode("0.0.0.0")
-    assert_not_nil location
-    assert !location.success
-  end  
-end
 \ No newline at end of file
@@ -1,112 +0,0 @@
-$LOAD_PATH.unshift File.join('..', 'lib')
-require 'geo_kit/mappable'
-require 'test/unit'
-
-class LatLngTest < Test::Unit::TestCase #:nodoc: all
-  
-  def setup
-    @loc_a = GeoKit::LatLng.new(32.918593,-96.958444)
-    @loc_e = GeoKit::LatLng.new(32.969527,-96.990159)
-    @point = GeoKit::LatLng.new(@loc_a.lat, @loc_a.lng)
-  end
-  
-  def test_distance_between_same_using_defaults
-    assert_equal 0, GeoKit::LatLng.distance_between(@loc_a, @loc_a)
-    assert_equal 0, @loc_a.distance_to(@loc_a)
-  end
-  
-  def test_distance_between_same_with_miles_and_flat
-    assert_equal 0, GeoKit::LatLng.distance_between(@loc_a, @loc_a, :units => :miles, :formula => :flat)
-    assert_equal 0, @loc_a.distance_to(@loc_a, :units => :miles, :formula => :flat)
-  end
-
-  def test_distance_between_same_with_kms_and_flat
-    assert_equal 0, GeoKit::LatLng.distance_between(@loc_a, @loc_a, :units => :kms, :formula => :flat)
-    assert_equal 0, @loc_a.distance_to(@loc_a, :units => :kms, :formula => :flat)
-  end
-  
-  def test_distance_between_same_with_miles_and_sphere
-    assert_equal 0, GeoKit::LatLng.distance_between(@loc_a, @loc_a, :units => :miles, :formula => :sphere)
-    assert_equal 0, @loc_a.distance_to(@loc_a, :units => :miles, :formula => :sphere)
-  end
-  
-  def test_distance_between_same_with_kms_and_sphere
-    assert_equal 0, GeoKit::LatLng.distance_between(@loc_a, @loc_a, :units => :kms, :formula => :sphere)
-    assert_equal 0, @loc_a.distance_to(@loc_a, :units => :kms, :formula => :sphere)
-  end
-  
-  def test_distance_between_diff_using_defaults
-    assert_in_delta 3.97, GeoKit::LatLng.distance_between(@loc_a, @loc_e), 0.01
-    assert_in_delta 3.97, @loc_a.distance_to(@loc_e), 0.01
-  end
-  
-  def test_distance_between_diff_with_miles_and_flat
-    assert_in_delta 3.97, GeoKit::LatLng.distance_between(@loc_a, @loc_e, :units => :miles, :formula => :flat), 0.2
-    assert_in_delta 3.97, @loc_a.distance_to(@loc_e, :units => :miles, :formula => :flat), 0.2
-  end
-
-  def test_distance_between_diff_with_kms_and_flat
-    assert_in_delta 6.39, GeoKit::LatLng.distance_between(@loc_a, @loc_e, :units => :kms, :formula => :flat), 0.4
-    assert_in_delta 6.39, @loc_a.distance_to(@loc_e, :units => :kms, :formula => :flat), 0.4
-  end
-  
-  def test_distance_between_diff_with_miles_and_sphere
-    assert_in_delta 3.97, GeoKit::LatLng.distance_between(@loc_a, @loc_e, :units => :miles, :formula => :sphere), 0.01
-    assert_in_delta 3.97, @loc_a.distance_to(@loc_e, :units => :miles, :formula => :sphere), 0.01
-  end
-  
-  def test_distance_between_diff_with_kms_and_sphere
-    assert_in_delta 6.39, GeoKit::LatLng.distance_between(@loc_a, @loc_e, :units => :kms, :formula => :sphere), 0.01
-    assert_in_delta 6.39, @loc_a.distance_to(@loc_e, :units => :kms, :formula => :sphere), 0.01
-  end
-  
-  def test_manually_mixed_in
-    assert_equal 0, GeoKit::LatLng.distance_between(@point, @point)
-    assert_equal 0, @point.distance_to(@point)
-    assert_equal 0, @point.distance_to(@loc_a)
-    assert_in_delta 3.97, @point.distance_to(@loc_e, :units => :miles, :formula => :flat), 0.2
-    assert_in_delta 6.39, @point.distance_to(@loc_e, :units => :kms, :formula => :flat), 0.4
-  end
-  
-  def test_heading_between
-    assert_in_delta 332, GeoKit::LatLng.heading_between(@loc_a,@loc_e), 0.5
-  end
-
-  def test_heading_to
-    assert_in_delta 332, @loc_a.heading_to(@loc_e), 0.5
-  end  
-  
-  def test_class_endpoint
-    endpoint=GeoKit::LatLng.endpoint(@loc_a, 332, 3.97)
-    assert_in_delta @loc_e.lat, endpoint.lat, 0.0005
-    assert_in_delta @loc_e.lng, endpoint.lng, 0.0005
-  end
-
-  def test_instance_endpoint
-    endpoint=@loc_a.endpoint(332, 3.97)
-    assert_in_delta @loc_e.lat, endpoint.lat, 0.0005
-    assert_in_delta @loc_e.lng, endpoint.lng, 0.0005
-  end  
-  
-  def test_midpoint
-    midpoint=@loc_a.midpoint_to(@loc_e)
-    assert_in_delta 32.944061, midpoint.lat, 0.0005
-    assert_in_delta -96.974296, midpoint.lng, 0.0005    
-  end  
-  
-  def test_normalize
-    lat=37.7690
-    lng=-122.443
-    res=GeoKit::LatLng.normalize(lat,lng)
-    assert_equal res,GeoKit::LatLng.new(lat,lng) 
-    res=GeoKit::LatLng.normalize("#{lat}, #{lng}")
-    assert_equal res,GeoKit::LatLng.new(lat,lng) 
-    res=GeoKit::LatLng.normalize("#{lat} #{lng}")
-    assert_equal res,GeoKit::LatLng.new(lat,lng)
-    res=GeoKit::LatLng.normalize("#{lat.to_i} #{lng.to_i}")
-    assert_equal res,GeoKit::LatLng.new(lat.to_i,lng.to_i)    
-    res=GeoKit::LatLng.normalize([lat,lng])
-    assert_equal res,GeoKit::LatLng.new(lat,lng)
-  end
-    
-end
 \ No newline at end of file
@@ -1,44 +0,0 @@
-require File.join(File.dirname(__FILE__), 'base_geocoder_test')
-
-GeoKit::Geocoders::provider_order=[:google,:yahoo,:us]
-
-class MultiGeocoderTest < BaseGeocoderTest #:nodoc: all
-  
-  def setup
-    super
-    @failure = GeoKit::GeoLoc.new
-  end
-  
-  def test_successful_first
-    GeoKit::Geocoders::GoogleGeocoder.expects(:geocode).with(@address).returns(@success)
-    assert_equal @success, GeoKit::Geocoders::MultiGeocoder.geocode(@address)
-  end
-  
-  def test_failover
-    GeoKit::Geocoders::GoogleGeocoder.expects(:geocode).with(@address).returns(@failure)
-    GeoKit::Geocoders::YahooGeocoder.expects(:geocode).with(@address).returns(@success)
-    assert_equal @success, GeoKit::Geocoders::MultiGeocoder.geocode(@address)    
-  end
-  
-  def test_double_failover
-    GeoKit::Geocoders::GoogleGeocoder.expects(:geocode).with(@address).returns(@failure)
-    GeoKit::Geocoders::YahooGeocoder.expects(:geocode).with(@address).returns(@failure)
-    GeoKit::Geocoders::UsGeocoder.expects(:geocode).with(@address).returns(@success)
-    assert_equal @success, GeoKit::Geocoders::MultiGeocoder.geocode(@address)    
-  end
-  
-  def test_failure
-    GeoKit::Geocoders::GoogleGeocoder.expects(:geocode).with(@address).returns(@failure)
-    GeoKit::Geocoders::YahooGeocoder.expects(:geocode).with(@address).returns(@failure)
-    GeoKit::Geocoders::UsGeocoder.expects(:geocode).with(@address).returns(@failure)
-    assert_equal @failure, GeoKit::Geocoders::MultiGeocoder.geocode(@address)    
-  end
-
-  def test_invalid_provider
-    temp = GeoKit::Geocoders::provider_order
-    GeoKit::Geocoders.provider_order = [:bogus]
-    assert_equal @failure, GeoKit::Geocoders::MultiGeocoder.geocode(@address)    
-    GeoKit::Geocoders.provider_order = temp
-  end
-
-end
 \ No newline at end of file
@@ -1,31 +0,0 @@
-ActiveRecord::Schema.define(:version => 0) do
-  create_table :companies, :force => true do |t|
-    t.column :name, :string
-  end  
-  
-  create_table :locations, :force => true do |t|
-    t.column :company_id,  :integer, :default => 0,  :null => false
-    t.column :street,      :string,  :limit => 60
-    t.column :city,        :string,  :limit => 60
-    t.column :state,       :string,  :limit => 2
-    t.column :postal_code, :string,  :limit => 16
-    t.column :lat,         :decimal, :precision => 15, :scale => 10
-    t.column :lng,         :decimal, :precision => 15, :scale => 10
-  end
-  
-  create_table :custom_locations, :force => true do |t|
-    t.column :company_id,  :integer, :default => 0,  :null => false
-    t.column :street,      :string,  :limit => 60
-    t.column :city,        :string,  :limit => 60
-    t.column :state,       :string,  :limit => 2
-    t.column :postal_code, :string,  :limit => 16
-    t.column :latitude,    :decimal, :precision => 15, :scale => 10
-    t.column :longitude,   :decimal, :precision => 15, :scale => 10
-  end
-  
-  create_table :stores, :force=> true do |t|
-    t.column :address,     :string
-    t.column :lat,         :decimal, :precision => 15, :scale => 10
-    t.column :lng,         :decimal, :precision => 15, :scale => 10
-  end
-end
 \ No newline at end of file
@@ -1,27 +0,0 @@
-require File.dirname(__FILE__) + '/test_helper'
-
-if ActiveRecord::Base.connection.adapter_name =~ /^sqlite$/i
-
-  # this test only makes sense when using sqlite
-  class SQliteExtensionTest < Test::Unit::TestCase
-  
-    def test_pow_function
-      assert_in_delta 8.0, ActiveRecord::Base.connection.execute('select pow(2.0, 3.0) as result').first['result'], 0.0001
-    end
-  
-    def test_radians_function
-      assert_in_delta Math::PI/2, ActiveRecord::Base.connection.execute('select radians(90) as rad').first['rad'], 0.0001
-    end
-  
-    def test_sqrt_function
-      assert_in_delta 1.4142, ActiveRecord::Base.connection.execute('select sqrt(2) as sqrt').first['sqrt'], 0.0001
-    end
-  
-    def test_spheric_distance_function
-      args = [32.918593, -96.958444, 32.951613, -96.958444].map{|l|l * Math::PI/180}
-      assert_in_delta 2.28402, ActiveRecord::Base.connection.execute("select spheric_distance(#{args.inspect[1..-2]}, 3963.19) as dist").first['dist'], 0.0001
-    end
-  
-  end
-
-end
@@ -1,20 +0,0 @@
-require 'test/unit'
-
-plugin_test_dir = File.dirname(__FILE__)
-
-# Load the Rails environment
-require File.join(plugin_test_dir, '../../../../config/environment')
-require 'active_record/fixtures'
-databases = YAML::load(IO.read(plugin_test_dir + '/database.yml'))
-ActiveRecord::Base.logger = Logger.new(plugin_test_dir + "/debug.log")
-
-# A specific database can be used by setting the DB environment variable
-ActiveRecord::Base.establish_connection(databases[ENV['DB'] || 'mysql'])
-
-# Load the test schema into the database
-load(File.join(plugin_test_dir, 'schema.rb'))
-
-# Load fixtures from the plugin
-Test::Unit::TestCase.fixture_path = File.join(plugin_test_dir, 'fixtures/')
-
-require File.join(plugin_test_dir, '..', 'lib', 'geo_kit', 'sqlite_extension')
@@ -1,47 +0,0 @@
-require File.join(File.dirname(__FILE__), 'base_geocoder_test')
-
-GeoKit::Geocoders::geocoder_us = nil
-
-class UsGeocoderTest < BaseGeocoderTest #:nodoc: all
-  
-  GEOCODER_US_FULL='37.792528,-122.393981,100 Spear St,San Francisco,CA,94105'  
-  
-  def setup
-    super
-    @us_full_hash = {:city=>"San Francisco", :state=>"CA"}
-    @us_full_loc = GeoKit::GeoLoc.new(@us_full_hash)
-  end  
-  
-  def test_geocoder_us
-    response = MockSuccess.new
-    response.expects(:body).returns(GEOCODER_US_FULL)
-    url = "http://geocoder.us/service/csv/geocode?address=#{CGI.escape(@address)}"
-    GeoKit::Geocoders::UsGeocoder.expects(:call_geocoder_service).with(url).returns(response)
-    verify(GeoKit::Geocoders::UsGeocoder.geocode(@address))
-  end
-  
-  def test_geocoder_with_geo_loc
-    response = MockSuccess.new
-    response.expects(:body).returns(GEOCODER_US_FULL)
-    url = "http://geocoder.us/service/csv/geocode?address=#{CGI.escape(@address)}"
-    GeoKit::Geocoders::UsGeocoder.expects(:call_geocoder_service).with(url).returns(response)
-    verify(GeoKit::Geocoders::UsGeocoder.geocode(@us_full_loc))    
-  end
-  
-  def test_service_unavailable
-    response = MockFailure.new
-    url = "http://geocoder.us/service/csv/geocode?address=#{CGI.escape(@address)}"
-    GeoKit::Geocoders::UsGeocoder.expects(:call_geocoder_service).with(url).returns(response)
-    assert !GeoKit::Geocoders::UsGeocoder.geocode(@us_full_loc).success   
-  end  
-  
-  private
-  
-  def verify(location)
-    assert_equal "CA", location.state
-    assert_equal "San Francisco", location.city 
-    assert_equal "37.792528,-122.393981", location.ll 
-    assert location.is_us?
-    assert_equal "100 Spear St, San Francisco, CA, 94105, US", location.full_address  #slightly different from yahoo    
-  end
-end
 \ No newline at end of file
@@ -1,87 +0,0 @@
-require File.join(File.dirname(__FILE__), 'base_geocoder_test')
-
-GeoKit::Geocoders::yahoo = 'Yahoo'
-
-class YahooGeocoderTest < BaseGeocoderTest #:nodoc: all
-    YAHOO_FULL=<<-EOF.strip
-  <?xml version="1.0"?>
-  <ResultSet xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns="urn:yahoo:maps" xsi:schemaLocation="urn:yahoo:maps http://api.local.yahoo.com/MapsService/V1/GeocodeResponse.xsd"><Result precision="address"><Latitude>37.792406</Latitude><Longitude>-122.39411</Longitude><Address>100 SPEAR ST</Address><City>SAN FRANCISCO</City><State>CA</State><Zip>94105-1522</Zip><Country>US</Country></Result></ResultSet>
-  <!-- ws01.search.scd.yahoo.com uncompressed/chunked Mon Jan 29 16:23:43 PST 2007 -->
-    EOF
-
-    YAHOO_CITY=<<-EOF.strip
-  <?xml version="1.0"?>
-  <ResultSet xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns="urn:yahoo:maps" xsi:schemaLocation="urn:yahoo:maps http://api.local.yahoo.com/MapsService/V1/GeocodeResponse.xsd"><Result precision="city"><Latitude>37.7742</Latitude><Longitude>-122.417068</Longitude><Address></Address><City>SAN FRANCISCO</City><State>CA</State><Zip></Zip><Country>US</Country></Result></ResultSet>
-  <!-- ws02.search.scd.yahoo.com uncompressed/chunked Mon Jan 29 18:00:28 PST 2007 -->
-    EOF
-    
-  def setup
-    super
-    @yahoo_full_hash = {:street_address=>"100 Spear St", :city=>"San Francisco", :state=>"CA", :zip=>"94105-1522", :country_code=>"US"}
-    @yahoo_city_hash = {:city=>"San Francisco", :state=>"CA"}
-    @yahoo_full_loc = GeoKit::GeoLoc.new(@yahoo_full_hash)
-    @yahoo_city_loc = GeoKit::GeoLoc.new(@yahoo_city_hash)
-  end
-  
-  # the testing methods themselves
-  def test_yahoo_full_address
-    response = MockSuccess.new
-    response.expects(:body).returns(YAHOO_FULL)
-    url = "http://api.local.yahoo.com/MapsService/V1/geocode?appid=Yahoo&location=#{CGI.escape(@address)}"
-    GeoKit::Geocoders::YahooGeocoder.expects(:call_geocoder_service).with(url).returns(response)
-    do_full_address_assertions(GeoKit::Geocoders::YahooGeocoder.geocode(@address))
-  end 
-  
-  def test_yahoo_full_address_with_geo_loc
-    response = MockSuccess.new
-    response.expects(:body).returns(YAHOO_FULL)
-    url = "http://api.local.yahoo.com/MapsService/V1/geocode?appid=Yahoo&location=#{CGI.escape(@full_address)}"
-    GeoKit::Geocoders::YahooGeocoder.expects(:call_geocoder_service).with(url).returns(response)
-    do_full_address_assertions(GeoKit::Geocoders::YahooGeocoder.geocode(@yahoo_full_loc))
-  end  
-
-  def test_yahoo_city
-    response = MockSuccess.new
-    response.expects(:body).returns(YAHOO_CITY)
-    url = "http://api.local.yahoo.com/MapsService/V1/geocode?appid=Yahoo&location=#{CGI.escape(@address)}"
-    GeoKit::Geocoders::YahooGeocoder.expects(:call_geocoder_service).with(url).returns(response)
-    do_city_assertions(GeoKit::Geocoders::YahooGeocoder.geocode(@address))
-  end
-  
-  def test_yahoo_city_with_geo_loc
-    response = MockSuccess.new
-    response.expects(:body).returns(YAHOO_CITY)
-    url = "http://api.local.yahoo.com/MapsService/V1/geocode?appid=Yahoo&location=#{CGI.escape(@address)}"  
-    GeoKit::Geocoders::YahooGeocoder.expects(:call_geocoder_service).with(url).returns(response)
-    do_city_assertions(GeoKit::Geocoders::YahooGeocoder.geocode(@yahoo_city_loc))
-  end  
-  
-  def test_service_unavailable
-    response = MockFailure.new
-    url = "http://api.local.yahoo.com/MapsService/V1/geocode?appid=Yahoo&location=#{CGI.escape(@address)}"
-    GeoKit::Geocoders::YahooGeocoder.expects(:call_geocoder_service).with(url).returns(response)
-    assert !GeoKit::Geocoders::YahooGeocoder.geocode(@yahoo_city_loc).success
-  end  
-
-  private
-
-  # next two methods do the assertions for both address-level and city-level lookups
-  def do_full_address_assertions(res)
-    assert_equal "CA", res.state
-    assert_equal "San Francisco", res.city
-    assert_equal "37.792406,-122.39411", res.ll
-    assert res.is_us?
-    assert_equal "100 Spear St, San Francisco, CA, 94105-1522, US", res.full_address
-    assert_equal "yahoo", res.provider
-  end
-  
-  def do_city_assertions(res)
-    assert_equal "CA", res.state
-    assert_equal "San Francisco", res.city 
-    assert_equal "37.7742,-122.417068", res.ll
-    assert res.is_us?
-    assert_equal "San Francisco, CA, US", res.full_address 
-    assert_nil res.street_address
-    assert_equal "yahoo", res.provider
-  end  
-end
 \ No newline at end of file
...	...	@@ -126,16 +126,6 @@ class ProductTest < ActiveSupport::TestCase
126	126	assert_in_delta 45.0, prod.lng, 0.0001
127	127	end
128	128
129		- should 'be searched by radius and distance' do
130		- prod1 = fast_create(Product, :name => 'prod test 1', :lat => 30.0, :lng => 30.0, :product_category_id => @product_category.id)
131		- prod2 = fast_create(Product, :name => 'prod test 2', :lat => 45.0, :lng => 45.0, :product_category_id => @product_category.id)
132		-
133		- prods = Product.find(:all, :within => 10, :origin => [30.0, 30.0])
134		-
135		- assert_includes prods, prod1
136		- assert_not_includes prods, prod2
137		- end
138		-
139	129	should 'provide url' do
140	130	product = Product.new
141	131
...	...
...	...	@@ -439,12 +439,6 @@ class ProfileTest < ActiveSupport::TestCase
439	439	assert_includes Enterprise.find_within(2, :origin => [45, 45]), e
440	440	end
441	441
442		- should 'have latitude and longitude and find' do
443		- e = fast_create(Enterprise, :lat => 45, :lng => 45)
444		-
445		- assert_includes Enterprise.find(:all, :within => 2, :origin => [45, 45]), e
446		- end
447		-
448	442	should 'have a public profile by default' do
449	443	assert_equal true, Profile.new.public_profile
450	444	end
...	...
...	...	@@ -1,20 +0,0 @@
1		-Copyright (c) 2007 Bill Eisenhauer & Andre Lewis
2		-
3		-Permission is hereby granted, free of charge, to any person obtaining
4		-a copy of this software and associated documentation files (the
5		-"Software"), to deal in the Software without restriction, including
6		-without limitation the rights to use, copy, modify, merge, publish,
7		-distribute, sublicense, and/or sell copies of the Software, and to
8		-permit persons to whom the Software is furnished to do so, subject to
9		-the following conditions:
10		-
11		-The above copyright notice and this permission notice shall be
12		-included in all copies or substantial portions of the Software.
13		-
14		-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
15		-EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
16		-MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
17		-NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
18		-LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
19		-OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
20		-WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
21	0	\ No newline at end of file
...	...	@@ -1,451 +0,0 @@
1		-## FEATURE SUMMARY
2		-
3		-This plugin provides key functionality for location-oriented Rails applications:
4		-
5		-- Distance calculations, for both flat and spherical environments. For example,
6		- given the location of two points on the earth, you can calculate the miles/KM
7		- between them.
8		-- ActiveRecord distance-based finders. For example, you can find all the points
9		- in your database within a 50-mile radius.
10		-- Geocoding from multiple providers. It currently supports Google, Yahoo,
11		- Geocoder.us, and Geocoder.ca geocoders, and it provides a uniform response
12		- structure from all of them. It also provides a fail-over mechanism, in case
13		- your input fails to geocode in one service.
14		-- IP-based location lookup utilizing hostip.info. Provide an IP address, and get
15		- city name and latitude/longitude in return
16		-- A before_filter helper to geocoder the user's location based on IP address,
17		- and retain the location in a cookie.
18		-
19		-The goal of this plugin is to provide the common functionality for location-oriented
20		-applications (geocoding, location lookup, distance calculation) in an easy-to-use
21		-package.
22		-
23		-## A NOTE ON TERMINOLOGY
24		-
25		-Throughout the code and API of this, latitude and longitude are referred to as lat
26		-and lng. We've found over the long term the abbreviation saves lots of typing time.
27		-
28		-## DISTANCE CALCULATIONS AND QUERIES
29		-
30		-If you want only distance calculation services, you need only mix in the Mappable
31		-module like so:
32		-
33		- class Location
34		- include GeoKit::Mappable
35		- end
36		-
37		-After doing so, you can do things like:
38		-
39		- Location.distance_between(from, to)
40		-
41		-with optional parameters :units and :formula. Values for :units can be :miles or
42		-:kms with :miles as the default. Values for :formula can be :sphere or :flat with
43		-:sphere as the default. :sphere gives you Haversine calculations, while :flat
44		-gives the Pythagoreum Theory. These defaults persist through out the plug-in.
45		-
46		-You can also do:
47		-
48		- location.distance_to(other)
49		-
50		-The real power and utility of the plug-in is in its query support. This is
51		-achieved through mixing into an ActiveRecord model object:
52		-
53		- class Location < ActiveRecord::Base
54		- acts_as_mappable
55		- end
56		-
57		-The plug-in uses the above-mentioned defaults, but can be modified to use
58		-different units and a different formulae. This is done through the :default_units
59		-and :default_formula keys which accept the same values as mentioned above.
60		-
61		-The plug-in creates a calculated column and potentially a calculated condition.
62		-By default, these are known as "distance" but this can be changed through the
63		-:distance_field_name key.
64		-
65		-So, an alternative invocation would look as below:
66		-
67		- class Location < ActiveRecord::Base
68		- acts_as_mappable :default_units => :kms,
69		- :default_formula => :flat,
70		- :distance_field_name => :distance
71		- end
72		-
73		-You can also define alternative column names for latitude and longitude using
74		-the :lat_column_name and :lng_column_name keys. The defaults are 'lat' and
75		-'lng' respectively.
76		-
77		-Thereafter, a set of finder methods are made available. Below are the
78		-different combinations:
79		-
80		-Origin as a two-element array of latititude/longitude:
81		-
82		- find(:all, :origin => [37.792,-122.393])
83		-
84		-Origin as a geocodeable string:
85		-
86		- find(:all, :origin => '100 Spear st, San Francisco, CA')
87		-
88		-Origin as an object which responds to lat and lng methods,
89		-or latitude and longitude methods, or whatever methods you have
90		-specified for lng_column_name and lat_column_name:
91		-
92		- find(:all, :origin=>my_store) # my_store.lat and my_store.lng methods exist
93		-
94		-Often you will need to find within a certain distance. The prefered syntax is:
95		-
96		- find(:all, :origin => @somewhere, :within => 5)
97		-
98		-. . . however these syntaxes will also work:
99		-
100		- find_within(5, :origin => @somewhere)
101		- find(:all, :origin => @somewhere, :conditions => "distance < 5")
102		-
103		-Note however that the third form should be avoided. With either of the first two,
104		-GeoKit automatically adds a bounding box to speed up the radial query in the database.
105		-With the third form, it does not.
106		-
107		-If you need to combine distance conditions with other conditions, you should do
108		-so like this:
109		-
110		- find(:all, :origin => @somewhere, :within => 5, :conditions=>['state=?',state])
111		-
112		-If :origin is not provided in the finder call, the find method
113		-works as normal. Further, the key is removed
114		-from the :options hash prior to invoking the superclass behavior.
115		-
116		-Other convenience methods work intuitively and are as follows:
117		-
118		- find_within(distance, :origin => @somewhere)
119		- find_beyond(distance, :origin => @somewhere)
120		- find_closest(:origin => @somewhere)
121		- find_farthest(:origin => @somewhere)
122		-
123		-where the options respect the defaults, but can be overridden if
124		-desired.
125		-
126		-Lastly, if all that is desired is the raw SQL for distance
127		-calculations, you can use the following:
128		-
129		- distance_sql(origin, units=default_units, formula=default_formula)
130		-
131		-Thereafter, you are free to use it in find_by_sql as you wish.
132		-
133		-There are methods available to enable you to get the count based upon
134		-the find condition that you have provided. These all work similarly to
135		-the finders. So for instance:
136		-
137		- count(:origin, :conditions => "distance < 5")
138		- count_within(distance, :origin => @somewhere)
139		- count_beyond(distance, :origin => @somewhere)
140		-
141		-## FINDING WITHIN A BOUNDING BOX
142		-
143		-If you are displaying points on a map, you probably need to query for whatever falls within the rectangular bounds of the map:
144		-
145		- Store.find :all, :bounds=>[sw_point,ne_point]
146		-
147		-The input to :bounds can be array with the two points or a Bounds object. However you provide them, the order should always be the southwest corner, northeast corner of the rectangle. Typically, you will be getting the sw_point and ne_point from a map that is displayed on a web page.
148		-
149		-If you need to calculate the bounding box from a point and radius, you can do that:
150		-
151		- bounds=Bounds.from_point_and_radius(home,5)
152		- Store.find :all, :bounds=>bounds
153		-
154		-## USING INCLUDES
155		-
156		-You can use includes along with your distance finders:
157		-
158		- stores=Store.find :all, :origin=>home, :include=>[:reviews,:cities] :within=>5, :order=>'distance'
159		-
160		-However, ActiveRecord drops the calculated distance column when you use include. So, if you need to
161		-use the distance column, you'll have to re-calculate it post-query in Ruby:
162		-
163		- stores.sort_by_distance_from(home)
164		-
165		-In this case, you may want to just use the bounding box
166		-condition alone in your SQL (there's no use calculating the distance twice):
167		-
168		- bounds=Bounds.from_point_and_radius(home,5)
169		- stores=Store.find :all, :include=>[:reviews,:cities] :bounds=>bounds
170		- stores.sort_by_distance_from(home)
171		-
172		-## IP GEOCODING
173		-
174		-You can obtain the location for an IP at any time using the geocoder
175		-as in the following example:
176		-
177		- location = IpGeocoder.geocode('12.215.42.19')
178		-
179		-where Location is a GeoLoc instance containing the latitude,
180		-longitude, city, state, and country code. Also, the success
181		-value is true.
182		-
183		-If the IP cannot be geocoded, a GeoLoc instance is returned with a
184		-success value of false.
185		-
186		-It should be noted that the IP address needs to be visible to the
187		-Rails application. In other words, you need to ensure that the
188		-requesting IP address is forwarded by any front-end servers that
189		-are out in front of the Rails app. Otherwise, the IP will always
190		-be that of the front-end server.
191		-
192		-## IP GEOCODING HELPER
193		-
194		-A class method called geocode_ip_address has been mixed into the
195		-ActionController::Base. This enables before_filter style lookup of
196		-the IP address. Since it is a filter, it can accept any of the
197		-available filter options.
198		-
199		-Usage is as below:
200		-
201		- class LocationAwareController < ActionController::Base
202		- geocode_ip_address
203		- end
204		-
205		-A first-time lookup will result in the GeoLoc class being stored
206		-in the session as :geo_location as well as in a cookie called
207		-:geo_session. Subsequent lookups will use the session value if it
208		-exists or the cookie value if it doesn't exist. The last resort is
209		-to make a call to the web service. Clients are free to manage the
210		-cookie as they wish.
211		-
212		-The intent of this feature is to be able to provide a good guess as
213		-to a new visitor's location.
214		-
215		-## INTEGRATED FIND AND GEOCODING
216		-
217		-Geocoding has been integrated with the finders enabling you to pass
218		-a physical address or an IP address. This would look the following:
219		-
220		- Location.find_farthest(:origin => '217.15.10.9')
221		- Location.find_farthest(:origin => 'Irving, TX')
222		-
223		-where the IP or physical address would be geocoded to a location and
224		-then the resulting latitude and longitude coordinates would be used
225		-in the find. This is not expected to be common usage, but it can be
226		-done nevertheless.
227		-
228		-## ADDRESS GEOCODING
229		-
230		-GeoKit can geocode addresses using multiple geocodeing web services.
231		-Currently, GeoKit supports Google, Yahoo, and Geocoder.us geocoding
232		-services.
233		-
234		-These geocoder services are made available through three classes:
235		-GoogleGeocoder, YahooGeocoder, and UsGeocoder. Further, an additional
236		-geocoder class called MultiGeocoder incorporates an ordered failover
237		-sequence to increase the probability of successful geocoding.
238		-
239		-All classes are called using the following signature:
240		-
241		- include GeoKit::Geocoders
242		- location = XxxGeocoder.geocode(address)
243		-
244		-where you replace Xxx Geocoder with the appropriate class. A GeoLoc
245		-instance is the result of the call. This class has a "success"
246		-attribute which will be true if a successful geocoding occurred.
247		-If successful, the lat and lng properties will be populated.
248		-
249		-Geocoders are named with the naming convention NameGeocoder. This
250		-naming convention enables Geocoder to auto-detect its sub-classes
251		-in order to create methods called name_geocoder(address) so that
252		-all geocoders are called through the base class. This is done
253		-purely for convenience; the individual geocoder classes are expected
254		-to be used independently.
255		-
256		-The MultiGeocoder class requires the configuration of a provider
257		-order which dictates what order to use the various geocoders. Ordering
258		-is done through the PROVIDER_ORDER constant found in environment.rb.
259		-
260		-On installation, this plugin appends a template for your API keys to
261		-your environment.rb.
262		-
263		-Make sure your failover configuration matches the usage characteristics
264		-of your application -- for example, if you routinely get bogus input to
265		-geocode, your code will be much slower if you have to failover among
266		-multiple geocoders before determining that the input was in fact bogus.
267		-
268		-The Geocoder.geocode method returns a GeoLoc object. Basic usage:
269		-
270		- loc=Geocoder.geocode('100 Spear St, San Francisco, CA')
271		- if loc.success
272		- puts loc.lat
273		- puts loc.lng
274		- puts loc.full_address
275		- end
276		-
277		-## INTEGRATED FIND WITH ADDRESS GEOCODING
278		-
279		-Just has you can pass an IP address directly into an ActiveRecord finder
280		-as the origin, you can also pass a physical address as the origin:
281		-
282		- Location.find_closest(:origin => '100 Spear st, San Francisco, CA')
283		-
284		-where the physical address would be geocoded to a location and then the
285		-resulting latitude and longitude coordinates would be used in the
286		-find.
287		-
288		-Note that if the address fails to geocode, the find method will raise an
289		-ActiveRecord::GeocodeError you must be prepared to catch. Alternatively,
290		-You can geocoder the address beforehand, and pass the resulting lat/lng
291		-into the finder if successful.
292		-
293		-## Auto Geocoding
294		-
295		-If your geocoding needs are simple, you can tell your model to automatically
296		-geocode itself on create:
297		-
298		- class Store < ActiveRecord::Base
299		- acts_as_mappable :auto_geocode=>true
300		- end
301		-
302		-It takes two optional params:
303		-
304		- class Store < ActiveRecord::Base
305		- acts_as_mappable :auto_geocode=>{:field=>:address, :error_message=>'Could not geocode address'}
306		- end
307		-
308		-. . . which is equivilent to:
309		-
310		- class Store << ActiveRecord::Base
311		- acts_as_mappable
312		- before_validation_on_create :geocode_address
313		-
314		- private
315		- def geocode_address
316		- geo=GeoKit::Geocoders::MultiGeocoder.geocode (address)
317		- errors.add(:address, "Could not Geocode address") if !geo.success
318		- self.lat, self.lng = geo.lat,geo.lng if geo.success
319		- end
320		- end
321		-
322		-If you need any more complicated geocoding behavior for your model, you should roll your own
323		-before_validate callback.
324		-
325		-
326		-## Distances, headings, endpoints, and midpoints
327		-
328		- distance=home.distance_from(work, :units=>:miles)
329		- heading=home.heading_to(work) # result is in degrees, 0 is north
330		- endpoint=home.endpoint(90,2) # two miles due east
331		- midpoing=home.midpoint_to(work)
332		-
333		-## Cool stuff you can do with bounds
334		-
335		- bounds=Bounds.new(sw_point,ne_point)
336		- bounds.contains?(home)
337		- puts bounds.center
338		-
339		-
340		-HOW TO . . .
341		-=================================================================================
342		-
343		-## How to install the GeoKit plugin
344		- cd [APP_ROOT]
345		- ruby script/plugin install svn://rubyforge.org/var/svn/geokit/trunk
346		- or, to install as an external (your project must be version controlled):
347		- ruby script/plugin install -x svn://rubyforge.org/var/svn/geokit/trunk
348		-
349		-## How to find all stores within a 10-mile radius of a given lat/lng
350		-1. ensure your stores table has lat and lng columns with numeric or float
351		- datatypes to store your latitude/longitude
352		-
353		-3. use acts_as_mappable on your store model:
354		- class Store < ActiveRecord::Base
355		- acts_as_mappable
356		- ...
357		- end
358		-3. finders now have extra capabilities:
359		- Store.find(:all, :origin =>[32.951613,-96.958444], :within=>10)
360		-
361		-## How to geocode an address
362		-
363		-1. configure your geocoder key(s) in environment.rb
364		-
365		-2. also in environment.rb, make sure that PROVIDER_ORDER reflects the
366		- geocoder(s). If you only want to use one geocoder, there should
367		- be only one symbol in the array. For example:
368		- PROVIDER_ORDER=[:google]
369		-
370		-3. Test it out in script/console
371		- include GeoKit::Geocoders
372		- res = MultiGeocoder.geocode('100 Spear St, San Francisco, CA')
373		- puts res.lat
374		- puts res.lng
375		- puts res.full_address
376		- ... etc. The return type is GeoLoc, see the API for
377		- all the methods you can call on it.
378		-
379		-## How to find all stores within 10 miles of a given address
380		-
381		-1. as above, ensure your table has the lat/lng columns, and you've
382		- applied acts_as_mappable to the Store model.
383		-
384		-2. configure and test out your geocoder, as above
385		-
386		-3. pass the address in under the :origin key
387		- Store.find(:all, :origin=>'100 Spear st, San Francisco, CA',
388		- :within=>10)
389		-
390		-4. you can also use a zipcode, or anything else that's geocodable:
391		- Store.find(:all, :origin=>'94117',
392		- :conditions=>'distance<10')
393		-
394		-## How to sort a query by distance from an origin
395		-
396		-You now have access to a 'distance' column, and you can use it
397		-as you would any other column. For example:
398		- Store.find(:all, :origin=>'94117', :order=>'distance')
399		-
400		-## How to elements of an array according to distance from a common point
401		-
402		-Usually, you can do your sorting in the database as part of your find call.
403		-If you need to sort things post-query, you can do so:
404		-
405		- stores=Store.find :all
406		- stores.sort_by_distance_from(home)
407		- puts stores.first.distance
408		-
409		-Obviously, each of the items in the array must have a latitude/longitude so
410		-they can be sorted by distance.
411		-
412		-Database Compatability
413		-=================================================================================
414		-GeoKit does not work with SQLite, as it lacks the necessary geometry functions.
415		-GeoKit works with MySQL (tested with version 5.0.41) or PostgreSQL (tested with version 8.2.6)
416		-GeoKit is known to not work with Postgres <8.1 -- it uses the least() funciton.
417		-
418		-
419		-HIGH-LEVEL NOTES ON WHAT'S WHERE
420		-=================================================================================
421		-
422		-acts_as_mappable.rb, as you'd expect, contains the ActsAsMappable
423		-module which gets mixed into your models to provide the
424		-location-based finder goodness.
425		-
426		-mappable.rb contains the Mappable module, which provides basic
427		-distance calculation methods, i.e., calculating the distance
428		-between two points.
429		-
430		-mappable.rb also contains LatLng, GeoLoc, and Bounds.
431		-LatLng is a simple container for latitude and longitude, but
432		-it's made more powerful by mixing in the above-mentioned Mappable
433		-module -- therefore, you can calculate easily the distance between two
434		-LatLng ojbects with distance = first.distance_to(other)
435		-
436		-GeoLoc (also in mappable.rb) represents an address or location which
437		-has been geocoded. You can get the city, zipcode, street address, etc.
438		-from a GeoLoc object. GeoLoc extends LatLng, so you also get lat/lng
439		-AND the Mappable modeule goodness for free.
440		-
441		-geocoders.rb contains the geocoder classes.
442		-
443		-ip_geocode_lookup.rb contains the before_filter helper method which
444		-enables auto lookup of the requesting IP address.
445		-
446		-## IMPORTANT NOTE: We have appended to your environment.rb file
447		-
448		-Installation of this plugin has appended an API key template
449		-to your environment.rb file. You must add your own keys for the various
450		-geocoding services if you want to use geocoding. If you need to refer to the original
451		-template again, see the api_keys_template file in the root of the plugin.
...	...	@@ -1,22 +0,0 @@
1		-require 'rake'
2		-require 'rake/testtask'
3		-require 'rake/rdoctask'
4		-
5		-desc 'Default: run unit tests.'
6		-task :default => :test
7		-
8		-desc 'Test the GeoKit plugin.'
9		-Rake::TestTask.new(:test) do \|t\|
10		- t.libs << 'lib'
11		- t.pattern = 'test/*/_test.rb'
12		- t.verbose = true
13		-end
14		-
15		-desc 'Generate documentation for the GeoKit plugin.'
16		-Rake::RDocTask.new(:rdoc) do \|rdoc\|
17		- rdoc.rdoc_dir = 'rdoc'
18		- rdoc.title = 'GeoKit'
19		- rdoc.options << '--line-numbers' << '--inline-source'
20		- rdoc.rdoc_files.include('README')
21		- rdoc.rdoc_files.include('lib/*/.rb')
22		-end
23	0	\ No newline at end of file
...	...	@@ -1,4 +0,0 @@
1		-01/20/08 Version 1.0.1. Further fix of distance calculation, this time in SQL. Now uses least() function, which is available in MySQL version 3.22.5+ and postgres versions 8.1+
2		-01/16/08 fixed the "zero-distance" bug (calculating between two points that are the same)
3		-12/11/07 fixed a small but with queries crossing meridian, and also fixed find(:closest)
4		-10/11/07 Fixed Rails2/Edge compatability
5	0	\ No newline at end of file
...	...	@@ -1,9 +0,0 @@
1		-author:
2		- name_1: Bill Eisenhauer
3		- homepage_1: http://blog.billeisenhauer.com
4		- name_2: Andre Lewis
5		- homepage_2: http://www.earthcode.com
6		-summary: Geo distance calculations, distance calculation query support, geocoding for physical and ip addresses.
7		-version: 1.0.1
8		-rails_version: 1.0+
9		-license: MIT
10	0	\ No newline at end of file
...	...	@@ -1,50 +0,0 @@
1		-# These defaults are used in GeoKit::Mappable.distance_to and in acts_as_mappable
2		-GeoKit::default_units = :miles
3		-GeoKit::default_formula = :sphere
4		-
5		-# This is the timeout value in seconds to be used for calls to the geocoder web
6		-# services. For no timeout at all, comment out the setting. The timeout unit
7		-# is in seconds.
8		-GeoKit::Geocoders::timeout = 3
9		-
10		-# These settings are used if web service calls must be routed through a proxy.
11		-# These setting can be nil if not needed, otherwise, addr and port must be
12		-# filled in at a minimum. If the proxy requires authentication, the username
13		-# and password can be provided as well.
14		-GeoKit::Geocoders::proxy_addr = nil
15		-GeoKit::Geocoders::proxy_port = nil
16		-GeoKit::Geocoders::proxy_user = nil
17		-GeoKit::Geocoders::proxy_pass = nil
18		-
19		-# This is your yahoo application key for the Yahoo Geocoder.
20		-# See http://developer.yahoo.com/faq/index.html#appid
21		-# and http://developer.yahoo.com/maps/rest/V1/geocode.html
22		-GeoKit::Geocoders::yahoo = 'REPLACE_WITH_YOUR_YAHOO_KEY'
23		-
24		-# This is your Google Maps geocoder key.
25		-# See http://www.google.com/apis/maps/signup.html
26		-# and http://www.google.com/apis/maps/documentation/#Geocoding_Examples
27		-GeoKit::Geocoders::google = 'REPLACE_WITH_YOUR_GOOGLE_KEY'
28		-
29		-# This is your username and password for geocoder.us.
30		-# To use the free service, the value can be set to nil or false. For
31		-# usage tied to an account, the value should be set to username:password.
32		-# See http://geocoder.us
33		-# and http://geocoder.us/user/signup
34		-GeoKit::Geocoders::geocoder_us = false
35		-
36		-# This is your authorization key for geocoder.ca.
37		-# To use the free service, the value can be set to nil or false. For
38		-# usage tied to an account, set the value to the key obtained from
39		-# Geocoder.ca.
40		-# See http://geocoder.ca
41		-# and http://geocoder.ca/?register=1
42		-GeoKit::Geocoders::geocoder_ca = false
43		-
44		-# This is the order in which the geocoders are called in a failover scenario
45		-# If you only want to use a single geocoder, put a single symbol in the array.
46		-# Valid symbols are :google, :yahoo, :us, and :ca.
47		-# Be aware that there are Terms of Use restrictions on how you can use the
48		-# various geocoders. Make sure you read up on relevant Terms of Use for each
49		-# geocoder you are going to use.
50		-GeoKit::Geocoders::provider_order = [:google,:us]
51	0	\ No newline at end of file
...	...	@@ -1,14 +0,0 @@
1		-# Load modules and classes needed to automatically mix in ActiveRecord and
2		-# ActionController helpers. All other functionality must be explicitly
3		-# required.
4		-require 'geo_kit/defaults'
5		-require 'geo_kit/mappable'
6		-require 'geo_kit/acts_as_mappable'
7		-require 'geo_kit/ip_geocode_lookup'
8		-require 'geo_kit/sqlite_extension'
9		-
10		-# Automatically mix in distance finder support into ActiveRecord classes.
11		-ActiveRecord::Base.send :include, GeoKit::ActsAsMappable
12		-
13		-# Automatically mix in ip geocoding helpers into ActionController classes.
14		-ActionController::Base.send :include, GeoKit::IpGeocodeLookup
...	...	@@ -1,7 +0,0 @@
1		-# Display to the console the contents of the README file.
2		-puts IO.read(File.join(File.dirname(__FILE__), 'README'))
3		-
4		-# Append the contents of api_keys_template to the application's environment.rb file
5		-environment_rb = File.open(File.expand_path(File.join(File.dirname(__FILE__), '../../../config/environment.rb')), "a")
6		-environment_rb.puts IO.read(File.join(File.dirname(__FILE__), '/assets/api_keys_template'))
7		-environment_rb.close