geocoder 1.2.6 → 1.8.2

data/lib/geocoder/results/ban_data_gouv_fr.rb

@@ -0,0 +1,282 @@
+# encoding: utf-8
+require 'geocoder/results/base'
+
+module Geocoder::Result
+  class BanDataGouvFr < Base
+
+    STATE_CODE_MAPPINGS = {
+      "Guadeloupe" => "01",
+      "Martinique" => "02",
+      "Guyane" => "03",
+      "La Réunion" => "04",
+      "Mayotte" => "06",
+      "Île-de-France" => "11",
+      "Centre-Val de Loire" => "24",
+      "Bourgogne-Franche-Comté" => "27",
+      "Normandie" => "28",
+      "Hauts-de-France" => "32",
+      "Grand Est" => "44",
+      "Pays de la Loire" => "52",
+      "Bretagne" => "53",
+      "Nouvelle-Aquitaine" => "75",
+      "Occitanie" => "76",
+      "Auvergne-Rhône-Alpes" => "84",
+      "Provence-Alpes-Côte d'Azur" => "93",
+      "Corse" => "94"
+    }.freeze
+
+    #### BASE METHODS ####
+
+    def self.response_attributes
+      %w[limit attribution version licence type features center]
+    end
+
+    response_attributes.each do |a|
+      unless method_defined?(a)
+        define_method a do
+          @data[a]
+        end
+      end
+    end
+
+    #### BEST RESULT ####
+
+    def result
+      features[0] if features.any?
+    end
+
+    #### GEOMETRY ####
+
+    def geometry
+      result['geometry'] if result
+    end
+
+    def precision
+      geometry['type'] if geometry
+    end
+
+    def coordinates
+      coords = geometry["coordinates"]
+      return [coords[1].to_f, coords[0].to_f]
+    end
+
+    #### PROPERTIES ####
+
+    # List of raw attrbutes returned by BAN data gouv fr API:
+    #
+    #   :id           =>    [string] UUID of the result, said to be not stable
+    #                       atm, based on IGN reference (Institut national de
+    #                       l'information géographique et forestière)
+    #
+    #   :type         =>    [string] result type (housenumber, street, city,
+    #                       town, village, locality)
+    #
+    #   :score        =>    [float] value between 0 and 1 giving result's
+    #                       relevancy
+    #
+    #   :housenumber  =>    [string] street number and extra information
+    #                       (bis, ter, A, B)
+    #
+    #   :street       =>    [string] street name
+    #
+    #   :name         =>    [string] housenumber and street name
+    #
+    #   :postcode     =>    [string] city post code (used for mails by La Poste,
+    #                       beware many cities got severeal postcodes)
+    #
+    #   :citycode     =>    [string] city code (INSEE reference,
+    #                       consider it as a french institutional UUID)
+    #
+    #   :city         =>    [string] city name
+    #
+    #   :context      =>    [string] department code, department name and
+    #                       region code
+    #
+    #   :label        =>    [string] full address without state, country name
+    #                       and country code
+    #
+    # CITIES ONLY PROPERTIES
+    #
+    #   :adm_weight   =>    [string] administrative weight (importance) of
+    #                       the city
+    #
+    #   :population   =>    [float] number of inhabitants with a 1000 factor
+    #
+    # For up to date doc (in french only) : https://adresse.data.gouv.fr/api/
+    #
+    def properties
+      result['properties'] if result
+    end
+
+    # List of usable Geocoder results' methods
+    #
+    #   score                   =>    [float] result relevance 0 to 1
+    #
+    #   location_id             =>    [string] location's IGN UUID
+    #
+    #   result_type             =>    [string] housenumber / street / city
+    #                                 / town / village / locality
+    #
+    #   international_address   =>    [string] full address with country code
+    #
+    #   national_address        =>    [string] full address with country code
+    #
+    #   street_address          =>    [string] housenumber + extra inf
+    #                                 + street name
+    #
+    #   street_number           =>    [string] housenumber + extra inf
+    #                                 (bis, ter, etc)
+    #
+    #   street_name             =>    [string] street's name
+    #
+    #   city_name               =>    [string] city's name
+    #
+    #   city_code               =>    [string] city's INSEE UUID
+    #
+    #   postal_code             =>    [string] city's postal code (used for mails)
+    #
+    #   context                 =>    [string] city's department code, department
+    #                                  name and region name
+    #
+    #   demartment_name         =>    [string] city's department name
+    #
+    #   department_code         =>    [string] city's department INSEE UUID
+    #
+    #   region_name             =>    [string] city's region name
+    #
+    #   population              =>    [string] city's inhabitants count
+    #
+    #   administrative_weight   =>    [integer] city's importance on a scale
+    #                                 from 6 (capital city) to 1 (regular village)
+    #
+    def score
+      properties['score']
+    end
+
+    def location_id
+      properties['id']
+    end
+
+    # Types
+    #
+    #   housenumber
+    #   street
+    #   city
+    #   town
+    #   village
+    #   locality
+    #
+    def result_type
+      properties['type']
+    end
+
+    def international_address
+      "#{national_address}, #{country}"
+    end
+
+    def national_address
+      properties['label']
+    end
+
+    def street_address
+      properties['name']
+    end
+
+    def street_number
+      properties['housenumber']
+    end
+
+    def street_name
+      properties['street']
+    end
+
+    def city_name
+      properties['city']
+    end
+
+    def city_code
+      properties['citycode']
+    end
+
+    def postal_code
+      properties['postcode']
+    end
+
+    def context
+      properties['context'].split(/,/).map(&:strip)
+    end
+
+    def department_code
+      context[0] if context.length > 0
+    end
+
+    # Monkey logic to handle fact Paris is both a city and a department
+    # in Île-de-France region
+    def department_name
+      if context.length > 1
+        if context[1] == "Île-de-France"
+          "Paris"
+        else
+          context[1]
+        end
+      end
+    end
+
+    def region_name
+      if context.length == 2 && context[1] == "Île-de-France"
+        context[1]
+      elsif context.length > 2
+        context[2]
+      end
+    end
+
+    def region_code
+      STATE_CODE_MAPPINGS[region_name]
+    end
+
+    def country
+      "France"
+    end
+
+    # Country code types
+    #    FR : France
+    #    GF : Guyane Française
+    #    RE : Réunion
+    #    NC : Nouvelle-Calédonie
+    #    GP : Guadeloupe
+    #    MQ : Martinique
+    #    MU : Maurice
+    #    PF : Polynésie française
+    #
+    # Will need refacto to handle different country codes, but BAN API
+    # is currently mainly designed for geocode FR country code addresses
+    def country_code
+      "FR"
+    end
+
+    #### ALIAS METHODS ####
+
+    alias_method :address, :international_address
+    alias_method :street, :street_name
+    alias_method :city, :city_name
+    alias_method :state, :region_name
+    alias_method :state_code, :region_code
+
+    #### CITIES' METHODS ####
+
+    def population
+      (properties['population'].to_f * 1000).to_i if city?(result_type)
+    end
+
+    def administrative_weight
+      properties['adm_weight'].to_i if city?(result_type)
+    end
+
+    private
+
+    def city?(result_type)
+      result_type == 'municipality'
+    end
+
+  end
+end

