geokit 1.8.5 → 1.9.0

data/lib/geokit/geocoders/geonames.rb

@@ -3,7 +3,7 @@ module Geokit
     # Another geocoding web service
     # http://www.geonames.org
     class GeonamesGeocoder < Geocoder
-      config :key
+      config :key, :premium
 
       private
 
@@ -13,29 +13,35 @@ module Geokit
       end
 
       def self.submit_url(address)
+        if key.nil? || key.empty?
+          raise Geokit::Geocoders::GeocodeError.new('Geonames requires a key to use their service.')
+        end
+
         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"
+        address_str.gsub!(/,/, ' ')
+        params = "/postalCodeSearch?placename=#{Geokit::Inflector.url_escape(address_str)}&maxRows=10"
 
-        if key
+        if premium
           "http://ws.geonames.net#{params}&username=#{key}"
         else
-          "http://ws.geonames.org#{params}"
+          "http://api.geonames.org#{params}&username=#{key}"
         end
       end
 
       XML_MAPPINGS = {
-        :city         => 'name',
-        :state        => 'adminName1',
-        :zip          => 'postalcode',
-        :country_code => 'countryCode',
-        :lat          => 'lat',
-        :lng          => 'lng'
+        city:         'name',
+        state_name:   'adminName1',
+        state_code:   'adminCode1',
+        zip:          'postalcode',
+        country_code: 'countryCode',
+        lat:          'lat',
+        lng:          'lng'
       }
 
       def self.parse_xml(xml)
-        return GeoLoc.new unless xml.elements['geonames/totalResultsCount'].text.to_i > 0
+        count = xml.elements['geonames/totalResultsCount']
+        return GeoLoc.new unless !count.nil? && count.text.to_i > 0
         loc = new_loc
         # only take the first result
         set_mappings(loc, xml.elements['geonames/code'], XML_MAPPINGS)

data/lib/geokit/geocoders/google.rb

@@ -5,11 +5,12 @@ module Geokit
       self.secure = true
 
       private
+
       # ==== OPTIONS
       # * :language - See: https://developers.google.com/maps/documentation/geocoding
       def self.do_reverse_geocode(latlng, options = {})
-        latlng=LatLng.normalize(latlng)
-        url = submit_url("latlng=#{Geokit::Inflector::url_escape(latlng.ll)}", options)
+        latlng = LatLng.normalize(latlng)
+        url = submit_url("latlng=#{Geokit::Inflector.url_escape(latlng.ll)}", options)
         process :json, url
       end
 
@@ -25,10 +26,10 @@ module Geokit
       #           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 Toledo, OH
+      # Geokit::Geocoders::GoogleGeocoder.geocode('Toledo').country_code # => 'US'
+      # # With country code biasing, it returns Toledo (spannish city), Spain
+      # Geokit::Geocoders::GoogleGeocoder.geocode('Toledo', :bias => :es).country_code # => 'Es'
       #
       # # By default, the geocoder will return Winnetka, IL
       # Geokit::Geocoders::GoogleGeocoder.geocode('Winnetka').state # => 'IL'
@@ -38,7 +39,7 @@ module Geokit
       def self.do_geocode(address, options = {})
         bias_str = options[:bias] ? construct_bias_string_from_options(options[:bias]) : ''
         address_str = address.is_a?(GeoLoc) ? address.to_geocodeable_s : address
-        url = submit_url("address=#{Geokit::Inflector::url_escape(address_str)}#{bias_str}", options)
+        url = submit_url("address=#{Geokit::Inflector.url_escape(address_str)}#{bias_str}", options)
         process :json, url
       end
 
@@ -48,14 +49,13 @@ module Geokit
         require 'base64'
         require 'openssl'
         # Decode the private key
-        rawKey = Base64.decode64(google_cryptographic_key.tr('-_','+/'))
+        rawKey = Base64.decode64(google_cryptographic_key.tr('-_', '+/'))
         # create a signature using the private key and the URL
         rawSignature = OpenSSL::HMAC.digest('sha1', rawKey, urlToSign)
         # encode the signature into base64 for url use form.
-        Base64.encode64(rawSignature).tr('+/','-_').gsub(/\n/, '')
+        Base64.encode64(rawSignature).tr('+/', '-_').gsub(/\n/, '')
       end
 
