geokit 1.10.0 → 1.11.0

data/lib/geokit/geocoders/mapquest.rb

@@ -16,17 +16,17 @@ module Geokit
       end
 
       # Template method which does the geocode lookup.
-      def self.do_geocode(address)
+      def self.do_geocode(address, _=nil)
         address_str = address.is_a?(GeoLoc) ? address.to_geocodeable_s : address
         url = "#{protocol}://www.mapquestapi.com/geocoding/v1/address?key=#{key}&location=#{Geokit::Inflector.url_escape(address_str)}"
         process :json, url
       end
 
       def self.parse_json(results)
-        return GeoLoc.new unless results["info"]["statuscode"] == 0
+        return GeoLoc.new unless results['info']['statuscode'] == 0
         loc = nil
-        results["results"].each do |result|
-          result["locations"].each do |location|
+        results['results'].each do |result|
+          result['locations'].each do |location|
             extracted_geoloc = extract_geoloc(location)
             if loc.nil?
               loc = extracted_geoloc
@@ -40,8 +40,8 @@ module Geokit
 
       def self.extract_geoloc(result_json)
         loc = new_loc
-        loc.lat = result_json["latLng"]["lat"]
-        loc.lng = result_json["latLng"]["lng"]
+        loc.lat = result_json['latLng']['lat']
+        loc.lng = result_json['latLng']['lng']
         set_address_components(result_json, loc)
         set_precision(result_json, loc)
         loc.success = true
@@ -49,15 +49,15 @@ module Geokit
       end
 
       def self.set_address_components(result_json, loc)
-        loc.country_code   = result_json["adminArea1"]
-        loc.street_address = result_json["street"].to_s.empty? ? nil : result_json["street"]
-        loc.city           = result_json["adminArea5"]
-        loc.state          = result_json["adminArea3"]
-        loc.zip            = result_json["postalCode"]
+        loc.country_code   = result_json['adminArea1']
+        loc.street_address = result_json['street'].to_s.empty? ? nil : result_json['street']
+        loc.city           = result_json['adminArea5']
+        loc.state          = result_json['adminArea3']
+        loc.zip            = result_json['postalCode']
       end
 
       def self.set_precision(result_json, loc)
-        loc.precision = result_json["geocodeQuality"]
+        loc.precision = result_json['geocodeQuality']
         loc.accuracy = %w(unknown country state state city zip zip+4 street address building).index(loc.precision)
       end
     end

data/lib/geokit/geocoders/maxmind.rb

@@ -6,7 +6,7 @@ module Geokit
 
       private
 
-      def self.do_geocode(ip)
+      def self.do_geocode(ip, _=nil)
         res = GeoIP.new(geoip_data_path).city(ip)
 
         loc = new_loc

data/lib/geokit/geocoders/opencage.rb

@@ -18,7 +18,7 @@ module Geokit
         url = "#{protocol}://api.opencagedata.com/geocode/v1/json?"
         url += "key=#{key}#{options_str}&"
         url += "query=#{Geokit::Inflector.url_escape(address_str)}&"
-        url += "no_annotations=1"
+        url += 'no_annotations=1'
         process :json, url
       end
       # Template method which does the reverse-geocode lookup.
@@ -34,7 +34,7 @@ module Geokit
       end
 
       def self.generate_param_for_option(param, options)
-        options[param] ? "&#{param}=#{Geokit::Inflector.url_escape(options[param])}" : ""
+        options[param] ? "&#{param}=#{Geokit::Inflector.url_escape(options[param])}" : ''
       end
 
       def self.generate_bool_param_for_option(param, options)
@@ -44,11 +44,11 @@ module Geokit
       def self.parse_json(results)
         return GeoLoc.new if results.empty?
         if results.is_a?(Hash)
-          return GeoLoc.new unless results["status"]["message"] == "OK"
+          return GeoLoc.new unless results['status']['message'] == 'OK'
         end
 
         loc = nil
