geocoder 1.6.4 → 1.7.0

data/lib/geocoder/cache.rb

@@ -18,6 +18,8 @@ module Geocoder
         when store.respond_to?(:read)
           store.read key_for(url)
       end
+    rescue => e
+      warn "Geocoder cache read error: #{e}"
     end
 
     ##
@@ -32,6 +34,8 @@ module Geocoder
         when store.respond_to?(:write)
           store.write key_for(url), value
       end
+    rescue => e
+      warn "Geocoder cache write error: #{e}"
     end
 
     ##
@@ -60,7 +64,11 @@ module Geocoder
     # Cache key for a given URL.
     #
     def key_for(url)
-      [prefix, url].join
+      if url.match(/^#{prefix}/)
+        url
+      else
+        [prefix, url].join
+      end
     end
 
     ##

data/lib/geocoder/configuration.rb

@@ -55,6 +55,7 @@ module Geocoder
       :lookup,
       :ip_lookup,
       :language,
+      :host,
       :http_headers,
       :use_https,
       :http_proxy,

data/lib/geocoder/ip_address.rb

@@ -7,6 +7,12 @@ module Geocoder
       '192.168.0.0/16',
     ].map { |ip| IPAddr.new(ip) }.freeze
 
+    def initialize(ip)
+      ip = ip.to_string if ip.is_a?(IPAddr)
+
+      super(ip)
+    end
+
     def internal?
       loopback? || private?
     end

data/lib/geocoder/lookup.rb

@@ -18,6 +18,14 @@ module Geocoder
       all_services - [:test]
     end
 
+    ##
+    # Array of valid Lookup service names, excluding any that do not build their own HTTP requests.
+    # For example, Amazon Location Service uses the AWS gem, not HTTP REST requests, to fetch data.
+    #
+    def all_services_with_http_requests
+      all_services_except_test - [:amazon_location_service]
+    end
+
     ##
     # All street address lookup services, default first.
     #
@@ -53,7 +61,11 @@ module Geocoder
         :test,
         :latlon,
         :amap,
-        :osmnames
+        :osmnames,
+        :melissa_street,
+        :amazon_location_service,
+        :geoapify,
+        :photon
       ]
     end
 
@@ -63,6 +75,7 @@ module Geocoder
     def ip_services
       @ip_services ||= [
         :baidu_ip,
+        :abstract_api,
         :freegeoip,
         :geoip2,
         :maxmind,
@@ -77,7 +90,8 @@ module Geocoder
         :db_ip_com,
         :ipstack,
         :ip2location,
-        :ipgeolocation
+        :ipgeolocation,
+        :ipqualityscore
       ]
     end
 

data/lib/geocoder/lookups/abstract_api.rb

@@ -0,0 +1,46 @@
+# encoding: utf-8
+
+require 'geocoder/lookups/base'
+require 'geocoder/results/abstract_api'
+
+module Geocoder::Lookup
+  class AbstractApi < Base
+
+    def name
+      "Abstract API"
+    end
+
+    def required_api_key_parts
+      ['api_key']
+    end
+
+    def supported_protocols
+      [:https]
+    end
+
+    private # ---------------------------------------------------------------
+
+    def base_query_url(query)
+      "#{protocol}://ipgeolocation.abstractapi.com/v1/?"
+    end
+
+    def query_url_params(query)
+      params = {api_key: configuration.api_key}
+
+      ip_address = query.sanitized_text
+      if ip_address.is_a?(String) && ip_address.length > 0
+        params[:ip_address] = ip_address
+      end
+
+      params.merge(super)
+    end
+
+    def results(query, reverse = false)
+      if doc = fetch_data(query)
+        [doc]
+      else
+        []
+      end
+    end
+  end
+end

data/lib/geocoder/lookups/amazon_location_service.rb

@@ -0,0 +1,53 @@
+require 'geocoder/lookups/base'
+require 'geocoder/results/amazon_location_service'
+
+module Geocoder::Lookup
+  class AmazonLocationService < Base
+    def results(query)
+      params = { **global_index_name, **query.options }
+      if query.reverse_geocode?
+        resp = client.search_place_index_for_position(**{ **params, position: query.coordinates.reverse })
+      else
+        resp = client.search_place_index_for_text(**{ **params, text: query.text })
+      end
+      resp.results.map(&:place)
+    end
+
+    private
+
+    def client
+      return @client if @client
+      require_sdk
+      keys = configuration.api_key
+      if keys
+        @client = Aws::LocationService::Client.new(
+          access_key_id: keys[:access_key_id],
+          secret_access_key: keys[:secret_access_key],
+        )
+      else
+        @client = Aws::LocationService::Client.new
+      end
+    end
+
+    def require_sdk
+      begin
+        require 'aws-sdk-locationservice'
+      rescue LoadError
+        raise_error(Geocoder::ConfigurationError) ||
+          Geocoder.log(
+            :error,
+            "Couldn't load the Amazon Location Service SDK. " +
+            "Install it with: gem install aws-sdk-locationservice -v '~> 1.4'"
+          )
+      end
+    end
+
+    def global_index_name
+      if configuration[:index_name]
+        { index_name: configuration[:index_name] }
+      else
+        {}
+      end
+    end
+  end
+end

