geokit 1.10.0 → 1.11.0

data/lib/geokit.rb

@@ -22,10 +22,10 @@ end
 
 path = File.expand_path(File.dirname(__FILE__))
 $:.unshift path unless $:.include?(path)
-require "geokit/core_ext"
-require "geokit/geocoders"
-require "geokit/mappable"
-require "geokit/bounds"
-require "geokit/lat_lng"
-require "geokit/geo_loc"
-require "geokit/polygon"
+require 'geokit/core_ext'
+require 'geokit/geocoders'
+require 'geokit/mappable'
+require 'geokit/bounds'
+require 'geokit/lat_lng'
+require 'geokit/geo_loc'
+require 'geokit/polygon'

data/lib/geokit/core_ext.rb

@@ -10,7 +10,7 @@ unless nil.respond_to?(:try)
   end
 
   class NilClass
-    def try(*args)
+    def try(*_args)
       nil
     end
   end

data/lib/geokit/geo_loc.rb

@@ -25,16 +25,16 @@ module Geokit
     # 100 Spear St, San Francisco, CA, 94101, US
     # Street number and street name are extracted from the street address
     # attribute if they don't exist
-    attr_accessor :street_number, :street_name, :street_address, :city, :state,
-                  :state_name, :state_code, :zip, :country_code, :country
-    attr_accessor :full_address, :all, :district, :province, :sub_premise,
+    attr_accessor :state_name, :state_code, :zip, :country_code, :country
+    attr_accessor :all, :district, :sub_premise,
                   :neighborhood
+    attr_writer :state, :full_address, :street_number, :street_name, :formatted_address
+    attr_reader :city, :street_address
     # Attributes set upon return from geocoding. Success will be true for
     # successful geocode lookups. The provider will be set to the name of the
     # providing geocoder. Finally, precision is an indicator of the accuracy of
     # the geocoding.
-    attr_accessor :success, :provider, :precision, :suggested_bounds, :place_id,
-                  :formatted_address
+    attr_accessor :success, :provider, :precision, :suggested_bounds, :place_id
     # accuracy is set for Yahoo and Google geocoders, it is a numeric value of
     # the precision. see
     # http://code.google.com/apis/maps/documentation/geocoding/#GeocodingAccuracy
@@ -42,10 +42,17 @@ module Geokit
     # FCC Attributes
     attr_accessor :district_fips, :state_fips, :block_fips
 
+    def province
+      state
+    end
+
     # Constructor expects a hash of symbols to correspond with attributes.
     def initialize(h = {})
       @all = [self]
-
+      
+      # sanatises the GeoLoc object so that it conforms to []
+      h = h.to_hash
+      
       @street_address = h[:street_address]
       @sub_premise = nil
       @street_number = nil
@@ -56,9 +63,8 @@ module Geokit
       @state_name = h[:state_name]
       @zip = h[:zip]
       @country_code = h[:country_code]
-      @province = h[:province]
       @success = false
-      @precision = "unknown"
+      @precision = 'unknown'
       @full_address = nil
       super(h[:lat], h[:lng])
     end
@@ -69,7 +75,7 @@ module Geokit
 
     # Returns true if geocoded to the United States.
     def is_us?
-      country_code == "US"
+      country_code == 'US'
     end
 
     def success?
@@ -104,7 +110,7 @@ module Geokit
     def hash
       res = {}
       fields = [:success, :lat, :lng, :country_code, :city, :state, :zip,
-       :street_address, :province, :district, :provider, :full_address, :is_us?,
+       :street_address, :district, :provider, :full_address, :is_us?,
        :ll, :precision, :district_fips, :state_fips, :block_fips, :sub_premise]
       fields.each { |s| res[s] = send(s.to_s) }
       res
@@ -119,24 +125,24 @@ module Geokit
     # Sets the street address after capitalizing each word within the street
     # address.
     def street_address=(address)
-      @street_address = if address && provider != "google"
-        Geokit::Inflector.titleize(address)
-      else
-        address
-      end
+      @street_address = if address && provider != 'google'
+                          Geokit::Inflector.titleize(address)
+                        else
+                          address
+                        end
     end
 
     # Returns a comma-delimited string consisting of the street address, city,
     # state, zip, and country code.  Only includes those attributes that are
     # non-blank.
     def to_geocodeable_s
-      a = [street_address, district, city, province, state, zip, country_code].compact
-      a.delete_if { |e| !e || e == "" }
-      a.join(", ")
+      a = [street_address, district, city, state, zip, country_code].compact
+      a.delete_if { |e| !e || e == '' }
+      a.join(', ')
     end
 
     def to_yaml_properties
-      (instance_variables - ["@all", :@all]).sort
+      (instance_variables - ['@all', :@all]).sort
     end
 
     def encode_with(coder)

