geocoder 1.6.4 → 1.8.2

data/lib/geocoder/lookups/geoip2.rb

@@ -37,6 +37,10 @@ module Geocoder
       def results(query)
         return [] unless configuration[:file]
 
+        if @mmdb.respond_to?(:local_ip_alias) && !configuration[:local_ip_alias].nil?
+          @mmdb.local_ip_alias = configuration[:local_ip_alias]
+        end
+
         result = @mmdb.lookup(query.to_s)
         result.nil? ? [] : [result]
       end

data/lib/geocoder/lookups/geoportail_lu.rb

@@ -56,7 +56,7 @@ module Geocoder
         else
           result = []
           raise_error(Geocoder::Error) ||
-              warn("Geportail.lu Geocoding API error")
+              Geocoder.log(:warn, "Geportail.lu Geocoding API error")
         end
         result
       end

data/lib/geocoder/lookups/google_places_details.rb

@@ -33,9 +33,29 @@ module Geocoder
         result
       end
 
+      def fields(query)
+        if query.options.has_key?(:fields)
+          return format_fields(query.options[:fields])
+        end
+
+        if configuration.has_key?(:fields)
+          return format_fields(configuration[:fields])
+        end
+
+        nil  # use Google Places defaults
+      end
+
+      def format_fields(*fields)
+        flattened = fields.flatten.compact
+        return if flattened.empty?
+
+        flattened.join(',')
+      end
+
       def query_url_google_params(query)
         {
           placeid: query.text,
+          fields: fields(query),
           language: query.language || configuration.language
         }
       end

data/lib/geocoder/lookups/google_places_search.rb

@@ -31,13 +31,19 @@ module Geocoder
           input: query.text,
           inputtype: 'textquery',
           fields: fields(query),
+          locationbias: locationbias(query),
           language: query.language || configuration.language
         }
       end
 
       def fields(query)
-        query_fields = query.options[:fields]
-        return format_fields(query_fields) if query_fields
+        if query.options.has_key?(:fields)
+          return format_fields(query.options[:fields])
+        end
+
+        if configuration.has_key?(:fields)
+          return format_fields(configuration[:fields])
+        end
 
         default_fields
       end
@@ -52,7 +58,18 @@ module Geocoder
       end
 
       def format_fields(*fields)
-        fields.flatten.join(',')
+        flattened = fields.flatten.compact
+        return if flattened.empty?
+
+        flattened.join(',')
+      end
+
+      def locationbias(query)
+        if query.options.has_key?(:locationbias)
+          query.options[:locationbias]
+        else
+          configuration[:locationbias]
+        end
       end
     end
   end

data/lib/geocoder/lookups/here.rb

@@ -19,50 +19,55 @@ module Geocoder::Lookup
     private # ---------------------------------------------------------------
 
     def base_query_url(query)
-      "#{protocol}://#{if query.reverse_geocode? then 'reverse.' end}geocoder.ls.hereapi.com/6.2/#{if query.reverse_geocode? then 'reverse' end}geocode.json?"
+      service = query.reverse_geocode? ? "revgeocode" : "geocode"
+
+      "#{protocol}://#{service}.search.hereapi.com/v1/#{service}?"
     end
 
     def results(query)
-      return [] unless doc = fetch_data(query)
-      return [] unless doc['Response'] && doc['Response']['View']
-      if r=doc['Response']['View']
-        return [] if r.nil? || !r.is_a?(Array) || r.empty?
-        return r.first['Result']
+      unless configuration.api_key.is_a?(String)
+        api_key_not_string!
+        return []
       end
-      []
+      return [] unless doc = fetch_data(query)
+      return [] if doc["items"].nil?
+
+      doc["items"]
     end
 
     def query_url_here_options(query, reverse_geocode)
       options = {
-        gen: 9,
-        apikey: configuration.api_key,
-        language: (query.language || configuration.language)
+        apiKey: configuration.api_key,
+        lang: (query.language || configuration.language)
       }
-      if reverse_geocode
-        options[:mode] = :retrieveAddresses
-        return options
-      end
+      return options if reverse_geocode
 
       unless (country = query.options[:country]).nil?
-        options[:country] = country
+        options[:in] = "countryCode:#{country}"
       end
 
