geocoder 1.1.9 → 1.3.7

data/lib/geocoder/lookups/opencagedata.rb

@@ -0,0 +1,58 @@
+require 'geocoder/lookups/base'
+require 'geocoder/results/opencagedata'
+
+module Geocoder::Lookup
+  class Opencagedata < Base
+
+    def name
+      "OpenCageData"
+    end
+
+    def query_url(query)
+      "#{protocol}://api.opencagedata.com/geocode/v1/json?key=#{configuration.api_key}&#{url_query_string(query)}"
+    end
+
+    def required_api_key_parts
+      ["key"]
+    end
+
+    private
+
+    def results(query)
+      return [] unless doc = fetch_data(query)
+      # return doc["results"]
+
+      messages = doc['status']['message']
+      case doc['status']['code']
+      when 400 # Error with input
+        raise_error(Geocoder::InvalidRequest, messages) ||
+          Geocoder.log(:warn, "Opencagedata Geocoding API error: #{messages}")
+      when 403 # Key related error
+        raise_error(Geocoder::InvalidApiKey, messages) ||
+          Geocoder.log(:warn, "Opencagedata Geocoding API error: #{messages}")
+      when 402 # Quata Exceeded
+          raise_error(Geocoder::OverQueryLimitError, messages) ||
+          Geocoder.log(:warn, "Opencagedata Geocoding API error: #{messages}")
+      when 500 # Unknown error
+        raise_error(Geocoder::Error, messages) ||
+          Geocoder.log(:warn, "Opencagedata Geocoding API error: #{messages}")
+      end
+
+      return doc["results"]
+    end
+
+    def query_url_params(query)
+      params = {
+        :q => query.sanitized_text,
+        :language => (query.language || configuration.language)
+      }.merge(super)
+
+      unless (bounds = query.options[:bounds]).nil?
+        params[:bounds] = bounds.map{ |point| "%f,%f" % point }.join(',')
+      end
+
+      params
+    end
+
+  end
+end

data/lib/geocoder/lookups/pelias.rb

@@ -0,0 +1,64 @@
+require 'geocoder/lookups/base'
+require 'geocoder/results/pelias'
+
+module Geocoder::Lookup
+  class Pelias < Base
+    def name
+      'Pelias'
+    end
+
+    def endpoint
+      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
+
+    def query_url_params(query)
+      params = {
+        api_key: configuration.api_key,
+        size: 1
+      }.merge(super)
+
+      if query.reverse_geocode?
+        lat,lon = query.coordinates
+        params[:'point.lat'] = lat
+        params[:'point.lon'] = lon
+      else
+        params[:text] = query.text
+      end
+      params
+    end
+
+    def results(query)
+      return [] unless doc = fetch_data(query)
+
+      # not all responses include a meta
+      if doc['meta']
+        error = doc.fetch('results', {}).fetch('error', {})
+        message = error.fetch('type', 'Unknown Error') + ': ' + error.fetch('message', 'No message')
+        log_message = 'Pelias Geocoding API error - ' + message
+        case doc['meta']['status_code']
+          when '200'
+            # nothing to see here
+          when '403'
+            raise_error(Geocoder::RequestDenied, message) || Geocoder.log(:warn, log_message)
+          when '429'
+            raise_error(Geocoder::OverQueryLimitError, message) || Geocoder.log(:warn, log_message)
+          else
+            raise_error(Geocoder::Error, message) || Geocoder.log(:warn, log_message)
+        end
+      end
+
+      doc['features'] || []
+    end
+  end
+end

data/lib/geocoder/lookups/pointpin.rb