data/lib/geokit/geocoders.rb

@@ -1,16 +1,16 @@
-require "geokit/net_adapter/net_http"
-require "geokit/net_adapter/typhoeus"
-require "ipaddr"
-require "json"
-require "logger"
-require "net/http"
-require "openssl"
-require "rexml/document"
-require "timeout"
-require "yaml"
+require 'geokit/net_adapter/net_http'
+require 'geokit/net_adapter/typhoeus'
+require 'ipaddr'
+require 'json'
+require 'logger'
+require 'net/http'
+require 'openssl'
+require 'rexml/document'
+require 'timeout'
+require 'yaml'
 
 module Geokit
-  require File.join(File.dirname(__FILE__), "inflectors")
+  require File.join(File.dirname(__FILE__), 'inflectors')
 
   # Contains a range of geocoders:
   #
@@ -33,6 +33,7 @@ module Geokit
   # Some of these geocoders require configuration. You don't have to provide it here. See the README.
   module Geocoders
     @@proxy = nil
+    @@useragent = nil
     @@request_timeout = nil
     @@provider_order = [:google, :us]
     @@ip_provider_order = [:geo_plugin, :ip]
@@ -45,7 +46,7 @@ module Geokit
 
     def self.__define_accessors
       class_variables.each do |v|
-        sym = v.to_s.delete("@").to_sym
+        sym = v.to_s.delete('@').to_sym
         next if self.respond_to? sym
         module_eval <<-EOS, __FILE__, __LINE__
           def self.#{sym}
@@ -138,14 +139,14 @@ module Geokit
       def self.call_geocoder_service(url)
         Timeout.timeout(Geokit::Geocoders.request_timeout) { return do_get(url) } if Geokit::Geocoders.request_timeout
         do_get(url)
-      rescue TimeoutError
+      rescue Timeout::Error
         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)
+      def self.do_reverse_geocode(_latlng)
         GeoLoc.new
       end
 
@@ -154,7 +155,7 @@ module Geokit
       end
 
       def self.protocol
-        use_https? ? "https" : "http"
+        use_https? ? 'https' : 'http'
       end
 
       # Wraps the geocoder call around a proxy if necessary.
@@ -167,7 +168,7 @@ module Geokit
       end
 
       def self.provider_name
-        name.split("::").last.gsub(/Geocoder$/, "")
+        name.split('::').last.gsub(/Geocoder$/, '')
       end
 
       def self.parse(format, body, *args)
@@ -176,7 +177,7 @@ module Geokit
         when :json then parse_json(JSON.load(body), *args)
         when :xml  then parse_xml(REXML::Document.new(body), *args)
         when :yaml then parse_yaml(YAML.load(body), *args)
-        when :csv  then parse_csv(body.chomp.split(","), *args)
+        when :csv  then parse_csv(body.chomp.split(','), *args)
         end
       end
 
@@ -191,24 +192,14 @@ module Geokit
         return GeoLoc.new unless net_adapter.success?(res)
         parse format, res.body, *args
       end
-
-      def self.transcode_to_utf8(body)
-        require "iconv" unless String.method_defined?(:encode)
-        if String.method_defined?(:encode)
-          body.encode!("UTF-8", "UTF-8", invalid: :replace)
-        else
-          ic = Iconv.new("UTF-8", "UTF-8//IGNORE")
-          ic.iconv(body)
-        end
-      end
     end
 
     # -------------------------------------------------------------------------------------------
     # "Regular" Address geocoders
     # -------------------------------------------------------------------------------------------
-    require File.join(File.dirname(__FILE__), "geocoders/base_ip")
-    Dir[File.join(File.dirname(__FILE__), "/geocoders/*.rb")].each { |f| require f }
+    require File.join(File.dirname(__FILE__), 'geocoders/base_ip')
+    Dir[File.join(File.dirname(__FILE__), '/geocoders/*.rb')].each { |f| require f }
 
-    require File.join(File.dirname(__FILE__), "multi_geocoder")
+    require File.join(File.dirname(__FILE__), 'multi_geocoder')
   end
 end

data/lib/geokit/geocoders/bing.rb

@@ -9,11 +9,11 @@ module Geokit
       private
 
       # Template method which does the geocode lookup.
-      def self.do_geocode(address)
+      def self.do_geocode(address, _=nil)
         url = submit_url(address)
         res = call_geocoder_service(url)
         return GeoLoc.new unless net_adapter.success?(res)
-        xml = transcode_to_utf8(res.body)
+        xml = res.body.encode!('UTF-8', 'UTF-8', invalid: :replace)
         parse :xml, xml
       end
 
@@ -51,7 +51,7 @@ module Geokit
         full_address:   'Address/FormattedAddress',
         city:           'Address/Locality',
         state:          'Address/AdminDistrict',
