bw-geocoder 1.2.5

data/lib/geocoder/results/okf.rb

@@ -0,0 +1,106 @@
+require 'geocoder/results/base'
+
+module Geocoder::Result
+  class Okf < Base
+
+    def coordinates
+      ['lat', 'lng'].map{ |i| geometry['location'][i] }
+    end
+
+    def address(format = :full)
+      formatted_address
+    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
+    ""
+  end
+
+  def sub_state
+    ""
+  end
+
+  def state_code
+    ""
+  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
+      [route, street_number].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/opencagedata.rb

@@ -0,0 +1,82 @@
+require 'geocoder/results/base'
+
+module Geocoder::Result
+  class Opencagedata < Base
+
+    def poi
+      %w[stadium bus_stop tram_stop].each do |key|
+        return @data['components'][key] if @data['components'].key?(key)
+      end
+      return nil
+    end
+
+    def house_number
+      @data['components']['house_number']
+    end
+
+    def address
+      @data['formatted']
+    end
+
+    def street
+      %w[road pedestrian highway].each do |key|
+        return @data['components'][key] if @data['components'].key?(key)
+      end
+      return nil
+    end
+
+    def city
+      %w[city town village hamlet].each do |key|
+        return @data['components'][key] if @data['components'].key?(key)
+      end
+      return nil
+    end
+
+    def village
+      @data['components']['village']
+    end
+
+
+    def state
+      @data['components']['state']
+    end
+
+    alias_method :state_code, :state
+
+    def postal_code
+      @data['components']['postcode'].to_s
+    end
+
+    def county
+      @data['components']['county']
+    end
+
+    def country
+      @data['components']['country']
+    end
+
+    def country_code
+      @data['components']['country_code']
+    end
+
+    def suburb
+      @data['components']['suburb']
+    end
+
+    def coordinates
+      [@data['geometry']['lat'].to_f, @data['geometry']['lng'].to_f]
+    end
+    def self.response_attributes
+      %w[boundingbox license 
+        formatted stadium]
+    end
+
+    response_attributes.each do |a|
+      unless method_defined?(a)
+        define_method a do
+          @data[a]
+        end
+      end
+    end
+  end
+end

data/lib/geocoder/results/ovi.rb

@@ -0,0 +1,62 @@
+require 'geocoder/results/base'
+
+module Geocoder::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/geocoder/results/pointpin.rb

@@ -0,0 +1,44 @@
+require 'geocoder/results/base'
+
+module Geocoder::Result
+  class Pointpin < Base
+
+    def address
+      [ city_name, state, postal_code, country ].select{ |i| i.to_s != "" }.join(", ")
+    end
+
+    def city
+      @data['city_name']
+    end
+
+    def state
+      @data['region_name']
+    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['postcode']
+    end
+
+    def self.response_attributes
+      %w[continent_code ip country_code country_name region_name city_name postcode latitude longitude time_zone languages]
+    end
+
+    response_attributes.each do |a|
+      define_method a do
+        @data[a]
+      end
+    end
+  end
+end

data/lib/geocoder/results/smarty_streets.rb

@@ -0,0 +1,106 @@
+require 'geocoder/lookups/base'
+
+module Geocoder::Result
+  class SmartyStreets < Base
+    def coordinates
+      %w(latitude longitude).map do |i|
+        zipcode_endpoint? ? zipcodes.first[i] : metadata[i]
+      end
+    end
+
+    def address
+      [
+        delivery_line_1,
+        delivery_line_2,
+        last_line
+      ].select{ |i| i.to_s != "" }.join(" ")
+    end
+
+    def state
+      zipcode_endpoint? ?
+        city_states.first['state'] :
+        components['state_abbreviation']
+    end
+
+    def state_code
+      zipcode_endpoint? ?
+        city_states.first['state_abbreviation'] :
+        components['state_abbreviation']
+    end
+
+    def country
+      # SmartyStreets returns results for USA only
+      "United States"
+    end
+
+    def country_code
+      # SmartyStreets returns results for USA only
+      "US"
+    end
+
+    ## Extra methods not in base.rb ------------------------
+
+    def street
+      components['street_name']
+    end
+
+    def city
+      zipcode_endpoint? ?
+        city_states.first['city'] :
+        components['city_name']
+    end
+
+    def zipcode
+      zipcode_endpoint? ?
+        zipcodes.first['zipcode'] :
+        components['zipcode']
+    end
+    alias_method :postal_code, :zipcode
+
+    def zip4
+      components['plus4_code']
+    end
+    alias_method :postal_code_extended, :zip4
+
+    def fips
+      zipcode_endpoint? ?
+        zipcodes.first['county_fips'] :
+        metadata['county_fips']
+    end
+
+    def zipcode_endpoint?
+      zipcodes.any?
+    end
+
+    [
+      :delivery_line_1,
+      :delivery_line_2,
+      :last_line,
+      :delivery_point_barcode,
+      :addressee
+    ].each do |m|
+      define_method(m) do
+        @data[m.to_s] || ''
+      end
+    end
+
+    [
+      :components,
+      :metadata,
+      :analysis
+    ].each do |m|
+      define_method(m) do
+        @data[m.to_s] || {}
+      end
+    end
+
+    [
+      :city_states,
+      :zipcodes
+    ].each do |m|
+      define_method(m) do
+        @data[m.to_s] || []
+      end
+    end
+  end
+end

