geocoder 1.1.9 → 1.3.7

data/lib/geocoder/results/bing.rb

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

@@ -29,11 +29,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/geocodio.rb

@@ -0,0 +1,70 @@
+require 'geocoder/results/base'
+
+module Geocoder::Result
+  class Geocodio < Base
+    def number
+      address_components["number"]
+    end
+
+    def street
+      address_components["street"]
+    end
+
+    def suffix
+      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"]
+    end
+    alias_method :postal_code, :zip
+
+    def country
+      "United States" # Geocodio only supports the US
+    end
+
+    def country_code
+      "US" # Geocodio only supports the US
+    end
+
+    def city
+      address_components["city"]
+    end
+
+    def postdirectional
+      address_components["postdirectional"]
+    end
+
+    def location
+      @data['location']
+    end
+
+    def coordinates
+      ['lat', 'lng'].map{ |i| location[i].to_f } if location
+    end
+
+    def accuracy
+      @data['accuracy'].to_f if @data.key?('accuracy')
+    end
+
+    def formatted_address(format = :full)
+      @data['formatted_address']
+    end
+    alias_method :address, :formatted_address
+
+    private
+
+    def address_components
+      @data['address_components'] || {}
+    end
+  end
+end

data/lib/geocoder/results/geoip2.rb

@@ -0,0 +1,62 @@
+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
+        %w[latitude longitude].map do |l|
+          data.fetch('location', {}).fetch(l, 0.0)
+        end
+      end
+
+      def city
+        data.fetch('city', {}).fetch('names', {}).fetch(locale, '')
+      end
+
+      def state
+        data.fetch('subdivisions', []).fetch(0, {}).fetch('names', {}).fetch(locale, '')
+      end
+
+      def state_code
+        data.fetch('subdivisions', []).fetch(0, {}).fetch('iso_code', '')
+      end
+
+      def country
+        data.fetch('country', {}).fetch('names', {}).fetch(locale, '')
+      end
+
+      def country_code
+        data.fetch('country', {}).fetch('iso_code', '')
+      end
+
+      def postal_code
+        data.fetch('postal', {}).fetch('code', '')
+      end
+
+      def self.response_attributes
+        %w[ip]
+      end
+
+      response_attributes.each do |a|
+        define_method a do
+          @data[a]
+        end
+      end
+
+      private
+
+      def data
+        @data.to_hash
+      end
+
+      def locale
+        @locale ||= Geocoder.config[:language].to_s
+      end
+    end
+  end
+end

data/lib/geocoder/results/geoportail_lu.rb

@@ -0,0 +1,69 @@
+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).present?
+    end
+
+    def try_to_extract(key, nullable_hash)
+      nullable_hash.try(:[], key)
+    end
+  end
+end

data/lib/geocoder/results/google.rb

@@ -120,5 +120,20 @@ 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
+      south, west = %w(lat lng).map { |c| viewport['southwest'][c] }
+      north, east = %w(lat lng).map { |c| viewport['northeast'][c] }
+      [south, west, north, east]
+    end
   end
 end

data/lib/geocoder/results/google_places_details.rb

@@ -0,0 +1,35 @@
+require "geocoder/results/google"
+
+module Geocoder
+  module Result
+    class GooglePlacesDetails < Google
+      def place_id
+        @data["place_id"]
+      end
+
+      def types
+        @data["types"] || []
+      end
+
+      def reviews
+        @data["reviews"] || []
+      end
+
+      def rating
+        @data["rating"]
+      end
+
+      def rating_count
+        @data["user_ratings_total"]
+      end
+
+      def phone_number
+        @data["international_phone_number"]
+      end
+
+      def website
+        @data["website"]
+      end
+    end
+  end
+end

data/lib/geocoder/results/here.rb

@@ -0,0 +1,71 @@
+require 'geocoder/results/base'
+
+module Geocoder::Result
+  class Here < Base
+
+    ##
+    # A string in the given format.
+    #
+    def address(format = :full)
+      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]
+    end
+
+    def state
+      address_data['County']
+    end
+
+    def province
+      address_data['County']
+    end
+
+    def postal_code
+      address_data['PostalCode']
+    end
+
+    def city
+      address_data['City']
+    end
+
+    def state_code
+      address_data['State']
+    end
+
+    def province_code
+      address_data['State']
+    end
+
+    def country
+      fail unless d = address_data['AdditionalData']
+      if v = d.find{|ad| ad['key']=='CountryName'}
+        return v['value']
+      end
+    end
+
+    def country_code
+      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['Location']['Address'] || fail
+    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/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'].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/latlon.rb

