geocoder 1.4.3 → 1.6.1

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 311
+        raise_error(Geocoder::InvalidApiKey, "invalid api key") ||
+          Geocoder.log(:warn, "#{name} Geocoding API error: invalid api key.")
+      when 310
+        raise_error(Geocoder::InvalidRequest, "invalid request.") ||
+          Geocoder.log(:warn, "#{name} Geocoding API error: invalid request, invalid parameters.")
+      when 306
+        raise_error(Geocoder::InvalidRequest, "invalid request.") ||
+          Geocoder.log(:warn, "#{name} Geocoding API error: invalid request, check response for more info.")
+      when 110
+        raise_error(Geocoder::RequestDenied, "request denied.") ||
+          Geocoder.log(:warn, "#{name} Geocoding API error: request source is not authorized.")
+      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']
@@ -47,12 +47,16 @@ module Geocoder::Lookup
       else
         q = query.sanitized_text
       end
-      {
+      params = {
         :geocode => q,
         :format => "json",
-        :plng => "#{query.language || configuration.language}", # supports ru, uk, be
-        :key => configuration.api_key
-      }.merge(super)
+        :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('~')
+      end
+      params.merge(super)
     end
   end
 end

data/lib/geocoder/models/active_record.rb

@@ -18,7 +18,8 @@ module Geocoder
           :units         => options[:units],
           :method        => options[:method],
           :lookup        => options[:lookup],
-          :language      => options[:language]
+          :language      => options[:language],
+          :params        => options[:params]
         )
       end
 
@@ -35,7 +36,8 @@ module Geocoder
           :units           => options[:units],
           :method          => options[:method],
           :lookup          => options[:lookup],
-          :language        => options[:language]
+          :language        => options[:language],
+          :params          => options[:params]
         )
       end
 
@@ -47,4 +49,3 @@ module Geocoder
     end
   end
 end
-

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/request.rb

@@ -1,3 +1,5 @@
+require 'ipaddr'
+
 module Geocoder
   module Request
 
@@ -54,6 +56,8 @@ module Geocoder
       GEOCODER_CANDIDATE_HEADERS.each do |header|
         if @env.has_key? header
           addrs = geocoder_split_ip_addresses(@env[header])
+          addrs = geocoder_remove_port_from_addresses(addrs)
+          addrs = geocoder_reject_non_ipv4_addresses(addrs)
           addrs = geocoder_reject_trusted_ip_addresses(addrs)
           return addrs.first if addrs.any?
         end
@@ -75,6 +79,34 @@ module Geocoder
     def geocoder_reject_trusted_ip_addresses(ip_addresses)
       ip_addresses.reject { |ip| trusted_proxy?(ip) }
     end
+
+    def geocoder_remove_port_from_addresses(ip_addresses)
+      ip_addresses.map do |ip|
+        # IPv4
+        if ip.count('.') > 0
+          ip.split(':').first
+        # IPv6 bracket notation
+        elsif match = ip.match(/\[(\S+)\]/)
+          match.captures.first
+        # IPv6 bare notation
+        else
+          ip
+        end
+      end
+    end
+
+    def geocoder_reject_non_ipv4_addresses(ip_addresses)
+      ips = []
+      for ip in ip_addresses
+        begin
+          valid_ip = IPAddr.new(ip)
+        rescue
+          valid_ip = false
+        end
+        ips << valid_ip.to_s if valid_ip
+      end
+      return ips.any? ? ips : ip_addresses
+    end
   end
 end
 

data/lib/geocoder/results/amap.rb

@@ -0,0 +1,87 @@
+require 'geocoder/results/base'
+
+module Geocoder::Result
+  class Amap < Base
+
+    def coordinates
+      location = @data['location'] || @data['roadinters'].try(:first).try(:[], 'location') \
+        || address_components.try(:[], 'streetNumber').try(:[], 'location')
+      location.to_s.split(",").reverse.map(&:to_f)
+    end
+
+    def address
+      formatted_address
+    end
+
+    def state
+      province
+    end
+
+    def province
+      address_components['province']
+    end
+
+    def city
+      address_components['city'] == [] ? province : address_components["city"]
+    end
+
+    def district
+      address_components['district']
+    end
+
+    def street
+      if address_components["neighborhood"]["name"] != []
+        return address_components["neighborhood"]["name"]
+      elsif address_components['township'] != []
+        return address_components["township"]
+      else
+        return @data['street'] || address_components['streetNumber'].try(:[], 'street')
+      end
+    end
+
+    def street_number
+      @data['number'] || address_components['streetNumber'].try(:[], 'number')
+    end
+
+    def formatted_address
+      @data['formatted_address']
+    end
+
+    def address_components
+      @data['addressComponent'] || @data
+    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[roads pois roadinters]
+    end
+
+    response_attributes.each do |a|
+      define_method a do
+        @data[a]
+      end
+    end
+  end
+end