geokit 1.10.0 → 1.11.0

data/lib/geokit/geocoders/geonames.rb

@@ -8,18 +8,18 @@ module Geokit
       private
 
       # Template method which does the geocode lookup.
-      def self.do_geocode(address)
+      def self.do_geocode(address, _=nil)
         process :xml, submit_url(address)
       end
 
       def self.submit_url(address)
         if key.nil? || key.empty?
-          raise(Geokit::Geocoders::GeocodeError, "Geonames requires a key to use their service.")
+          raise(Geokit::Geocoders::GeocodeError, '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!(/,/, " ")
+        address_str.gsub!(/,/, ' ')
         params = "/postalCodeSearch?placename=#{Geokit::Inflector.url_escape(address_str)}&maxRows=10"
 
         if premium
@@ -30,21 +30,21 @@ module Geokit
       end
 
       XML_MAPPINGS = {
-        city:         "name",
-        state_name:   "adminName1",
-        state_code:   "adminCode1",
-        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)
-        count = xml.elements["geonames/totalResultsCount"]
+        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)
+        set_mappings(loc, xml.elements['geonames/code'], XML_MAPPINGS)
         loc.success = true
         loc
       end

data/lib/geokit/geocoders/google.rb

@@ -8,9 +8,18 @@ module Geokit
 
       # ==== OPTIONS
       # * :language - See: https://developers.google.com/maps/documentation/geocoding
+      # * :result_type - This option allows restricting results by specific result types.
+      #                  See https://developers.google.com/maps/documentation/geocoding/intro#reverse-restricted
+      #                  Note: This parameter is available only for requests that include an API key or a client ID.
+      # * :location_type - This option allows restricting results by specific location type.
+      #                    See https://developers.google.com/maps/documentation/geocoding/intro#reverse-restricted
+      #                    Note: This parameter is available only for requests that include an API key or a client ID.
       def self.do_reverse_geocode(latlng, options = {})
         latlng = LatLng.normalize(latlng)
-        url = submit_url("latlng=#{Geokit::Inflector.url_escape(latlng.ll)}", options)
+        latlng_str = "latlng=#{Geokit::Inflector.url_escape(latlng.ll)}"
+        result_type_str = options[:result_type] ? "&result_type=#{options[:result_type]}" : ''
+        location_type_str = options[:location_type] ? "&location_type=#{options[:location_type]}" : ''
+        url = submit_url("#{latlng_str}#{result_type_str}#{location_type_str}", options)
         process :json, url
       end
 
@@ -24,6 +33,9 @@ module Geokit
       #
       #           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.
+      # * :components - This option allows restricting results by specific areas. See
+      #           https://developers.google.com/maps/documentation/geocoding/intro#ComponentFiltering
+      #           for details.
       #
       # ==== EXAMPLES
       # # By default, the geocoder will return Toledo, OH
@@ -36,31 +48,40 @@ module Geokit
       # # 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'
+      #
+      # # By default, the geocoder will return several matches for Austin with
+      # the first one being in Texas
+      # Geokit::Geocoders::GoogleGeocoder.geocode('Austin').state # => 'TX'
+      # # Using Component Filtering the results can be restricted to a specific
+      # area, e.g. IL
+      # Geokit::Geocoders::GoogleGeocoder.geocode('Austin',
+      #   :components => {administrative_area: 'IL', country: 'US'}).state # => 'IL'
       def self.do_geocode(address, options = {})
-        bias_str = options[:bias] ? construct_bias_string_from_options(options[:bias]) : ""
+        bias_str = options[:bias] ? construct_bias_string_from_options(options[:bias]) : ''
+        components_str = options[:components] ? construct_components_string_from_options(options[:components]) : ''
         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}#{components_str}", options)
         process :json, url
       end
 
       # This code comes from Googles Examples
       # http://gmaps-samples.googlecode.com/svn/trunk/urlsigning/urlsigner.rb
       def self.sign_gmap_bus_api_url(urlToSign, google_cryptographic_key)
-        require "base64"
-        require "openssl"
+        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)
+        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]}" : ""
+        language_str = options[:language] ? "&language=#{options[:language]}" : ''
         query_string = "/maps/api/geocode/json?sensor=false&#{query_string}#{language_str}"
         if client_id && cryptographic_key
-          channel_string = channel ? "&channel=#{channel}" : ""
+          channel_string = channel ? "&channel=#{channel}" : ''
           urlToSign = query_string + "&client=#{client_id}" + channel_string
           signature = sign_gmap_bus_api_url(urlToSign, cryptographic_key)
           "#{protocol}://maps.googleapis.com" + urlToSign + "&signature=#{signature}"
@@ -84,21 +105,27 @@ module Geokit
         end
       end
 
+      def self.construct_components_string_from_options(components={})
+        unless components.empty?
+          "&components=#{components.to_a.map { |pair| pair.join(':').downcase }.join(CGI.escape('|'))}"
+        end
+      end
+
       def self.parse_json(results)