-
       def self.submit_url(query_string, options = {})
         language_str = options[:language] ? "&language=#{options[:language]}" : ''
         query_string = "/maps/api/geocode/json?sensor=false&#{query_string}#{language_str}"
@@ -72,7 +72,6 @@ module Geokit
         end
       end
 
-
       def self.construct_bias_string_from_options(bias)
         case bias
         when String, Symbol
@@ -80,7 +79,7 @@ module Geokit
           "&region=#{bias.to_s.downcase}"
         when Bounds
           # viewport biasing
-          url_escaped_string = Geokit::Inflector::url_escape("#{bias.sw.to_s}|#{bias.ne.to_s}")
+          url_escaped_string = Geokit::Inflector.url_escape("#{bias.sw}|#{bias.ne}")
           "&bounds=#{url_escaped_string}"
         end
       end
@@ -99,13 +98,12 @@ module Geokit
           single_json_to_geoloc(addr)
         end
 
-        all = unsorted.sort_by(&:accuracy).reverse
+        all = unsorted.sort {|a, b| b.accuracy <=> a.accuracy }
         encoded = all.first
         encoded.all = all
         encoded
       end
 
-
       # location_type stores additional data about the specified location.
       # The following values are currently supported:
       # "ROOFTOP" indicates that the returned result is a precise geocode
@@ -123,10 +121,10 @@ module Geokit
       # these do not map well. Perhaps we should guess better based on size
       # of bounding box where it exists? Does it really matter?
       ACCURACY = {
-        "ROOFTOP" => 9,
-        "RANGE_INTERPOLATED" => 8,
-        "GEOMETRIC_CENTER" => 5,
-        "APPROXIMATE" => 4
+        'ROOFTOP' => 9,
+        'RANGE_INTERPOLATED' => 8,
+        'GEOMETRIC_CENTER' => 5,
+        'APPROXIMATE' => 4
       }
 
       def self.single_json_to_geoloc(addr)
@@ -137,7 +135,7 @@ module Geokit
         set_address_components(loc, addr)
         set_precision(loc, addr)
         if loc.street_name
-          loc.street_address=[loc.street_number, loc.street_name].join(' ').strip
+          loc.street_address = [loc.street_number, loc.street_name].join(' ').strip
         end
 
         ll = addr['geometry']['location']
@@ -160,39 +158,42 @@ module Geokit
         addr['address_components'].each do |comp|
           types = comp['types']
           case
-          when types.include?("subpremise")
+          when types.include?('subpremise')
             loc.sub_premise = comp['short_name']
-          when types.include?("street_number")
+          when types.include?('street_number')
             loc.street_number = comp['short_name']
-          when types.include?("route")
+          when types.include?('route')
             loc.street_name = comp['long_name']
-          when types.include?("locality")
+          when types.include?('locality')
             loc.city = comp['long_name']
-          when types.include?("administrative_area_level_1")
-            loc.state = comp['short_name']
+          when types.include?('administrative_area_level_1')
+            loc.state_code = comp['short_name']
+            loc.state_name = comp['long_name']
             loc.province = comp['short_name']
-          when types.include?("postal_code")
+          when types.include?('postal_code')
             loc.zip = comp['long_name']
-          when types.include?("country")
+          when types.include?('country')
             loc.country_code = comp['short_name']
             loc.country = comp['long_name']
-          when types.include?("administrative_area_level_2")
+          when types.include?('administrative_area_level_2')
             loc.district = comp['long_name']
           when types.include?('neighborhood')
             loc.neighborhood = comp['short_name']
+          when types.include?('sublocality')
+            loc.city = comp['long_name'] if loc.city.nil?
           end
         end
       end
 
       def self.set_precision(loc, addr)
         loc.accuracy = ACCURACY[addr['geometry']['location_type']]
-        loc.precision=%w{unknown country state state city zip zip+4 street address building}[loc.accuracy]
+        loc.precision = %w{unknown country state state city zip zip+4 street address building}[loc.accuracy]
         # try a few overrides where we can
         if loc.sub_premise
           loc.accuracy = 9
           loc.precision = 'building'
         end
-        if loc.street_name && loc.precision=='city'
+        if loc.street_name && loc.precision == 'city'
           loc.precision = 'street'
           loc.accuracy = 7
         end

