geokit 1.7.1 → 1.8.0

data/Manifest.txt

@@ -1,21 +0,0 @@
-History.txt
-Manifest.txt
-README.markdown
-Rakefile
-geokit.gemspec
-lib/geokit.rb
-lib/geokit/geocoders.rb
-lib/geokit/mappable.rb
-test/test_base_geocoder.rb
-test/test_bounds.rb
-test/test_ca_geocoder.rb
-test/test_geoloc.rb
-test/test_geoplugin_geocoder.rb
-test/test_google_geocoder.rb
-test/test_google_reverse_geocoder.rb
-test/test_inflector.rb
-test/test_ipgeocoder.rb
-test/test_latlng.rb
-test/test_multi_geocoder.rb
-test/test_us_geocoder.rb
-test/test_yahoo_geocoder.rb

data/lib/geokit/services/ca_geocoder.rb

@@ -1,55 +0,0 @@
-
-# Geocoder CA geocoder implementation.  Requires the Geokit::Geocoders::GEOCODER_CA variable to
-# contain true or false based upon whether authentication is to occur.  Conforms to the
-# interface set by the Geocoder class.
-#
-# Returns a response like:
-# <?xml version="1.0" encoding="UTF-8" ?>
-# <geodata>
-#   <latt>49.243086</latt>
-#   <longt>-123.153684</longt>
-# </geodata>
-module Geokit
- module Geocoders
-   class CaGeocoder < Geocoder
-
-     private
-
-     # Template method which does the geocode lookup.
-     def self.do_geocode(address, options = {})
-       raise ArgumentError('Geocoder.ca requires a GeoLoc argument') unless address.is_a?(GeoLoc)
-       url = construct_request(address)
-       res = self.call_geocoder_service(url)
-       return GeoLoc.new if !res.is_a?(Net::HTTPSuccess)
-       xml = res.body
-       logger.debug "Geocoder.ca geocoding. Address: #{address}. Result: #{xml}"
-       # Parse the document.
-       doc = REXML::Document.new(xml)
-       address.lat = doc.elements['//latt'].text
-       address.lng = doc.elements['//longt'].text
-       address.success = true
-       return address
-     rescue
-       logger.error "Caught an error during Geocoder.ca geocoding call: "+$!
-       return GeoLoc.new
-     end
-
-     # Formats the request in the format acceptable by the CA geocoder.
-     def self.construct_request(location)
-       url = ""
-       url += add_ampersand(url) + "stno=#{location.street_number}" if location.street_address
-       url += add_ampersand(url) + "addresst=#{Geokit::Inflector::url_escape(location.street_name)}" if location.street_address
-       url += add_ampersand(url) + "city=#{Geokit::Inflector::url_escape(location.city)}" if location.city
-       url += add_ampersand(url) + "prov=#{location.state}" if location.state
-       url += add_ampersand(url) + "postal=#{location.zip}" if location.zip
-       url += add_ampersand(url) + "auth=#{Geokit::Geocoders::geocoder_ca}" if Geokit::Geocoders::geocoder_ca
-       url += add_ampersand(url) + "geoit=xml"
-       'http://geocoder.ca/?' + url
-     end
-
-     def self.add_ampersand(url)
-       url && url.length > 0 ? "&" : ""
-     end
-   end
- end
-end

data/lib/geokit/services/geo_plugin.rb

@@ -1,31 +0,0 @@
-module Geokit
-  module Geocoders
-    # Provides geocoding based upon an IP address.  The underlying web service is geoplugin.net
-    class GeoPluginGeocoder < Geocoder
-      private
-
-      def self.do_geocode(ip, options = {})
-        return GeoLoc.new unless /^(\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3})?$/.match(ip)
-        response = self.call_geocoder_service("http://www.geoplugin.net/xml.gp?ip=#{ip}")
-        return response.is_a?(Net::HTTPSuccess) ? parse_xml(response.body) : GeoLoc.new
-      rescue
-        logger.error "Caught an error during GeoPluginGeocoder geocoding call: "+$!
-        return GeoLoc.new
-      end
-
-      def self.parse_xml(xml)
-        xml = REXML::Document.new(xml)
-        geo = GeoLoc.new
-        geo.provider='geoPlugin'
-        geo.city = xml.elements['//geoplugin_city'].text
-        geo.state = xml.elements['//geoplugin_region'].text
-        geo.country_code = xml.elements['//geoplugin_countryCode'].text
-        geo.lat = xml.elements['//geoplugin_latitude'].text.to_f
-        geo.lng = xml.elements['//geoplugin_longitude'].text.to_f
-        geo.success = !!geo.city && !geo.city.empty?
-        return geo
-      end
-    end
-
-  end
-end

data/lib/geokit/services/geonames.rb