data/lib/geocoder/lookups/bing.rb

@@ -54,7 +54,7 @@ module Geocoder::Lookup
     def query_url_params(query)
       {
         key: configuration.api_key,
-        language: (query.language || configuration.language)
+        culture: (query.language || configuration.language)
       }.merge(super)
     end
 

data/lib/geocoder/lookups/geoapify.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+require 'geocoder/lookups/base'
+require 'geocoder/results/geoapify'
+
+module Geocoder
+  module Lookup
+    # https://apidocs.geoapify.com/docs/geocoding/api
+    class Geoapify < Base
+      def name
+        'Geoapify'
+      end
+
+      def required_api_key_parts
+        ['api_key']
+      end
+
+      def supported_protocols
+        [:https]
+      end
+
+      private
+
+      def base_query_url(query)
+        method = query.reverse_geocode? ? 'reverse' : 'search'
+        "https://api.geoapify.com/v1/geocode/#{method}?"
+      end
+
+      def results(query)
+        return [] unless (doc = fetch_data(query))
+
+        # The rest of the status codes should be already handled by the default
+        # functionality as the API returns correct HTTP response codes in most
+        # cases. There may be some unhandled cases still (such as over query
+        # limit reached) but there is not enough documentation to cover them.
+        case doc['statusCode']
+        when 500
+          raise_error(Geocoder::InvalidRequest) || Geocoder.log(:warn, doc['message'])
+        end
+
+        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 = { apiKey: configuration.api_key, 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)
+        { text: query.sanitized_text }
+      end
+
+      def query_url_params_reverse(query)
+        {
+          lat: query.coordinates[0],
+          lon: query.coordinates[1]
+        }
+      end
+    end
+  end
+end

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/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/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/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/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

@@ -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

@@ -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/results/abstract_api.rb

@@ -0,0 +1,146 @@
+require 'geocoder/results/base'
+
+module Geocoder
+  module Result
+    class AbstractApi < Base
+
+      ##
+      # Geolocation
+
+      def state
+        @data['region']
+      end
+
+      def state_code
+        @data['region_iso_code']
+      end
+
+      def city
+        @data["city"]
+      end
+
+      def city_geoname_id
+        @data["city_geoname_id"]
+      end
+
+      def region_geoname_id
+        @data["region_geoname_id"]
+      end
+
+      def postal_code
+        @data["postal_code"]
+      end
+
+      def country
+        @data["country"]
+      end
+
+      def country_code
+        @data["country_code"]
+      end
+
+      def country_geoname_id
+        @data["country_geoname_id"]
+      end
+
+      def country_is_eu
+        @data["country_is_eu"]
+      end
+
+      def continent
+        @data["continent"]
+      end
+
+      def continent_code
+        @data["continent_code"]
+      end
+
+      def continent_geoname_id
+        @data["continent_geoname_id"]
+      end
+
+      ##
+      # Security
+
+      def is_vpn?
+        @data.dig "security", "is_vpn"
+      end
+
+      ##
+      # Timezone
+
+      def timezone_name
+        @data.dig "timezone", "name"
+      end
+
+      def timezone_abbreviation
+        @data.dig "timezone", "abbreviation"
+      end
+
+      def timezone_gmt_offset
+        @data.dig "timezone", "gmt_offset"
+      end
+
+      def timezone_current_time
+        @data.dig "timezone", "current_time"
+      end
+
+      def timezone_is_dst
+        @data.dig "timezone", "is_dst"
+      end
+
+      ##
+      # Flag
+
+      def flag_emoji
+        @data.dig "flag", "emoji"
+      end
+
+      def flag_unicode
+        @data.dig "flag", "unicode"
+      end
+
+      def flag_png
+        @data.dig "flag", "png"
+      end
+
+      def flag_svg
+        @data.dig "flag", "svg"
+      end
+
+      ##
+      # Currency
+
+      def currency_currency_name
+        @data.dig "currency", "currency_name"
+      end
+
+      def currency_currency_code
+        @data.dig "currency", "currency_code"
+      end
+
+      ##
+      # Connection
+
+      def connection_autonomous_system_number
+        @data.dig "connection", "autonomous_system_number"
+      end
+
+      def connection_autonomous_system_organization
+        @data.dig "connection", "autonomous_system_organization"
+      end
+
+      def connection_connection_type
+        @data.dig "connection", "connection_type"
+      end
+
+      def connection_isp_name
+        @data.dig "connection", "isp_name"
+      end
+
+      def connection_organization_name
+        @data.dig "connection", "organization_name"
+      end
+    end
+  end
+end