geokit 1.6.5 → 1.6.6

data/lib/geokit/services/google3.rb

@@ -0,0 +1,202 @@
+module Geokit
+  module Geocoders
+    class GoogleGeocoder3 < Geocoder
+
+      private
+      # Template method which does the reverse-geocode lookup.
+      def self.do_reverse_geocode(latlng)
+        latlng=LatLng.normalize(latlng)
+        submit_url = submit_url("/maps/api/geocode/json?sensor=false&latlng=#{Geokit::Inflector::url_escape(latlng.ll)}")
+        res = self.call_geocoder_service(submit_url)
+        return GeoLoc.new unless (res.is_a?(Net::HTTPSuccess) || res.is_a?(Net::HTTPOK))
+        json = res.body
+        logger.debug "Google reverse-geocoding. LL: #{latlng}. Result: #{CGI.escape(json)}"
+        return self.json2GeoLoc(json)
+      end
+
+      # Template method which does the geocode lookup.
+      #
+      # Supports viewport/country code biasing
+      #
+      # ==== OPTIONS
+      # * :bias - This option makes the Google Geocoder return results biased to a particular
+      #           country or viewport. Country code biasing is achieved by passing the ccTLD
+      #           ('uk' for .co.uk, for example) as a :bias value. For a list of ccTLD's,
+      #           look here: http://en.wikipedia.org/wiki/CcTLD. By default, the geocoder
+      #           will be biased to results within the US (ccTLD .com).
+      #
+      #           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.
+      #
+      # ==== 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 Winnetka, IL
+      # Geokit::Geocoders::GoogleGeocoder.geocode('Winnetka').state # => 'IL'
+      # # 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'
+      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
+        submit_url = submit_url("/maps/api/geocode/json?sensor=false&address=#{Geokit::Inflector::url_escape(address_str)}#{bias_str}")
+
+        res = self.call_geocoder_service(submit_url)
+        return GeoLoc.new if !res.is_a?(Net::HTTPSuccess)
+
+        json = res.body
+        logger.debug "Google geocoding. Address: #{address}. Result: #{CGI.escape(json)}"
+
+        return self.json2GeoLoc(json, address)
+      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'
+        # Decode the private key
+        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.
+        return Base64.encode64(rawSignature).tr('+/','-_').gsub(/\n/, '')
+      end
+
+
+      def self.submit_url(query_string)
+        if !Geokit::Geocoders::google_client_id.nil? and !Geokit::Geocoders::google_cryptographic_key.nil?
+          urlToSign = query_string + "&client=#{Geokit::Geocoders::google_client_id}" + "#{(!Geokit::Geocoders::google_channel.nil? ? ("&channel="+ Geokit::Geocoders::google_channel) : "")}"
+          signature = sign_gmap_bus_api_url(urlToSign, Geokit::Geocoders::google_cryptographic_key)
+          "http://maps.googleapis.com" + urlToSign + "&signature=#{signature}"
+        else
+          "http://maps.google.com" + query_string
+        end
+      end
+
+
+      def self.construct_bias_string_from_options(bias)
+        case bias
+        when String, Symbol
+          # country code biasing
+          "&region=#{bias.to_s.downcase}"
+        when Bounds
+          # viewport biasing
+          url_escaped_string = Geokit::Inflector::url_escape("#{bias.sw.to_s}|#{bias.ne.to_s}")
+          "&bounds=#{url_escaped_string}"
+        end
+      end
+
+      def self.json2GeoLoc(json, address="")
+        results = MultiJson.load(json)
+
+        case results['status']
+        when 'OVER_QUERY_LIMIT' then raise Geokit::TooManyQueriesError
+        when 'ZERO_RESULTS' then return GeoLoc.new
+        end
+        # this should probably be smarter.
+        if results['status'] != 'OK'
+          raise Geokit::Geocoders::GeocodeError
+        end
+
+        unsorted = results['results'].map do |addr|
+          single_json_to_geoloc(addr)
+        end
+
+        all = unsorted.sort_by(&:accuracy).reverse
+        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
+      # for which we have location information accurate down to street
+      # address precision.
+      # "RANGE_INTERPOLATED" indicates that the returned result reflects an
+      # approximation (usually on a road) interpolated between two precise
+      # points (such as intersections). Interpolated results are generally
+      # returned when rooftop geocodes are unavailable for a street address.
+      # "GEOMETRIC_CENTER" indicates that the returned result is the
+      # geometric center of a result such as a polyline (for example, a
+      # street) or polygon (region).
+      # "APPROXIMATE" indicates that the returned result is approximate
+
+      # 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
+      }
+
+      def self.single_json_to_geoloc(addr)
+        res = GeoLoc.new
+        res.provider = 'google3'
+        res.success = true
+        res.full_address = addr['formatted_address']
+
+        addr['address_components'].each do |comp|
+          case
+          when comp['types'].include?("subpremise")
+            res.sub_premise = comp['short_name']
+          when comp['types'].include?("street_number")
+            res.street_number = comp['short_name']
+          when comp['types'].include?("route")
+            res.street_name = comp['long_name']
+          when comp['types'].include?("locality")
+            res.city = comp['long_name']
+          when comp['types'].include?("administrative_area_level_1")
+            res.state = comp['short_name']
+            res.province = comp['short_name']
+          when comp['types'].include?("postal_code")
+            res.zip = comp['long_name']
+          when comp['types'].include?("country")
+            res.country_code = comp['short_name']
+            res.country = comp['long_name']
+          when comp['types'].include?("administrative_area_level_2")
+            res.district = comp['long_name']
+          when comp['types'].include?('neighborhood')
+            res.neighborhood = comp['short_name']
+          end
+        end
+        if res.street_name
+          res.street_address=[res.street_number,res.street_name].join(' ').strip
+        end
+        res.accuracy = ACCURACY[addr['geometry']['location_type']]
+        res.precision=%w{unknown country state state city zip zip+4 street address building}[res.accuracy]
+        # try a few overrides where we can
+        if res.sub_premise
+          res.accuracy = 9
+          res.precision = 'building'
+        end
+        if res.street_name && res.precision=='city'
+          res.precision = 'street'
+          res.accuracy = 7
+        end
+
+        res.lat=addr['geometry']['location']['lat'].to_f
+        res.lng=addr['geometry']['location']['lng'].to_f
+
+        ne=Geokit::LatLng.new(
+          addr['geometry']['viewport']['northeast']['lat'].to_f,
+          addr['geometry']['viewport']['northeast']['lng'].to_f
+        )
+        sw=Geokit::LatLng.new(
+          addr['geometry']['viewport']['southwest']['lat'].to_f,
+          addr['geometry']['viewport']['southwest']['lng'].to_f
+        )
+        res.suggested_bounds = Geokit::Bounds.new(sw,ne)
+
+        res
+      end
+    end
+    Google3Geocoder = GoogleGeocoder3
+  end
+end

