geokit-premier 0.0.4 → 0.0.5

data/.gitignore

@@ -0,0 +1,6 @@
+.loadpath
+.project
+pkg
+.idea
+.bundle
+.rvmrc

data/Gemfile

@@ -0,0 +1,9 @@
+source "http://rubygems.org"
+
+# source 'http://rubygems.org'
+# source 'http://gemcutter.org'
+# gem 'rspec-mocks', ">= 2.0.0.beta.23"
+# gem "rspec-rails", ">= 2.0.0.beta.23"
+
+# Specify your gem's dependencies in geokit-premier.gemspec
+gemspec

data/Gemfile.lock

@@ -0,0 +1,58 @@
+PATH
+  remote: .
+  specs:
+    geokit-premier (0.0.5)
+      hoe
+      json_pure
+
+GEM
+  remote: http://rubygems.org/
+  specs:
+    ZenTest (4.4.2)
+    activemodel (3.0.3)
+      activesupport (= 3.0.3)
+      builder (~> 2.1.2)
+      i18n (~> 0.4)
+    activerecord (3.0.3)
+      activemodel (= 3.0.3)
+      activesupport (= 3.0.3)
+      arel (~> 2.0.2)
+      tzinfo (~> 0.3.23)
+    activesupport (3.0.3)
+    arel (2.0.7)
+    autotest (4.4.2)
+    builder (2.1.2)
+    diff-lcs (1.1.2)
+    hoe (2.8.0)
+      rake (>= 0.8.7)
+    i18n (0.5.0)
+    json_pure (1.4.6)
+    mysql (2.8.1)
+    rake (0.8.7)
+    rspec (2.0.1)
+      rspec-core (~> 2.0.1)
+      rspec-expectations (~> 2.0.1)
+      rspec-mocks (~> 2.0.1)
+    rspec-core (2.0.1)
+    rspec-expectations (2.0.1)
+      diff-lcs (>= 1.1.2)
+    rspec-mocks (2.0.1)
+      rspec-core (~> 2.0.1)
+      rspec-expectations (~> 2.0.1)
+    standalone_migrations (0.3.0)
+      activerecord
+      rake
+    tzinfo (0.3.24)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  ZenTest
+  autotest
+  geokit-premier!
+  hoe
+  json_pure
+  mysql
+  rspec
+  standalone_migrations

data/History.txt

@@ -0,0 +1,77 @@
+=== 1.5.0 / 2009-09-21
+* fixed jruby compatibility (thanks manalang)
+* added country name to Google reverse geocoder (thanks joahking)
+* added  DependentLocalityName as district, and SubAdministrativeAreaName as province (google geocoder only)
+* Google geocoder throws an error if you exceed geocoding rates (thanks drogus)
+
+=== 1.4.1 / 2009-06-15
+* Fixed Ruby 1.9.1 compat and load order (thanks Niels Ganser)
+
+=== 1.4.0 / 2009-05-27
+* Added country code/viewport biasing to GoogleGeocoder. Added Bounds#to_span method
+* Added suggested_bounds (Geokit::Bounds) property to GeoLoc. (Google geocoder only)
+* Added LatLng#reverse_geocode convenience method (thanks Tisho Georgiev for all three)
+
+=== 1.3.2 / 2009-05-27
+* Fixed blank address geocoding bug
+
+=== 1.3.1 / 2009-05-21
+* Support for External geocoders file (thanks dreamcat4)
+* Support multiple ip geocoders, including new setting for ip_provider_order (thanks dreamcat4)
+
+=== 1.3.0 / 2009-04-11
+* Added capability to define multiple API keys for different domains that may be pointing to the same application (thanks Glenn Powell)
+* Added numeric accuracy accessor for Yahoo and Google geocoders (thanks Andrew Fecheyr Lippens)
+* Implement #hash and #eql? on LatLng to allow for using it as a hash key (thanks Luke Melia and Ross Kaffenberger)
+*
+
+=== 1.2.6 / 2009-03-19
+* misc minor fixes
+
+=== 1.2.5 / 2009-02-25
+
+* fixed GeoLoc.to_yaml
+* fixed minor google geocoding bug
+* now periodically publishing the Geokit gem to Rubyforge. Still maintaining development and managing contributions at Github
+
+=== 1.2.4 / 2009-02-25
+
+* Improved Google geocoder in the Gem: Support for multiple geocoding results from the Google geocoder. (thanks github/pic)
+
+=== 1.2.3 / 2009-02-01
+
+* Adding GeoPluginGeocoder for IP geocoding (thanks github/xjunior)
+* Ruby 1.9.1 compatibility and Unicode fixes (thanks github/Nielsomat)
+* various bug fixes
+
+=== 1.2.1 / 2009-01-05
+
+* minor bug fixes
+* reverse geocoding added (Google only): res=Geokit::Geocoders::GoogleGeocoder.reverse_geocode "37.791821,-122.394679"
+* nautical miles added (in addition to miles and KM)
+
+=== 1.2.0 / 2008-12-01
+
+* Improved Geocoder.us support -- respects authentication, and can geocode city names or zipcodes alone
+* cross-meridian finds work correctly with bounds conditions
+* fixed a problem with columns with "distance" in their name
+* added Geonames geocoder
+* the gem and plugin are now hosted at Github.
+
+=== 1.1.1 / 2008-01-20
+* fixes for distance calculation (in-memory and database) when distances are either very small or 0. 
+* NOTE: older versions of MySQL/Postgres may not work. See readme for more info.
+
+=== 1.1.0 / 2007-12-07
+* Geokit is now Rails 2.0 / Edge friendly. 
+
+=== 1.0.0 / 2007-07-22
+* see http://earthcode.com/blog/2007/07/new_geokit_release.html
+* auto geocoding: an option to automatically geocode a model's address field on create
+* in-memory sort-by-distance for arrays of location objects
+* bounding box queries: `Location.find :all, :bounds=>[sw,ne]`
+* improved performance by automatically adding a bounding box condition to radial queries
+* new Bounds class for in-memory bounds-related operations
+* ability to calculate heading and midpoint between two points
+* ability to calculate endpoint given a point, heading, and distance
+