@@ -0,0 +1,68 @@
+require 'geocoder/lookups/base'
+require 'geocoder/results/pointpin'
+
+module Geocoder::Lookup
+  class Pointpin < Base
+
+    def name
+      "Pointpin"
+    end
+
+    def required_api_key_parts
+      ["key"]
+    end
+
+    def query_url(query)
+      "#{ protocol }://geo.pointp.in/#{ api_key }/json/#{ query.sanitized_text }"
+    end
+
+  private
+
+    def results(query)
+      # don't look up a loopback address, just return the stored result
+      return [] if query.loopback_ip_address?
+      doc = fetch_data(query)
+      if doc and doc.is_a?(Hash)
+        if !data_contains_error?(doc)
+          return [doc]
+        elsif doc['error']
+          case doc['error']
+          when "Invalid IP address"
+            raise_error(Geocoder::InvalidRequest) || Geocoder.log(:warn, "Invalid Pointpin request.")
+          when "Invalid API key"
+            raise_error(Geocoder::InvalidApiKey) || Geocoder.log(:warn, "Invalid Pointpin API key.")
+          when "Address not found"
+            Geocoder.log(:warn, "Address not found.")
+          end
+        else
+          raise_error(Geocoder::Error) || Geocoder.log(:warn, "Pointpin server error")
+        end
+      end
+      
+      return []
+    end
+
+    def data_contains_error?(parsed_data)
+      parsed_data.keys.include?('error')
+    end
+
+    def reserved_result(ip)
+      {
+        "ip"           => ip,
+        "city"         => "",
+        "region_code"  => "",
+        "region_name"  => "",
+        "metrocode"    => "",
+        "zipcode"      => "",
+        "latitude"     => "0",
+        "longitude"    => "0",
+        "country_name" => "Reserved",
+        "country_code" => "RD"
+      }
+    end
+
+    def api_key
+      configuration.api_key
+    end
+  end
+end

data/lib/geocoder/lookups/postcode_anywhere_uk.rb

@@ -0,0 +1,51 @@
+require 'geocoder/lookups/base'
+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'
+
+    def name
+      'PostcodeAnywhereUk'
+    end
+
+    def required_api_key_parts
+      %w(key)
+    end
+
+    def query_url(query)
+      format('%s://%s?%s', protocol, BASE_URL_GEOCODE_V2_00, url_query_string(query))
+    end
+
+    private
+
+    def results(query)
+      response = fetch_data(query)
+      return [] if response.nil? || !response.is_a?(Array) || response.empty?
+
+      raise_exception_for_response(response[0]) if response[0]['Error']
+      response
+    end
+
+    def raise_exception_for_response(response)
+      case response['Error']
+      when *DAILY_LIMIT_EXEEDED_ERROR_CODES
+        raise_error(Geocoder::OverQueryLimitError, response['Cause']) || Geocoder.log(:warn, response['Cause'])
+      when INVALID_API_KEY_ERROR_CODE
+        raise_error(Geocoder::InvalidApiKey, response['Cause']) || Geocoder.log(:warn, response['Cause'])
+      else # anything else just raise general error with the api cause
+        raise_error(Geocoder::Error, response['Cause']) || Geocoder.log(:warn, response['Cause'])
+      end
+    end
+
+    def query_url_params(query)
+      {
+        :location => query.sanitized_text,
+        :key => configuration.api_key
+      }.merge(super)
+    end
+  end
+end

data/lib/geocoder/lookups/smarty_streets.rb

@@ -0,0 +1,53 @@
+require 'geocoder/lookups/base'
+require 'geocoder/results/smarty_streets'
+
+module Geocoder::Lookup
+  class SmartyStreets < Base
+    def name
+      "SmartyStreets"
+    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}://api.smartystreets.com/street-address?#{url_query_string(query)}"
+      end
+    end
+
+    # required by API as of 26 March 2015
+    def supported_protocols
+      [:https]
+    end
+
+    private # ---------------------------------------------------------------
+
+    def zipcode_only?(query)
+      !query.text.is_a?(Array) and query.to_s.strip =~ /\A\d{5}(-\d{4})?\Z/
+    end
+
+    def query_url_params(query)
+      params = {}
+      if zipcode_only?(query)
+        params[:zipcode] = query.sanitized_text
+      else
+        params[:street] = query.sanitized_text
+      end
+      if configuration.api_key.is_a?(Array)
+        params[:"auth-id"] = configuration.api_key[0]
+        params[:"auth-token"] = configuration.api_key[1]
+      else
+        params[:"auth-token"] = configuration.api_key
+      end
+      params.merge(super)
+    end
+
+    def results(query)
+      fetch_data(query) || []
+    end
+  end
+end