data/lib/geokit/geocoders/ip.rb

@@ -34,7 +34,7 @@ module Geokit
       # then instantiates a GeoLoc instance to populate with location data.
       def self.parse_yaml(yaml) # :nodoc:
         loc = new_loc
-        loc.city, loc.state = yaml['City'].split(', ')
+        loc.city, loc.state_code = yaml['City'].split(', ')
         loc.country, loc.country_code = yaml['Country'].split(' (')
         loc.lat = yaml['Latitude']
         loc.lng = yaml['Longitude']
@@ -51,10 +51,10 @@ module Geokit
         if (enc_string = extract_charset(res))
           if defined?(Encoding) && Encoding.aliases.values.include?(enc_string.upcase)
             res.body.force_encoding(enc_string.upcase) if res.body.respond_to?(:force_encoding)
-            res.body.encode("UTF-8")
+            res.body.encode('UTF-8')
           else
             require 'iconv'
-            res.body.replace Iconv.conv("UTF8", "iso88591", res.body)
+            res.body.replace Iconv.conv('UTF8', 'iso88591', res.body)
           end
         end
       end
@@ -69,4 +69,3 @@ module Geokit
     end
   end
 end
-

data/lib/geokit/geocoders/mapbox.rb

@@ -0,0 +1,94 @@
+module Geokit
+  module Geocoders
+    # Mapbox geocoder implementation.  Requires the Geokit::Geocoders::MapboxGeocoder:key variable to
+    # contain a Mapbox access token.  Conforms to the interface set by the Geocoder class.
+    class MapboxGeocoder < Geocoder
+      config :key
+      self.secure = true
+
+      private
+
+      # Template method which does the reverse-geocode lookup.
+      def self.do_reverse_geocode(latlng)
+        latlng = LatLng.normalize(latlng)
+        url =  "#{protocol}://api.tiles.mapbox.com/v4/geocode/mapbox.places-v1/"
+        url += "#{latlng.lng},#{latlng.lat}.json?access_token=#{key}"
+        process :json, url
+      end
+
+      # Template method which does the geocode lookup.
+      def self.do_geocode(address)
+        address_str = address.is_a?(GeoLoc) ? address.to_geocodeable_s : address
+        url =  "#{protocol}://api.tiles.mapbox.com/v4/geocode/mapbox.places-v1/"
+        url += "#{Geokit::Inflector.url_escape(address_str)}.json?access_token=#{key}"
+        process :json, url
+      end
+
+      def self.parse_json(results)
+        return GeoLoc.new unless results['features'].count > 0
+        loc = nil
+        results['features'].each do |feature|
+          extracted_geoloc = extract_geoloc(feature)
+          if loc.nil?
+            loc = extracted_geoloc
+          else
+            loc.all.push(extracted_geoloc)
+          end
+        end
+        loc
+      end
+
+      def self.extract_geoloc(result_json)
+        loc = new_loc
+        loc.lng = result_json['center'][0]
+        loc.lat = result_json['center'][1]
+        set_address_components(result_json, loc)
+        set_precision(loc)
+        set_bounds(result_json['bbox'], loc)
+        loc.success = true
+        loc
+      end
+
+      def self.set_address_components(result_json, loc)
+        if result_json['context']
+          result_json['context'].each do |context|
+            if context['id'] =~ /^country\./
+              loc.country = context['text']
+            elsif context['id'] =~ /^province\./
+              loc.state = context['text']
+            elsif context['id'] =~ /^city\./
+              loc.city = context['text']
+            elsif context['id'] =~ /^postcode-/
+              loc.zip = context['text']
+              loc.country_code = context['id'].split('.')[0].gsub(/^postcode-/, '').upcase
+            end
+          end
+          if loc.country_code && !loc.country
+            loc.country = loc.country_code
+          end
+        end
+        if result_json['place_name']
+          loc.full_address = result_json['place_name']
+        end
+      end
+
+      PRECISION_VALUES = %w{unknown country state city zip full_address}
+
+      def self.set_precision(loc)
+        for i in 1...PRECISION_VALUES.length - 1
+          if loc.send(PRECISION_VALUES[i]) && loc.send(PRECISION_VALUES[i]).length
+            loc.precision = PRECISION_VALUES[i]
+          else
+            break
+          end
+        end
+      end
+
+      def self.set_bounds(result_json, loc)
+        if bounds = result_json
+          loc.suggested_bounds = Bounds.normalize([bounds[1], bounds[0]], [bounds[3], bounds[2]])
+        end
+      end
+    end
+  end
+end

