geokit 1.8.5 → 1.9.0

data/lib/geokit/geocoders/openstreetmap.rb

@@ -2,7 +2,6 @@ module Geokit
   module Geocoders
     # Open Street Map geocoder implementation.
     class OSMGeocoder < Geocoder
-
       private
 
       # Template method which does the geocode lookup.
@@ -11,10 +10,12 @@ module Geokit
         options_str << generate_param_for_option(:json_callback, options)
         options_str << generate_param_for_option(:countrycodes, options)
         options_str << generate_param_for_option(:viewbox, options)
+        options_str << generate_param_for_option(:'accept-language', options)
+        options_str << generate_param_for_option(:email, options)
 
         address_str = address.is_a?(GeoLoc) ? address.to_geocodeable_s : address
 
-        url = "http://nominatim.openstreetmap.org/search?format=json#{options_str}&addressdetails=1&q=#{Geokit::Inflector::url_escape(address_str)}"
+        url = "http://nominatim.openstreetmap.org/search?format=json#{options_str}&addressdetails=1&q=#{Geokit::Inflector.url_escape(address_str)}"
         process :json, url
       end
 
@@ -22,6 +23,8 @@ module Geokit
         latlng = LatLng.normalize(latlng)
         options_str = generate_param_for(:lat, latlng.lat)
         options_str << generate_param_for(:lon, latlng.lng)
+        options_str << generate_param_for_option(:'accept-language', options)
+        options_str << generate_param_for_option(:email, options)
         options_str << generate_param_for_option(:zoom, options)
         options_str << generate_param_for_option(:osm_type, options)
         options_str << generate_param_for_option(:osm_id, options)
@@ -31,11 +34,11 @@ module Geokit
       end
 
       def self.generate_param_for(param, value)
-        "&#{param}=#{Geokit::Inflector::url_escape(value.to_s)}"
+        "&#{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])}" : ''
+        options[param] ? "&#{param}=#{Geokit::Inflector.url_escape(options[param])}" : ''
       end
 
       def self.generate_bool_param_for_option(param, options)
@@ -80,7 +83,7 @@ module Geokit
         return unless address_data
         loc.country = address_data['country']
         loc.country_code = address_data['country_code'].upcase if address_data['country_code']
-        loc.state = address_data['state']
+        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']
@@ -93,7 +96,7 @@ module Geokit
 
       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.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']
       end

data/lib/geokit/geocoders/ripe.rb

@@ -3,6 +3,7 @@ module Geokit
     # Provides geocoding based upon an IP address.  The underlying web service is geoplugin.net
     class RipeGeocoder < BaseIpGeocoder
       self.secure = false # supports HTTPS, but Net::HTTPS doesn't like the server
+
       private
 
       def self.do_geocode(ip)
@@ -27,9 +28,9 @@ module Geokit
       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 = match[1]
+          loc.state_code = match[1]
           loc.country_code = match[3]
         else
           loc.country_code = match[1]
@@ -38,6 +39,5 @@ module Geokit
         loc.city = data['city']
       end
     end
-
   end
 end

data/lib/geokit/geocoders/us_geocoder.rb

@@ -2,32 +2,33 @@
 # contain true or false based upon whether authentication is to occur.  Conforms to the
 # interface set by the Geocoder class.
 module Geokit
- module Geocoders
+  module Geocoders
     class UsGeocoder < Geocoder
       config :key
 
       private
+
       def self.do_geocode(address)
         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
 
       def self.parse_csv(array)
         loc = GeoLoc.new
         if array.length == 5
-          loc.lat,loc.lng,loc.city,loc.state,loc.zip=array
-          loc.country_code='US'
-          loc.success=true
+          loc.lat, loc.lng, loc.city, loc.state, loc.zip = array
+          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.success=true
+          loc.lat, loc.lng, loc.street_address, loc.city, loc.state, loc.zip = array
+          loc.country_code = 'US'
+          loc.success = true
         end
         loc
       end

data/lib/geokit/geocoders/yahoo.rb

@@ -7,9 +7,10 @@ module Geokit
       self.secure = true
 
       private
+
       def self.submit_url(address)
         address_str = address.is_a?(GeoLoc) ? address.to_geocodeable_s : address
-        query_string = "?q=#{Geokit::Inflector::url_escape(address_str)}&flags=J"
+        query_string = "?q=#{Geokit::Inflector.url_escape(address_str)}&flags=J"
 
         o = OauthUtil.new
         o.consumer_key = key
@@ -59,15 +60,15 @@ module Geokit
 
       def self.set_precision(result_json, loc)
         loc.precision = case result_json['quality'].to_i
-                        when 9,10         then 'country'
+                        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 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'
+                        when 62, 63, 90, 99  then 'building'
                         else 'unknown'
                         end
 