-        case results["status"]
-        when "OVER_QUERY_LIMIT"
-          raise Geokit::Geocoders::TooManyQueriesError, results["error_message"]
-        when "REQUEST_DENIED"
-          raise Geokit::Geocoders::AccessDeniedError, results["error_message"]
-        when "ZERO_RESULTS"
+        case results['status']
+        when 'OVER_QUERY_LIMIT'
+          raise Geokit::Geocoders::TooManyQueriesError, results['error_message']
+        when 'REQUEST_DENIED'
+          raise Geokit::Geocoders::AccessDeniedError, results['error_message']
+        when 'ZERO_RESULTS'
           return GeoLoc.new
-        when "OK"
+        when 'OK'
           # all good
         else
-          raise Geokit::Geocoders::GeocodeError, results["error_message"]
+          raise Geokit::Geocoders::GeocodeError, results['error_message']
         end
 
-        unsorted = results["results"].map do |addr|
+        unsorted = results['results'].map do |addr|
           single_json_to_geoloc(addr)
         end
 
@@ -125,10 +152,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,
       }
 
       PRECISIONS = %w(unknown country state state city zip zip+4 street address building)
@@ -136,17 +163,17 @@ module Geokit
       def self.single_json_to_geoloc(addr)
         loc = new_loc
         loc.success = true
-        loc.full_address = addr["formatted_address"]
+        loc.full_address = addr['formatted_address']
 
         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"]
-        loc.lat = ll["lat"].to_f
-        loc.lng = ll["lng"].to_f
+        ll = addr['geometry']['location']
+        loc.lat = ll['lat'].to_f
+        loc.lng = ll['lng'].to_f
 
         set_bounds(loc, addr)
 
@@ -157,59 +184,60 @@ module Geokit
       end
 
       def self.set_bounds(loc, addr)
-        viewport = addr["geometry"]["viewport"]
-        ne = Geokit::LatLng.from_json(viewport["northeast"])
-        sw = Geokit::LatLng.from_json(viewport["southwest"])
+        viewport = addr['geometry']['viewport']
+        ne = Geokit::LatLng.from_json(viewport['northeast'])
+        sw = Geokit::LatLng.from_json(viewport['southwest'])
         loc.suggested_bounds = Geokit::Bounds.new(sw, ne)
       end
 
       def self.set_address_components(loc, addr)
-        addr["address_components"].each do |comp|
-          types = comp["types"]
+        addr['address_components'].each do |comp|
+          types = comp['types']
           case
-          when types.include?("subpremise")
-            loc.sub_premise = comp["short_name"]
-          when types.include?("street_number")
-            loc.street_number = comp["short_name"]
-          when types.include?("route")
-            loc.street_name = comp["long_name"]
-          when types.include?("locality")
-            loc.city = comp["long_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")
-            loc.zip = comp["long_name"]
-          when types.include?("country")
-            loc.country_code = comp["short_name"]
-            loc.country = comp["long_name"]
-          when types.include?("administrative_area_level_2")
-            loc.district = comp["long_name"]
-          when types.include?("neighborhood")
-            loc.neighborhood = comp["short_name"]
+          when types.include?('subpremise')
+            loc.sub_premise = comp['short_name']
+          when types.include?('street_number')
+            loc.street_number = comp['short_name']
+          when types.include?('route')
+            loc.street_name = comp['long_name']
+          when types.include?('locality')
+            loc.city = comp['long_name']
+          when types.include?('administrative_area_level_1') # state
+            loc.state_code = comp['short_name']
+            loc.state_name = comp['long_name']
+          when types.include?('postal_town')
+            loc.city = comp['long_name']
+          when types.include?('postal_code')
+            loc.zip = comp['long_name']
+          when types.include?('country')
+            loc.country_code = comp['short_name']
+            loc.country = comp['long_name']
+          when types.include?('administrative_area_level_2')
+            loc.district = comp['long_name']
+          when types.include?('neighborhood')
+            loc.neighborhood = comp['short_name']
           # Use either sublocality or admin area level 3 if google does not return a city
-          when types.include?("sublocality")
-            loc.city = comp["long_name"] if loc.city.nil?
-          when types.include?("administrative_area_level_3")
-            loc.city = comp["long_name"] if loc.city.nil?
+          when types.include?('sublocality')
+            loc.city = comp['long_name'] if loc.city.nil?
+          when types.include?('administrative_area_level_3')
+            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.accuracy = ACCURACY[addr['geometry']['location_type']]
         loc.precision = PRECISIONS[loc.accuracy]
         # try a few overrides where we can
         if loc.sub_premise
           loc.precision = PRECISIONS[9]
           loc.accuracy  = 9
         end
-        if loc.street_name && loc.precision == "city"
+        if loc.street_name && loc.precision == 'city'
           loc.precision = PRECISIONS[7]
           loc.accuracy  = 7
         end
