geocoder 1.4.7 → 1.5.2

data/lib/geocoder/lookups/pelias.rb

@@ -11,25 +11,24 @@ module Geocoder::Lookup
       configuration[:endpoint] || 'localhost'
     end
 
-    def query_url(query)
-      query_type = query.reverse_geocode? ? 'reverse' : 'search'
-      "#{protocol}://#{endpoint}/v1/#{query_type}?" + url_query_string(query)
-    end
-
     def required_api_key_parts
       ['search-XXXX']
     end
 
-    private
+    private # ----------------------------------------------------------------
+
+    def base_query_url(query)
+      query_type = query.reverse_geocode? ? 'reverse' : 'search'
+      "#{protocol}://#{endpoint}/v1/#{query_type}?"
+    end
 
     def query_url_params(query)
       params = {
-        api_key: configuration.api_key,
-        size: 1
+        api_key: configuration.api_key
       }.merge(super)
 
       if query.reverse_geocode?
-        lat,lon = query.coordinates
+        lat, lon = query.coordinates
         params[:'point.lat'] = lat
         params[:'point.lon'] = lon
       else

data/lib/geocoder/lookups/pickpoint.rb

@@ -15,12 +15,18 @@ module Geocoder::Lookup
       ["api_key"]
     end
 
-    def query_url(query)
+    private # ----------------------------------------------------------------
+
+    def base_query_url(query)
       method = query.reverse_geocode? ? "reverse" : "forward"
-      "#{protocol}://api.pickpoint.io/v1/#{method}?key=#{configuration.api_key}&" + url_query_string(query)
+      "#{protocol}://api.pickpoint.io/v1/#{method}?"
     end
 
-    private
+    def query_url_params(query)
+      params = {
+        key: configuration.api_key
+      }.merge(super)
+    end
 
     def results(query)
       return [] unless doc = fetch_data(query)

data/lib/geocoder/lookups/pointpin.rb

@@ -13,14 +13,18 @@ module Geocoder::Lookup
     end
 
     def query_url(query)
-      "#{ protocol }://geo.pointp.in/#{ api_key }/json/#{ query.sanitized_text }"
+      "#{protocol}://geo.pointp.in/#{configuration.api_key}/json/#{query.sanitized_text}"
     end
 
-  private
+    private # ----------------------------------------------------------------
+
+    def cache_key(query)
+      "#{protocol}://geo.pointp.in/json/#{query.sanitized_text}"
+    end
 
     def results(query)
-      # don't look up a loopback address, just return the stored result
-      return [] if query.loopback_ip_address?
+      # don't look up a loopback or private address, just return the stored result
+      return [] if query.internal_ip_address?
       doc = fetch_data(query)
       if doc and doc.is_a?(Hash)
         if !data_contains_error?(doc)
@@ -38,7 +42,7 @@ module Geocoder::Lookup
           raise_error(Geocoder::Error) || Geocoder.log(:warn, "Pointpin server error")
         end
       end
-      
+
       return []
     end
 
@@ -46,6 +50,7 @@ module Geocoder::Lookup
       parsed_data.keys.include?('error')
     end
 
+    # TODO: replace this hash with what's actually returned by Pointpin
     def reserved_result(ip)
       {
         "ip"           => ip,
@@ -60,9 +65,5 @@ module Geocoder::Lookup
         "country_code" => "RD"
       }
     end
-
-    def api_key
-      configuration.api_key
-    end
   end
 end

data/lib/geocoder/lookups/postcode_anywhere_uk.rb

@@ -4,7 +4,6 @@ require 'geocoder/results/postcode_anywhere_uk'
 module Geocoder::Lookup
   class PostcodeAnywhereUk < Base
     # API documentation: http://www.postcodeanywhere.co.uk/Support/WebService/Geocoding/UK/Geocode/2/
-    BASE_URL_GEOCODE_V2_00 = 'services.postcodeanywhere.co.uk/Geocoding/UK/Geocode/v2.00/json.ws'
     DAILY_LIMIT_EXEEDED_ERROR_CODES = ['8', '17'] # api docs say these two codes are the same error
     INVALID_API_KEY_ERROR_CODE = '2'
 
@@ -16,11 +15,11 @@ module Geocoder::Lookup
       %w(key)
     end
 
-    def query_url(query)
-      format('%s://%s?%s', protocol, BASE_URL_GEOCODE_V2_00, url_query_string(query))
-    end
+    private # ----------------------------------------------------------------
 
-    private
+    def base_query_url(query)
+      "#{protocol}://services.postcodeanywhere.co.uk/Geocoding/UK/Geocode/v2.00/json.ws?"
+    end
 
     def results(query)
       response = fetch_data(query)

data/lib/geocoder/lookups/postcodes_io.rb