data/lib/geocoder/results/telize.rb

@@ -0,0 +1,45 @@
+require 'geocoder/results/base'
+
+module Geocoder::Result
+  class Telize < Base
+
+    def address(format = :full)
+      s = state_code.to_s == "" ? "" : ", #{state_code}"
+      "#{city}#{s} #{postal_code}, #{country}".sub(/^[ ,]*/, "")
+    end
+
+    def city
+      @data['city']
+    end
+
+    def state
+      @data['region']
+    end
+
+    def state_code
+      @data['region_code']
+    end
+
+    def country
+      @data['country']
+    end
+
+    def country_code
+      @data['country_code']
+    end
+
+    def postal_code
+      @data['postal_code']
+    end
+
+    def self.response_attributes
+      %w[timezone isp dma_code area_code ip asn continent_code country_code3]
+    end
+
+    response_attributes.each do |a|
+      define_method a do
+        @data[a]
+      end
+    end
+  end
+end

data/lib/geocoder/results/test.rb

@@ -0,0 +1,33 @@
+require 'geocoder/results/base'
+
+module Geocoder
+  module Result
+    class Test < Base
+
+      def self.add_result_attribute(attr)
+        begin
+          remove_method(attr) if method_defined?(attr)
+        rescue NameError # method defined on superclass
+        end
+
+        define_method(attr) do
+          @data[attr.to_s] || @data[attr.to_sym]
+        end
+      end
+
+      %w[latitude longitude neighborhood city state state_code sub_state
+      sub_state_code province province_code postal_code country
+      country_code address street_address street_number route geometry].each do |attr|
+        add_result_attribute(attr)
+      end
+
+      def initialize(data)
+        data.keys.each do |attr|
+          Test.add_result_attribute(attr)
+        end
+
+        super
+      end
+    end
+  end
+end

data/lib/geocoder/results/yahoo.rb

@@ -0,0 +1,55 @@
+require 'geocoder/results/base'
+
+module Geocoder::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/geocoder/results/yandex.rb

@@ -0,0 +1,84 @@
+require 'geocoder/results/base'
+
+module Geocoder::Result
+  class Yandex < Base
+
+    def coordinates
+      @data['GeoObject']['Point']['pos'].split(' ').reverse.map(&:to_f)
+    end
+
+    def address(format = :full)
+      @data['GeoObject']['metaDataProperty']['GeocoderMetaData']['text']
+    end
+
+    def city
+      if state.empty? and address_details.has_key? 'Locality'
+        address_details['Locality']['LocalityName']
+      elsif sub_state.empty? and address_details['AdministrativeArea'].has_key? 'Locality'
+        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 kind
+      @data['GeoObject']['metaDataProperty']['GeocoderMetaData']['kind']
+    end
+
+    def precision
+      @data['GeoObject']['metaDataProperty']['GeocoderMetaData']['precision']
+    end
+
+    private # ----------------------------------------------------------------
+
+    def address_details
+      @data['GeoObject']['metaDataProperty']['GeocoderMetaData']['AddressDetails']['Country']
+    end
+
+    def sub_state_city
+      if !sub_state.empty? and address_details['AdministrativeArea']['SubAdministrativeArea'].has_key? 'Locality'
+        address_details['AdministrativeArea']['SubAdministrativeArea']['Locality']['LocalityName'] || ""
+      else
+        ""
+      end
+    end
+  end
+end