data/Rakefile

@@ -1,21 +1,2 @@
-# -*- ruby -*-
-
-require 'rubygems'
-require 'hoe'
-require './lib/geokit.rb'
-
-# undefined method `empty?' for nil:NilClass
-# /Library/Ruby/Site/1.8/rubygems/specification.rb:886:in `validate' 
-class NilClass
-  def empty?
-    true
-  end
-end 
-
-project=Hoe.new('geokit-premier', Geokit::VERSION) do |p|
-  p.developer('Andrew Forward', 'aforward@gmail.com')
-  p.summary="Fork of Geokit to provide for Google Premier users"
-end
-
-
-# vim: syntax=Ruby
+require 'bundler'
+Bundler::GemHelper.install_tasks

data/autotest/discover.rb

@@ -0,0 +1,2 @@
+#Autotest.add_discovery { "rails" }
+Autotest.add_discovery { "rspec2" }

data/geokit-premier.gemspec

@@ -0,0 +1,54 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "geokit/version"
+
+Gem::Specification.new do |s|
+  s.name        = "geokit-premier"
+  s.version     = Geokit::VERSION
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = ["Andrew Forward (forked project from Andre Lewis and Bill Eisenhauer)"]
+  s.email       = ["aforward@gmail.com"]
+  s.homepage    = "https://github.com/aforward/geokit-premier-gem"
+  s.summary     = %q{Enables google geocoding using a premier account}
+  s.description = %q{Enhanced the google geocoder to take advantage of the premier account offering}
+
+  s.add_dependency('json_pure')
+  s.add_dependency('hoe')
+  
+  s.add_development_dependency('rspec')
+  s.add_development_dependency('autotest')
+  s.add_development_dependency('ZenTest')
+  s.add_development_dependency('standalone_migrations')
+  s.add_development_dependency('mysql')
+  
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+end
+
+# -*- encoding: utf-8 -*-
+# Gem::Specification.new do |s|
+#   # s.name = %q{geokit-premier}
+#   s.version = "0.0.4"
+# 
+#   # s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+#   # s.date = %q{2009-08-02}
+#   # s.extra_rdoc_files = ["Manifest.txt", "README.markdown"]
+#   # s.files = ["Manifest.txt", "README.markdown", "Rakefile", "lib/geokit/geocoders.rb", "lib/geokit.rb", "lib/geokit/mappable.rb", "spec/geocoder_spec.rb", "spec/spec_helper.rb", "test/test_base_geocoder.rb", "test/test_bounds.rb", "test/test_ca_geocoder.rb", "test/test_geoloc.rb", "test/test_google_geocoder.rb", "test/test_latlng.rb", "test/test_multi_geocoder.rb", "test/test_us_geocoder.rb", "test/test_yahoo_geocoder.rb"]
+#   # s.has_rdoc = true
+#   # s.rdoc_options = ["--main", "README.markdown"]
+#   # s.rubygems_version = %q{1.3.5}
+#   # s.summary = %q{none}
+#   # s.test_files = ["spec/geocoder_spec.rb", "test/test_base_geocoder.rb", "test/test_bounds.rb", "test/test_ca_geocoder.rb", "test/test_geoloc.rb", 
+#   #                 "test/test_geoplugin_geocoder.rb", "test/test_google_geocoder.rb", "test/test_google_reverse_geocoder.rb", 
+#   #                 "test/test_inflector.rb", "test/test_ipgeocoder.rb", "test/test_latlng.rb", "test/test_multi_geocoder.rb", 
+#   #                 "test/test_multi_ip_geocoder.rb", "test/test_us_geocoder.rb", "test/test_yahoo_geocoder.rb"]
+# 
+#   if s.respond_to? :specification_version then
+#     current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
+#     s.specification_version = 2
+#   end
+# end
+
+