data/lib/geokit/services/ip.rb

@@ -0,0 +1,103 @@
+module Geokit
+  module Geocoders
+    # Provides geocoding based upon an IP address.  The underlying web service is a hostip.info
+    # which sources their data through a combination of publicly available information as well
+    # as community contributions.
+    class IpGeocoder < Geocoder
+
+      # A number of non-routable IP ranges.
+      #
+      # --
+      # Sources for these:
+      #   RFC 3330: Special-Use IPv4 Addresses
+      #   The bogon list: http://www.cymru.com/Documents/bogon-list.html
+
+      NON_ROUTABLE_IP_RANGES = [
+        IPAddr.new('0.0.0.0/8'),      # "This" Network
+        IPAddr.new('10.0.0.0/8'),     # Private-Use Networks
+        IPAddr.new('14.0.0.0/8'),     # Public-Data Networks
+        IPAddr.new('127.0.0.0/8'),    # Loopback
+        IPAddr.new('169.254.0.0/16'), # Link local
+        IPAddr.new('172.16.0.0/12'),  # Private-Use Networks
+        IPAddr.new('192.0.2.0/24'),   # Test-Net
+        IPAddr.new('192.168.0.0/16'), # Private-Use Networks
+        IPAddr.new('198.18.0.0/15'),  # Network Interconnect Device Benchmark Testing
+        IPAddr.new('224.0.0.0/4'),    # Multicast
+        IPAddr.new('240.0.0.0/4')     # Reserved for future use
+      ].freeze
+
+      private
+
+      # 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, options = {})
+        return GeoLoc.new unless /^(\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3})?$/.match(ip)
+        return GeoLoc.new if self.private_ip_address?(ip)
+        url = "http://api.hostip.info/get_html.php?ip=#{ip}&position=true"
+        response = self.call_geocoder_service(url)
+        ensure_utf8_encoding(response)
+        response.is_a?(Net::HTTPSuccess) ? parse_body(response.body) : GeoLoc.new
+      rescue
+        logger.error "Caught an error during HostIp geocoding call: " + $!.to_s
+        return GeoLoc.new
+      end
+
+      # Converts the body to YAML since its in the form of:
+      #
+      # Country: UNITED STATES (US)
+      # City: Sugar Grove, IL
+      # Latitude: 41.7696
+      # Longitude: -88.4588
+      #
+      # then instantiates a GeoLoc instance to populate with location data.
+      def self.parse_body(body) # :nodoc:
+        body = body.encode('UTF-8') if body.respond_to? :encode
+        yaml = YAML.load(body)
+        res = GeoLoc.new
+        res.provider = 'hostip'
+        res.city, res.state = yaml['City'].split(', ')
+        res.country, res.country_code = yaml['Country'].split(' (')
+        res.lat = yaml['Latitude']
+        res.lng = yaml['Longitude']
+        res.country_code.chop!
+        res.success = !(res.city =~ /\(.+\)/)
+        res
+      end
+
+      # Forces UTF-8 encoding on the body
+      # Rails expects string input to be UTF-8
+      # hostip.info specifies the charset encoding in the headers
+      # thus extract encoding from headers and tell Rails about it by forcing it
+      def self.ensure_utf8_encoding(response)
+        if (enc_string = extract_charset(response))
+          if defined?(Encoding) && Encoding.aliases.values.include?(enc_string.upcase)
+            response.body.force_encoding(enc_string.upcase) if response.body.respond_to?(:force_encoding)
+            response.body.encode("UTF-8")
+          else
+            require 'iconv'
+            response.body.replace Iconv.conv("UTF8", "iso88591", response.body)
+          end
+        end
+      end
+
+      # Extracts charset out of the response headers
+      def self.extract_charset(response)
+        if (content_type = response['content-type'])
+          capture = content_type.match(/charset=(.+)/)
+          capture && capture[1]
+        end
+      end
+
+      # Checks whether the IP address belongs to a private address range.
+      #
+      # This function is used to reduce the number of useless queries made to
+      # the geocoding service. Such queries can occur frequently during
+      # integration tests.
+      def self.private_ip_address?(ip)
+        return NON_ROUTABLE_IP_RANGES.any? { |range| range.include?(ip) }
+      end
+    end
+  end
+end
+