data/lib/geokit/geocoders/mapquest.rb

@@ -1,7 +1,7 @@
 module Geokit
   module Geocoders
-    # MapQuest geocoder implementation.  Requires the Geokit::Geocoders::mapquest variable to
-    # contain a MapQuest API key.  Conforms to the interface set by the Geocoder class.
+    # MapQuest geocoder implementation.  Requires the Geokit::Geocoders::MapQuestGeocoder:key
+    # variable to contain a MapQuest API key.  Conforms to the interface set by the Geocoder class.
     class MapQuestGeocoder < Geocoder
       config :key
       self.secure = true
@@ -10,7 +10,7 @@ module Geokit
 
       # Template method which does the reverse-geocode lookup.
       def self.do_reverse_geocode(latlng)
-        latlng=LatLng.normalize(latlng)
+        latlng = LatLng.normalize(latlng)
         url = "#{protocol}://www.mapquestapi.com/geocoding/v1/reverse?key=#{key}&location=#{latlng.lat},#{latlng.lng}"
         process :json, url
       end
@@ -18,7 +18,7 @@ module Geokit
       # Template method which does the geocode lookup.
       def self.do_geocode(address)
         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)}"
+        url = "#{protocol}://www.mapquestapi.com/geocoding/v1/address?key=#{key}&location=#{Geokit::Inflector.url_escape(address_str)}"
         process :json, url
       end
 
@@ -34,7 +34,7 @@ module Geokit
               loc.all.push(extracted_geoloc)
             end
           end
-        end          
+        end
         loc
       end
 

data/lib/geokit/geocoders/opencage.rb

@@ -0,0 +1,93 @@
+module Geokit
+  module Geocoders
+    # OpenCage geocoder implementation.  Requires the Geokit::Geocoders::OpencageGeocoder.key
+    # variable to contain an API key.  Conforms to the interface set by the Geocoder class.
+    class OpencageGeocoder < Geocoder
+      config :key
+      self.secure = true
+
+      private
+
+      # Template method which does the geocode lookup.
+      def self.do_geocode(address, options = {})
+        options_str = generate_param_for_option(:language, options)
+        options_str << generate_param_for_option(:bounds, options)
+        options_str << generate_param_for_option(:min_confidence, options)
+
+        address_str = address.is_a?(GeoLoc) ? address.to_geocodeable_s : address
+        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'
+        process :json, url
+      end
+            # Template method which does the reverse-geocode lookup.
+      def self.do_reverse_geocode(latlng)
+        latlng = LatLng.normalize(latlng)
+        url = "#{protocol}://api.opencagedata.com/geocode/v1/json?"
+        url += "key=#{key}&query=#{latlng.lat},#{latlng.lng}"
+        process :json, url
+      end
+
+      def self.generate_param_for(param, value)
+        "&#{param}=#{Geokit::Inflector.url_escape(value.to_s)}"
+      end
+
+      def self.generate_param_for_option(param, options)
+        options[param] ? "&#{param}=#{Geokit::Inflector.url_escape(options[param])}" : ''
+      end
+
+      def self.generate_bool_param_for_option(param, options)
+        options[param] ? "&#{param}=1" : "&#{param}=0"
+      end
+
+      def self.parse_json(results)
+        return GeoLoc.new if results.empty?
+        if results.is_a?(Hash)
+          return GeoLoc.new unless results['status']['message'] == 'OK'
+        end
+
+        loc = nil
+        results['results'].each do |result|
+          extracted_geoloc = extract_geoloc(result)
+          if loc.nil?
+            loc = extracted_geoloc
+          else
+            loc.all.push(extracted_geoloc)
+          end
+        end
+        loc
+      end
+
+      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)
+        set_precision(result_json, loc)
+        loc.success = true
+        loc
+      end
+
+      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']
+      end
+
+      def self.set_precision(result_json, loc)
+        # a value between 1 (worse) and 10 (best). 0 means unknown
+        loc.precision = result_json['confidence']
+      end
+    end
+  end
+end