@@ -0,0 +1,71 @@
+require 'geocoder/results/base'
+
+module Geocoder::Result
+  class Latlon < Base
+
+    def city
+      address_components["city"]
+    end
+
+    def coordinates
+      [@data['lat'].to_f, @data['lon'].to_f]
+    end
+
+    def country
+      "United States" # LatLon.io only supports the US
+    end
+
+    def country_code
+      "US" # LatLon.io only supports the US
+    end
+
+    def formatted_address(format = :full)
+      address_components["address"]
+    end
+    alias_method :address, :formatted_address
+
+    def number
+      address_components["number"]
+    end
+
+    def prefix
+      address_components["prefix"]
+    end
+
+    def state
+      address_components["state"]
+    end
+    alias_method :state_code, :state
+
+    def street
+      [street_name, street_type].compact.join(' ')
+    end
+
+    def street_name
+      address_components["street_name"]
+    end
+
+    def street_type
+      address_components["street_type"]
+    end
+
+    def suffix
+      address_components["suffix"]
+    end
+
+    def unit
+      address_components["unit"]
+    end
+
+    def zip
+      address_components["zip"]
+    end
+    alias_method :postal_code, :zip
+
+    private
+
+    def address_components
+      @data["address"] || {}
+    end
+  end
+end

data/lib/geocoder/results/mapbox.rb

@@ -0,0 +1,47 @@
+require 'geocoder/results/base'
+
+module Geocoder::Result
+  class Mapbox < Base
+
+    def coordinates
+      @data["geometry"]["coordinates"].reverse.map(&:to_f)
+    end
+
+    def place_name
+      @data['text']
+    end
+
+    def street
+      @data['properties']['address']
+    end
+
+    def city
+      @data['context'].map { |c| c['text'] if c['id'] =~ /place/ }.compact.first
+    end
+
+    def state
+      @data['context'].map { |c| c['text'] if c['id'] =~ /region/ }.compact.first
+    end
+
+    alias_method :state_code, :state
+
+    def postal_code
+      @data['context'].map { |c| c['text'] if c['id'] =~ /postcode/ }.compact.first
+    end
+
+    def country
+      @data['context'].map { |c| c['text'] if c['id'] =~ /country/ }.compact.first
+    end
+
+    alias_method :country_code, :country
+
+    def neighborhood
+      @data['context'].map { |c| c['text'] if c['id'] =~ /neighborhood/ }.compact.first
+    end
+
+    def address
+      [place_name, street, city, state, postal_code, country].compact.join(", ")
+    end
+  end
+end
+

data/lib/geocoder/results/mapquest.rb

@@ -2,16 +2,9 @@ require 'geocoder/results/base'
 
 module Geocoder::Result
   class Mapquest < Base
-    def latitude
-      @data["latLng"]["lat"]
-    end
-
-    def longitude
-      @data["latLng"]["lng"]
-    end
 
     def coordinates
-      [latitude, longitude]
+      %w[lat lng].map{ |l| @data["latLng"][l] }
     end
 
     def city
@@ -26,6 +19,10 @@ module Geocoder::Result
       @data['adminArea3']
     end
 
+    def county
+      @data['adminArea4']
+    end
+
     alias_method :state_code, :state
 
     #FIXME: these might not be right, unclear with MQ documentation

data/lib/geocoder/results/mapzen.rb

@@ -0,0 +1,5 @@
+require 'geocoder/results/pelias'
+
+module Geocoder::Result
+  class Mapzen < Pelias; end
+end

data/lib/geocoder/results/maxmind_geoip2.rb

@@ -0,0 +1,9 @@
+require 'geocoder/results/geoip2'
+
+module Geocoder::Result
+  class MaxmindGeoip2 < Geoip2
+    # MindmindGeoip2 has the same results as Geoip2 because both are from MaxMind's GeoIP2 Precision Services
+    # See http://dev.maxmind.com/geoip/geoip2/web-services/ The difference being that Maxmind calls the service
+    # directly while GeoIP2 uses Hive::GeoIP2. See https://github.com/desuwa/hive_geoip2
+  end
+end