geocoder 1.2.6 → 1.6.1

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['stateProv']
+    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,12 +4,16 @@ 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
@@ -19,8 +23,8 @@ module Geocoder::Result
     alias_method :state, :state_code
 
     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 +33,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 +68,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/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

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

@@ -17,9 +17,20 @@ module Geocoder::Result
       fail unless d = @data['Location']['DisplayPosition']
       [d['Latitude'].to_f, d['Longitude'].to_f]
     end
+    
+    def route
+      address_data['Street']
+    end
+    
+    def street_number
+      address_data['HouseNumber']
+    end  
 
     def state
-      address_data['County']
+      fail unless d = address_data['AdditionalData']
+      if v = d.find{|ad| ad['key']=='StateName'}
+        return v['value']
+      end
     end
 
     def province
@@ -53,6 +64,15 @@ module Geocoder::Result
       address_data['Country']
     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']
+      [south, west, north, east]
+    end
+
     private # ----------------------------------------------------------------
 
     def address_data

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