data/lib/geokit/services/openstreetmap.rb

@@ -0,0 +1,119 @@
+module Geokit
+  module Geocoders
+    # Open Street Map geocoder implementation.
+    class OSMGeocoder < Geocoder
+
+      private
+
+      # Template method which does the geocode lookup.
+      def self.do_geocode(address, options = {})
+        options_str = generate_bool_param_for_option(:polygon, options)
+        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)
+
+        address_str = address.is_a?(GeoLoc) ? address.to_geocodeable_s : address
+
+        #url="http://where.yahooapis.com/geocode?flags=J&appid=#{Geokit::Geocoders::yahoo}&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)}"
+        res = self.call_geocoder_service(url)
+        return GeoLoc.new if !res.is_a?(Net::HTTPSuccess)
+        json = res.body
+        logger.debug "OSM geocoding. Address: #{address}. Result: #{json}"
+        return self.json2GeoLoc(json, address)
+      end
+
+      def self.do_reverse_geocode(latlng, options = {})
+        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(:zoom, options)
+        options_str << generate_param_for_option(:osm_type, options)
+        options_str << generate_param_for_option(:osm_id, options)
+        options_str << generate_param_for_option(:json_callback, options)
+        url = "http://nominatim.openstreetmap.org/reverse?format=json&addressdetails=1#{options_str}"
+        res = self.call_geocoder_service(url)
+        return GeoLoc.new if !res.is_a?(Net::HTTPSuccess)
+        json = res.body
+        logger.debug "OSM reverse geocoding: Lat: #{latlng.lat}, Lng: #{latlng.lng}. Result: #{json}"
+        return self.json2GeoLoc(json, latlng)
+      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.json2GeoLoc(json, obj)
+        results = MultiJson.load(json)
+        if results.is_a?(Hash)
+          return GeoLoc.new if results['error']
+          results = [results]
+        end
+        unless results.empty?
+          geoloc = nil
+          results.each do |result|
+            extract_geoloc = extract_geoloc(result)
+            if geoloc.nil?
+              geoloc = extract_geoloc
+            else
+              geoloc.all.push(extract_geoloc)
+            end
+          end
+          return geoloc
+        else
+          logger.info "OSM was unable to geocode #{obj}"
+          return GeoLoc.new
+        end
+      end
+
+      def self.extract_geoloc(result_json)
+        geoloc = GeoLoc.new
+
+        # basic
+        geoloc.lat = result_json['lat']
+        geoloc.lng = result_json['lon']
+
+        geoloc.provider = 'osm'
+        geoloc.precision = result_json['class']
+        geoloc.accuracy = result_json['type']
+
+        # Todo accuracy does not work as Yahoo and Google maps on OSM
+        #geoloc.accuracy = %w{unknown amenity building highway historic landuse leisure natural place railway shop tourism waterway man_made}.index(geoloc.precision)
+        #geoloc.full_address = result_json['display_name']
+        if result_json['address']
+          address_data = result_json['address']
+
+          geoloc.country = address_data['country']
+          geoloc.country_code = address_data['country_code'].upcase if address_data['country_code']
+          geoloc.state = address_data['state']
+          geoloc.city = address_data['city']
+          geoloc.city = address_data['county'] if geoloc.city.nil? && address_data['county']
+          geoloc.zip = address_data['postcode']
+          geoloc.district = address_data['city_district']
+          geoloc.district = address_data['state_district'] if geoloc.district.nil? && address_data['state_district']
+          geoloc.street_address = "#{address_data['road']} #{address_data['house_number']}".strip if address_data['road']
+          geoloc.street_name = address_data['road']
+          geoloc.street_number = address_data['house_number']
+        end
+
+        if result_json['boundingbox']
+          geoloc.suggested_bounds = Bounds.normalize(
+              [result_json['boundingbox'][0], result_json['boundingbox'][1]],
+              [result_json['boundingbox'][2], result_json['boundingbox'][3]])
+        end
+
+        geoloc.success = true
+
+        return geoloc
+      end
+    end
+  end
+end