-        if addr["types"].include?("postal_code")
+        if addr['types'].include?('postal_code')
           loc.precision = PRECISIONS[6]
           loc.accuracy  = 6
         end

data/lib/geokit/geocoders/ip.rb

@@ -9,14 +9,14 @@ module Geokit
       # 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)
+      def self.do_geocode(ip, _=nil)
         return GeoLoc.new unless valid_ip?(ip)
         url = submit_url(ip)
         res = call_geocoder_service(url)
         return GeoLoc.new unless net_adapter.success?(res)
         ensure_utf8_encoding(res)
         body = res.body
-        body = body.encode("UTF-8") if body.respond_to? :encode
+        body = body.encode('UTF-8') if body.respond_to? :encode
         parse :yaml, body
       end
 
@@ -34,10 +34,10 @@ 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_code = yaml["City"].split(", ")
-        loc.country, loc.country_code = yaml["Country"].split(" (")
-        loc.lat = yaml["Latitude"]
-        loc.lng = yaml["Longitude"]
+        loc.city, loc.state_code = yaml['City'].split(', ')
+        loc.country, loc.country_code = yaml['Country'].split(' (')
+        loc.lat = yaml['Latitude']
+        loc.lng = yaml['Longitude']
         loc.country_code.chop!
         loc.success = !(loc.city =~ /\(.+\)/)
         loc
@@ -49,19 +49,14 @@ module Geokit
       # thus extract encoding from headers and tell Rails about it by forcing it
       def self.ensure_utf8_encoding(res)
         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")
-          else
-            require "iconv"
-            res.body.replace Iconv.conv("UTF8", "iso88591", res.body)
-          end
+          res.body.force_encoding(enc_string.upcase) if res.body.respond_to?(:force_encoding)
+          res.body.encode('UTF-8')
         end
       end
 
       # Extracts charset out of the response headers
       def self.extract_charset(res)
-        if (content_type = res["content-type"])
+        if (content_type = res['content-type'])
           capture = content_type.match(/charset=(.+)/)
           capture && capture[1]
         end

data/lib/geokit/geocoders/mapbox.rb

@@ -9,7 +9,7 @@ module Geokit
       private
 
       # Template method which does the reverse-geocode lookup.
-      def self.do_reverse_geocode(latlng, options = {})
+      def self.do_reverse_geocode(latlng, _options = nil)
         latlng = LatLng.normalize(latlng)
         url =  "#{protocol}://api.tiles.mapbox.com/v4/geocode/mapbox.places-v1/"
         url += "#{latlng.lng},#{latlng.lat}.json?access_token=#{key}"
@@ -17,7 +17,7 @@ module Geokit
       end
 
       # Template method which does the geocode lookup.
-      def self.do_geocode(address, options = {})
+      def self.do_geocode(address, _options = nil)
         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}"
@@ -25,9 +25,9 @@ module Geokit
       end
 
       def self.parse_json(results)
-        return GeoLoc.new unless results["features"].count > 0
+        return GeoLoc.new unless results['features'].count > 0
         loc = nil
-        results["features"].each do |feature|
+        results['features'].each do |feature|
           extracted_geoloc = extract_geoloc(feature)
           if loc.nil?
             loc = extracted_geoloc
@@ -40,52 +40,52 @@ module Geokit
 
       def self.extract_geoloc(result_json)
         loc = new_loc
-        loc.lng = result_json["center"][0]
-        loc.lat = result_json["center"][1]
+        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)
+        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"]
+        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']
             end
           end
           loc.country = loc.country_code if loc.country_code && !loc.country
         end
-        if result_json["place_name"]
-          loc.full_address = result_json["place_name"]
+        if result_json['place_name']
+          loc.full_address = result_json['place_name']
         end
-        if !loc.city && result_json["id"] =~ /^city\./
-          loc.city = result_json["text"]
+        if !loc.city && result_json['id'] =~ /^city\./
+          loc.city = result_json['text']
+        end
+        if !loc.state && result_json['id'] =~ /^province\./
+          loc.state = result_json['text']
         end
       end
 
-      PRECISION_VALUES = %w(unknown country state city zip full_address)
+      PRECISION_VALUES = %w(country state city zip)
 
       def self.set_precision(loc)
-        (1...PRECISION_VALUES.length - 1).each do |i|
-          if loc.send(PRECISION_VALUES[i]) && loc.send(PRECISION_VALUES[i]).length
-            loc.precision = PRECISION_VALUES[i]
-          else
-            break
-          end
+        PRECISION_VALUES.each do |precision|
+          break unless loc.send(precision) && loc.send(precision).length
+          loc.precision = precision
         end
       end
 
-      def self.set_bounds(result_json, loc)
-        if bounds = result_json
+      def self.set_bounds(bounds, loc)
+        if bounds
           loc.suggested_bounds = Bounds.normalize([bounds[1], bounds[0]], [bounds[3], bounds[2]])
         end
       end