geocoder 1.5.2 → 1.7.0

data/lib/geocoder/lookups/google_places_search.rb

@@ -18,16 +18,42 @@ module Geocoder
 
       private
 
+      def result_root_attr
+        'candidates'
+      end
+
       def base_query_url(query)
-        "#{protocol}://maps.googleapis.com/maps/api/place/textsearch/json?"
+        "#{protocol}://maps.googleapis.com/maps/api/place/findplacefromtext/json?"
       end
 
       def query_url_google_params(query)
         {
-          query: query.text,
+          input: query.text,
+          inputtype: 'textquery',
+          fields: fields(query),
           language: query.language || configuration.language
         }
       end
+
+      def fields(query)
+        query_fields = query.options[:fields]
+        return format_fields(query_fields) if query_fields
+
+        default_fields
+      end
+
+      def default_fields
+        legacy = %w[id reference]
+        basic = %w[business_status formatted_address geometry icon name 
+          photos place_id plus_code types]
+        contact = %w[opening_hours]
+        atmosphere = %W[price_level rating user_ratings_total]
+        format_fields(legacy, basic, contact, atmosphere)
+      end
+
+      def format_fields(*fields)
+        fields.flatten.join(',')
+      end
     end
   end
 end

data/lib/geocoder/lookups/google_premier.rb

@@ -21,6 +21,10 @@ module Geocoder::Lookup
 
     private # ---------------------------------------------------------------
 
+    def result_root_attr
+      'results'
+    end
+
     def cache_key(query)
       "#{protocol}://maps.googleapis.com/maps/api/geocode/json?" + hash_to_query(cache_key_params(query))
     end

data/lib/geocoder/lookups/here.rb

@@ -9,13 +9,17 @@ module Geocoder::Lookup
     end
 
     def required_api_key_parts
-      ["app_id", "app_code"]
+      ['api_key']
+    end
+
+    def supported_protocols
+      [:https]
     end
 
     private # ---------------------------------------------------------------
 
     def base_query_url(query)
-      "#{protocol}://#{if query.reverse_geocode? then 'reverse.' end}geocoder.api.here.com/6.2/#{if query.reverse_geocode? then 'reverse' end}geocode.json?"
+      "#{protocol}://#{if query.reverse_geocode? then 'reverse.' end}geocoder.ls.hereapi.com/6.2/#{if query.reverse_geocode? then 'reverse' end}geocode.json?"
     end
 
     def results(query)
@@ -31,8 +35,7 @@ module Geocoder::Lookup
     def query_url_here_options(query, reverse_geocode)
       options = {
         gen: 9,
-        app_id: api_key,
-        app_code: api_code,
+        apikey: configuration.api_key,
         language: (query.language || configuration.language)
       }
       if reverse_geocode
@@ -61,17 +64,5 @@ module Geocoder::Lookup
         )
       end
     end
-
-    def api_key
-      if (a = configuration.api_key)
-        return a.first if a.is_a?(Array)
-      end
-    end
-
-    def api_code
-      if (a = configuration.api_key)
-        return a.last if a.is_a?(Array)
-      end
-    end
   end
 end

data/lib/geocoder/lookups/ip2location.rb

@@ -8,6 +8,10 @@ module Geocoder::Lookup
       "IP2LocationApi"
     end
 
+    def required_api_key_parts
+      ['key']
+    end
+
     def supported_protocols
       [:http, :https]
     end
@@ -15,15 +19,15 @@ module Geocoder::Lookup
     private # ----------------------------------------------------------------
 
     def base_query_url(query)
-      "#{protocol}://api.ip2location.com/?"
+      "#{protocol}://api.ip2location.com/v2/?"
     end
 
     def query_url_params(query)
-      {
-        key: configuration.api_key ? configuration.api_key : "demo",
-        format: "json",
-        ip: query.sanitized_text
-      }.merge(super)
+      super.merge(
+        key: configuration.api_key,
+        ip: query.sanitized_text,
+        package: configuration[:package],
+      )
     end
 
     def results(query)
@@ -63,13 +67,5 @@ module Geocoder::Lookup
       }
     end
 
-    def query_url_params(query)
-      params = super
-      if configuration.has_key?(:package)
-        params.merge!(package: configuration[:package])
-      end
-      params
-    end
-
   end
 end

data/lib/geocoder/lookups/ipgeolocation.rb

