geocoder 1.6.7 → 1.7.5

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

@@ -0,0 +1,57 @@
+require 'geocoder/results/base'
+
+module Geocoder::Result
+  class AmazonLocationService < Base
+    def initialize(result)
+      @place = result
+    end
+
+    def coordinates
+      [@place.geometry.point[1], @place.geometry.point[0]]
+    end
+
+    def address
+      @place.label
+    end
+
+    def neighborhood
+      @place.neighborhood
+    end
+
+    def route
+      @place.street
+    end
+
+    def city
+      @place.municipality || @place.sub_region
+    end
+
+    def state
+      @place.region
+    end
+
+    def state_code
+      @place.region
+    end
+
+    def province
+      @place.region
+    end
+
+    def province_code
+      @place.region
+    end
+
+    def postal_code
+      @place.postal_code
+    end
+
+    def country
+      @place.country
+    end
+
+    def country_code
+      @place.country
+    end
+  end
+end

data/lib/geocoder/results/esri.rb

@@ -16,11 +16,14 @@ module Geocoder::Result
       end
     end
 
-    def state_code
+    def state
       attributes['Region']
     end
 
-    alias_method :state, :state_code
+    def state_code
+      abbr = attributes['RegionAbbr']
+      abbr.to_s == "" ? state : abbr
+    end
 
     def country
       country_key = reverse_geocode? ? "CountryCode" : "Country"

data/lib/geocoder/results/geoapify.rb

@@ -0,0 +1,179 @@
+# frozen_string_literal: true
+
+require 'geocoder/results/base'
+
+module Geocoder
+  module Result
+    # https://apidocs.geoapify.com/docs/geocoding/api
+    class Geoapify < Base
+      def address(_format = :full)
+        properties['formatted']
+      end
+
+      def address_line1
+        properties['address_line1']
+      end
+
+      def address_line2
+        properties['address_line2']
+      end
+
+      def house_number
+        properties['housenumber']
+      end
+
+      def street
+        properties['street']
+      end
+
+      def postal_code
+        properties['postcode']
+      end
+
+      def district
+        properties['district']
+      end
+
+      def suburb
+        properties['suburb']
+      end
+
+      def city
+        properties['city']
+      end
+
+      def county
+        properties['county']
+      end
+
+      def state
+        properties['state']
+      end
+
+      # Not currently available in the API
+      def state_code
+        ''
+      end
+
+      def country
+        properties['country']
+      end
+
+      def country_code
+        return unless properties['country_code']
+
+        properties['country_code'].upcase
+      end
+
+      def coordinates
+        return unless properties['lat']
+        return unless properties['lon']
+
+        [properties['lat'], properties['lon']]
+      end
+
+      # See: https://tools.ietf.org/html/rfc7946#section-3.1
+      #
+      # Each feature has a "Point" type in the Geoapify API.
+      def geometry
+        return unless data['geometry']
+
+        symbol_hash data['geometry']
+      end
+
+      # See: https://tools.ietf.org/html/rfc7946#section-5
+      def bounds
+        data['bbox']
+      end
+
+      # Type of the result, one of:
+      #
+      #   * :unknown
+      #   * :amenity
+      #   * :building
+      #   * :street
+      #   * :suburb
+      #   * :district
+      #   * :postcode
+      #   * :city
+      #   * :county
+      #   * :state
+      #   * :country
+      #
+      def type
+        return :unknown unless properties['result_type']
+
+        properties['result_type'].to_sym
+      end
+
+      # Distance in meters to given bias:proximity or to given coordinates for
+      # reverse geocoding
+      def distance
+        properties['distance']
+      end
+
+      # Calculated rank for the result, containing the following keys:
+      #
+      #   * `popularity` - The popularity score of the result
+      #   * `confidence` - The confidence value of the result (0-1)
+      #   * `match_type` - The result's match type, one of following:
+      #      * full_match
+      #      * inner_part
+      #      * match_by_building
+      #      * match_by_street
+      #      * match_by_postcode
+      #      * match_by_city_or_disrict
+      #      * match_by_country_or_state
+      #
+      # Example:
+      #   {
+      #     popularity: 8.615793062435909,
+      #     confidence: 0.88,
+      #     match_type: :full_match
+      #   }
+      def rank
+        return unless properties['rank']
+
+        r = symbol_hash(properties['rank'])
+        r[:match_type] = r[:match_type].to_sym if r[:match_type]
+        r
+      end
+
+      # Examples:
+      #
+      # Open
+      #   {
+      #     sourcename: 'openstreetmap',
+      #     wheelchair: 'limited',
+      #     wikidata: 'Q186125',
+      #     wikipedia: 'en:Madison Square Garden',
+      #     website: 'http://www.thegarden.com/',
+      #     phone: '12124656741',
+      #     osm_type: 'W',
+      #     osm_id: 138141251,
+      #     continent: 'North America',
+      #   }
+      def datasource
+        return unless properties['datasource']
+
+        symbol_hash properties['datasource']
+      end
+
+      private
+
+      def properties
+        @properties ||= data['properties'] || {}
+      end
+
+      def symbol_hash(orig_hash)
+        {}.tap do |result|
+          orig_hash.each_key do |key|
+            next unless orig_hash[key]
+
+            result[key.to_sym] = orig_hash[key]
+          end
+        end
+      end
+    end
+  end
+end

data/lib/geocoder/results/ipqualityscore.rb