data/lib/geokit.rb

@@ -1,5 +1,4 @@
 module Geokit
-  VERSION = '0.0.4'
   # These defaults are used in Geokit::Mappable.distance_to and in acts_as_mappable
   @@default_units = :miles
   @@default_formula = :sphere

data/lib/geokit/geocoders_mine.rb

@@ -0,0 +1,728 @@
+require 'net/http'
+require 'ipaddr'
+require 'rexml/document'
+require 'yaml'
+require 'timeout'
+require 'logger'
+require 'base64'
+
+module Geokit
+
+  class TooManyQueriesError < StandardError; end
+
+  module Inflector
+   
+    extend self
+   
+    def titleize(word)
+      humanize(underscore(word)).gsub(/\b([a-z])/u) { $1.capitalize }
+    end
+   
+    def underscore(camel_cased_word)
+      camel_cased_word.to_s.gsub(/::/, '/').
+      gsub(/([A-Z]+)([A-Z][a-z])/u,'\1_\2').
+      gsub(/([a-z\d])([A-Z])/u,'\1_\2').
+      tr("-", "_").
+      downcase
+    end
+   
+    def humanize(lower_case_and_underscored_word)
+      lower_case_and_underscored_word.to_s.gsub(/_id$/, "").gsub(/_/, " ").capitalize
+    end
+    
+    def snake_case(s)
+      return s.downcase if s =~ /^[A-Z]+$/u
+      s.gsub(/([A-Z]+)(?=[A-Z][a-z]?)|\B[A-Z]/u, '_\&') =~ /_*(.*)/
+        return $+.downcase
+      
+    end
+    
+    def url_escape(s)
+    s.gsub(/([^ a-zA-Z0-9_.-]+)/nu) do
+      '%' + $1.unpack('H2' * $1.size).join('%').upcase
+      end.tr(' ', '+')
+    end
+    
+    def camelize(str)
+      str.split('_').map {|w| w.capitalize}.join
+    end
+  end  
+  
+  # Contains a range of geocoders:
+  # 
+  # ### "regular" address geocoders 
+  # * 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.
+  # * Geonames - a free geocoder
+  #
+  # ### address geocoders that also provide reverse geocoding 
+  # * Google Geocoder - requires an API key.
+  #  
+  # ### IP address geocoders 
+  # * IP Geocoder - geocodes an IP address using hostip.info's web service.
+  # * Geoplugin.net -- another IP address geocoder
+  #
+  # ### The Multigeocoder
+  # * Multi Geocoder - provides failover for the physical location geocoders.
+  # 
+  # Some of these geocoders require configuration. You don't have to provide it here. See the README.
+  module Geocoders
+    @@proxy_addr = nil
+    @@proxy_port = nil
+    @@proxy_user = nil
+    @@proxy_pass = nil
+    @@request_timeout = nil    
+    @@yahoo = 'REPLACE_WITH_YOUR_YAHOO_KEY'
+    @@google = 'REPLACE_WITH_YOUR_GOOGLE_KEY'
+    @@google_client_id = nil #only used for premier accounts
+    @@google_premier_secret_key = nil
+    @@geocoder_us = false
+    @@geocoder_ca = false
+    @@geonames = false
+    @@provider_order = [:google,:us]
+    @@ip_provider_order = [:geo_plugin,:ip]
+    @@logger=Logger.new(STDOUT)
+    @@logger.level=Logger::INFO
+    @@domain = nil
+    
+    def self.__define_accessors
+      class_variables.each do |v| 
+        sym = v.to_s.delete("@").to_sym
+        unless self.respond_to? sym
+          module_eval <<-EOS, __FILE__, __LINE__
+            def self.#{sym}
+              value = if defined?(#{sym.to_s.upcase})
+                #{sym.to_s.upcase}
+              else
+                @@#{sym}
+              end
+              if value.is_a?(Hash)
+                value = (self.domain.nil? ? nil : value[self.domain]) || value.values.first
+              end
+              value
+            end
+          
+            def self.#{sym}=(obj)
+              @@#{sym} = obj
+            end
+          EOS
+        end
+      end
+    end
+
+    __define_accessors
+    
+    # Error which is thrown in the event a geocoding error occurs.
+    class GeocodeError < StandardError; end
+
+    # -------------------------------------------------------------------------------------------
+    # Geocoder Base class -- every geocoder should inherit from this
+    # -------------------------------------------------------------------------------------------    
+    
+    # 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, options = {}) 
+        res = do_geocode(address, options)
+        return res.nil? ? GeoLoc.new : res
+      end  
+      # Main method which calls the do_reverse_geocode template method which subclasses
+      # are responsible for implementing.  Returns a populated GeoLoc or an
+      # empty one with a failed success code.
+      def self.reverse_geocode(latlng)
+        res = do_reverse_geocode(latlng)
+        return res.success? ? res : GeoLoc.new        
+      end
+      
+      # Call the geocoder service using the timeout if configured.
+      def self.call_geocoder_service(url)
+        Timeout::timeout(Geokit::Geocoders::request_timeout) { return self.do_get(url) } if Geokit::Geocoders::request_timeout        
+        return self.do_get(url)
+      rescue TimeoutError
+        return nil  
+      end
+
+      # Not all geocoders can do reverse geocoding. So, unless the subclass explicitly overrides this method,
+      # a call to reverse_geocode will return an empty GeoLoc. If you happen to be using MultiGeocoder,
+      # this will cause it to failover to the next geocoder, which will hopefully be one which supports reverse geocoding.
+      def self.do_reverse_geocode(latlng)
+        return GeoLoc.new
+      end
+
+      # This will sign a raw url with a private key
+      def self.sign_url(raw_url,private_key)
+        uri = URI.parse(raw_url)
+        url_to_sign = uri.path + "?" + uri.query
+        decoded_key = Geocoder.urlsafe_decode64(private_key)
+
+        sha1_digest  = OpenSSL::Digest::Digest.new('sha1')
+        signature = OpenSSL::HMAC.digest(sha1_digest,decoded_key,url_to_sign)
+        encoded_signature = Geocoder.urlsafe_encode64(signature)
+        signed_url = "#{uri.scheme}://#{uri.host}#{uri.path}?#{uri.query}&signature=#{encoded_signature}".strip!
+        signed_url
+      end
+
+      # This will provide url safe base64 decoding
+      def self.urlsafe_decode64(raw_text)
+        decoded_text = raw_text.gsub('-','+').gsub('_', '/')
+        decoded_text = Base64.decode64(decoded_text)
+        decoded_text
+      end
+
+      # This will provide url safe base64 encoding
+      def self.urlsafe_encode64(raw_text)
+        encoded_text = Base64.encode64(raw_text)
+        encoded_text = encoded_text.gsub('+','-').gsub('/', '_')
+        encoded_text
+      end
+
+
+      protected
+
+      def self.logger() 
+        Geokit::Geocoders::logger
+      end
+      
+      private
+      
+      # Wraps the geocoder call around a proxy if necessary.
+      def self.do_get(url) 
+        uri = URI.parse(url)
+        req = Net::HTTP::Get.new(url)
+        req.basic_auth(uri.user, uri.password) if uri.userinfo
+        res = Net::HTTP::Proxy(GeoKit::Geocoders::proxy_addr,
+                GeoKit::Geocoders::proxy_port,
+                GeoKit::Geocoders::proxy_user,
+                GeoKit::Geocoders::proxy_pass).start(uri.host, uri.port) { |http| http.get(uri.path + "?" + uri.query) }
+        return res
+      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.#{Geokit::Inflector.underscore(class_name)}(address, options = {})
+            #{class_name}.geocode(address, options)
+          end
+        END_SRC
+        class_eval(src)
+      end
+    end
+
+    # -------------------------------------------------------------------------------------------
+    # "Regular" Address geocoders
+    # -------------------------------------------------------------------------------------------    
+    
+    # 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, options = {})
+        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=#{Geokit::Inflector::url_escape(location.street_name)}" if location.street_address
+        url += add_ampersand(url) + "city=#{Geokit::Inflector::url_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    
+    
+    # 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
+      def self.do_geocode(address, options = {})
+        address_str = address.is_a?(GeoLoc) ? address.to_geocodeable_s : address
+        
+        query = (address_str =~ /^\d{5}(?:-\d{4})?$/ ? "zip" : "address") + "=#{Geokit::Inflector::url_escape(address_str)}"
+        url = if GeoKit::Geocoders::geocoder_us         
+          "http://#{GeoKit::Geocoders::geocoder_us}@geocoder.us/member/service/csv/geocode"
+        else
+          "http://geocoder.us/service/csv/geocode"
+        end
+        
+        url = "#{url}?#{query}"  
+        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 == 5
+          res=GeoLoc.new
+          res.lat,res.lng,res.city,res.state,res.zip=array
+          res.country_code='US'
+          res.success=true
+          return res
+        elsif 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, options = {})
+        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=#{Geokit::Inflector::url_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']
+          # set the accuracy as google does (added by Andruby)
+          res.accuracy=%w{unknown country state state city zip zip+4 street address building}.index(res.precision)
+          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
+
+    # Another geocoding web service
+    # http://www.geonames.org
+    class GeonamesGeocoder < Geocoder
+
+      private 
+      
+      # Template method which does the geocode lookup.
+      def self.do_geocode(address, options = {})
+        address_str = address.is_a?(GeoLoc) ? address.to_geocodeable_s : address
+        # geonames need a space seperated search string
+        address_str.gsub!(/,/, " ")
+        params = "/postalCodeSearch?placename=#{Geokit::Inflector::url_escape(address_str)}&maxRows=10"
+        
+        if(GeoKit::Geocoders::geonames)
+          url = "http://ws.geonames.net#{params}&username=#{GeoKit::Geocoders::geonames}"
+        else
+          url = "http://ws.geonames.org#{params}"
+        end
+        
+        res = self.call_geocoder_service(url)
+        
+        return GeoLoc.new if !res.is_a?(Net::HTTPSuccess)
+        
+        xml=res.body
+        logger.debug "Geonames geocoding. Address: #{address}. Result: #{xml}"
+        doc=REXML::Document.new(xml)
+        
+        if(doc.elements['//geonames/totalResultsCount'].text.to_i > 0)
+          res=GeoLoc.new
+        
+          # only take the first result
+          res.lat=doc.elements['//code/lat'].text if doc.elements['//code/lat']
+          res.lng=doc.elements['//code/lng'].text if doc.elements['//code/lng']
+          res.country_code=doc.elements['//code/countryCode'].text if doc.elements['//code/countryCode']
+          res.provider='genomes'  
+          res.city=doc.elements['//code/name'].text if doc.elements['//code/name']
+          res.state=doc.elements['//code/adminName1'].text if doc.elements['//code/adminName1']
+          res.zip=doc.elements['//code/postalcode'].text if doc.elements['//code/postalcode']
+          res.success=true
+          return res
+        else 
+          logger.info "Geonames was unable to geocode address: "+address
+          return GeoLoc.new
+        end
+        
+        rescue
+          logger.error "Caught an error during Geonames geocoding call: "+$!
+      end
+    end
+
+    # -------------------------------------------------------------------------------------------
+    # Address geocoders that also provide reverse geocoding
+    # -------------------------------------------------------------------------------------------
+
+    # 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 reverse-geocode lookup.
+      def self.do_reverse_geocode(latlng) 
+        latlng=LatLng.normalize(latlng)
+        res = self.call_geocoder_service("http://maps.google.com/maps/geo?ll=#{Geokit::Inflector::url_escape(latlng.ll)}&output=xml&key=#{Geokit::Geocoders::google}&oe=utf-8")
+        #        res = Net::HTTP.get_response(URI.parse("http://maps.google.com/maps/geo?ll=#{Geokit::Inflector::url_escape(address_str)}&output=xml&key=#{Geokit::Geocoders::google}&oe=utf-8"))
+        return GeoLoc.new unless (res.is_a?(Net::HTTPSuccess) || res.is_a?(Net::HTTPOK))
+        xml = res.body
+        logger.debug "Google reverse-geocoding. LL: #{latlng}. Result: #{xml}"
+        return self.xml2GeoLoc(xml)        
+      end  
+
+      # Template method which does the geocode lookup.
+      #
+      # Supports viewport/country code biasing
+      #
+      # ==== OPTIONS
+      # * :bias - This option makes the Google Geocoder return results biased to a particular
+      #           country or viewport. Country code biasing is achieved by passing the ccTLD
+      #           ('uk' for .co.uk, for example) as a :bias value. For a list of ccTLD's, 
+      #           look here: http://en.wikipedia.org/wiki/CcTLD. By default, the geocoder
+      #           will be biased to results within the US (ccTLD .com).
+      #
+      #           If you'd like the Google Geocoder to prefer results within a given viewport,
+      #           you can pass a Geokit::Bounds object as the :bias value.
+      #
+      # ==== EXAMPLES
+      # # By default, the geocoder will return Syracuse, NY
+      # Geokit::Geocoders::GoogleGeocoder.geocode('Syracuse').country_code # => 'US'
+      # # With country code biasing, it returns Syracuse in Sicily, Italy
+      # Geokit::Geocoders::GoogleGeocoder.geocode('Syracuse', :bias => :it).country_code # => 'IT'
+      #
+      # # By default, the geocoder will return Winnetka, IL
+      # Geokit::Geocoders::GoogleGeocoder.geocode('Winnetka').state # => 'IL'
+      # # When biased to an bounding box around California, it will now return the Winnetka neighbourhood, CA
+      # bounds = Geokit::Bounds.normalize([34.074081, -118.694401], [34.321129, -118.399487])
+      # Geokit::Geocoders::GoogleGeocoder.geocode('Winnetka', :bias => bounds).state # => 'CA'
+      def self.do_geocode(address, options = {})
+        res = self.call_geocoder_service(self.geocode_url(address,options))
+        return GeoLoc.new if !res.is_a?(Net::HTTPSuccess)
+        xml = res.body
+        logger.debug "Google geocoding. Address: #{address}. Result: #{xml}"
+        return self.xml2GeoLoc(xml, address)        
+      end
+      
+      # Determine the Google API url based on the google api key, or based on the client / private key for premier users
+      def self.geocode_url(address,options = {})
+        bias_str = options[:bias] ? construct_bias_string_from_options(options[:bias]) : ''
+        address_str = address.is_a?(GeoLoc) ? address.to_geocodeable_s : address
+
+        if !Geokit::Geocoders::google_client_id.nil? && !Geokit::Geocoders::google_premier_secret_key.nil?
+          url = "http://maps.googleapis.com/maps/api/geocode/xml?address=#{Geokit::Inflector::url_escape(address_str)}&client=#{Geokit::Geocoders::google_client_id}&sensor=false&oe=utf-8"
+          Geokit::Geocoders::Geocoder.sign_url(url,Geokit::Geocoders::google_premier_secret_key)
+        else
+          "http://maps.google.com/maps/geo?q=#{Geokit::Inflector::url_escape(address_str)}&output=xml#{bias_str}&key=#{Geokit::Geocoders::google}&oe=utf-8"
+        end
+      end
+      
+      
+      def self.construct_bias_string_from_options(bias)
+        if bias.is_a?(String) or bias.is_a?(Symbol)
+          # country code biasing
+          "&gl=#{bias.to_s.downcase}"
+        elsif bias.is_a?(Bounds)
+          # viewport biasing
+          "&ll=#{bias.center.ll}&spn=#{bias.to_span.ll}"
+        end
+      end
+      
+      def self.xml2GeoLoc(xml, address="")
+        doc=REXML::Document.new(xml)
+
+        if doc.elements['//kml/Response/Status/code'].text == '200'
+          geoloc = nil
+          # Google can return multiple results as //Placemark elements. 
+          # iterate through each and extract each placemark as a geoloc
+          doc.each_element('//Placemark') do |e|
+            extracted_geoloc = extract_placemark(e) # g is now an instance of GeoLoc
+            if geoloc.nil? 
+              # first time through, geoloc is still nil, so we make it the geoloc we just extracted
+              geoloc = extracted_geoloc 
+            else
+              # second (and subsequent) iterations, we push additional 
+              # geolocs onto "geoloc.all" 
+              geoloc.all.push(extracted_geoloc) 
+            end  
+          end
+          return geoloc
+        elsif doc.elements['//kml/Response/Status/code'].text == '620'
+           raise Geokit::TooManyQueriesError
+        else
+          logger.info "Google was unable to geocode address: "+address
+          return GeoLoc.new
+        end
+
+      rescue Geokit::TooManyQueriesError
+        # re-raise because of other rescue
+        raise Geokit::TooManyQueriesError, "Google returned a 620 status, too many queries. The given key has gone over the requests limit in the 24 hour period or has submitted too many requests in too short a period of time. If you're sending multiple requests in parallel or in a tight loop, use a timer or pause in your code to make sure you don't send the requests too quickly."
+      rescue
+        logger.error "Caught an error during Google geocoding call: "+$!
+        return GeoLoc.new
+      end  
+
+      # extracts a single geoloc from a //placemark element in the google results xml
+      def self.extract_placemark(doc)
+        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 if doc.elements['.//CountryNameCode']
+        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.province = doc.elements['.//SubAdministrativeAreaName'].text if doc.elements['.//SubAdministrativeAreaName']
+        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']
+        res.country = doc.elements['.//CountryName'].text if doc.elements['.//CountryName']
+        res.district = doc.elements['.//DependentLocalityName'].text if doc.elements['.//DependentLocalityName']
+        # Translate accuracy into Yahoo-style token address, street, zip, zip+4, city, state, country
+        # For Google, 1=low accuracy, 8=high accuracy
+        address_details=doc.elements['.//*[local-name() = "AddressDetails"]']
+        res.accuracy = address_details ? address_details.attributes['Accuracy'].to_i : 0
+        res.precision=%w{unknown country state state city zip zip+4 street address building}[res.accuracy]
+        
+        # google returns a set of suggested boundaries for the geocoded result
+        if suggested_bounds = doc.elements['//LatLonBox']  
+          res.suggested_bounds = Bounds.normalize(
+                                  [suggested_bounds.attributes['south'], suggested_bounds.attributes['west']], 
+                                  [suggested_bounds.attributes['north'], suggested_bounds.attributes['east']])
+        end
+        
+        res.success=true
+
+        return res
+      end
+    end
+
+
+    # -------------------------------------------------------------------------------------------
+    # IP Geocoders
+    # -------------------------------------------------------------------------------------------
+  
+    # Provides geocoding based upon an IP address.  The underlying web service is geoplugin.net
+    class GeoPluginGeocoder < Geocoder
+      private
+      
+      def self.do_geocode(ip, options = {})
+        return GeoLoc.new unless /^(\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3})?$/.match(ip)
+        response = self.call_geocoder_service("http://www.geoplugin.net/xml.gp?ip=#{ip}")
+        return response.is_a?(Net::HTTPSuccess) ? parse_xml(response.body) : GeoLoc.new
+      rescue
+        logger.error "Caught an error during GeoPluginGeocoder geocoding call: "+$!
+        return GeoLoc.new
+      end
+
+      def self.parse_xml(xml)
+        xml = REXML::Document.new(xml)
+        geo = GeoLoc.new
+        geo.provider='geoPlugin'
+        geo.city = xml.elements['//geoplugin_city'].text
+        geo.state = xml.elements['//geoplugin_region'].text
+        geo.country_code = xml.elements['//geoplugin_countryCode'].text
+        geo.lat = xml.elements['//geoplugin_latitude'].text.to_f
+        geo.lng = xml.elements['//geoplugin_longitude'].text.to_f
+        geo.success = !!geo.city && !geo.city.empty?
+        return geo
+      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 
+
+      # A number of non-routable IP ranges.
+      #
+      # --
+      # Sources for these:
+      #   RFC 3330: Special-Use IPv4 Addresses
+      #   The bogon list: http://www.cymru.com/Documents/bogon-list.html
+
+      NON_ROUTABLE_IP_RANGES = [
+	IPAddr.new('0.0.0.0/8'),      # "This" Network
+	IPAddr.new('10.0.0.0/8'),     # Private-Use Networks
+	IPAddr.new('14.0.0.0/8'),     # Public-Data Networks
+	IPAddr.new('127.0.0.0/8'),    # Loopback
+	IPAddr.new('169.254.0.0/16'), # Link local
+	IPAddr.new('172.16.0.0/12'),  # Private-Use Networks
+	IPAddr.new('192.0.2.0/24'),   # Test-Net
+	IPAddr.new('192.168.0.0/16'), # Private-Use Networks
+	IPAddr.new('198.18.0.0/15'),  # Network Interconnect Device Benchmark Testing
+	IPAddr.new('224.0.0.0/4'),    # Multicast
+	IPAddr.new('240.0.0.0/4')     # Reserved for future use
+      ].freeze
+
+      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, options = {})
+        return GeoLoc.new unless /^(\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3})?$/.match(ip)
+        return GeoLoc.new if self.private_ip_address?(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 =~ /\(.+\)/)
+        res
+      end
+
+      # Checks whether the IP address belongs to a private address range.
+      #
+      # This function is used to reduce the number of useless queries made to
+      # the geocoding service. Such queries can occur frequently during
+      # integration tests.
+      def self.private_ip_address?(ip)
+	return NON_ROUTABLE_IP_RANGES.any? { |range| range.include?(ip) }
+      end
+    end
+    
+    # -------------------------------------------------------------------------------------------
+    # The Multi Geocoder
+    # -------------------------------------------------------------------------------------------    
+    
+    # Provides methods to geocode with a variety of geocoding service providers, plus failover
+    # among providers in the order you configure. When 2nd parameter is set 'true', perform
+    # ip location lookup with 'address' as the ip address.
+    # 
+    # 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, options = {})
+        geocode_ip = /^(\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3})$/.match(address)
+        provider_order = geocode_ip ? Geokit::Geocoders::ip_provider_order : Geokit::Geocoders::provider_order
+        
+        provider_order.each do |provider|
+          begin
+            klass = Geokit::Geocoders.const_get "#{Geokit::Inflector::camelize(provider.to_s)}Geocoder"
+            res = klass.send :geocode, address, options
+            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
+      
+      # This method will call one or more geocoders in the order specified in the 
+      # configuration until one of the geocoders work, only this time it's going
+      # to try to reverse geocode a geographical point.
+      def self.do_reverse_geocode(latlng)
+        Geokit::Geocoders::provider_order.each do |provider|
+          begin
+            klass = Geokit::Geocoders.const_get "#{Geokit::Inflector::camelize(provider.to_s)}Geocoder"
+            res = klass.send :reverse_geocode, latlng
+            return res if res.success?
+          rescue
+            logger.error("Something has gone very wrong during reverse geocoding, OR you have configured an invalid class name in Geokit::Geocoders::provider_order. LatLng: #{latlng}. Provider: #{provider}")
+          end
+        end
+        # If we get here, we failed completely.
+        GeoLoc.new
+      end
+    end   
+  end
+end