-        province:       'Address/AdminDistrict2',
+        district:       'Address/AdminDistrict2',
         zip:            'Address/PostalCode',
         country:        'Address/CountryRegion',
         lat:            'Point/Latitude',
@@ -91,7 +91,8 @@ module Geokit
       end
 
       def self.set_bounds(loc, xml)
-        if suggested_bounds = xml.elements['.//BoundingBox']
+        suggested_bounds = xml.elements['.//BoundingBox']
+        if suggested_bounds
           bounds = suggested_bounds.elements
           loc.suggested_bounds = Bounds.normalize(
             [bounds['.//SouthLatitude'].text, bounds['.//WestLongitude'].text],

data/lib/geokit/geocoders/ca_geocoder.rb

@@ -17,19 +17,18 @@ module Geokit
       private
 
       # Template method which does the geocode lookup.
-      def self.do_geocode(loc)
+      def self.do_geocode(loc, _=nil)
         process :xml, submit_url(loc), GeoLoc.new
       end
 
       def self.parse_xml(xml, loc)
-        loc.lat = xml.elements["//latt"].text
-        loc.lng = xml.elements["//longt"].text
-        loc.city = xml.elements["//city"].text
-        loc.street_number = xml.elements["//stnumber"].text
-        loc.street_address = xml.elements["//staddress"].text
-        loc.state = xml.elements["//prov"].text
-        loc.province = xml.elements["//prov"].text
-        loc.zip = xml.elements["//postal"].text
+        loc.lat = xml.elements['//latt'].text
+        loc.lng = xml.elements['//longt'].text
+        loc.city = xml.elements['//city'].text
+        loc.street_number = xml.elements['//stnumber'].text
+        loc.street_address = xml.elements['//staddress'].text
+        loc.state = xml.elements['//prov'].text
+        loc.zip = xml.elements['//postal'].text
         loc.success = true
         loc
       end
@@ -38,8 +37,8 @@ module Geokit
       def self.submit_url(loc)
         args = ["locate=#{Geokit::Inflector.url_escape(loc)}"]
         args << "auth=#{key}" if key
-        args << "geoit=xml"
-        "http://geocoder.ca/?" + args.join("&")
+        args << 'geoit=xml'
+        'http://geocoder.ca/?' + args.join('&')
       end
     end
   end

data/lib/geokit/geocoders/fcc.rb

@@ -26,21 +26,21 @@ module Geokit
       # "status"=>"OK"}
 
       def self.parse_json(results)
-        if results.key?("Err") && results["Err"]["msg"] == "There are no results for this location"
+        if results.key?('Err') && results['Err']['msg'] == 'There are no results for this location'
           return GeoLoc.new
         end
         # this should probably be smarter.
-        raise Geokit::Geocoders::GeocodeError if !results["status"] == "OK"
+        raise Geokit::Geocoders::GeocodeError if !results['status'] == 'OK'
 
         loc = new_loc
         loc.success       = true
-        loc.precision     = "block"
-        loc.country_code  = "US"
-        loc.district      = results["County"]["name"]
-        loc.district_fips = results["County"]["FIPS"]
-        loc.state         = results["State"]["code"]
-        loc.state_fips    = results["State"]["FIPS"]
-        loc.block_fips    = results["Block"]["FIPS"]
+        loc.precision     = 'block'
+        loc.country_code  = 'US'
+        loc.district      = results['County']['name']
+        loc.district_fips = results['County']['FIPS']
+        loc.state         = results['State']['code']
+        loc.state_fips    = results['State']['FIPS']
+        loc.block_fips    = results['Block']['FIPS']
         loc
       end
     end

data/lib/geokit/geocoders/free_geo_ip.rb

@@ -4,7 +4,7 @@ module Geokit
     class FreeGeoIpGeocoder < BaseIpGeocoder
       private
 
-      def self.do_geocode(ip)
+      def self.do_geocode(ip, _=nil)
         process :xml, ip
       end
 
@@ -13,17 +13,17 @@ module Geokit
       end
 
       XML_MAPPINGS = {
-        city:         "City",
-        state:        "RegionCode",
-        zip:          "ZipCode",
-        country_code: "CountryCode",
-        lat:          "Latitude",
-        lng:          "Longitude",
+        city:         'City',
+        state:        'RegionCode',
+        zip:          'ZipCode',
+        country_code: 'CountryCode',
+        lat:          'Latitude',
+        lng:          'Longitude',
       }
 
       def self.parse_xml(xml)
         loc = new_loc
-        set_mappings(loc, xml.elements["Response"], XML_MAPPINGS)
+        set_mappings(loc, xml.elements['Response'], XML_MAPPINGS)
         loc.success = !!loc.city && !loc.city.empty?
         loc
       end

data/lib/geokit/geocoders/geo_plugin.rb

@@ -4,7 +4,7 @@ module Geokit
     class GeoPluginGeocoder < BaseIpGeocoder
       private
 
-      def self.do_geocode(ip)
+      def self.do_geocode(ip, _=nil)
         process :xml, ip
       end
 
@@ -13,16 +13,16 @@ module Geokit
       end
 
       XML_MAPPINGS = {
-        city:         "geoplugin_city",
-        state:        "geoplugin_region",
-        country_code: "geoplugin_countryCode",
-        lat:          "geoplugin_latitude",
-        lng:          "geoplugin_longitude",
+        city:         'geoplugin_city',
+        state:        'geoplugin_region',
+        country_code: 'geoplugin_countryCode',
+        lat:          'geoplugin_latitude',
+        lng:          'geoplugin_longitude',
       }
 
       def self.parse_xml(xml)
         loc = new_loc
-        set_mappings(loc, xml.elements["geoPlugin"], XML_MAPPINGS)
+        set_mappings(loc, xml.elements['geoPlugin'], XML_MAPPINGS)
         loc.success = !!loc.city && !loc.city.empty?
         loc
       end

data/lib/geokit/geocoders/geobytes.rb

@@ -2,7 +2,7 @@ module Geokit
   module Geocoders
     # Provides geocoding based upon an IP address.  The underlying web service is GeoSelect
     class GeobytesGeocoder < BaseIpGeocoder
-      def self.do_geocode(ip)
+      def self.do_geocode(ip, _=nil)
         process :json, ip
       end
 
@@ -12,15 +12,15 @@ module Geokit
 
       def self.parse_json(json)
         loc = new_loc
-        loc.city          = json["geobytescity"]
-        loc.country_code  = json["geobytesinternet"]
-        loc.full_address  = json["geobytesfqcn"]
-        loc.lat           = json["geobyteslatitude"]
-        loc.lng           = json["geobyteslongitude"]
-        loc.state         = json["geobytescode"]
-        loc.precision     = json["geobytescertainty"]
-        loc.state_name    = json["geobytesregion"]
-        loc.success       = !json["geobytescity"].empty?
+        loc.city          = json['geobytescity']
+        loc.country_code  = json['geobytesinternet']
+        loc.full_address  = json['geobytesfqcn']
+        loc.lat           = json['geobyteslatitude']
+        loc.lng           = json['geobyteslongitude']
+        loc.state         = json['geobytescode']
+        loc.precision     = json['geobytescertainty']
+        loc.state_name    = json['geobytesregion']
+        loc.success       = !json['geobytescity'].empty?
         loc
       end
     end

data/lib/geokit/geocoders/geocodio.rb

@@ -5,7 +5,7 @@ module Geokit
 
       private
 
-      def self.do_geocode(address)
+      def self.do_geocode(address, _=nil)
         process :json, submit_url(address)
       end
 
@@ -13,15 +13,15 @@ module Geokit
         params = [
           "q=#{Geokit::Inflector.url_escape(address)}",
           "api_key=#{key}",
-        ].join("&")
+        ].join('&')
 