@@ -0,0 +1,54 @@
+require 'geocoder/results/base'
+
+module Geocoder
+  module Result
+    class Ipqualityscore < Base
+
+      def self.key_method_mappings
+        {
+          'request_id' => :request_id,
+          'success' => :success?,
+          'message' => :message,
+          'city' => :city,
+          'region' => :state,
+          'country_code' => :country_code,
+          'mobile' => :mobile?,
+          'fraud_score' => :fraud_score,
+          'ISP' => :isp,
+          'ASN' => :asn,
+          'organization' => :organization,
+          'is_crawler' => :crawler?,
+          'host' => :host,
+          'proxy' => :proxy?,
+          'vpn' => :vpn?,
+          'tor' => :tor?,
+          'active_vpn' => :active_vpn?,
+          'active_tor' => :active_tor?,
+          'recent_abuse' => :recent_abuse?,
+          'bot_status' => :bot?,
+          'connection_type' => :connection_type,
+          'abuse_velocity' => :abuse_velocity,
+          'timezone' => :timezone,
+        }
+      end
+
+      key_method_mappings.each_pair do |key, meth|
+        define_method meth do
+          @data[key]
+        end
+      end
+
+      alias_method :state_code, :state
+      alias_method :country, :country_code
+
+      def postal_code
+        '' # No suitable fallback
+      end
+
+      def address
+        [city, state, country_code].compact.reject(&:empty?).join(', ')
+      end
+
+    end
+  end
+end

data/lib/geocoder/results/mapbox.rb

@@ -23,7 +23,10 @@ module Geocoder::Result
       context_part('region')
     end
 
-    alias_method :state_code, :state
+    def state_code
+      value = context_part('region', 'short_code')
+      value.split('-').last unless value.nil?
+    end
 
     def postal_code
       context_part('postcode')
@@ -33,7 +36,10 @@ module Geocoder::Result
       context_part('country')
     end
 
-    alias_method :country_code, :country
+    def country_code
+      value = context_part('country', 'short_code')
+      value.upcase unless value.nil?
+    end
 
     def neighborhood
       context_part('neighborhood')
@@ -45,8 +51,8 @@ module Geocoder::Result
 
     private
 
-    def context_part(name)
-      context.map { |c| c['text'] if c['id'] =~ Regexp.new(name) }.compact.first
+    def context_part(name, key = 'text')
+      (context.detect { |c| c['id'] =~ Regexp.new(name) } || {})[key]
     end
 
     def context

data/lib/geocoder/results/melissa_street.rb

@@ -0,0 +1,46 @@
+require 'geocoder/results/base'
+
+module Geocoder::Result
+  class MelissaStreet < Base
+    def address(format = :full)
+      @data['FormattedAddress']
+    end
+
+    def street_address
+      @data['AddressLine1']
+    end
+
+    def suffix
+      @data['ThoroughfareTrailingType']
+    end
+
+    def number
+      @data['PremisesNumber']
+    end
+
+    def city
+      @data['Locality']
+    end
+
+    def state_code
+      @data['AdministrativeArea']
+    end
+    alias_method :state, :state_code
+
+    def country
+      @data['CountryName']
+    end
+
+    def country_code
+      @data['CountryISO3166_1_Alpha2']
+    end
+
+    def postal_code
+      @data['PostalCode']
+    end
+
+    def coordinates
+      [@data['Latitude'].to_f, @data['Longitude'].to_f]
+    end
+  end
+end

data/lib/geocoder/results/nominatim.rb

@@ -4,12 +4,12 @@ module Geocoder::Result
   class Nominatim < Base
 
     def poi
-      return @data['address'][place_type] if @data['address'].key?(place_type)
+      return address_data[place_type] if address_data.key?(place_type)
       return nil
     end
 
     def house_number
-      @data['address']['house_number']
+      address_data['house_number']
     end
 
     def address
@@ -18,69 +18,71 @@ module Geocoder::Result
 
     def street
       %w[road pedestrian highway].each do |key|
-        return @data['address'][key] if @data['address'].key?(key)
+        return address_data[key] if address_data.key?(key)
       end
       return nil
     end
 
     def city
       %w[city town village hamlet].each do |key|
-        return @data['address'][key] if @data['address'].key?(key)
+        return address_data[key] if address_data.key?(key)
       end
       return nil
     end
 
     def village
-      @data['address']['village']
+      address_data['village']
     end
 
     def town
-      @data['address']['town']
+      address_data['town']
     end
 
     def state
-      @data['address']['state']
+      address_data['state']
     end
 
     alias_method :state_code, :state
 
     def postal_code
-      @data['address']['postcode']
+      address_data['postcode']
     end
 
     def county
-      @data['address']['county']
+      address_data['county']
     end
 
     def country
-      @data['address']['country']
+      address_data['country']
     end
 
     def country_code
-      @data['address']['country_code']
+      address_data['country_code']
     end
 
     def suburb
-      @data['address']['suburb']
+      address_data['suburb']
     end
 
     def city_district
-      @data['address']['city_district']
+      address_data['city_district']
     end
 
     def state_district
-      @data['address']['state_district']
+      address_data['state_district']
     end
 
     def neighbourhood
-      @data['address']['neighbourhood']
+      address_data['neighbourhood']
     end
 
     def municipality
-      @data['address']['municipality']
+      address_data['municipality']
     end
 
     def coordinates
+      return [] unless @data['lat'] && @data['lon']
+
       [@data['lat'].to_f, @data['lon'].to_f]
     end
 
@@ -109,5 +111,11 @@ module Geocoder::Result
         end
       end
     end
+
+    private
+
+    def address_data
+      @data['address'] || {}
+    end
   end
 end