@@ -0,0 +1,51 @@
+require 'geocoder/lookups/base'
+require 'geocoder/results/ipgeolocation'
+
+
+module Geocoder::Lookup
+  class Ipgeolocation < Base
+
+    ERROR_CODES = {
+      400 => Geocoder::RequestDenied, # subscription is paused
+      401 => Geocoder::InvalidApiKey, # missing/invalid API key
+      403 => Geocoder::InvalidRequest, # invalid IP address
+      404 => Geocoder::InvalidRequest, # not found
+      423 => Geocoder::InvalidRequest # bogon/reserved IP address
+    }
+    ERROR_CODES.default = Geocoder::Error
+
+    def name
+      "Ipgeolocation"
+    end
+
+    def supported_protocols
+      [:https]
+    end
+
+    private # ----------------------------------------------------------------
+
+    def base_query_url(query)
+      "#{protocol}://api.ipgeolocation.io/ipgeo?"
+    end
+    def query_url_params(query)
+      {
+          ip: query.sanitized_text,
+          apiKey: configuration.api_key
+      }.merge(super)
+    end
+
+    def results(query)
+      # don't look up a loopback or private address, just return the stored result
+      return [reserved_result(query.text)] if query.internal_ip_address?
+      [fetch_data(query)]
+    end
+
+    def reserved_result(ip)
+      {
+          "ip"           => ip,
+          "country_name" => "Reserved",
+          "country_code2" => "RD"
+      }
+    end
+  end
+end

data/lib/geocoder/lookups/ipqualityscore.rb

@@ -0,0 +1,50 @@
+# encoding: utf-8
+
+require 'geocoder/lookups/base'
+require 'geocoder/results/ipqualityscore'
+
+module Geocoder::Lookup
+  class Ipqualityscore < Base
+
+    def name
+      "IPQualityScore"
+    end
+
+    def required_api_key_parts
+      ['api_key']
+    end
+
+    private # ---------------------------------------------------------------
+
+    def base_query_url(query)
+      "#{protocol}://ipqualityscore.com/api/json/ip/#{configuration.api_key}/#{query.sanitized_text}?"
+    end
+
+    def valid_response?(response)
+      if (json = parse_json(response.body))
+        success = json['success']
+      end
+      super && success == true
+    end
+
+    def results(query, reverse = false)
+      return [] unless doc = fetch_data(query)
+
+      return [doc] if doc['success']
+
+      case doc['message']
+      when /invalid (.*) key/i
+        raise_error Geocoder::InvalidApiKey ||
+                    Geocoder.log(:warn, "#{name} API error: invalid api key.")
+      when /insufficient credits/, /exceeded your request quota/
+        raise_error Geocoder::OverQueryLimitError ||
+                    Geocoder.log(:warn, "#{name} API error: query limit exceeded.")
+      when /invalid (.*) address/i
+        raise_error Geocoder::InvalidRequest ||
+                    Geocoder.log(:warn, "#{name} API error: invalid request.")
+      end
+
+      [doc]
+    end
+  end
+end

data/lib/geocoder/lookups/latlon.rb

@@ -25,8 +25,7 @@ module Geocoder::Lookup
       # The API returned a 404 response, which indicates no results found
       elsif doc['error']['type'] == 'api_error'
         []
-      elsif
-        doc['error']['type'] == 'authentication_error'
+      elsif doc['error']['type'] == 'authentication_error'
         raise_error(Geocoder::InvalidApiKey) ||
           Geocoder.log(:warn, "LatLon.io service error: invalid API key.")
       else

data/lib/geocoder/lookups/maxmind_local.rb

@@ -30,7 +30,13 @@ module Geocoder::Lookup
     def results(query)
       if configuration[:file]
         geoip_class = RUBY_PLATFORM == "java" ? JGeoIP : GeoIP
-        result = geoip_class.new(configuration[:file]).city(query.to_s)
+        geoip_instance = geoip_class.new(configuration[:file])
+        result =
+          if configuration[:package] == :country
+            geoip_instance.country(query.to_s)
+          else
+            geoip_instance.city(query.to_s)
+          end
         result.nil? ? [] : [encode_hash(result.to_hash)]
       elsif configuration[:package] == :city
         addr = IPAddr.new(query.text).to_i

data/lib/geocoder/lookups/melissa_street.rb

@@ -0,0 +1,41 @@
+require 'geocoder/lookups/base'
+require "geocoder/results/melissa_street"
+
+module Geocoder::Lookup
+  class MelissaStreet < Base
+
+    def name
+      "MelissaStreet"
+    end
+
+    def results(query)
+      return [] unless doc = fetch_data(query)
+
+      if doc["TransmissionResults"] == "GE05"
+        raise_error(Geocoder::InvalidApiKey) ||
+          Geocoder.log(:warn, "Melissa service error: invalid API key.")
+      end
+
+      return doc["Records"]
+    end
+
+    private # ---------------------------------------------------------------
+
+    def base_query_url(query)
+      "#{protocol}://address.melissadata.net/v3/WEB/GlobalAddress/doGlobalAddress?"
+    end
+
+    def query_url_params(query)
+      params = {
+        id: configuration.api_key,
+        format: "JSON",
+        a1: query.sanitized_text,
+        loc: query.options[:city],
+        admarea: query.options[:state],
+        postal: query.options[:postal],
+        ctry: query.options[:country]
+      }
+      params.merge(super)
+    end
+  end
+end