-        results["results"].each do |result|
+        results['results'].each do |result|
           extracted_geoloc = extract_geoloc(result)
           if loc.nil?
             loc = extracted_geoloc
@@ -61,9 +61,9 @@ module Geokit
 
       def self.extract_geoloc(result_json)
         loc = new_loc
-        loc.lat = result_json["geometry"]["lat"]
-        loc.lng = result_json["geometry"]["lng"]
-        set_address_components(result_json["components"], loc)
+        loc.lat = result_json['geometry']['lat']
+        loc.lng = result_json['geometry']['lng']
+        set_address_components(result_json['components'], loc)
         set_precision(result_json, loc)
         loc.success = true
         loc
@@ -71,22 +71,22 @@ module Geokit
 
       def self.set_address_components(address_data, loc)
         return unless address_data
-        loc.country        = address_data["country"]
-        loc.country_code   = address_data["country_code"].upcase if address_data["country_code"]
-        loc.state_name     = address_data["state"]
-        loc.city           = address_data["city"]
-        loc.city           = address_data["county"] if loc.city.nil? && address_data["county"]
-        loc.zip            = address_data["postcode"]
-        loc.district       = address_data["city_district"]
-        loc.district       = address_data["state_district"] if loc.district.nil? && address_data["state_district"]
-        loc.street_address = "#{address_data['road']} #{address_data['house_number']}".strip if address_data["road"]
-        loc.street_name    = address_data["road"]
-        loc.street_number  = address_data["house_number"]
+        loc.country        = address_data['country']
+        loc.country_code   = address_data['country_code'].upcase if address_data['country_code']
+        loc.state_name     = address_data['state']
+        loc.city           = address_data['city']
+        loc.city           = address_data['county'] if loc.city.nil? && address_data['county']
+        loc.zip            = address_data['postcode']
+        loc.district       = address_data['city_district']
+        loc.district       = address_data['state_district'] if loc.district.nil? && address_data['state_district']
+        loc.street_address = "#{address_data['road']} #{address_data['house_number']}".strip if address_data['road']
+        loc.street_name    = address_data['road']
+        loc.street_number  = address_data['house_number']
       end
 
       def self.set_precision(result_json, loc)
         # a value between 1 (worse) and 10 (best). 0 means unknown
-        loc.precision = result_json["confidence"]
+        loc.precision = result_json['confidence']
       end
     end
   end

data/lib/geokit/geocoders/openstreetmap.rb

@@ -38,7 +38,7 @@ module Geokit
       end
 
       def self.generate_param_for_option(param, options)
-        options[param] ? "&#{param}=#{Geokit::Inflector.url_escape(options[param])}" : ""
+        options[param] ? "&#{param}=#{Geokit::Inflector.url_escape(options[param])}" : ''
       end
 
       def self.generate_bool_param_for_option(param, options)
@@ -47,7 +47,7 @@ module Geokit
 
       def self.parse_json(results)
         if results.is_a?(Hash)
-          return GeoLoc.new if results["error"]
+          return GeoLoc.new if results['error']
           results = [results]
         end
         return GeoLoc.new if results.empty?
@@ -68,12 +68,12 @@ module Geokit
         loc = new_loc
 
         # basic
-        loc.lat = result_json["lat"]
-        loc.lng = result_json["lon"]
+        loc.lat = result_json['lat']
+        loc.lng = result_json['lon']
 
-        set_address_components(result_json["address"], loc)
+        set_address_components(result_json['address'], loc)
         set_precision(result_json, loc)
-        set_bounds(result_json["boundingbox"], loc)
+        set_bounds(result_json['boundingbox'], loc)
         loc.success = true
 
         loc
@@ -81,24 +81,24 @@ module Geokit
 
       def self.set_address_components(address_data, loc)
         return unless address_data