data/lib/geocoder/results/base.rb

@@ -20,8 +20,20 @@ module Geocoder
       ##
       # A string in the given format.
       #
+      # This default implementation dumbly follows the United States address
+      # format and will return incorrect results for most countries. Some APIs
+      # return properly formatted addresses and those should be funneled
+      # through this method.
+      #
       def address(format = :full)
-        fail
+        if state_code.to_s != ""
+          s = ", #{state_code}"
+        elsif state.to_s != ""
+          s = ", #{state}"
+        else
+          s = ""
+        end
+        "#{city}#{s} #{postal_code}, #{country}".sub(/^[ ,]*/, '')
       end
 
       ##

data/lib/geocoder/results/bing.rb

@@ -24,7 +24,7 @@ module Geocoder::Result
     alias_method :country_code, :country
 
     def postal_code
-      @data['address']['postalCode']
+      @data['address']['postalCode'].to_s
     end
 
     def coordinates
@@ -35,6 +35,10 @@ module Geocoder::Result
       @data['address']
     end
 
+    def viewport
+      @data['bbox']
+    end
+
     def self.response_attributes
       %w[bbox name confidence entityType]
     end

data/lib/geocoder/results/db_ip_com.rb

@@ -0,0 +1,58 @@
+require 'geocoder/results/base'
+
+module Geocoder::Result
+  class DbIpCom < Base
+
+    def coordinates
+      ['latitude', 'longitude'].map{ |coordinate_name| @data[coordinate_name] }
+    end
+
+    def city
+      @data['city']
+    end
+
+    def district
+      @data['district']
+    end
+
+    def state_code
+      @data['stateProvCode']
+    end
+    alias_method :state, :state_code
+
+    def zip_code
+      @data['zipCode']
+    end
+    alias_method :postal_code, :zip_code
+
+    def country_name
+      @data['countryName']
+    end
+    alias_method :country, :country_name
+
+    def country_code
+      @data['countryCode']
+    end
+
+    def continent_name
+      @data['continentName']
+    end
+    alias_method :continent, :continent_name
+
+    def continent_code
+      @data['continentCode']
+    end
+
+    def time_zone
+      @data['timeZone']
+    end
+
+    def gmt_offset
+      @data['gmtOffset']
+    end
+
+    def currency_code
+      @data['currencyCode']
+    end
+  end
+end

