bw-geocoder 1.2.5

data/lib/geocoder/results/geocodio.rb

@@ -0,0 +1,66 @@
+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 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/google.rb

@@ -0,0 +1,124 @@
+require 'geocoder/results/base'
+
+module Geocoder::Result
+  class Google < Base
+
+    def coordinates
+      ['lat', 'lng'].map{ |i| geometry['location'][i] }
+    end
+
+    def address(format = :full)
+      formatted_address
+    end
+
+    def neighborhood
+      if neighborhood = address_components_of_type(:neighborhood).first
+        neighborhood['long_name']
+      end
+    end
+
+    def city
+      fields = [:locality, :sublocality,
+        :administrative_area_level_3,
+        :administrative_area_level_2]
+      fields.each do |f|
+        if entity = address_components_of_type(f).first
+          return entity['long_name']
+        end
+      end
+      return nil # no appropriate components found
+    end
+
+    def state
+      if state = address_components_of_type(:administrative_area_level_1).first
+        state['long_name']
+      end
+    end
+
+    def state_code
+      if state = address_components_of_type(:administrative_area_level_1).first
+        state['short_name']
+      end
+    end
+
+    def sub_state
+      if state = address_components_of_type(:administrative_area_level_2).first
+        state['long_name']
+      end
+    end
+
+    def sub_state_code
+      if state = address_components_of_type(:administrative_area_level_2).first
+        state['short_name']
+      end
+    end
+
+    def country
+      if country = address_components_of_type(:country).first
+        country['long_name']
+      end
+    end
+
+    def country_code
+      if country = address_components_of_type(:country).first
+        country['short_name']
+      end
+    end
+
+    def postal_code
+      if postal = address_components_of_type(:postal_code).first
+        postal['long_name']
+      end
+    end
+
+    def route
+      if route = address_components_of_type(:route).first
+        route['long_name']
+      end
+    end
+
+    def street_number
+      if street_number = address_components_of_type(:street_number).first
+        street_number['long_name']
+      end
+    end
+
+    def street_address
+      [street_number, route].compact.join(' ')
+    end
+
+    def types
+      @data['types']
+    end
+
+    def formatted_address
+      @data['formatted_address']
+    end
+
+    def address_components
+      @data['address_components']
+    end
+
+    ##
+    # Get address components of a given type. Valid types are defined in
+    # Google's Geocoding API documentation and include (among others):
+    #
+    #   :street_number
+    #   :locality
+    #   :neighborhood
+    #   :route
+    #   :postal_code
+    #
+    def address_components_of_type(type)
+      address_components.select{ |c| c['types'].include?(type.to_s) }
+    end
+
+    def geometry
+      @data['geometry']
+    end
+
+    def precision
+      geometry['location_type'] if geometry
+    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/google_premier.rb

@@ -0,0 +1,6 @@
+require 'geocoder/results/google'
+
+module Geocoder::Result
+  class GooglePremier < Google
+  end
+end

data/lib/geocoder/results/here.rb

@@ -0,0 +1,62 @@
+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
+
+    private # ----------------------------------------------------------------
+
+    def address_data
+      @data['Location']['Address'] || fail
+    end
+  end
+end

data/lib/geocoder/results/ip_address_labs.rb

@@ -0,0 +1,78 @@
+require 'geocoder/results/base'
+
+module Geocoder::Result
+  class IpAddressLabs < Base
+
+    def coordinates
+      [ @data["latitude"], @data["longitude"] ]
+    end
+
+    def continent_code
+      @data["continent_code"]
+    end
+
+    def continent_name
+      @data["continent_name"]
+    end
+
+    def country_code_iso3166alpha2
+      @data["country_code_iso3166alpha2"]
+    end
+
+    def country_code_iso3166alpha3
+      @data["country_code_iso3166alpha3"]
+    end
+
+    def country_code_iso3166numeric
+      @data["country_code_iso3166numeric"]
+    end
+
+    def country_code_fips10_4
+      @data["country_code_fips10-4"]
+    end
+
+    def country_name
+      @data["country_name"]
+    end
+
+    def region_code
+      @data["region_code"]
+    end
+
+    def region_name
+      @data["region_name"]
+    end
+
+    def city
+      @data["city"]
+    end
+
+    def postal_code
+      @data["postal_code"]
+    end
+
+    def metro_code
+      @data["metro_code"]
+    end
+
+    def area_code
+      @data["area_code"]
+    end
+
+    def latitude
+      @data["latitude"]
+    end
+
+    def longitude
+      @data["longitude"]
+    end
+
+    def isp
+      @data["isp"]
+    end
+
+    def organization
+      @data["organization"]
+    end
+  end
+end

data/lib/geocoder/results/mapquest.rb

@@ -0,0 +1,51 @@
+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]
+    end
+
+    def city
+      @data['adminArea5']
+    end
+
+    def street
+      @data['street']
+    end
+
+    def state
+      @data['adminArea3']
+    end
+
+    alias_method :state_code, :state
+
+    #FIXME: these might not be right, unclear with MQ documentation
+    alias_method :province, :state
+    alias_method :province_code, :state
+
+    def postal_code
+      @data['postalCode'].to_s
+    end
+
+    def country
+      @data['adminArea1']
+    end
+
+    def country_code
+      country
+    end
+
+    def address
+      [street, city, state, postal_code, country].reject{|s| s.length == 0 }.join(", ")
+    end
+  end
+end

data/lib/geocoder/results/maxmind.rb

