geocoder 1.5.1 → 1.8.5

data/lib/geocoder/results/azure.rb

@@ -0,0 +1,65 @@
+require 'geocoder/results/base'
+
+module Geocoder::Result
+  class Azure < Base
+    def address
+      @data['address']['freeformAddress']
+    end
+
+    def building_number
+      @data['address']['buildingNumber']
+    end
+
+    def city
+      @data['address']['municipality']
+    end
+
+    def coordinates
+      if @data['position'].is_a?(String) # reverse geocoding result
+        @data['position'].split(',').map(&:to_f)
+      elsif @data['position'].is_a?(Hash) # forward geocoding result
+        [@data['position']['lat'], @data['position']['lon']]
+      end
+    end
+
+    def country
+      @data['address']['country']
+    end
+
+    def country_code
+      @data['address']['countryCode']
+    end
+
+    def district
+      @data['address']['municipalitySubdivision']
+    end
+
+    def postal_code
+      @data['address']['postalCode']
+    end
+
+    def province
+      @data['address']['countrySubdivision']
+    end
+
+    def state
+      @data['address']['countrySubdivision']
+    end
+
+    def state_code
+      @data['address']['countrySubdivisionCode']
+    end
+
+    def street_name
+      @data['address']['streetName']
+    end
+
+    def street_number
+      @data['address']['streetNumber']
+    end
+
+    def viewport
+      @data['viewport'] || {}
+    end
+  end
+end

data/lib/geocoder/results/baidu.rb

@@ -7,10 +7,6 @@ module Geocoder::Result
       ['lat', 'lng'].map{ |i| @data['location'][i] }
     end
 
-    def address
-      @data['formatted_address']
-    end
-
     def province
       @data['addressComponent'] and @data['addressComponent']['province'] or ""
     end

data/lib/geocoder/results/ban_data_gouv_fr.rb

@@ -4,10 +4,31 @@ 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]
+      %w[limit attribution version licence type features center]
     end
 
     response_attributes.each do |a|
@@ -209,6 +230,10 @@ module Geocoder::Result
       end
     end
 
+    def region_code
+      STATE_CODE_MAPPINGS[region_name]
+    end
+
     def country
       "France"
     end
@@ -235,7 +260,7 @@ module Geocoder::Result
     alias_method :street, :street_name
     alias_method :city, :city_name
     alias_method :state, :region_name
-    alias_method :state_code, :state
+    alias_method :state_code, :region_code
 
     #### CITIES' METHODS ####
 
@@ -250,7 +275,7 @@ module Geocoder::Result
     private
 
     def city?(result_type)
-      %w(village town city).include?(result_type)
+      result_type == 'municipality'
     end
 
   end

data/lib/geocoder/results/db_ip_com.rb

@@ -16,7 +16,7 @@ module Geocoder::Result
     end
 
     def state_code
-      @data['stateProv']
+      @data['stateProvCode']
     end
     alias_method :state, :state_code
 

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

@@ -7,73 +7,71 @@ module Geocoder::Result
     # A string in the given format.
     #
     def address(format = :full)
-      address_data['Label']
+      address_data["label"]
     end
 
     ##
     # A two-element array: [lat, lon].
     #
     def coordinates
-      fail unless d = @data['Location']['DisplayPosition']
-      [d['Latitude'].to_f, d['Longitude'].to_f]
+      fail unless d = @data["position"]
+      [d["lat"].to_f, d["lng"].to_f]
     end
     
     def route
-      address_data['Street']
+      address_data["street"]
     end
     
     def street_number
-      address_data['HouseNumber']
+      address_data["houseNumber"]
     end  
 
     def state
-      address_data['County']
+      address_data["state"]
     end
 
     def province
-      address_data['County']
+      address_data["county"]
     end
 
     def postal_code
-      address_data['PostalCode']
+      address_data["postalCode"]
     end
 
     def city
-      address_data['City']
+      address_data["city"]
     end
 
     def state_code
-      address_data['State']
+      address_data["stateCode"]
     end
 
     def province_code
-      address_data['State']
+      address_data["state"]
     end
 
     def country
-      fail unless d = address_data['AdditionalData']
-      if v = d.find{|ad| ad['key']=='CountryName'}
-        return v['value']
-      end
+      address_data["countryName"]
     end
 
     def country_code
-      address_data['Country']
+      address_data["countryCode"]
     end
 
     def viewport