data/lib/geokit/services/us_geocoder.rb

@@ -0,0 +1,50 @@
+# Geocoder Us geocoder implementation.  Requires the Geokit::Geocoders::GEOCODER_US variable to
+# contain true or false based upon whether authentication is to occur.  Conforms to the
+# interface set by the Geocoder class.
+module Geokit
+ module Geocoders
+    class UsGeocoder < Geocoder
+
+      private
+      def self.do_geocode(address, options = {})
+        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)}"
+        url = if GeoKit::Geocoders::geocoder_us
+          "http://#{GeoKit::Geocoders::geocoder_us}@geocoder.us/member/service/csv/geocode"
+        else
+          "http://geocoder.us/service/csv/geocode"
+        end
+
+        url = "#{url}?#{query}"
+        res = self.call_geocoder_service(url)
+
+        return GeoLoc.new if !res.is_a?(Net::HTTPSuccess)
+        data = res.body
+        logger.debug "Geocoder.us geocoding. Address: #{address}. Result: #{data}"
+        array = data.chomp.split(',')
+
+        if array.length == 5
+          res=GeoLoc.new
+          res.lat,res.lng,res.city,res.state,res.zip=array
+          res.country_code='US'
+          res.success=true
+          return res
+        elsif array.length == 6
+          res=GeoLoc.new
+          res.lat,res.lng,res.street_address,res.city,res.state,res.zip=array
+          res.country_code='US'
+          res.success=true
+          return res
+        else
+          logger.info "geocoder.us was unable to geocode address: "+address
+          return GeoLoc.new
+        end
+        rescue
+          logger.error "Caught an error during geocoder.us geocoding call: "+$!
+          return GeoLoc.new
+
+      end
+    end
+ end
+end