data/lib/geocoder/results/esri.rb

@@ -4,23 +4,30 @@ module Geocoder::Result
   class Esri < Base
 
     def address
-      address = reverse_geocode? ? 'Address' : 'Match_addr'
-      attributes[address]
+      address_key = reverse_geocode? ? 'Address' : 'Match_addr'
+      attributes[address_key]
     end
 
     def city
-      attributes['City']
+      if !reverse_geocode? && is_city?
+        place_name
+      else
+        attributes['City']
+      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 = reverse_geocode? ? "CountryCode" : "Country"
-      attributes[country]
+      country_key = reverse_geocode? ? "CountryCode" : "Country"
+      attributes[country_key]
     end
 
     alias_method :country_code, :country
@@ -29,10 +36,27 @@ module Geocoder::Result
       attributes['Postal']
     end
 
+    def place_name
+      place_name_key = reverse_geocode? ? "Address" : "PlaceName"
+      attributes[place_name_key]
+    end
+
+    def place_type
+      reverse_geocode? ? "Address" : attributes['Type']
+    end
+
     def coordinates
       [geometry["y"], geometry["x"]]
     end
 
+    def viewport
+      north = attributes['Ymax']
+      south = attributes['Ymin']
+      east = attributes['Xmax']
+      west = attributes['Xmin']
+      [south, west, north, east]
+    end
+
     private
 
     def attributes
@@ -47,5 +71,8 @@ module Geocoder::Result
       @data['locations'].nil?
     end
 
+    def is_city?
+      ['City', 'State Capital', 'National Capital'].include?(place_type)
+    end
   end
-end
+end

data/lib/geocoder/results/freegeoip.rb

@@ -3,11 +3,6 @@ require 'geocoder/results/base'
 module Geocoder::Result
   class Freegeoip < Base
 
-    def address(format = :full)
-      s = state_code.to_s == "" ? "" : ", #{state_code}"
-      "#{city}#{s} #{postal_code}, #{country}".sub(/^[ ,]*/, "")
-    end
-
     def city
       @data['city']
     end
@@ -29,11 +24,11 @@ module Geocoder::Result
     end
 
     def postal_code
-      @data['zipcode']
+      @data['zipcode'] || @data['zip_code']
     end
 
     def self.response_attributes
-      %w[metrocode ip]
+      %w[metro_code ip]
     end
 
     response_attributes.each do |a|

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

@@ -16,17 +16,17 @@ module Geocoder::Result
     end
 
     def city
-      @data['city']
+      @data['city'] or (@data['standard'] and @data['standard']['city']) or ""
     end
 
     def state
-      @data['prov']
+      @data['prov'] or (@data['standard'] and @data['standard']['prov']) or ""
     end
 
     alias_method :state_code, :state
 
     def postal_code
-      @data['postal']
+      @data['postal'] or (@data['standard'] and @data['standard']['postal']) or ""
     end
 
     def country