@@ -1,53 +0,0 @@
-module Geokit
-  module Geocoders
-    # Another geocoding web service
-    # http://www.geonames.org
-    class GeonamesGeocoder < Geocoder
-
-      private
-
-      # Template method which does the geocode lookup.
-      def self.do_geocode(address, options = {})
-        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"
-
-        if(Geokit::Geocoders::geonames)
-          url = "http://ws.geonames.net#{params}&username=#{Geokit::Geocoders::geonames}"
-        else
-          url = "http://ws.geonames.org#{params}"
-        end
-
-        res = self.call_geocoder_service(url)
-
-        return GeoLoc.new if !res.is_a?(Net::HTTPSuccess)
-
-        xml=res.body
-        logger.debug "Geonames geocoding. Address: #{address}. Result: #{xml}"
-        doc=REXML::Document.new(xml)
-
-        if(doc.elements['//geonames/totalResultsCount'].text.to_i > 0)
-          res=GeoLoc.new
-
-          # only take the first result
-          res.lat=doc.elements['//code/lat'].text if doc.elements['//code/lat']
-          res.lng=doc.elements['//code/lng'].text if doc.elements['//code/lng']
-          res.country_code=doc.elements['//code/countryCode'].text if doc.elements['//code/countryCode']
-          res.provider='genomes'
-          res.city=doc.elements['//code/name'].text if doc.elements['//code/name']
-          res.state=doc.elements['//code/adminName1'].text if doc.elements['//code/adminName1']
-          res.zip=doc.elements['//code/postalcode'].text if doc.elements['//code/postalcode']
-          res.success=true
-          return res
-        else
-          logger.info "Geonames was unable to geocode address: "+address
-          return GeoLoc.new
-        end
-
-      rescue
-        logger.error "Caught an error during Geonames geocoding call: "+$!
-      end
-    end
-  end
-end

data/lib/geokit/services/google.rb

