geocoder 1.2.6 → 1.8.2

data/lib/geocoder/results/geocodio.rb

@@ -14,22 +14,34 @@ module Geocoder::Result
       address_components["suffix"]
     end
 
+    def street_address
+      [number, address_components["formatted_street"]].compact.join(' ')
+    end
+
     def state
       address_components["state"]
     end
     alias_method :state_code, :state
 
     def zip
-      address_components["zip"]
+      # Postal code is not returned for Canada geocode results
+      address_components["zip"] || ""
     end
     alias_method :postal_code, :zip
 
     def country
-      "United States" # Geocodio only supports the US
+      # Geocodio supports US and Canada, however they don't return the full
+      # country name.
+
+      if country_code == "CA"
+        "Canada"
+      else
+        "United States"
+      end
     end
 
     def country_code
-      "US" # Geocodio only supports the US
+      address_components['country']
     end
 
     def city

data/lib/geocoder/results/geoip2.rb

@@ -3,51 +3,41 @@ require 'geocoder/results/base'
 module Geocoder
   module Result
     class Geoip2 < Base
-      def address(format = :full)
-        s = state.to_s == '' ? '' : ", #{state_code}"
-        "#{city}#{s} #{postal_code}, #{country}".sub(/^[ ,]*/, '')
-      end
 
       def coordinates
-        [latitude, longitude]
-      end
-
-      def latitude
-        return 0.0 unless @data['location']
-        @data['location']['latitude'].to_f
-      end
-
-      def longitude
-        return 0.0 unless @data['location']
-        @data['location']['longitude'].to_f
+        %w[latitude longitude].map do |l|
+          data.fetch('location', {}).fetch(l, 0.0)
+        end
       end
 
       def city
-        return '' unless @data['city']
-        @data['city']['names']['en']
+        fetch_name(
+          data.fetch('city', {}).fetch('names', {})
+        )
       end
 
       def state
-        return '' unless @data['subdivisions']
-        @data['subdivisions'][0]['names']['en']
+        fetch_name(
+          data.fetch('subdivisions', []).fetch(0, {}).fetch('names', {})
+        )
       end
 
       def state_code
-        return '' unless @data['subdivisions']
-        @data['subdivisions'][0]['iso_code']
+        data.fetch('subdivisions', []).fetch(0, {}).fetch('iso_code', '')
       end
 
       def country
-        @data['country']['names']['en']
+        fetch_name(
+          data.fetch('country', {}).fetch('names', {})
+        )
       end
 
       def country_code
-        @data['country']['iso_code']
+        data.fetch('country', {}).fetch('iso_code', '')
       end
 
       def postal_code
-        return '' unless @data['postal']
-        @data['postal']['code']
+        data.fetch('postal', {}).fetch('code', '')
       end
 
       def self.response_attributes
@@ -59,6 +49,28 @@ module Geocoder
           @data[a]
         end
       end
+
+      def language=(l)
+        @language = l.to_s
+      end
+
+      def language
+        @language ||= default_language
+      end
+
+      def data
+        @data.to_hash
+      end
+
+      private
+
+      def default_language
+        @default_language = Geocoder.config[:language].to_s
+      end
+
+      def fetch_name(names)
+        names[language] || names[default_language] || ''
+      end
     end
   end
 end

data/lib/geocoder/results/geoportail_lu.rb

@@ -0,0 +1,71 @@
+require 'geocoder/results/base'
+
+module Geocoder::Result
+  class GeoportailLu < Base
+
+    def coordinates
+      geomlonlat['coordinates'].reverse if geolocalized?
+    end
+
+    def address
+      full_address
+    end
+
+    def city
+      try_to_extract 'locality', detailled_address
+    end
+
+    def state
+      'Luxembourg'
+    end
+
+    def state_code
+      'LU'
+    end
+
+    def postal_code
+      try_to_extract 'zip', detailled_address
+    end
+
+    def street_address
+      [street_number, street].compact.join(' ')
+    end
+
+    def street_number
+      try_to_extract 'postnumber', detailled_address
+    end
+
+    def street
+      try_to_extract 'street', detailled_address
+    end
+
+    def full_address
+      data['address']
+    end
+
+    def geomlonlat
+      data['geomlonlat']
+    end
+
+    def detailled_address
+      data['AddressDetails']
+    end
+
+    alias_method :country, :state
+    alias_method :province, :state
+    alias_method :country_code, :state_code
+    alias_method :province_code, :state_code
+
+    private
+
+    def geolocalized?
+      !!try_to_extract('coordinates', geomlonlat)
+    end
+
+    def try_to_extract(key, hash)
+      if hash.is_a?(Hash) and hash.include?(key)
+        hash[key]
+      end
+    end
+  end
+end

data/lib/geocoder/results/google.rb

@@ -120,5 +120,31 @@ module Geocoder::Result
     def precision
       geometry['location_type'] if geometry
     end