-      unless (mapview = query.options[:bounds]).nil?
-        options[:mapview] = mapview.map{ |point| "%f,%f" % point }.join(';')
-      end
       options
     end
 
     def query_url_params(query)
       if query.reverse_geocode?
         super.merge(query_url_here_options(query, true)).merge(
-          prox: query.sanitized_text
+          at: query.sanitized_text
         )
       else
         super.merge(query_url_here_options(query, false)).merge(
-          searchtext: query.sanitized_text
+          q: query.sanitized_text
         )
       end
     end
+
+    def api_key_not_string!
+      msg = <<~MSG
+        API key for HERE Geocoding and Search API should be a string.
+        For more info on how to obtain it, please see https://developer.here.com/documentation/identity-access-management/dev_guide/topics/plat-using-apikeys.html
+      MSG
+
+      raise_error(Geocoder::ConfigurationError, msg) || Geocoder.log(:warn, msg)
+    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)
-      params = super
-      if configuration.has_key?(:package)
-        params.merge!(package: configuration[:package])
-      end
-      params
+      super.merge(
+        key: configuration.api_key,
+        ip: query.sanitized_text,
+        package: configuration[:package],
+      )
     end
 
     def results(query)

data/lib/geocoder/lookups/ipbase.rb

@@ -0,0 +1,49 @@
+require 'geocoder/lookups/base'
+require 'geocoder/results/ipbase'
+
+module Geocoder::Lookup
+  class Ipbase < Base
+
+    def name
+      "ipbase.com"
+    end
+
+    def supported_protocols
+      [:https]
+    end
+
+    private # ---------------------------------------------------------------
+
+    def base_query_url(query)
+      "https://api.ipbase.com/v2/info?"
+    end
+
+    def query_url_params(query)
+      {
+        :ip => query.sanitized_text,
+        :apikey => configuration.api_key
+      }
+    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?
+      doc = fetch_data(query) || {}
+      doc.fetch("data", {})["location"] ? [doc] : []
+    end
+
+    def reserved_result(ip)
+      {
+        "data" => {
+          "ip" => ip,
+          "location" => {
+            "city" => { "name" => "" },
+            "country" => { "alpha2" => "RD", "name" => "Reserved" },
+            "region" => { "alpha2" => "", "name" => "" },
+            "zip" => ""
+          }
+        }
+      }
+    end
+  end
+end

data/lib/geocoder/lookups/ipdata_co.rb

@@ -47,7 +47,7 @@ module Geocoder::Lookup
     end
 
     def host
-      "api.ipdata.co"
+      configuration[:host] || "api.ipdata.co"
     end
 
     def check_response_for_errors!(response)

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

@@ -11,6 +11,10 @@ module Geocoder::Lookup
       ["api_key"]
     end
 
+    def supported_protocols
+      [:https]
+    end
+
     private # ----------------------------------------------------------------
 
     def base_query_url(query)
@@ -25,7 +29,7 @@ module Geocoder::Lookup
     end
 
     def configured_host
-      configuration[:host] || "locationiq.org"
+      configuration[:host] || "us1.locationiq.com"
     end
 
     def results(query)

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

@@ -0,0 +1,85 @@
+require 'geocoder/lookups/base'
+require "geocoder/results/pc_miler"
+require 'cgi' unless defined?(CGI) && defined?(CGI.escape)
+
+module Geocoder::Lookup
+  class PcMiler < Base
+
+    # https://developer.trimblemaps.com/restful-apis/location/single-search/single-search-api/#test-the-api-now
+    def valid_region_codes
+      # AF: Africa
+      # AS: Asia
+      # EU: Europe
+      # NA: North America
+      # OC: Oceania
+      # SA: South America
+      %w[AF AS EU NA OC SA]
+    end
+
+    def name
+      "PCMiler"
+    end
+
+    private # ---------------------------------------------------------------
+
+    def base_query_url(query)
+      region_code = region(query)
+      if !valid_region_codes.include?(region_code)
+        raise "region_code '#{region_code}' is invalid. use one of #{valid_region_codes}." \
+          "https://developer.trimblemaps.com/restful-apis/location/single-search/single-search-api/#test-the-api-now"
+      end
+
+      "#{protocol}://singlesearch.alk.com/#{region_code}/api/search?"
+    end
+
+    def results(query)
+      return [] unless data = fetch_data(query)
+      if data['Locations']
+        add_metadata_to_locations!(data)
+        data['Locations']
+      else
+        []
+      end
+    end
+
+    def add_metadata_to_locations!(data)
+      confidence = data['QueryConfidence']
+      data['Locations'].each do |location|
+        location['QueryConfidence'] = confidence
+      end
+    end
+
+    def query_url_params(query)
+      if query.reverse_geocode?
+        lat,lon = query.coordinates
+        formatted_query = "#{CGI.escape(lat)},#{CGI.escape(lon)}"
+      else
+        formatted_query = query.text.to_s
+      end
+
+      {
+        authToken: configuration.api_key,
+        query: formatted_query,
+        # to add additional metadata to response such as QueryConfidence
+        include: 'Meta'
+      }.merge(super(query))
+    end
+
+    def region(query)
+      query.options[:region] || query.options['region'] || configuration[:region] || "NA"
+    end
+
+    def check_response_for_errors!(response)
+      if response.code.to_i == 403
+        raise_error(Geocoder::RequestDenied) ||
+          Geocoder.log(:warn, "Geocoding API error: 403 API key does not exist")
+      else
+        super(response)
+      end
+    end
+
+    def supported_protocols
+      [:https]
+    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/test.rb