-        ["http://api.geocod.io/v1/geocode", params].join("?")
+        ['http://api.geocod.io/v1/geocode', params].join('?')
       end
 
       def self.parse_json(json)
         loc = nil
 
-        json["results"].each do |address|
+        json['results'].each do |address|
           if loc.nil?
             loc = create_new_loc(address)
           else
@@ -40,19 +40,19 @@ module Geokit
       end
 
       def self.set_address_components(json, loc)
-        loc.street_address  = json["address_components"]["street"]
-        loc.street_number   = json["address_components"]["number"]
-        loc.sub_premise     = json["address_components"]["suffix"]
-        loc.street_name     = json["address_components"]["street"]
-        loc.city            = json["address_components"]["city"]
-        loc.state           = json["address_components"]["state"]
-        loc.zip             = json["address_components"]["zip"]
-        loc.full_address    = json["formatted_address"]
+        loc.street_address  = json['address_components']['street']
+        loc.street_number   = json['address_components']['number']
+        loc.sub_premise     = json['address_components']['suffix']
+        loc.street_name     = json['address_components']['street']
+        loc.city            = json['address_components']['city']
+        loc.state           = json['address_components']['state']
+        loc.zip             = json['address_components']['zip']
+        loc.full_address    = json['formatted_address']
       end
 
       def self.set_coordinates(json, loc)
-        loc.lat = json["location"]["lat"]
-        loc.lng = json["location"]["lng"]
+        loc.lat = json['location']['lat']
+        loc.lng = json['location']['lng']
       end
     end
   end