data/lib/geokit/version.rb

@@ -0,0 +1,3 @@
+module Geokit
+  VERSION = "0.0.5"
+end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: geokit-premier
 version: !ruby/object:Gem::Version 
-  hash: 23
-  prerelease: false
+  hash: 21
+  prerelease: 
   segments: 
   - 0
   - 0
-  - 4
-  version: 0.0.4
+  - 5
+  version: 0.0.5
 platform: ruby
 authors: 
 - Andrew Forward (forked project from Andre Lewis and Bill Eisenhauer)
@@ -15,51 +15,155 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-08-02 00:00:00 -04:00
+date: 2011-01-19 00:00:00 -05:00
 default_executable: 
-dependencies: []
-
-description: Geokit Premier Gem
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: json_pure
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :runtime
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: hoe
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :runtime
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: rspec
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id003
+- !ruby/object:Gem::Dependency 
+  name: autotest
+  prerelease: false
+  requirement: &id004 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id004
+- !ruby/object:Gem::Dependency 
+  name: ZenTest
+  prerelease: false
+  requirement: &id005 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id005
+- !ruby/object:Gem::Dependency 
+  name: standalone_migrations
+  prerelease: false
+  requirement: &id006 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id006
+- !ruby/object:Gem::Dependency 
+  name: mysql
+  prerelease: false
+  requirement: &id007 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id007
+description: Enhanced the google geocoder to take advantage of the premier account offering
 email: 
 - aforward@gmail.com
 executables: []
 
 extensions: []
 