@@ -0,0 +1,135 @@
+require 'geocoder/results/base'
+
+module Geocoder::Result
+  class Maxmind < Base
+
+    ##
+    # Hash mapping service names to names of returned fields.
+    #
+    def self.field_names
+      {
+        :country => [
+          :country_code,
+          :error
+        ],
+
+        :city => [
+          :country_code,
+          :region_code,
+          :city_name,
+          :latitude,
+          :longitude,
+          :error
+        ],
+
+        :city_isp_org => [
+          :country_code,
+          :region_code,
+          :city_name,
+          :postal_code,
+          :latitude,
+          :longitude,
+          :metro_code,
+          :area_code,
+          :isp_name,
+          :organization_name,
+          :error
+        ],
+
+        :omni => [
+          :country_code,
+          :country_name,
+          :region_code,
+          :region_name,
+          :city_name,
+          :latitude,
+          :longitude,
+          :metro_code,
+          :area_code,
+          :time_zone,
+          :continent_code,
+          :postal_code,
+          :isp_name,
+          :organization_name,
+          :domain,
+          :as_number,
+          :netspeed,
+          :user_type,
+          :accuracy_radius,
+          :country_confidence_factor,
+          :city_confidence_factor,
+          :region_confidence_factor,
+          :postal_confidence_factor,
+          :error
+        ]
+      }
+    end
+
+    ##
+    # Name of the MaxMind service being used.
+    #
+    def service_name
+      # it would be much better to infer this from the length of the @data
+      # array, but MaxMind seems to send inconsistent and wide-ranging response
+      # lengths (see https://github.com/alexreisner/geocoder/issues/396)
+      Geocoder.config.maxmind[:service]
+    end
+
+    def field_names
+      self.class.field_names[service_name]
+    end
+
+    def data_hash
+      @data_hash ||= Hash[*field_names.zip(@data).flatten]
+    end
+
+    def coordinates
+      [data_hash[:latitude].to_f, data_hash[:longitude].to_f]
+    end
+
+    def address(format = :full)
+      s = state_code.to_s == "" ? "" : ", #{state_code}"
+      "#{city}#{s} #{postal_code}, #{country_code}".sub(/^[ ,]*/, "")
+    end
+
+    def city
+      data_hash[:city_name]
+    end
+
+    def state # not given by MaxMind
+      data_hash[:region_name] || data_hash[:region_code]
+    end
+
+    def state_code
+      data_hash[:region_code]
+    end
+
+    def country #not given by MaxMind
+      data_hash[:country_name] || data_hash[:country_code]
+    end
+
+    def country_code
+      data_hash[:country_code]
+    end
+
+    def postal_code
+      data_hash[:postal_code]
+    end
+
+    def method_missing(method, *args, &block)
+      if field_names.include?(method)
+        data_hash[method]
+      else
+        super
+      end
+    end
+
+    def respond_to?(method)
+      if field_names.include?(method)
+        true
+      else
+        super
+      end
+    end
+  end
+end

data/lib/geocoder/results/maxmind_local.rb

@@ -0,0 +1,49 @@
+require 'geocoder/results/base'
+
+module Geocoder::Result
+  class MaxmindLocal < Base
+
+    def address(format = :full)
+      s = state.to_s == "" ? "" : ", #{state}"
+      "#{city}#{s} #{postal_code}, #{country}".sub(/^[ ,]*/, "")
+    end
+
+    def coordinates
+      [@data[:latitude], @data[:longitude]]
+    end
+
+    def city
+      @data[:city_name]
+    end
+
+    def state
+      @data[:region_name]
+    end
+
+    def state_code
+      "" # Not available in Maxmind's database
+    end
+
+    def country
+      @data[:country_name]
+    end
+
+    def country_code
+      @data[:country_code2]
+    end
+
+    def postal_code
+      @data[:postal_code]
+    end
+
+    def self.response_attributes
+      %w[ip]
+    end
+
+    response_attributes.each do |a|
+      define_method a do
+        @data[a]
+      end
+    end
+  end
+end

data/lib/geocoder/results/nominatim.rb

@@ -0,0 +1,94 @@
+require 'geocoder/results/base'
+
+module Geocoder::Result
+  class Nominatim < Base
+
+    def poi
+      %w[stadium bus_stop tram_stop].each do |key|
+        return @data['address'][key] if @data['address'].key?(key)
+      end
+      return nil
+    end
+
+    def house_number
+      @data['address']['house_number']
+    end
+
+    def address
+      @data['display_name']
+    end
+
+    def street
+      %w[road pedestrian highway].each do |key|
+        return @data['address'][key] if @data['address'].key?(key)
+      end
+      return nil
+    end
+
+    def city
+      %w[city town village hamlet].each do |key|
+        return @data['address'][key] if @data['address'].key?(key)
+      end
+      return nil
+    end
+
+    def village
+      @data['address']['village']
+    end
+
+    def town
+      @data['address']['town']
+    end
+
+    def state
+      @data['address']['state']
+    end
+
+    alias_method :state_code, :state
+
+    def postal_code
+      @data['address']['postcode']
+    end
+
+    def county
+      @data['address']['county']
+    end
+
+    def country
+      @data['address']['country']
+    end
+
+    def country_code
+      @data['address']['country_code']
+    end
+
+    def suburb
+      @data['address']['suburb']
+    end
+
+    def coordinates
+      [@data['lat'].to_f, @data['lon'].to_f]
+    end
+
+    def place_class
+      @data['class']
+    end
+
+    def place_type
+      @data['type']
+    end
+
+    def self.response_attributes
+      %w[place_id osm_type osm_id boundingbox license
+         polygonpoints display_name class type stadium]
+    end
+
+    response_attributes.each do |a|
+      unless method_defined?(a)
+        define_method a do
+          @data[a]
+        end
+      end
+    end
+  end
+end