data/lib/geocoder/lookups/nationaal_georegister_nl.rb

@@ -0,0 +1,38 @@
+require 'geocoder/lookups/base'
+require "geocoder/results/nationaal_georegister_nl"
+
+module Geocoder::Lookup
+  class NationaalGeoregisterNl < Base
+
+    def name
+      'Nationaal Georegister Nederland'
+    end
+
+    private # ---------------------------------------------------------------
+
+    def cache_key(query)
+      base_query_url(query) + hash_to_query(query_url_params(query))
+    end
+
+    def base_query_url(query)
+      "#{protocol}://geodata.nationaalgeoregister.nl/locatieserver/v3/free?"
+    end
+
+    def valid_response?(response)
+      json   = parse_json(response.body)
+      super(response) if json
+    end
+
+    def results(query)
+      return [] unless doc = fetch_data(query)
+      return doc['response']['docs']
+    end
+
+    def query_url_params(query)
+      {
+        fl: '*',
+        q:  query.text
+      }.merge(super)
+    end
+  end
+end

data/lib/geocoder/lookups/osmnames.rb

@@ -0,0 +1,57 @@
+require 'cgi'
+require 'geocoder/lookups/base'
+require 'geocoder/results/osmnames'
+
+module Geocoder::Lookup
+  class Osmnames < Base
+
+    def name
+      'OSM Names'
+    end
+
+    def required_api_key_parts
+      configuration[:host] ? [] : ['key']
+    end
+
+    def supported_protocols
+      [:https]
+    end
+
+    private
+
+    def base_query_url(query)
+      "#{base_url(query)}/#{params_url(query)}.js?"
+    end
+
+    def base_url(query)
+      host = configuration[:host] || 'geocoder.tilehosting.com'
+      "#{protocol}://#{host}"
+    end
+
+    def params_url(query)
+      method, args = 'q', CGI.escape(query.sanitized_text)
+      method, args = 'r', query.coordinates.join('/') if query.reverse_geocode?
+      "#{country_limited(query)}#{method}/#{args}"
+    end
+
+    def results(query)
+      return [] unless doc = fetch_data(query)
+      if (error = doc['message'])
+        raise_error(Geocoder::InvalidRequest, error) ||
+          Geocoder.log(:warn, "OSMNames Geocoding API error: #{error}")
+      else
+        return doc['results']
+      end
+    end
+
+    def query_url_params(query)
+      {
+        key: configuration.api_key
+      }.merge(super)
+    end
+
+    def country_limited(query)
+      "#{query.options[:country_code].downcase}/" if query.options[:country_code] && !query.reverse_geocode?
+    end
+  end
+end

data/lib/geocoder/lookups/photon.rb

@@ -0,0 +1,89 @@
+require 'geocoder/lookups/base'
+require 'geocoder/results/photon'
+
+module Geocoder::Lookup
+  class Photon < Base
+    def name
+      'Photon'
+    end
+
+    private # ---------------------------------------------------------------
+
+    def supported_protocols
+      [:https]
+    end
+
+    def base_query_url(query)
+      host = configuration[:host] || 'photon.komoot.io'
+      method = query.reverse_geocode? ? 'reverse' : 'api'
+      "#{protocol}://#{host}/#{method}?"
+    end
+
+    def results(query)
+      return [] unless (doc = fetch_data(query))
+      return [] unless doc['type'] == 'FeatureCollection'
+      return [] unless doc['features'] || doc['features'].present?
+
+      doc['features']
+    end
+
+    def query_url_params(query)
+      lang = query.language || configuration.language
+      params = { lang: lang, limit: query.options[:limit] }
+
+      if query.reverse_geocode?
+        params.merge!(query_url_params_reverse(query))
+      else
+        params.merge!(query_url_params_coordinates(query))
+      end
+
+      params.merge!(super)
+    end
+
+    def query_url_params_coordinates(query)
+      params = { q: query.sanitized_text }
+
+      if (bias = query.options[:bias])
+        params.merge!(lat: bias[:latitude], lon: bias[:longitude], location_bias_scale: bias[:scale])
+      end
+
+      if (filter = query_url_params_coordinates_filter(query))
+        params.merge!(filter)
+      end
+
+      params
+    end
+
+    def query_url_params_coordinates_filter(query)
+      filter = query.options[:filter]
+      return unless filter
+
+      bbox = filter[:bbox]
+      {
+        bbox: bbox.is_a?(Array) ? bbox.join(',') : bbox,
+        osm_tag: filter[:osm_tag]
+      }
+    end
+
+    def query_url_params_reverse(query)
+      params = { lat: query.coordinates[0], lon: query.coordinates[1], radius: query.options[:radius] }
+
+      if (dsort = query.options[:distance_sort])
+        params[:distance_sort] = dsort ? 'true' : 'false'
+      end
+
+      if (filter = query_url_params_reverse_filter(query))
+        params.merge!(filter)
+      end
+
+      params
+    end
+
+    def query_url_params_reverse_filter(query)
+      filter = query.options[:filter]
+      return unless filter
+
+      { query_string_filter: filter[:string] }
+    end
+  end
+end