-        loc.country = address_data["country"]
-        loc.country_code = address_data["country_code"].upcase if address_data["country_code"]
-        loc.state_name = address_data["state"]
-        loc.city = address_data["city"]
-        loc.city = address_data["county"] if loc.city.nil? && address_data["county"]
-        loc.zip = address_data["postcode"]
-        loc.district = address_data["city_district"]
-        loc.district = address_data["state_district"] if loc.district.nil? && address_data["state_district"]
-        loc.street_address = "#{address_data['road']} #{address_data['house_number']}".strip if address_data["road"]
-        loc.street_name = address_data["road"]
-        loc.street_number = address_data["house_number"]
+        loc.country = address_data['country']
+        loc.country_code = address_data['country_code'].upcase if address_data['country_code']
+        loc.state_name = address_data['state']
+        loc.city = address_data['city']
+        loc.city = address_data['county'] if loc.city.nil? && address_data['county']
+        loc.zip = address_data['postcode']
+        loc.district = address_data['city_district']
+        loc.district = address_data['state_district'] if loc.district.nil? && address_data['state_district']
+        loc.street_address = "#{address_data['road']} #{address_data['house_number']}".strip if address_data['road']
+        loc.street_name = address_data['road']
+        loc.street_number = address_data['house_number']
       end
 
       def self.set_precision(result_json, loc)
         # Todo accuracy does not work as Yahoo and Google maps on OSM
         # loc.accuracy = %w{unknown amenity building highway historic landuse leisure natural place railway shop tourism waterway man_made}.index(loc.precision)
-        loc.precision = result_json["class"]
-        loc.accuracy = result_json["type"]
+        loc.precision = result_json['class']
+        loc.accuracy = result_json['type']
       end
 
       def self.set_bounds(result_json, loc)
@@ -110,4 +110,6 @@ module Geokit
       end
     end
   end
+
+  Geokit::Geocoders::OsmGeocoder = Geokit::Geocoders::OSMGeocoder
 end

data/lib/geokit/geocoders/ripe.rb

@@ -6,7 +6,7 @@ module Geokit
 
       private
 
-      def self.do_geocode(ip)
+      def self.do_geocode(ip, _=nil)
         process :json, ip
       end
 
@@ -16,19 +16,19 @@ module Geokit
 
       def self.parse_json(json)
         loc = new_loc
-        data = json["data"]["locations"][0]
+        data = json['data']['locations'][0]
 
         if data
-          loc.lat = data["latitude"]
-          loc.lng = data["longitude"]
+          loc.lat = data['latitude']
+          loc.lng = data['longitude']
           set_address_components(data, loc)
-          loc.success = data && (data["status_code"] == 200)
+          loc.success = data && (data['status_code'] == 200)
         end
         loc
       end
 
       def self.set_address_components(data, loc)
-        match = data["country"].match(/([A-Z]+)(\(([A-Z]+)\))?/)
+        match = data['country'].match(/([A-Z]+)(\(([A-Z]+)\))?/)
         if match[3]
           loc.state_code = match[1]
           loc.country_code = match[3]
@@ -36,7 +36,7 @@ module Geokit
           loc.country_code = match[1]
         end
 
-        loc.city = data["city"]
+        loc.city = data['city']
       end
     end
   end

data/lib/geokit/geocoders/us_geocoder.rb

@@ -8,14 +8,14 @@ module Geokit
 
       private
 
-      def self.do_geocode(address)
+      def self.do_geocode(address, _=nil)
         process :csv, submit_url(address)
       end
 
       def self.submit_url(address)
         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)}"
-        base = key ? "http://#{key}@geocoder.us/member" : "http://geocoder.us"
+        query = (address_str =~ /^\d{5}(?:-\d{4})?$/ ? 'zip' : 'address') + "=#{Geokit::Inflector.url_escape(address_str)}"
+        base = key ? "http://#{key}@geocoder.us/member" : 'http://geocoder.us'
         "#{base}/service/csv/geocode?#{query}"
       end
 