@@ -0,0 +1,31 @@
+require 'geocoder/lookups/base'
+require 'geocoder/results/postcodes_io'
+
+module Geocoder::Lookup
+  class PostcodesIo < Base
+    def name
+      'Postcodes.io'
+    end
+
+    def query_url(query)
+      "#{protocol}://api.postcodes.io/postcodes/#{query.sanitized_text.gsub(/\s/, '')}"
+    end
+
+    def supported_protocols
+      [:https]
+    end
+
+    private # ----------------------------------------------------------------
+
+    def cache_key(query)
+      query_url(query)
+    end
+
+    def results(query)
+      response = fetch_data(query)
+      return [] if response.nil? || response['status'] != 200 || response.empty?
+
+      [response['result']]
+    end
+  end
+end

data/lib/geocoder/lookups/smarty_streets.rb

@@ -8,15 +8,7 @@ module Geocoder::Lookup
     end
 
     def required_api_key_parts
-      %w(auti-id auth-token)
-    end
-
-    def query_url(query)
-      if zipcode_only?(query)
-        "#{protocol}://us-zipcode.api.smartystreets.com/lookup?#{url_query_string(query)}"
-      else
-        "#{protocol}://us-street.api.smartystreets.com/street-address?#{url_query_string(query)}"
-      end
+      %w(auth-id auth-token)
     end
 
     # required by API as of 26 March 2015
@@ -26,13 +18,31 @@ module Geocoder::Lookup
 
     private # ---------------------------------------------------------------
 
+    def base_query_url(query)
+      if international?(query)
+        "#{protocol}://international-street.api.smartystreets.com/verify?"
+      elsif zipcode_only?(query)
+        "#{protocol}://us-zipcode.api.smartystreets.com/lookup?"
+      else
+        "#{protocol}://us-street.api.smartystreets.com/street-address?"
+      end
+    end
+
     def zipcode_only?(query)
       !query.text.is_a?(Array) and query.to_s.strip =~ /\A\d{5}(-\d{4})?\Z/
     end
 
+    def international?(query)
+      !query.options[:country].nil?
+    end
+
     def query_url_params(query)
       params = {}
-      if zipcode_only?(query)
+      if international?(query)
+        params[:freeform] = query.sanitized_text
+        params[:country] = query.options[:country]
+        params[:geocode] = true
+      elsif zipcode_only?(query)
         params[:zipcode] = query.sanitized_text
       else
         params[:street] = query.sanitized_text

data/lib/geocoder/lookups/telize.rb

@@ -14,9 +14,9 @@ module Geocoder::Lookup
 
     def query_url(query)
       if configuration[:host]
-        "#{protocol}://#{configuration[:host]}/geoip/#{query.sanitized_text}"
+        "#{protocol}://#{configuration[:host]}/location/#{query.sanitized_text}"
       else
-        "#{protocol}://telize-v1.p.mashape.com/geoip/#{query.sanitized_text}?mashape-key=#{api_key}"
+        "#{protocol}://telize-v1.p.mashape.com/location/#{query.sanitized_text}?mashape-key=#{api_key}"
       end
     end
 
@@ -29,9 +29,13 @@ module Geocoder::Lookup
 
     private # ---------------------------------------------------------------
 
+    def cache_key(query)
+      query_url(query)[/(.*)\?.*/, 1]
+    end
+
     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?
+      # don't look up a loopback or private address, just return the stored result
+      return [reserved_result(query.text)] if query.internal_ip_address?
       if (doc = fetch_data(query)).nil? or doc['code'] == 401 or empty_result?(doc)
         []
       else
@@ -44,12 +48,28 @@ module Geocoder::Lookup
     end
 
     def reserved_result(ip)
-      {"message" => "Input string is not a valid IP address", "code" => 401}
+      {
+        "ip" => ip,
+        "latitude" => 0,
+        "longitude" => 0,
+        "city" => "",
+        "timezone" => "",
+        "asn" => 0,
+        "region" => "",
+        "offset" => 0,
+        "organization" => "",
+        "country_code" => "",
+        "country_code3" => "",
+        "postal_code" => "",
+        "continent_code" => "",
+        "country" => "",
+        "region_code" => ""
+      }
     end
 
     def api_key
       configuration.api_key
     end
-    
+
   end
 end

data/lib/geocoder/lookups/tencent.rb

@@ -0,0 +1,59 @@
+require 'geocoder/lookups/base'
+require "geocoder/results/tencent"
+
+module Geocoder::Lookup
+  class Tencent < Base
+
+    def name
+      "Tencent"
+    end
+
+    def required_api_key_parts
+      ["key"]
+    end
+
+    def supported_protocols
+      [:https]
+    end
+
+    private # ---------------------------------------------------------------
+
+    def base_query_url(query)
+      "#{protocol}://apis.map.qq.com/ws/geocoder/v1/?"
+    end
+
+    def content_key
+      'result'
+    end
+
+    def results(query, reverse = false)
+      return [] unless doc = fetch_data(query)
+      case doc['status']
+      when 0
+        return [doc[content_key]]
+      when 199
+        raise error(Geocoder::InvalidApiKey, "invalid api key") ||
+        Geocoder.log(:warn, "#{name} Geocoding API error: key is not enabled for web service usage.")
+      when 311
+        raise_error(Geocoder::RequestDenied, "request denied") ||
+          Geocoder.log(:warn, "#{name} Geocoding API error: request denied.")
+      when 310, 306
+        raise_error(Geocoder::InvalidRequest, "invalid request.") ||
+          Geocoder.log(:warn, "#{name} Geocoding API error: invalid request.")
+      when 311
+        raise_error(Geocoder::InvalidApiKey, "invalid api key") ||
+          Geocoder.log(:warn, "#{name} Geocoding API error: invalid api key.")
+      end
+      return []
+    end
+
+    def query_url_params(query)
+      {
+        (query.reverse_geocode? ? :location : :address) => query.sanitized_text,
+        :key => configuration.api_key,
+        :output => "json"
+      }.merge(super)
+    end
+
+  end
+end