-extra_rdoc_files: 
-- Manifest.txt
-- README.markdown
+extra_rdoc_files: []
+
 files: 
+- .gitignore
+- Gemfile
+- Gemfile.lock
+- History.txt
 - Manifest.txt
 - README.markdown
 - Rakefile
-- lib/geokit/geocoders.rb
+- autotest/discover.rb
+- geokit-premier-0.0.4.gem
+- geokit-premier.gemspec
 - lib/geokit.rb
+- lib/geokit/geocoders.rb
+- lib/geokit/geocoders_mine.rb
 - lib/geokit/mappable.rb
+- lib/geokit/version.rb
 - spec/geocoder_spec.rb
 - spec/spec_helper.rb
 - test/test_base_geocoder.rb
 - test/test_bounds.rb
 - test/test_ca_geocoder.rb
 - test/test_geoloc.rb
-- test/test_google_geocoder.rb
-- test/test_latlng.rb
-- test/test_multi_geocoder.rb
-- test/test_us_geocoder.rb
-- test/test_yahoo_geocoder.rb
 - test/test_geoplugin_geocoder.rb
+- test/test_google_geocoder.rb
 - test/test_google_reverse_geocoder.rb
 - test/test_inflector.rb
 - test/test_ipgeocoder.rb
+- test/test_latlng.rb
+- test/test_multi_geocoder.rb
 - test/test_multi_ip_geocoder.rb
+- test/test_us_geocoder.rb
+- test/test_yahoo_geocoder.rb
 has_rdoc: true
-homepage: http://github.com/aforward/geokit-gem
+homepage: https://github.com/aforward/geokit-premier-gem
 licenses: []
 
 post_install_message: 
-rdoc_options: 
-- --main
-- README.markdown
+rdoc_options: []
+
 require_paths: 
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement 
@@ -83,12 +187,13 @@ required_rubygems_version: !ruby/object:Gem::Requirement
 requirements: []
 
 rubyforge_project: 
-rubygems_version: 1.3.7
+rubygems_version: 1.4.1
 signing_key: 
-specification_version: 2
-summary: none
+specification_version: 3
+summary: Enables google geocoding using a premier account
 test_files: 
 - spec/geocoder_spec.rb
+- spec/spec_helper.rb
 - test/test_base_geocoder.rb
 - test/test_bounds.rb
 - test/test_ca_geocoder.rb