data/lib/geocoder/lookups/telize.rb

@@ -0,0 +1,55 @@
+require 'geocoder/lookups/base'
+require 'geocoder/results/telize'
+
+module Geocoder::Lookup
+  class Telize < Base
+
+    def name
+      "Telize"
+    end
+
+    def required_api_key_parts
+      configuration[:host] ? [] : ["key"]
+    end
+
+    def query_url(query)
+      if configuration[:host]
+        "#{protocol}://#{configuration[:host]}/geoip/#{query.sanitized_text}"
+      else
+        "#{protocol}://telize-v1.p.mashape.com/geoip/#{query.sanitized_text}?mashape-key=#{api_key}"
+      end
+    end
+
+    def supported_protocols
+      [].tap do |array|
+        array << :https
+        array << :http if configuration[:host]
+      end
+    end
+
+    private # ---------------------------------------------------------------
+
+    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?
+      if (doc = fetch_data(query)).nil? or doc['code'] == 401 or empty_result?(doc)
+        []
+      else
+        [doc]
+      end
+    end
+
+    def empty_result?(doc)
+      !doc.is_a?(Hash) or doc.keys == ["ip"]
+    end
+
+    def reserved_result(ip)
+      {"message" => "Input string is not a valid IP address", "code" => 401}
+    end
+
+    def api_key
+      configuration.api_key
+    end
+    
+  end
+end

data/lib/geocoder/lookups/yandex.rb

@@ -15,6 +15,10 @@ module Geocoder::Lookup
     def query_url(query)
       "#{protocol}://geocode-maps.yandex.ru/1.x/?" + url_query_string(query)
     end
+    
+    def supported_protocols
+      [:https]
+    end
 
     private # ---------------------------------------------------------------
 
@@ -22,9 +26,9 @@ module Geocoder::Lookup
       return [] unless doc = fetch_data(query)
       if err = doc['error']
         if err["status"] == 401 and err["message"] == "invalid key"
-          raise_error(Geocoder::InvalidApiKey) || warn("Invalid API key.")
+          raise_error(Geocoder::InvalidApiKey) || Geocoder.log(:warn, "Invalid API key.")
         else
-          warn "Yandex Geocoding API error: #{err['status']} (#{err['message']})."
+          Geocoder.log(:warn, "Yandex Geocoding API error: #{err['status']} (#{err['message']}).")
         end
         return []
       end
@@ -32,7 +36,7 @@ module Geocoder::Lookup
         meta = doc['metaDataProperty']['GeocoderResponseMetaData']
         return meta['found'].to_i > 0 ? doc['featureMember'] : []
       else
-        warn "Yandex Geocoding API error: unexpected response format."
+        Geocoder.log(:warn, "Yandex Geocoding API error: unexpected response format.")
         return []
       end
     end
@@ -46,7 +50,7 @@ module Geocoder::Lookup
       {
         :geocode => q,
         :format => "json",
-        :plng => "#{configuration.language}", # supports ru, uk, be
+        :plng => "#{query.language || configuration.language}", # supports ru, uk, be
         :key => configuration.api_key
       }.merge(super)
     end

data/lib/geocoder/models/active_record.rb

@@ -16,7 +16,9 @@ module Geocoder
           :longitude     => options[:longitude] || :longitude,
           :geocode_block => block,
           :units         => options[:units],
-          :method        => options[:method]
+          :method        => options[:method],
+          :lookup        => options[:lookup],
+          :language      => options[:language]
         )
       end
 
@@ -30,8 +32,10 @@ module Geocoder
           :latitude        => latitude_attr,
           :longitude       => longitude_attr,
           :reverse_block   => block,
-          :units         => options[:units],
-          :method        => options[:method]
+          :units           => options[:units],
+          :method          => options[:method],
+          :lookup          => options[:lookup],
+          :language        => options[:language]
         )
       end
 

data/lib/geocoder/models/base.rb

@@ -1,5 +1,3 @@
-require 'geocoder'
-
 module Geocoder
 
   ##
@@ -29,7 +27,7 @@ module Geocoder
       private # ----------------------------------------------------------------
 
       def geocoder_init(options)
