geocoder 1.1.8 → 1.1.9

data/lib/geocoder/lookups/baidu.rb

@@ -0,0 +1,54 @@
+require 'geocoder/lookups/base'
+require "geocoder/results/baidu"
+
+module Geocoder::Lookup
+  class Baidu < Base
+
+    def name
+      "Baidu"
+    end
+
+    def required_api_key_parts
+      ["key"]
+    end
+
+    def query_url(query)
+      "http://api.map.baidu.com/geocoder/v2/?" + url_query_string(query)
+    end
+
+    private # ---------------------------------------------------------------
+
+    def results(query, reverse = false)
+      return [] unless doc = fetch_data(query)
+      case doc['status']; when 0
+        return [doc['result']] unless doc['result'].blank?
+      when 1, 3, 4
+        raise_error(Geocoder::Error, messages) ||
+          warn("Baidu Geocoding API error: server error.")
+      when 2
+        raise_error(Geocoder::InvalidRequest, messages) ||
+          warn("Baidu Geocoding API error: invalid request.")
+      when 5
+        raise_error(Geocoder::InvalidApiKey, messages) ||
+          warn("Baidu Geocoding API error: invalid api key.")
+      when 101, 102, 200..299
+        raise_error(Geocoder::RequestDenied) ||
+          warn("Baidu Geocoding API error: request denied.")
+      when 300..399
+        raise_error(Geocoder::OverQueryLimitError) ||
+          warn("Baidu Geocoding API error: over query limit.")
+      end
+      return []
+    end
+
+    def query_url_params(query)
+      {
+        (query.reverse_geocode? ? :location : :address) => query.sanitized_text,
+        :ak => configuration.api_key,
+        :output => "json"
+      }.merge(super)
+    end
+
+  end
+end
+

data/lib/geocoder/lookups/base.rb

@@ -72,7 +72,7 @@ module Geocoder
       def query_url(query)
         fail
       end
-      
+
       ##
       # The working Cache object.
       #
@@ -99,7 +99,7 @@ module Geocoder
         protocol = "http#{'s' if configuration.use_https}"
         proxy_name = "#{protocol}_proxy"
         if proxy = configuration.send(proxy_name)