@@ -1,158 +0,0 @@
-module Geokit
-  module Geocoders
-    # -------------------------------------------------------------------------------------------
-    # Address geocoders that also provide reverse geocoding
-    # -------------------------------------------------------------------------------------------
-
-    # Google geocoder implementation.  Requires the Geokit::Geocoders::GOOGLE variable to
-    # contain a Google API key.  Conforms to the interface set by the Geocoder class.
-    class GoogleGeocoder < Geocoder
-
-      private
-
-      # Template method which does the reverse-geocode lookup.
-      def self.do_reverse_geocode(latlng)
-        latlng=LatLng.normalize(latlng)
-        res = self.call_geocoder_service("http://maps.google.com/maps/geo?ll=#{Geokit::Inflector::url_escape(latlng.ll)}&output=xml&key=#{Geokit::Geocoders::google}&oe=utf-8")
-        #        res = Net::HTTP.get_response(URI.parse("http://maps.google.com/maps/geo?ll=#{Geokit::Inflector::url_escape(address_str)}&output=xml&key=#{Geokit::Geocoders::google}&oe=utf-8"))
-        return GeoLoc.new unless (res.is_a?(Net::HTTPSuccess) || res.is_a?(Net::HTTPOK))
-        xml = self.transcode_to_utf8(res.body)
-        logger.debug "Google reverse-geocoding. LL: #{latlng}. Result: #{xml}"
-        return self.xml2GeoLoc(xml)
-      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
-        res = self.call_geocoder_service("http://maps.google.com/maps/geo?q=#{Geokit::Inflector::url_escape(address_str)}&output=xml#{bias_str}&key=#{Geokit::Geocoders::google}&oe=utf-8")
-        return GeoLoc.new if !res.is_a?(Net::HTTPSuccess)
-        xml = self.transcode_to_utf8(res.body)
-        logger.debug "Google geocoding. Address: #{address}. Result: #{xml}"
-        return self.xml2GeoLoc(xml, address)
-      end
-
-      def self.construct_bias_string_from_options(bias)
-        if bias.is_a?(String) or bias.is_a?(Symbol)
-          # country code biasing
-          "&gl=#{bias.to_s.downcase}"
-        elsif bias.is_a?(Bounds)
-          # viewport biasing
-          "&ll=#{precise_ll(bias.center)}&spn=#{precise_ll(bias.to_span)}"
-        end
-      end
-
-      # Precision to 6 decimal places as per:
-      # https://developers.google.com/maps/documentation/staticmaps/?hl=en#Latlons
-      def self.precise_ll(loc)
-        "#{"%.6f" % loc.lat},#{"%.6f" % loc.lng}"
-      end
-
-      def self.xml2GeoLoc(xml, address="")
-        doc=REXML::Document.new(xml)
-
-        if doc.elements['//kml/Response/Status/code'].text == '200'
-          geoloc = nil
-          # Google can return multiple results as //Placemark elements.
-          # iterate through each and extract each placemark as a geoloc
-          doc.each_element('//Placemark') do |e|
-            extracted_geoloc = extract_placemark(e) # g is now an instance of GeoLoc
-            if geoloc.nil?
-              # first time through, geoloc is still nil, so we make it the geoloc we just extracted
-              geoloc = extracted_geoloc
-            else
-              # second (and subsequent) iterations, we push additional
-              # geolocs onto "geoloc.all"
-              geoloc.all.push(extracted_geoloc)
-            end
-          end
-          return geoloc
-        elsif doc.elements['//kml/Response/Status/code'].text == '620'
-          raise Geokit::TooManyQueriesError
-        else
-          logger.info "Google was unable to geocode address: "+address
-          return GeoLoc.new
-        end
-
-      rescue Geokit::TooManyQueriesError
-        # re-raise because of other rescue
-        raise Geokit::TooManyQueriesError, "Google returned a 620 status, too many queries. The given key has gone over the requests limit in the 24 hour period or has submitted too many requests in too short a period of time. If you're sending multiple requests in parallel or in a tight loop, use a timer or pause in your code to make sure you don't send the requests too quickly."
-      rescue
-        logger.error "Caught an error during Google geocoding call: "+$!
-        return GeoLoc.new
-      end
-
-      # extracts a single geoloc from a //placemark element in the google results xml
-      def self.extract_placemark(doc)
-        res = GeoLoc.new
-        coordinates=doc.elements['.//coordinates'].text.to_s.split(',')
-
-        #basics
-        res.lat=coordinates[1]
-        res.lng=coordinates[0]
-        res.country_code=doc.elements['.//CountryNameCode'].text if doc.elements['.//CountryNameCode']
-        res.provider='google'
-
-        #extended -- false if not not available
-        res.city = doc.elements['.//LocalityName'].text if doc.elements['.//LocalityName']
-        res.state = doc.elements['.//AdministrativeAreaName'].text if doc.elements['.//AdministrativeAreaName']
-        res.province = doc.elements['.//SubAdministrativeAreaName'].text if doc.elements['.//SubAdministrativeAreaName']
-        res.full_address = doc.elements['.//address'].text if doc.elements['.//address'] # google provides it
-        res.zip = doc.elements['.//PostalCodeNumber'].text if doc.elements['.//PostalCodeNumber']
-        res.street_address = doc.elements['.//ThoroughfareName'].text if doc.elements['.//ThoroughfareName']
-        res.country = doc.elements['.//CountryName'].text if doc.elements['.//CountryName']
-        res.district = doc.elements['.//DependentLocalityName'].text if doc.elements['.//DependentLocalityName']
-        # Translate accuracy into Yahoo-style token address, street, zip, zip+4, city, state, country
-        # For Google, 1=low accuracy, 8=high accuracy
-        address_details=doc.elements['.//*[local-name() = "AddressDetails"]']
-        res.accuracy = address_details ? address_details.attributes['Accuracy'].to_i : 0
-        res.precision=%w{unknown country state state city zip zip+4 street address building}[res.accuracy]
-
-        # google returns a set of suggested boundaries for the geocoded result
-        if suggested_bounds = doc.elements['//LatLonBox']
-          res.suggested_bounds = Bounds.normalize(
-            [suggested_bounds.attributes['south'], suggested_bounds.attributes['west']],
-            [suggested_bounds.attributes['north'], suggested_bounds.attributes['east']])
-        end
-
-        res.success=true
-
-        return res
-      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')
-          body = ic.iconv(body)
-        end        
-      end
-    end
-  end
-end

data/lib/geokit/services/ip.rb

@@ -1,103 +0,0 @@
-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/maxmind.rb

@@ -1,39 +0,0 @@
-module Geokit
-  module Geocoders
-
-  @@geoip_data_path = File.expand_path(File.join(File.dirname(__FILE__),'../../..','data','GeoLiteCity.dat')) 
-  __define_accessors
-
-    # Provides geocoding based upon an IP address.  The underlying web service is MaxMind
-    class MaxmindGeocoder < Geocoder
-      private
-
-      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 maxmind(ip)
-      rescue
-        logger.error "Caught an error during MaxMind geocoding call: " + $!.to_s
-        return GeoLoc.new
-      end
-
-
-      def self.maxmind(ip)
-        res = GeoIP.new(Geokit::Geocoders::geoip_data_path).city(ip)
-
-        loc = GeoLoc.new(
-          :provider => 'maxmind_city',
-          :lat      => res.latitude,
-          :lng      => res.longitude,
-          :city     => res.city_name,
-          :state    => res.region_name,
-          :zip      => res.postal_code,
-          :country_code => res.country_code3
-        )
-
-        # loc.success = res.city_name && res.city_name != ''
-        loc.success = (res.longitude > 0 && res.latitude > 0)
-        return loc
-      end
-    end
-  end
-end