-        unless @geocoder_options
+        unless defined?(@geocoder_options)
           @geocoder_options = {}
           require "geocoder/stores/#{geocoder_file_name}"
           include Geocoder::Store.const_get(geocoder_module_name)
@@ -39,4 +37,3 @@ module Geocoder
     end
   end
 end
-

data/lib/geocoder/models/mongo_base.rb

@@ -1,5 +1,3 @@
-require 'geocoder'
-
 module Geocoder
 
   ##
@@ -19,7 +17,9 @@ module Geocoder
           :geocode_block => block,
           :units         => options[:units],
           :method        => options[:method],
-          :skip_index    => options[:skip_index] || false
+          :skip_index    => options[:skip_index] || false,
+          :lookup        => options[:lookup],
+          :language      => options[:language]
         )
       end
 
@@ -34,7 +34,9 @@ module Geocoder
           :reverse_block   => block,
           :units           => options[:units],
           :method          => options[:method],
-          :skip_index      => options[:skip_index] || false
+          :skip_index      => options[:skip_index] || false,
+          :lookup          => options[:lookup],
+          :language        => options[:language]
         )
       end
 

data/lib/geocoder/query.rb

@@ -32,10 +32,10 @@ module Geocoder
     # appropriate to the Query text.
     #
     def lookup
-      if ip_address?
-        name = Configuration.ip_lookup || Geocoder::Lookup.ip_services.first
+      if !options[:street_address] and (options[:ip_address] or ip_address?)
+        name = options[:ip_lookup] || Configuration.ip_lookup || Geocoder::Lookup.ip_services.first
       else
-        name = Configuration.lookup || Geocoder::Lookup.street_services.first
+        name = options[:lookup] || Configuration.lookup || Geocoder::Lookup.street_services.first
       end
       Lookup.get(name)
     end
@@ -63,14 +63,14 @@ module Geocoder
     # dot-delimited numbers.
     #
     def ip_address?
-      !!text.to_s.match(/\A(::ffff:)?(\d{1,3})\.(\d{1,3})\.(\d{1,3})\.(\d{1,3})\z/)
+      IpAddress.new(text).valid? rescue false
     end
 
     ##
     # Is the Query text a loopback IP address?
     #
     def loopback_ip_address?
-      !!(self.ip_address? and (text == "0.0.0.0" or text.to_s.match(/\A127/)))
+      ip_address? && IpAddress.new(text).loopback?
     end
 
     ##
@@ -98,6 +98,10 @@ module Geocoder
       coordinates?
     end
 
+    def language
+      options[:language]
+    end
+
     private # ----------------------------------------------------------------
 
     def params_given?

data/lib/geocoder/railtie.rb

@@ -1,4 +1,3 @@
-require 'geocoder'
 require 'geocoder/models/active_record'
 
 module Geocoder
@@ -12,6 +11,7 @@ module Geocoder
       end
       rake_tasks do
         load "tasks/geocoder.rake"
+        load "tasks/maxmind.rake"
       end
     end
   end

data/lib/geocoder/request.rb

@@ -1,23 +1,85 @@
-require 'geocoder'
-
 module Geocoder
   module Request
 
+    # The location() method is vulnerable to trivial IP spoofing.
+    #   Don't use it in authorization/authentication code, or any
+    #   other security-sensitive application.  Use safe_location
+    #   instead.
     def location