@@ -83,17 +84,16 @@ end
 # Note: the standard Ruby OAuth lib is here http://github.com/mojodna/oauth
 # License: http://gist.github.com/375593
 # Usage: see example.rb below
- 
+
 require 'uri'
 require 'cgi'
 require 'openssl'
 require 'base64'
- 
+
 class OauthUtil
-  
-  attr_accessor :consumer_key, :consumer_secret, :token, :token_secret, :req_method, 
+  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 = ''
@@ -104,37 +104,37 @@ class OauthUtil
     @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
   end
-  
+
   def percent_encode( string )
     # ref http://snippets.dzone.com/posts/show/1260
     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 )
-    
+
     # ref: http://blog.nathanielbibler.com/post/63031273/openssl-hmac-vs-ruby-hmac-benchmarks
-    digest = OpenSSL::Digest::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/, '' )
   end
-  
+
   # sort (very important as it affects the signature), concat, and percent encode
   # @ref http://oauth.net/core/1.0/#rfc.section.9.1.1
   # @ref http://oauth.net/core/1.0/#9.2.1
   # @ref http://oauth.net/core/1.0/#rfc.section.A.5.1
   def query_string
     pairs = []
-    @params.sort.each { | key, val | 
+    @params.sort.each { | key, val |
       pairs.push( "#{ percent_encode( key ) }=#{ percent_encode( val.to_s ) }" )
     }
     pairs.join '&'
@@ -143,10 +143,9 @@ class OauthUtil
   def timestamp
     Time.now.to_i.to_s
   end
-  
+
   # organize params & create signature
   def sign( parsed_url )
-    
     @params = {
       'oauth_consumer_key' => @consumer_key,
       'oauth_nonce' => nonce,
@@ -154,10 +153,10 @@ class OauthUtil
       'oauth_timestamp' => timestamp,
       'oauth_version' => @oauth_version
     }
- 
+
     # if url has query, merge key/values into params obj overwriting defaults
     if parsed_url.query
-      CGI.parse( parsed_url.query ).each do |k,v|
+      CGI.parse( parsed_url.query ).each do |k, v|
         if v.is_a?(Array) && v.count == 1
           @params[k] = v.first
         else
@@ -165,24 +164,24 @@ class OauthUtil
         end
       end
     end
-    
+
     # @ref http://oauth.net/core/1.0/#rfc.section.9.1.2
     @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
-    @base_str = [ 
-      @req_method, 
-      percent_encode( req_url ), 
-      
+    @base_str = [
+      @req_method,
+      percent_encode( req_url ),
+
       # normalization is just x-www-form-urlencoded
-      percent_encode( query_string ) 
-      
+      percent_encode( query_string )
+
     ].join( '&' )
- 
+
     # add signature
     @params[ 'oauth_signature' ] = signature
-    
+
     self
   end
 end

data/lib/geokit/geocoders/yandex.rb

@@ -14,7 +14,7 @@ module Geokit
 
       def self.submit_url(address)
         address_str = address.is_a?(GeoLoc) ? address.to_geocodeable_s : address
-        url = "http://geocode-maps.yandex.ru/1.x/?geocode=#{Geokit::Inflector::url_escape(address_str)}&format=json"
+        url = "http://geocode-maps.yandex.ru/1.x/?geocode=#{Geokit::Inflector.url_escape(address_str)}&format=json"
         url += "&key=#{key}" if key
         url
       end
@@ -22,18 +22,18 @@ module Geokit
       def self.parse_json(result)
         loc = new_loc
 
-        coll = result["response"]["GeoObjectCollection"]
-        return loc unless coll["metaDataProperty"]["GeocoderResponseMetaData"]["found"].to_i > 0
+        coll = result['response']['GeoObjectCollection']
+        return loc unless coll['metaDataProperty']['GeocoderResponseMetaData']['found'].to_i > 0
 
-        l = coll["featureMember"][0]["GeoObject"]
+        l = coll['featureMember'][0]['GeoObject']
 
         loc.success = true
-        ll = l["Point"]["pos"].split(" ")
+        ll = l['Point']['pos'].split(' ')
         loc.lng = ll.first
         loc.lat = ll.last
 
-        country = l["metaDataProperty"]["GeocoderMetaData"]["AddressDetails"]["Country"]
-        locality = country["Locality"] || country["AdministrativeArea"]["Locality"] || country["AdministrativeArea"]["SubAdministrativeArea"]["Locality"] rescue nil
+        country = l['metaDataProperty']['GeocoderMetaData']['AddressDetails']['Country']
+        locality = country['Locality'] || country['AdministrativeArea']['Locality'] || country['AdministrativeArea']['SubAdministrativeArea']['Locality'] rescue nil
         set_address_components(loc, l, country, locality)
         set_precision(loc, l, locality)
 
@@ -41,19 +41,19 @@ module Geokit
       end
 
       def self.set_address_components(loc, l, country, locality)
-        loc.country_code = country["CountryNameCode"]
-        loc.full_address = country["AddressLine"]
-        loc.street_address = l["name"]
-        loc.street_number = locality["Thoroughfare"]["Premise"]["PremiseNumber"] rescue nil
-        loc.street_name = locality["Thoroughfare"]["ThoroughfareName"] rescue nil
-        loc.city = locality["LocalityName"] rescue nil
-        loc.state = country["AdministrativeArea"]["AdministrativeAreaName"] rescue nil
-        loc.state ||= country["Locality"]["LocalityName"] rescue nil
+        loc.country_code = country['CountryNameCode']
+        loc.full_address = country['AddressLine']
+        loc.street_address = l['name']
+        loc.street_number = locality['Thoroughfare']['Premise']['PremiseNumber'] rescue nil
+        loc.street_name = locality['Thoroughfare']['ThoroughfareName'] rescue nil
+        loc.city = locality['LocalityName'] rescue nil
+        loc.state_name = country['AdministrativeArea']['AdministrativeAreaName'] rescue nil
+        loc.state ||= country['Locality']['LocalityName'] rescue nil
       end
 
       def self.set_precision(loc, l, locality)
-        loc.precision = l["metaDataProperty"]["GeocoderMetaData"]["precision"].sub(/exact/, "building").sub(/number|near/, "address").sub(/other/, "city")
-        loc.precision = "country" unless locality
+        loc.precision = l['metaDataProperty']['GeocoderMetaData']['precision'].sub(/exact/, 'building').sub(/number|near/, 'address').sub(/other/, 'city')
+        loc.precision = 'country' unless locality
       end
     end
   end

data/lib/geokit/inflectors.rb

@@ -10,20 +10,14 @@ module Geokit
 
     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("-", "_").
+        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, '_\&') =~ /_*(.*)/
-      $+.downcase
+      lower_case_and_underscored_word.to_s.gsub(/_id$/, '').gsub(/_/, ' ').capitalize
     end
 
     def url_escape(s)

data/lib/geokit/lat_lng.rb

@@ -4,9 +4,18 @@ module Geokit
 
     attr_accessor :lat, :lng
 
+    # Provide users with the ability to use :latitude and :longitude
+    # to access the lat/lng instance variables.
+    # Alias the attr_accessor :lat to :latitude
+    alias_method :latitude, :lat
+    alias_method :latitude=, :lat=
+    # Alias the attr_accessor :lng to :longitude
+    alias_method :longitude, :lng
+    alias_method :longitude=, :lng=
+
     # Accepts latitude and longitude or instantiates an empty instance
     # if lat and lng are not provided. Converted to floats if provided
-    def initialize(lat=nil, lng=nil)
+    def initialize(lat = nil, lng = nil)
       lat = lat.to_f if lat && !lat.is_a?(Numeric)
       lng = lng.to_f if lng && !lng.is_a?(Numeric)
       @lat = lat
@@ -24,7 +33,7 @@ module Geokit
 
     # Longitude attribute setter; stored as a float;
     def lng=(lng)
-      @lng=lng.to_f if lng
+      @lng = lng.to_f if lng
     end
 
     # Returns the lat and lng attributes as a comma-separated string.
@@ -42,17 +51,19 @@ module Geokit
       self.class.decimal_to_dms(lng)
     end
 
-    #returns a string with comma-separated lat,lng values
+    # returns a string with comma-separated lat,lng values
     def to_s
       ll
     end
 
-    #returns a two-element array
+    # returns a two-element array
     def to_a
-      [lat,lng]
+      [lat, lng]
     end
-    # Returns true if the candidate object is logically equal.  Logical equivalence
-    # is true if the lat and lng attributes are the same for both objects.
+
+    # Returns true if the candidate object is logically equal. Logical
+    # equivalence is true if the lat and lng attributes are the same for both
+    # objects.
     def ==(other)
       return false unless other.is_a?(LatLng)
       lat == other.lat && lng == other.lng
@@ -71,23 +82,26 @@ module Geokit
       lat && lng
     end
 
-    # A *class* method to take anything which can be inferred as a point and generate
-    # a LatLng from it. You should use this anything you're not sure what the input is,
-    # and want to deal with it as a LatLng if at all possible. Can take:
+    # A *class* method to take anything which can be inferred as a point and
+    # generate a LatLng from it. You should use this anything you're not sure
+    # what the input is, and want to deal with it as a LatLng if at all
+    # possible. Can take:
     #  1) two arguments (lat,lng)
     #  2) a string in the format "37.1234,-129.1234" or "37.1234 -129.1234"
     #  3) a string which can be geocoded on the fly
     #  4) an array in the format [37.1234,-129.1234]
     #  5) a LatLng or GeoLoc (which is just passed through as-is)
-    #  6) anything responding to to_lat_lng -- a LatLng will be extracted from it
-    def self.normalize(thing, other=nil)
+    #  6) anything responding to to_lat_lng -- a LatLng will be extracted from
+    #     it
+    def self.normalize(thing, other = nil)
       return Geokit::LatLng.new(thing, other) if other
 
       case thing
       when String
         from_string(thing)
       when Array
-        thing.size == 2 or raise ArgumentError.new("Must initialize with an Array with both latitude and longitude")
+        thing.size == 2 or raise ArgumentError.new(
+          'Must initialize with an Array with both latitude and longitude')
         Geokit::LatLng.new(thing[0], thing[1])
       when LatLng # will also be true for GeoLocs
         thing
@@ -95,14 +109,16 @@ module Geokit
         if thing.respond_to? :to_lat_lng
           thing.to_lat_lng
         else
-          raise ArgumentError.new("#{thing} (#{thing.class}) cannot be normalized to a LatLng. We tried interpreting it as an array, string, etc., but no dice.")
+          raise ArgumentError.new(
+            "#{thing} (#{thing.class}) cannot be normalized to a LatLng. " +
+            "We tried interpreting it as an array, string, etc., but no dice.")
         end
       end
     end
 
     def self.from_string(thing)
       thing.strip!
-      if match=thing.match(/(\-?\d+\.?\d*)[, ] ?(\-?\d+\.?\d*)$/)
+      if match = thing.match(/(\-?\d+\.?\d*)[, ] ?(\-?\d+\.?\d*)$/)
         Geokit::LatLng.new(match[1], match[2])
       else
         res = Geokit::Geocoders::MultiGeocoder.geocode(thing)
@@ -111,22 +127,30 @@ module Geokit
       end
     end
 
-    # Reverse geocodes a LatLng object using the MultiGeocoder (default), or optionally
-    # using a geocoder of your choosing. Returns a new Geokit::GeoLoc object
+    # Reverse geocodes a LatLng object using the MultiGeocoder (default), or
+    # optionally using a geocoder of your choosing. Returns a new Geokit::GeoLoc
+    # object
     #
     # ==== Options
-    # * :using  - Specifies the geocoder to use for reverse geocoding. Defaults to
-    #             MultiGeocoder. Can be either the geocoder class (or any class that
-    #             implements do_reverse_geocode for that matter), or the name of
-    #             the class without the "Geocoder" part (e.g. :google)
+    # * :using  - Specifies the geocoder to use for reverse geocoding. Defaults
+    #             to MultiGeocoder. Can be either the geocoder class (or any
+    #             class that implements do_reverse_geocode for that matter), or
+    #             the name of the class without the "Geocoder" part
+    #             (e.g. :google)
     #
     # ==== Examples
-    # LatLng.new(51.4578329, 7.0166848).reverse_geocode # => #<Geokit::GeoLoc:0x12dac20 @state...>
-    # LatLng.new(51.4578329, 7.0166848).reverse_geocode(:using => :google) # => #<Geokit::GeoLoc:0x12dac20 @state...>
-    # LatLng.new(51.4578329, 7.0166848).reverse_geocode(:using => Geokit::Geocoders::GoogleGeocoder) # => #<Geokit::GeoLoc:0x12dac20 @state...>
-    def reverse_geocode(options = { :using => Geokit::Geocoders::MultiGeocoder })
+    # LatLng.new(51.4578329, 7.0166848).reverse_geocode
+    # => #<Geokit::GeoLoc:0x12dac20 @state...>
+    # LatLng.new(51.4578329, 7.0166848).reverse_geocode(:using => :google)
+    # => #<Geokit::GeoLoc:0x12dac20 @state...>
+    # LatLng.new(51.4578329, 7.0166848).reverse_geocode(:using =>
+    #   Geokit::Geocoders::GoogleGeocoder)
+    # => #<Geokit::GeoLoc:0x12dac20 @state...>
+    def reverse_geocode(options = { using: Geokit::Geocoders::MultiGeocoder })
       if options[:using].is_a?(String) || options[:using].is_a?(Symbol)
-        provider = Geokit::Geocoders.const_get("#{Geokit::Inflector::camelize(options[:using].to_s)}Geocoder")
+        class_name =
+          "#{Geokit::Inflector.camelize(options[:using].to_s)}Geocoder"
+        provider = Geokit::Geocoders.const_get(class_name)
       elsif options[:using].respond_to?(:do_reverse_geocode)
         provider = options[:using]
       else