data/lib/geocoder/lookups/pickpoint.rb

@@ -23,7 +23,7 @@ module Geocoder::Lookup
     end
 
     def query_url_params(query)
-      params = {
+      {
         key: configuration.api_key
       }.merge(super)
     end

data/lib/geocoder/lookups/smarty_streets.rb

@@ -57,7 +57,12 @@ module Geocoder::Lookup
     end
 
     def results(query)
-      fetch_data(query) || []
+      doc = fetch_data(query) || []
+      if doc.is_a?(Hash) and doc.key?('status') # implies there's an error
+        return []
+      else
+        return doc
+      end
     end
   end
 end

data/lib/geocoder/lookups/telize.rb

@@ -16,7 +16,7 @@ module Geocoder::Lookup
       if configuration[:host]
         "#{protocol}://#{configuration[:host]}/location/#{query.sanitized_text}"
       else
-        "#{protocol}://telize-v1.p.mashape.com/location/#{query.sanitized_text}?mashape-key=#{api_key}"
+        "#{protocol}://telize-v1.p.rapidapi.com/location/#{query.sanitized_text}?rapidapi-key=#{api_key}"
       end
     end
 

data/lib/geocoder/lookups/tencent.rb

@@ -31,18 +31,18 @@ module Geocoder::Lookup
       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.")
+      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

data/lib/geocoder/lookups/test.rb

@@ -28,6 +28,10 @@ module Geocoder
         @stubs ||= {}
       end
 
+      def self.delete_stub(query_text)
+        stubs.delete(query_text)
+      end
+
       def self.reset
         @stubs = {}
         @default_stub = nil

data/lib/geocoder/lookups/uk_ordnance_survey_names.rb

@@ -0,0 +1,59 @@
+require 'geocoder/lookups/base'
+require 'geocoder/results/uk_ordnance_survey_names'
+
+module Geocoder::Lookup
+  class UkOrdnanceSurveyNames < Base
+
+    def name
+      'Ordance Survey Names'
+    end
+
+    def supported_protocols
+      [:https]
+    end
+
+    def base_query_url(query)
+      "#{protocol}://api.os.uk/search/names/v1/find?"
+    end
+
+    def required_api_key_parts
+      ["key"]
+    end
+
+    def query_url(query)
+      base_query_url(query) + url_query_string(query)
+    end
+
+    private # -------------------------------------------------------------
+
+    def results(query)
+      return [] unless doc = fetch_data(query)
+      return [] if doc['header']['totalresults'].zero?
+      return doc['results'].map { |r| r['GAZETTEER_ENTRY'] }
+    end
+
+    def query_url_params(query)
+      {
+        query: query.sanitized_text,
+        key: configuration.api_key,
+        fq: filter
+      }.merge(super)
+    end
+
+    def local_types
+      %w[
+        City
+        Hamlet
+        Other_Settlement
+        Town
+        Village
+        Postcode
+      ]
+    end
+
+    def filter
+      local_types.map { |t| "local_type:#{t}" }.join(' ')
+    end
+
+  end
+end

data/lib/geocoder/lookups/yandex.rb

@@ -33,8 +33,7 @@ module Geocoder::Lookup
         return []
       end
       if doc = doc['response']['GeoObjectCollection']
-        meta = doc['metaDataProperty']['GeocoderResponseMetaData']
-        return meta['found'].to_i > 0 ? doc['featureMember'] : []
+        return doc['featureMember'].to_a
       else
         Geocoder.log(:warn, "Yandex Geocoding API error: unexpected response format.")
         return []