-      unless defined?(@location)
-        if env.has_key?('HTTP_X_REAL_IP')
-          @location = Geocoder.search(env['HTTP_X_REAL_IP']).first
-        elsif env.has_key?('HTTP_X_FORWARDED_FOR')
-          @location = Geocoder.search(env['HTTP_X_FORWARDED_FOR'].split(/\s*,\s*/)[0]).first
-        else
-          @location = Geocoder.search(ip).first
+      @location ||= Geocoder.search(geocoder_spoofable_ip, ip_address: true).first
+    end
+
+    # This safe_location() protects you from trivial IP spoofing.
+    #   For requests that go through a proxy that you haven't
+    #   whitelisted as trusted in your Rack config, you will get the
+    #   location for the IP of the last untrusted proxy in the chain,
+    #   not the original client IP.  You WILL NOT get the location
+    #   corresponding to the original client IP for any request sent
+    #   through a non-whitelisted proxy.
+    def safe_location
+      @safe_location ||= Geocoder.search(ip, ip_address: true).first
+    end
+
+    # There's a whole zoo of nonstandard headers added by various
+    #   proxy softwares to indicate original client IP.
+    # ANY of these can be trivially spoofed!
+    #   (except REMOTE_ADDR, which should by set by your server,
+    #    and is included at the end as a fallback.
+    # Order does matter: we're following the convention established in
+    #   ActionDispatch::RemoteIp::GetIp::calculate_ip()
+    #   https://github.com/rails/rails/blob/master/actionpack/lib/action_dispatch/middleware/remote_ip.rb
+    #   where the forwarded_for headers, possibly containing lists,
+    #   are arbitrarily preferred over headers expected to contain a
+    #   single address.
+    GEOCODER_CANDIDATE_HEADERS = ['HTTP_X_FORWARDED_FOR',
+                                  'HTTP_X_FORWARDED',
+                                  'HTTP_FORWARDED_FOR',
+                                  'HTTP_FORWARDED',
+                                  'HTTP_X_CLIENT_IP',
+                                  'HTTP_CLIENT_IP',
+                                  'HTTP_X_REAL_IP',
+                                  'HTTP_X_CLUSTER_CLIENT_IP',
+                                  'REMOTE_ADDR']
+
+    def geocoder_spoofable_ip
+
+      # We could use a more sophisticated IP-guessing algorithm here,
+      # in which we'd try to resolve the use of different headers by
+      # different proxies.  The idea is that by comparing IPs repeated
+      # in different headers, you can sometimes decide which header
+      # was used by a proxy further along in the chain, and thus
+      # prefer the headers used earlier.  However, the gains might not
+      # be worth the performance tradeoff, since this method is likely
+      # to be called on every request in a lot of applications.
+      GEOCODER_CANDIDATE_HEADERS.each do |header|
+        if @env.has_key? header
+          addrs = geocoder_split_ip_addresses(@env[header])
+          addrs = geocoder_reject_trusted_ip_addresses(addrs)
+          return addrs.first if addrs.any?
         end
       end
-      @location
+
+      @env['REMOTE_ADDR']
+    end
+
+    private
+
+    def geocoder_split_ip_addresses(ip_addresses)
+      ip_addresses ? ip_addresses.strip.split(/[,\s]+/) : []
+    end
+
+    # use Rack's trusted_proxy?() method to filter out IPs that have
+    #   been configured as trusted; includes private ranges by
+    #   default.  (we don't want every lookup to return the location
+    #   of our own proxy/load balancer)
+    def geocoder_reject_trusted_ip_addresses(ip_addresses)
+      ip_addresses.reject { |ip| trusted_proxy?(ip) }
     end
   end
 end
 
-if defined?(Rack) and defined?(Rack::Request)
-  Rack::Request.send :include, Geocoder::Request
+if defined?(ActionDispatch::Request)
+  ActionDispatch::Request.__send__(:include, Geocoder::Request)
+elsif defined?(Rack::Request)
+  Rack::Request.__send__(:include, Geocoder::Request)
 end

data/lib/geocoder/results/baidu_ip.rb

@@ -0,0 +1,62 @@
+require 'geocoder/results/base'
+
+module Geocoder::Result
+  class BaiduIp < Base
+    def coordinates
+      [point['y'].to_f, point['x'].to_f]
+    end
+
+    def address
+      @data['address']
+    end
+
+    def state
+      province
+    end
+
+    def province
+      address_detail['province']
+    end
+
+    def city
+      address_detail['city']
+    end
+
+    def district
+      address_detail['district']
+    end
+
+    def street
+      address_detail['street']
+    end
+
+    def street_number
+      address_detail['street_number']
+    end
+
+    def state_code
+      ""
+    end
+
+    def postal_code
+      ""
+    end
+
+    def country
+      "China"
+    end
+
+    def country_code
+      "CN"
+    end
+
+    private
+    def address_detail
+      @data['address_detail']
+    end
+
+    def point
+      @data['point']
+    end
+  end
+end