@@ -23,11 +23,11 @@ module Geokit
         loc = GeoLoc.new
         if array.length == 5
           loc.lat, loc.lng, loc.city, loc.state, loc.zip = array
-          loc.country_code = "US"
+          loc.country_code = 'US'
           loc.success = true
         elsif array.length == 6
           loc.lat, loc.lng, loc.street_address, loc.city, loc.state, loc.zip = array
-          loc.country_code = "US"
+          loc.country_code = 'US'
           loc.success = true
         end
         loc

data/lib/geokit/geocoders/yahoo.rb

@@ -21,12 +21,12 @@ module Geokit
       end
 
       # Template method which does the geocode lookup.
-      def self.do_geocode(address)
+      def self.do_geocode(address, _=nil)
         process :json, submit_url(address)
       end
 
       def self.parse_json(results)
-        boss_results = results && results["bossresponse"] && results["bossresponse"]["placefinder"] && results["bossresponse"]["placefinder"]["results"]
+        boss_results = results && results['bossresponse'] && results['bossresponse']['placefinder'] && results['bossresponse']['placefinder']['results']
         return GeoLoc.new unless boss_results && boss_results.first
         loc = nil
         boss_results.each do |result|
@@ -42,8 +42,8 @@ module Geokit
 
       def self.extract_geoloc(result_json)
         loc = new_loc
-        loc.lat      = result_json["latitude"]
-        loc.lng      = result_json["longitude"]
+        loc.lat      = result_json['latitude']
+        loc.lng      = result_json['longitude']
         set_address_components(result_json, loc)
         set_precision(result_json, loc)
         loc.success  = true
@@ -51,25 +51,25 @@ module Geokit
       end
 
       def self.set_address_components(result_json, loc)
-        loc.country_code   = result_json["countrycode"]
-        loc.street_address = result_json["line1"].to_s.empty? ? nil : result_json["line1"]
-        loc.city           = result_json["city"]
-        loc.state          = loc.is_us? ? result_json["statecode"] : result_json["state"]
-        loc.zip            = result_json["postal"]
+        loc.country_code   = result_json['countrycode']
+        loc.street_address = result_json['line1'].to_s.empty? ? nil : result_json['line1']
+        loc.city           = result_json['city']
+        loc.state          = loc.is_us? ? result_json['statecode'] : result_json['state']
+        loc.zip            = result_json['postal']
       end
 
       def self.set_precision(result_json, loc)
-        loc.precision = case result_json["quality"].to_i
-                        when 9, 10         then "country"
-                        when 19..30       then "state"
-                        when 39, 40        then "city"
-                        when 49, 50        then "neighborhood"
-                        when 59, 60, 64     then "zip"
-                        when 74, 75        then "zip+4"
-                        when 70..72       then "street"
-                        when 80..87       then "address"
-                        when 62, 63, 90, 99  then "building"
-                        else "unknown"
+        loc.precision = case result_json['quality'].to_i
+                        when 9, 10         then 'country'
+                        when 19..30       then 'state'
+                        when 39, 40        then 'city'
+                        when 49, 50        then 'neighborhood'
+                        when 59, 60, 64     then 'zip'
+                        when 74, 75        then 'zip+4'
+                        when 70..72       then 'street'
+                        when 80..87       then 'address'
+                        when 62, 63, 90, 99  then 'building'
+                        else 'unknown'
                         end
 
         loc.accuracy = %w(unknown country state state city zip zip+4 street address building).index(loc.precision)
@@ -85,47 +85,47 @@ end
 # License: http://gist.github.com/375593
 # Usage: see example.rb below
 
-require "uri"
-require "cgi"
-require "openssl"
-require "base64"
+require 'uri'
+require 'cgi'
+require 'openssl'
+require 'base64'
 
 class OauthUtil
   attr_accessor :consumer_key, :consumer_secret, :token, :token_secret, :req_method,
                 :sig_method, :oauth_version, :callback_url, :params, :req_url, :base_str
 
   def initialize