@@ -18,6 +18,7 @@ module Geocoder
       end
 
       def self.read_stub(query_text)
+        @default_stub ||= nil
         stubs.fetch(query_text) {
           return @default_stub unless @default_stub.nil?
           raise ArgumentError, "unknown stub request #{query_text}"
@@ -28,6 +29,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/twogis.rb

@@ -0,0 +1,58 @@
+require 'geocoder/lookups/base'
+require "geocoder/results/twogis"
+
+module Geocoder::Lookup
+  class Twogis < Base
+
+    def name
+      "2gis"
+    end
+
+    def required_api_key_parts
+      ["key"]
+    end
+
+    def map_link_url(coordinates)
+      "https://2gis.ru/?m=#{coordinates.join(',')}"
+    end
+
+    def supported_protocols
+      [:https]
+    end
+
+    private # ---------------------------------------------------------------
+
+    def base_query_url(query)
+      "#{protocol}://catalog.api.2gis.com/3.0/items/geocode?"
+    end
+
+    def results(query)
+      return [] unless doc = fetch_data(query)
+      if doc['meta'] && doc['meta']['error']
+        Geocoder.log(:warn, "2gis Geocoding API error: #{doc['meta']["code"]} (#{doc['meta']['error']["message"]}).")
+        return []
+      end
+      if doc['result'] && doc = doc['result']['items']
+        return doc.to_a
+      else
+        Geocoder.log(:warn, "2gis Geocoding API error: unexpected response format.")
+        return []
+      end
+    end
+
+    def query_url_params(query)
+      if query.reverse_geocode?
+        q = query.coordinates.reverse.join(",")
+      else
+        q = query.sanitized_text
+      end
+      params = {
+        :q => q,
+        :lang => "#{query.language || configuration.language}",
+        :key => configuration.api_key,
+        :fields => 'items.street,items.adm_div,items.full_address_name,items.point,items.geometry.centroid'
+      }
+      params.merge(super)
+    end
+  end
+end

data/lib/geocoder/lookups/uk_ordnance_survey_names.rb

@@ -13,7 +13,7 @@ module Geocoder::Lookup
     end
 
     def base_query_url(query)
-      "#{protocol}://api.ordnancesurvey.co.uk/opennames/v1/find?"
+      "#{protocol}://api.os.uk/search/names/v1/find?"
     end
 
     def required_api_key_parts

data/lib/geocoder/lookups/yandex.rb

@@ -24,11 +24,11 @@ module Geocoder::Lookup
 
     def results(query)
       return [] unless doc = fetch_data(query)
-      if err = doc['error']
-        if err["status"] == 401 and err["message"] == "invalid key"
+      if [400, 403].include? doc['statusCode']
+        if doc['statusCode'] == 403 and doc['message'] == 'Invalid key'
           raise_error(Geocoder::InvalidApiKey) || Geocoder.log(:warn, "Invalid API key.")
         else
-          Geocoder.log(:warn, "Yandex Geocoding API error: #{err['status']} (#{err['message']}).")
+          Geocoder.log(:warn, "Yandex Geocoding API error: #{doc['statusCode']} (#{doc['message']}).")
         end
         return []
       end