-          proxy_url = protocol + '://' + proxy
+          proxy_url = !!(proxy =~ /^#{protocol}/) ? proxy : protocol + '://' + proxy
           begin
             uri = URI.parse(proxy_url)
           rescue URI::InvalidURIError
@@ -171,15 +171,19 @@ module Geocoder
           "(use Geocoder.configure(:timeout => ...) to set limit)."
       end
 
+      def parse_json(data)
+        if defined?(ActiveSupport::JSON)
+          ActiveSupport::JSON.decode(data)
+        else
+          JSON.parse(data)
+        end
+      end
+
       ##
       # Parses a raw search result (returns hash or array).
       #
       def parse_raw_data(raw_data)
-        if defined?(ActiveSupport::JSON)
-          ActiveSupport::JSON.decode(raw_data)
-        else
-          JSON.parse(raw_data)
-        end
+        parse_json(raw_data)
       rescue
         warn "Geocoding API's response was not valid JSON."
       end
@@ -192,6 +196,10 @@ module Geocoder
         "http" + (configuration.use_https ? "s" : "")
       end
 
+      def valid_response?(response)
+        (200..399).include?(response.code.to_i)
+      end
+
       ##
       # Fetch a raw geocoding result (JSON string).
       # The result might or might not be cached.
@@ -204,7 +212,7 @@ module Geocoder
           check_api_key_configuration!(query)
           response = make_api_request(query)
           body = response.body
-          if cache and (200..399).include?(response.code.to_i)
+          if cache and valid_response?(response)
             cache[key] = body
           end
           @cache_hit = false
@@ -219,9 +227,16 @@ module Geocoder
       def make_api_request(query)
         timeout(configuration.timeout) do
           uri = URI.parse(query_url(query))
-          client = http_client.new(uri.host, uri.port)
-          client.use_ssl = true if configuration.use_https
-          client.get(uri.request_uri, configuration.http_headers)
+          # client = http_client.new(uri.host, uri.port)
+          # client.use_ssl = true if configuration.use_https
+          # client.get(uri.request_uri, configuration.http_headers)
+
+          http_client.start(uri.host, uri.port) do |client|
+            client.use_ssl = true if configuration.use_https
+            req = Net::HTTP::Get.new(uri.request_uri, configuration.http_headers)
+            req.basic_auth(uri.user, uri.password) if uri.user and uri.password
+            client.request(req)
+          end
         end
       end
 

data/lib/geocoder/lookups/dstk.rb

@@ -0,0 +1,20 @@
+# More information about the Data Science Toolkit can be found at:
+# http://www.datasciencetoolkit.org/. The provided APIs mimic the
+# Google geocoding api.
+
+require 'geocoder/lookups/google'
+require 'geocoder/results/dstk'
+
+module Geocoder::Lookup
+  class Dstk < Google
+
+    def name
+      "Data Science Toolkit"
+    end
+
+    def query_url(query)
+      host = configuration[:host] || "www.datasciencetoolkit.org"
+      "#{protocol}://#{host}/maps/api/geocode/json?" + url_query_string(query)
+    end
+  end
+end

data/lib/geocoder/lookups/freegeoip.rb

@@ -21,12 +21,8 @@ module Geocoder::Lookup
     def results(query)
       # don't look up a loopback address, just return the stored result
       return [reserved_result(query.text)] if query.loopback_ip_address?
-      begin
-        return (doc = fetch_data(query)) ? [doc] : []
-      rescue StandardError => err # Freegeoip.net returns HTML on bad request
-        raise_error(err)
-        return []
-      end
+      # note: Freegeoip.net returns plain text "Not Found" on bad request
+      (doc = fetch_data(query)) ? [doc] : []
     end
 
     def reserved_result(ip)

data/lib/geocoder/lookups/geocoder_us.rb

@@ -0,0 +1,39 @@
+require 'geocoder/lookups/base'
+require "geocoder/results/geocoder_us"
+
+module Geocoder::Lookup
+  class GeocoderUs < Base
+
+    def name
+      "Geocoder.us"
+    end
+
+    def query_url(query)
+      if configuration.api_key
+        "http://#{configuration.api_key}@geocoder.us/member/service/csv/geocode?" + url_query_string(query)
+      else
+        "http://geocoder.us/service/csv/geocode?" + url_query_string(query)
+      end
+    end
+
+    private
+
+    def results(query)
+      return [] unless doc = fetch_data(query)
+      if doc[0].to_s =~ /^(\d+)\:/
+        return []
+      else
+        return [doc.size == 5 ? ((doc[0..1] << nil) + doc[2..4]) : doc]
+      end
+    end
+
+    def query_url_params(query)
+      (query.text =~ /^\d{5}(?:-\d{4})?$/ ? {:zip => query} : {:address => query.sanitized_text}).merge(super)
+    end
+
+    def parse_raw_data(raw_data)
+      raw_data.chomp.split(',')
+    end
+  end
+end
+

data/lib/geocoder/lookups/google.rb

@@ -18,6 +18,11 @@ module Geocoder::Lookup
 
     private # ---------------------------------------------------------------
 
+    def valid_response?(response)
+      status = parse_json(response.body)["status"]
+      super(response) and ['OK', 'ZERO_RESULTS'].include?(status)
+    end
+
     def results(query)
       return [] unless doc = fetch_data(query)
       case doc['status']; when "OK" # OK status implies >0 results

data/lib/geocoder/lookups/mapquest.rb

@@ -10,13 +10,13 @@ module Geocoder::Lookup
     end
 
     def required_api_key_parts
-      []
+      ["key"]
     end
 
     def query_url(query)
-      key = configuration.api_key
-      domain = key ? "www" : "open"
-      url = "#{protocol}://#{domain}.mapquestapi.com/geocoding/v1/#{search_type(query)}?"
+      domain = configuration[:licensed] ? "www" : "open"
+      version = configuration[:version] || 1
+      url = "#{protocol}://#{domain}.mapquestapi.com/geocoding/v#{version}/#{search_type(query)}?"
       url + url_query_string(query)
     end
 
@@ -34,9 +34,25 @@ module Geocoder::Lookup
       params.merge(super)
     end
 
+    # http://www.mapquestapi.com/geocoding/status_codes.html
+    # http://open.mapquestapi.com/geocoding/status_codes.html
     def results(query)
       return [] unless doc = fetch_data(query)
-      doc["results"][0]['locations']
+      return doc["results"][0]['locations'] if doc['info']['statuscode'] == 0 # A successful geocode call
+
+      messages = doc['info']['messages'].join
+
+      case doc['info']['statuscode']
+      when 400 # Error with input
+        raise_error(Geocoder::InvalidRequest, messages) ||
+          warn("Mapquest Geocoding API error: #{messages}")
+      when 403 # Key related error
+        raise_error(Geocoder::InvalidApiKey, messages) ||
+          warn("Mapquest Geocoding API error: #{messages}")
+      when 500 # Unknown error
+        raise_error(Geocoder::Error, messages) ||
+          warn("Mapquest Geocoding API error: #{messages}")
+      end
     end
 
   end

data/lib/geocoder/lookups/maxmind.rb

@@ -75,7 +75,7 @@ module Geocoder::Lookup
     end
 
     def reserved_result
-      ",,,,0,0,0,0,,,"
+      ",,,,0,0,0,0,,,".split(",")
     end
 
     def query_url_params(query)

data/lib/geocoder/lookups/nominatim.rb

@@ -28,7 +28,6 @@ module Geocoder::Lookup
     def query_url_params(query)
       params = {
         :format => "json",
-        :polygon => "1",
         :addressdetails => "1",
         :"accept-language" => configuration.language
       }.merge(super)

data/lib/geocoder/lookups/ovi.rb

@@ -13,7 +13,7 @@ module Geocoder::Lookup
     end
 
     def query_url(query)
-      "#{protocol}://lbs.ovi.com/search/6.2/geocode.json?" + url_query_string(query)
+      "#{protocol}://lbs.ovi.com/search/6.2/#{if query.reverse_geocode? then 'reverse' end}geocode.json?" + url_query_string(query)
     end
 
     private # ---------------------------------------------------------------
@@ -29,12 +29,22 @@ module Geocoder::Lookup
     end
 
     def query_url_params(query)
-      super.merge(
-        :searchtext=>query.sanitized_text,
+      options = {
         :gen=>1,
         :app_id=>api_key,
         :app_code=>api_code
-      )
+      }
+
+      if query.reverse_geocode?
+        super.merge(options).merge(
+          :prox=>query.sanitized_text,
+          :mode=>:retrieveAddresses
+        )
+      else
+        super.merge(options).merge(
+          :searchtext=>query.sanitized_text
+        )
+      end
     end
 
     def api_key

data/lib/geocoder/query.rb

@@ -17,7 +17,11 @@ module Geocoder
 
     def sanitized_text
       if coordinates?
-        text.split(/\s*,\s*/).join(',')
+        if text.is_a?(Array)
+          text.join(',')
+        else
+          text.split(/\s*,\s*/).join(',')
+        end
       else
         text
       end

data/lib/geocoder/results/baidu.rb

@@ -0,0 +1,79 @@
+require 'geocoder/results/base'
+
+module Geocoder::Result
+  class Baidu < Base
+
+    def coordinates
+      ['lat', 'lng'].map{ |i| @data['location'][i] }
+    end
+
+    def address
+      @data['formatted_address']
+    end
+
+    def state
+      province
+    end
+    
+    def province
+      @data['addressComponent']['province']
+    end
+
+    def city
+      @data['addressComponent']['city']
+    end
+
+    def district
+      @data['addressComponent']['district']
+    end
+
+    def street
+      @data['addressComponent']['street']
+    end
+
+    def street_number
+      @data['addressComponent']['street_number']
+    end
+
+    def formatted_address
+      @data['formatted_address']
+    end
+
+    def address_components
+      @data['addressComponent']
+    end
+
+    def state_code
+      ""
+    end
+
+    def postal_code
+      ""
+    end
+
+    def country
+      "China"
+    end
+
+    def country_code
+      "CN"
+    end
+
+    ##
+    # Get address components of a given type. Valid types are defined in
+    # Baidu's Geocoding API documentation and include (among others):
+    #
+    #   :business
+    #   :cityCode
+    #
+    def self.response_attributes
+      %w[business cityCode]
+    end
+
+    response_attributes.each do |a|
+      define_method a do
+        @data[a]
+      end
+    end
+  end
+end

data/lib/geocoder/results/dstk.rb

@@ -0,0 +1,6 @@
+require 'geocoder/results/google'
+
+module Geocoder::Result
+  class Dstk < Google
+  end
+end

data/lib/geocoder/results/geocoder_us.rb

@@ -0,0 +1,39 @@
+require 'geocoder/results/base'
+
+module Geocoder::Result
+  class GeocoderUs < Base
+    def coordinates
+      [@data[0].to_f, @data[1].to_f]
+    end
+
+    def address(format = :full)
+      "#{street_address}, #{city}, #{state} #{postal_code}, #{country}".sub(/^[ ,]*/, "")
+    end
+
+    def street_address
+      @data[2]
+    end
+
+    def city
+      @data[3]
+    end
+
+    def state
+      @data[4]
+    end
+
+    alias_method :state_code, :state
+
+    def postal_code
+      @data[5]
+    end
+
+    def country
+      'United States'
+    end
+
+    def country_code
+      'US'
+    end
+  end
+end