-      map_view = data['Location']['MapView'] || fail
-      south = map_view['BottomRight']['Latitude']
-      west = map_view['TopLeft']['Longitude']
-      north = map_view['TopLeft']['Latitude']
-      east = map_view['BottomRight']['Longitude']
+      return [] if data["resultType"] == "place"
+      map_view = data["mapView"]
+      south = map_view["south"]
+      west = map_view["west"]
+      north = map_view["north"]
+      east = map_view["east"]
       [south, west, north, east]
     end
 
     private # ----------------------------------------------------------------
 
     def address_data
-      @data['Location']['Address'] || fail
+      @data["address"] || fail
     end
   end
 end

data/lib/geocoder/results/ip2location_io.rb

@@ -0,0 +1,21 @@
+require 'geocoder/results/base'
+
+module Geocoder::Result
+  class Ip2locationIo < Base
+
+    def address(format = :full)
+      "#{city_name} #{zip_code}, #{country_name}".sub(/^[ ,]*/, '')
+    end
+
+    def self.response_attributes
+      %w[ip country_code country_name region_name city_name latitude longitude
+        zip_code time_zone asn as is_proxy]
+    end
+
+    response_attributes.each do |attr|
+      define_method attr do
+        @data[attr] || ""
+      end
+    end
+  end
+end

data/lib/geocoder/results/ip2location_lite.rb

@@ -0,0 +1,47 @@
+require 'geocoder/results/base'
+
+module Geocoder::Result
+  class Ip2locationLite < Base
+
+    def coordinates
+      [@data[:latitude], @data[:longitude]]
+    end
+
+    def city
+      @data[:city]
+    end
+
+    def state
+      @data[:region]
+    end
+
+    def state_code
+      "" # Not available in Maxmind's database
+    end
+
+    def country
+      @data[:country_long]
+    end
+
+    def country_code
+      @data[:country_short]
+    end
+
+    def postal_code
+      @data[:zipcode]
+    end
+
+    def self.response_attributes
+      %w[country_short country_long region latitude longitude isp
+        domain netspeed areacode iddcode timezone zipcode weatherstationname
+        weatherstationcode mcc mnc mobilebrand elevation usagetype addresstype
+        category district asn as]
+    end
+
+    response_attributes.each do |a|
+      define_method a do
+        @data[a] || ""
+      end
+    end
+  end
+end

data/lib/geocoder/results/ipbase.rb

@@ -0,0 +1,40 @@
+require 'geocoder/results/base'
+
+module Geocoder::Result
+  class Ipbase < Base
+    def ip
+      @data["data"]['ip']
+    end
+
+    def country_code
+      @data["data"]["location"]["country"]["alpha2"]
+    end
+
+    def country
+      @data["data"]["location"]["country"]["name"]
+    end
+
+    def state_code
+      @data["data"]["location"]["region"]["alpha2"]
+    end
+
+    def state
+      @data["data"]["location"]["region"]["name"]
+    end
+
+    def city
+      @data["data"]["location"]["city"]["name"]
+    end
+
+    def postal_code
+      @data["data"]["location"]["zip"]
+    end
+
+    def coordinates
+      [
+        @data["data"]["location"]["latitude"].to_f,
+        @data["data"]["location"]["longitude"].to_f
+      ]
+    end
+  end
+end

data/lib/geocoder/results/ipgeolocation.rb

@@ -0,0 +1,59 @@
+require 'geocoder/results/base'
+
+module Geocoder::Result
+  class Ipgeolocation < Base
+
+    def coordinates
+      [@data['latitude'].to_f, @data['longitude'].to_f]
+    end
+
+    def address(format = :full)
+      "#{city}, #{state} #{postal_code}, #{country_name}".sub(/^[ ,]*/, "")
+    end
+
+    def state
+      @data['state_prov']
+    end
+
+    def state_code
+      @data['state_prov']
+    end
+
+    def country
+      @data['country_name']
+    end
+
+    def country_code
+      @data['country_code2']
+    end
+
+    def postal_code
+      @data['zipcode']
+    end
+
+    def self.response_attributes
+      [
+          ['ip', ''],
+          ['hostname', ''],
+          ['continent_code', ''],
+          ['continent_name', ''],
+          ['country_code2', ''],
+          ['country_code3', ''],
+          ['country_name', ''],
+          ['country_capital',''],
+          ['district',''],
+          ['state_prov',''],
+          ['city', ''],
+          ['zipcode', ''],
+          ['time_zone', {}],
+          ['currency', {}]
+      ]
+    end
+
+    response_attributes.each do |attr, default|
+      define_method attr do
+        @data[attr] || default
+      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