+
+    def partial_match
+      @data['partial_match']
+    end
+
+    def place_id
+      @data['place_id']
+    end
+
+    def viewport
+      viewport = geometry['viewport'] || fail
+      bounding_box_from viewport
+    end
+
+    def bounds
+      bounding_box_from geometry['bounds']
+    end
+
+    private
+
+    def bounding_box_from(box)
+      return nil unless box
+      south, west = %w(lat lng).map { |c| box['southwest'][c] }
+      north, east = %w(lat lng).map { |c| box['northeast'][c] }
+      [south, west, north, east]
+    end
   end
 end

data/lib/geocoder/results/google_places_details.rb

@@ -30,6 +30,10 @@ module Geocoder
       def website
         @data["website"]
       end
+
+      def photos
+        @data["photos"]
+      end
     end
   end
 end

data/lib/geocoder/results/google_places_search.rb

@@ -0,0 +1,52 @@
+require "geocoder/results/google"
+
+module Geocoder
+  module Result
+    class GooglePlacesSearch < Google
+
+      def types
+        @data["types"] || []
+      end
+
+      def rating
+        @data["rating"]
+      end
+
+      def photos
+        @data["photos"]
+      end
+
+      def city
+        ""
+      end
+
+      def state
+        ""
+      end
+
+      def state_code
+        ""
+      end
+
+      def province
+        ""
+      end
+
+      def province_code
+        ""
+      end
+
+      def postal_code
+        ""
+      end
+
+      def country
+        ""
+      end
+
+      def country_code
+        ""
+      end
+    end
+  end
+end

data/lib/geocoder/results/here.rb

@@ -7,56 +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"]
+    end
+    
+    def street_number
+      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
+      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.rb

@@ -0,0 +1,22 @@
+require 'geocoder/results/base'
+
+module Geocoder::Result
+  class Ip2location < Base
+
+    def address(format = :full)
+      "#{city_name} #{zip_code}, #{country_name}".sub(/^[ ,]*/, '')
+    end
+
+    def self.response_attributes
+      %w[country_code country_name region_name city_name latitude longitude
+        zip_code time_zone isp domain net_speed idd_code area_code usage_type
+        weather_station_code weather_station_name mcc mnc mobile_brand elevation]
+    end
+
+    response_attributes.each do |attr|
+      define_method attr do
+        @data[attr] || ""
+      end
+    end
+  end
+end

data/lib/geocoder/results/ipapi_com.rb

@@ -0,0 +1,45 @@
+require 'geocoder/results/base'
+
+module Geocoder::Result
+  class IpapiCom < Base
+
+    def coordinates
+      [lat, lon]
+    end
+
+    def address
+      "#{city}, #{state_code} #{postal_code}, #{country}".sub(/^[ ,]*/, "")
+    end
+
+    def state
+      region_name
+    end
+
+    def state_code
+      region
+    end
+
+    def postal_code
+      zip
+    end
+
+    def country_code
+      @data['countryCode']
+    end
+
+    def region_name
+      @data['regionName']
+    end
+
+    def self.response_attributes
+      %w[country region city zip timezone isp org as reverse query status message mobile proxy lat lon]
+    end
+
+    response_attributes.each do |attribute|
+      define_method attribute do
+        @data[attribute]
+      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/ipdata_co.rb

@@ -0,0 +1,40 @@
+require 'geocoder/results/base'
+
+module Geocoder::Result
+  class IpdataCo < Base
+
+    def city
+      @data['city']
+    end
+
+    def state
+      @data['region']
+    end
+
+    def state_code
+      @data['region_code']
+    end
+
+    def country
+      @data['country_name']
+    end
+
+    def country_code
+      @data['country_code']
+    end
+
+    def postal_code
+      @data['postal']
+    end
+
+    def self.response_attributes
+      %w[ip asn organisation currency currency_symbol calling_code flag time_zone is_eu]
+    end
+
+    response_attributes.each do |a|
+      define_method a do
+        @data[a]
+      end
+    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/ipinfo_io.rb

@@ -0,0 +1,48 @@
+require 'geocoder/results/base'
+
+module Geocoder::Result
+  class IpinfoIo < Base
+
+    def address(format = :full)
+      "#{city} #{postal_code}, #{country}".sub(/^[ ,]*/, "")
+    end
+
+    def coordinates
+      @data['loc'].to_s.split(",").map(&:to_f)
+    end
+
+    def city
+      @data['city']
+    end
+
+    def state
+      @data['region']
+    end
+
+    def country
+      @data['country']
+    end
+
+    def postal_code
+      @data['postal']
+    end
+
+    def country_code
+      @data.fetch('country', '')
+    end
+
+    def state_code
+      @data.fetch('region_code', '')
+    end
+
+    def self.response_attributes
+      %w(ip region postal)
+    end
+
+    response_attributes.each do |a|
+      define_method a do
+        @data[a]
+      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