data/lib/geocoder/lookups/yandex.rb

@@ -12,16 +12,16 @@ module Geocoder::Lookup
       "http://maps.yandex.ru/?ll=#{coordinates.reverse.join(',')}"
     end
 
-    def query_url(query)
-      "#{protocol}://geocode-maps.yandex.ru/1.x/?" + url_query_string(query)
-    end
-    
     def supported_protocols
       [:https]
     end
 
     private # ---------------------------------------------------------------
 
+    def base_query_url(query)
+      "#{protocol}://geocode-maps.yandex.ru/1.x/?"
+    end
+
     def results(query)
       return [] unless doc = fetch_data(query)
       if err = doc['error']
@@ -50,8 +50,8 @@ module Geocoder::Lookup
       params = {
         :geocode => q,
         :format => "json",
-        :plng => "#{query.language || configuration.language}", # supports ru, uk, be
-        :key => configuration.api_key
+        :lang => "#{query.language || configuration.language}", # supports ru, uk, be, default -> ru
+        :apikey => configuration.api_key
       }
       unless (bounds = query.options[:bounds]).nil?
         params[:bbox] = bounds.map{ |point| "%f,%f" % point }.join('~')

data/lib/geocoder/query.rb

@@ -66,6 +66,13 @@ module Geocoder
       IpAddress.new(text).valid? rescue false
     end
 
+    ##
+    # Is the Query text a loopback or private IP address?
+    #
+    def internal_ip_address?
+      ip_address? && IpAddress.new(text).internal?
+    end
+
     ##
     # Is the Query text a loopback IP address?
     #
@@ -73,6 +80,13 @@ module Geocoder
       ip_address? && IpAddress.new(text).loopback?
     end
 
+    ##
+    # Is the Query text a private IP address?
+    #
+    def private_ip_address?
+      ip_address? && IpAddress.new(text).private?
+    end
+
     ##
     # Does the given string look like latitude/longitude coordinates?
     #

data/lib/geocoder/railtie.rb

@@ -4,7 +4,7 @@ module Geocoder
   if defined? Rails::Railtie
     require 'rails'
     class Railtie < Rails::Railtie
-      initializer 'geocoder.insert_into_active_record' do
+      initializer 'geocoder.insert_into_active_record', before: :load_config_initializers do
         ActiveSupport.on_load :active_record do
           Geocoder::Railtie.insert
         end

data/lib/geocoder/results/baidu.rb

@@ -11,34 +11,34 @@ module Geocoder::Result
       @data['formatted_address']
     end
 
-    def state
-      province
-    end
-    
     def province
-      @data['addressComponent']['province']
+      @data['addressComponent'] and @data['addressComponent']['province'] or ""
     end
 
+    alias_method :state, :province
+
     def city
-      @data['addressComponent']['city']
+      @data['addressComponent'] and @data['addressComponent']['city'] or ""
     end
 
     def district
-      @data['addressComponent']['district']
+      @data['addressComponent'] and @data['addressComponent']['district'] or ""
     end
 
     def street
-      @data['addressComponent']['street']
+      @data['addressComponent'] and @data['addressComponent']['street'] or ""
     end
 
     def street_number
-      @data['addressComponent']['street_number']
+      @data['addressComponent'] and @data['addressComponent']['street_number']
     end
 
     def formatted_address
-      @data['formatted_address']
+      @data['formatted_address'] or ""
     end
 
+    alias_method :address, :formatted_address
+
     def address_components
       @data['addressComponent']
     end

data/lib/geocoder/results/base.rb

@@ -20,8 +20,20 @@ module Geocoder
       ##
       # A string in the given format.
       #
+      # This default implementation dumbly follows the United States address
+      # format and will return incorrect results for most countries. Some APIs
+      # return properly formatted addresses and those should be funneled
+      # through this method.
+      #
       def address(format = :full)
-        fail
+        if state_code.to_s != ""
+          s = ", #{state_code}"
+        elsif state.to_s != ""
+          s = ", #{state}"
+        else
+          s = ""
+        end
+        "#{city}#{s} #{postal_code}, #{country}".sub(/^[ ,]*/, '')
       end
 
       ##