geocoder2 0.1.0

data/lib/geocoder2/results/google.rb

@@ -0,0 +1,124 @@
+require 'geocoder2/results/base'
+
+module Geocoder2::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/geocoder2/results/google_premier.rb

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

data/lib/geocoder2/results/mapquest.rb

@@ -0,0 +1,51 @@
+require 'geocoder2/results/base'
+
+module Geocoder2::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/geocoder2/results/maxmind.rb

@@ -0,0 +1,135 @@
+require 'geocoder2/results/base'
+
+module Geocoder2::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/geocoder2/issues/396)
+      Geocoder2.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/geocoder2/results/nominatim.rb

@@ -0,0 +1,94 @@
+require 'geocoder2/results/base'
+
+module Geocoder2::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

data/lib/geocoder2/results/ovi.rb

@@ -0,0 +1,62 @@
+require 'geocoder2/results/base'
+
+module Geocoder2::Result
+  class Ovi < 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/geocoder2/results/test.rb

@@ -0,0 +1,16 @@
+require 'geocoder2/results/base'
+
+module Geocoder2
+  module Result
+    class Test < Base
+
+      %w[latitude longitude city state state_code province
+      province_code postal_code country country_code address
+      street_address street_number route].each do |attr|
+        define_method(attr) do
+          @data[attr.to_s] || @data[attr.to_sym]
+        end
+      end
+    end
+  end
+end

data/lib/geocoder2/results/yahoo.rb

@@ -0,0 +1,55 @@
+require 'geocoder2/results/base'
+
+module Geocoder2::Result
+  class Yahoo < Base
+
+    def address(format = :full)
+      (1..4).to_a.map{ |i| @data["line#{i}"] }.reject{ |i| i.nil? or i == "" }.join(", ")
+    end
+
+    def city
+      @data['city']
+    end
+
+    def state
+      @data['state']
+    end
+
+    def state_code
+      @data['statecode']
+    end
+
+    def country
+      @data['country']
+    end
+
+    def country_code
+      @data['countrycode']
+    end
+
+    def postal_code
+      @data['postal']
+    end
+
+    def address_hash
+      @data['hash']
+    end
+
+    def self.response_attributes
+      %w[quality offsetlat offsetlon radius boundingbox name
+        line1 line2 line3 line4 cross house street xstreet unittype unit
+        city state statecode country countrycode postal
+        neighborhood county countycode
+        level0 level1 level2 level3 level4 level0code level1code level2code
+        timezone areacode uzip hash woeid woetype]
+    end
+
+    response_attributes.each do |a|
+      unless method_defined?(a)
+        define_method a do
+          @data[a]
+        end
+      end
+    end
+  end
+end

data/lib/geocoder2/results/yandex.rb

@@ -0,0 +1,80 @@
+require 'geocoder2/results/base'
+
+module Geocoder2::Result
+  class Yandex < Base
+
+    def coordinates
+      @data['GeoObject']['Point']['pos'].split(' ').reverse.map(&:to_f)
+    end
+
+    def address(format = :full)
+      @data['GeoObject']['metaDataProperty']['Geocoder2MetaData']['text']
+    end
+
+    def city
+      if state.empty? and address_details.has_key? 'Locality'
+        address_details['Locality']['LocalityName']
+      elsif sub_state.empty?
+        address_details['AdministrativeArea']['Locality']['LocalityName']
+      elsif not sub_state_city.empty?
+        sub_state_city
+      else
+        ""
+      end
+    end
+
+    def country
+      address_details['CountryName']
+    end
+
+    def country_code
+      address_details['CountryNameCode']
+    end
+
+    def state
+      if address_details['AdministrativeArea']
+        address_details['AdministrativeArea']['AdministrativeAreaName']
+      else
+        ""
+      end
+    end
+
+    def sub_state
+      if !state.empty? and address_details['AdministrativeArea']['SubAdministrativeArea']
+        address_details['AdministrativeArea']['SubAdministrativeArea']['SubAdministrativeAreaName']
+      else
+        ""
+      end
+    end
+
+    def state_code
+      ""
+    end
+
+    def postal_code
+      ""
+    end
+
+    def premise_name
+      address_details['Locality']['Premise']['PremiseName']
+    end
+
+    def precision
+      @data['GeoObject']['metaDataProperty']['Geocoder2MetaData']['precision']
+    end
+
+    private # ----------------------------------------------------------------
+
+    def address_details
+      @data['GeoObject']['metaDataProperty']['Geocoder2MetaData']['AddressDetails']['Country']
+    end
+
+    def sub_state_city
+      if sub_state && sub_state["Locality"]
+        sub_state['Locality']['LocalityName']          
+      else
+        ""
+      end
+    end
+  end
+end