-    @consumer_key = ""
-    @consumer_secret = ""
-    @token = ""
-    @token_secret = ""
-    @req_method = "GET"
-    @sig_method = "HMAC-SHA1"
-    @oauth_version = "1.0"
-    @callback_url = ""
+    @consumer_key = ''
+    @consumer_secret = ''
+    @token = ''
+    @token_secret = ''
+    @req_method = 'GET'
+    @sig_method = 'HMAC-SHA1'
+    @oauth_version = '1.0'
+    @callback_url = ''
   end
 
   # openssl::random_bytes returns non-word chars, which need to be removed. using alt method to get length
   # ref http://snippets.dzone.com/posts/show/491
   def nonce
-    Array.new(5) { rand(256) }.pack("C*").unpack("H*").first
+    Array.new(5) { rand(256) }.pack('C*').unpack('H*').first
   end
 
   def percent_encode(string)
     # ref http://snippets.dzone.com/posts/show/1260
-    URI.escape(string, Regexp.new("[^#{URI::PATTERN::UNRESERVED}]")).gsub("*", "%2A")
+    URI.escape(string, Regexp.new("[^#{URI::PATTERN::UNRESERVED}]")).gsub('*', '%2A')
   end
 
   # @ref http://oauth.net/core/1.0/#rfc.section.9.2
   def signature
-    key = percent_encode(@consumer_secret) + "&" + percent_encode(@token_secret)
+    key = percent_encode(@consumer_secret) + '&' + percent_encode(@token_secret)
 
     # ref: http://blog.nathanielbibler.com/post/63031273/openssl-hmac-vs-ruby-hmac-benchmarks
-    digest = OpenSSL::Digest.new("sha1")
+    digest = OpenSSL::Digest.new('sha1')
     hmac = OpenSSL::HMAC.digest(digest, key, @base_str)
 
     # ref http://groups.google.com/group/oauth-ruby/browse_thread/thread/9110ed8c8f3cae81
-    Base64.encode64(hmac).chomp.gsub(/\n/, "")
+    Base64.encode64(hmac).chomp.gsub(/\n/, '')
   end
 
   # sort (very important as it affects the signature), concat, and percent encode
@@ -137,7 +137,7 @@ class OauthUtil
     @params.sort.each do |key, val|
       pairs.push("#{ percent_encode(key) }=#{ percent_encode(val.to_s) }")
     end
-    pairs.join "&"
+    pairs.join '&'
   end
 
   def timestamp
@@ -147,11 +147,11 @@ class OauthUtil
   # organize params & create signature
   def sign(parsed_url)
     @params = {
-      "oauth_consumer_key" => @consumer_key,
-      "oauth_nonce" => nonce,
-      "oauth_signature_method" => @sig_method,
-      "oauth_timestamp" => timestamp,
-      "oauth_version" => @oauth_version,
+      'oauth_consumer_key' => @consumer_key,
+      'oauth_nonce' => nonce,
+      'oauth_signature_method' => @sig_method,
+      'oauth_timestamp' => timestamp,
+      'oauth_version' => @oauth_version,
     }
 
     # if url has query, merge key/values into params obj overwriting defaults
@@ -166,7 +166,7 @@ class OauthUtil
     end
 
     # @ref http://oauth.net/core/1.0/#rfc.section.9.1.2
-    @req_url = parsed_url.scheme + "://" + parsed_url.host + parsed_url.path
+    @req_url = parsed_url.scheme + '://' + parsed_url.host + parsed_url.path
 
     # create base str. make it an object attr for ez debugging
     # ref http://oauth.net/core/1.0/#anchor14
@@ -177,10 +177,10 @@ class OauthUtil
       # normalization is just x-www-form-urlencoded
       percent_encode(query_string),
 
-    ].join("&")
+    ].join('&')
 
     # add signature
-    @params["oauth_signature"] = signature
+    @params['oauth_signature'] = signature
 
     self
   end