geocoder 1.1.9 → 1.3.7

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

@@ -4,7 +4,7 @@ module Geocoder::Result
   class Nominatim < Base
 
     def poi
-      %w[stadium bus_stop tram_stop].each do |key|
+      %w[building university school hospital mall hotel restaurant stadium bus_stop tram_stop].each do |key|
         return @data['address'][key] if @data['address'].key?(key)
       end
       return nil
@@ -78,6 +78,11 @@ module Geocoder::Result
       @data['type']
     end
 
+    def viewport
+      south, north, west, east = @data['boundingbox'].map(&:to_f)
+      [south, west, north, east]
+    end
+
     def self.response_attributes
       %w[place_id osm_type osm_id boundingbox license
          polygonpoints display_name class type stadium]

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,90 @@
+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 viewport
+      bounds = @data['bounds'] || fail
+      south, west = %w(lat lng).map { |i| bounds['southwest'][i] }
+      north, east = %w(lat lng).map { |i| bounds['northeast'][i] }
+      [south, west, north, east]
+    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

@@ -53,6 +53,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/pelias.rb

@@ -0,0 +1,58 @@
+require 'geocoder/results/base'
+
+module Geocoder::Result
+  class Pelias < Base
+    def address(format = :full)
+      properties['label']
+    end
+
+    def city
+      locality
+    end
+
+    def coordinates
+      geometry['coordinates'].reverse
+    end
+
+    def country_code
+      properties['country_a']
+    end
+
+    def postal_code
+      properties['postalcode'].to_s
+    end
+
+    def province
+      state
+    end
+
+    def state
+      properties['region']
+    end
+
+    def state_code
+      properties['region_a']
+    end
+
+    def self.response_attributes
+      %w[county confidence country gid id layer localadmin locality neighborhood]
+    end
+
+    response_attributes.each do |a|
+      define_method a do
+        properties[a]
+      end
+    end
+
+    private
+
+    def geometry
+      @data.fetch('geometry', {})
+    end
+
+    def properties
+      @data.fetch('properties', {})
+    end
+  end
+end
+

data/lib/geocoder/results/pointpin.rb

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

@@ -0,0 +1,42 @@
+require 'geocoder/results/base'
+
+module Geocoder::Result
+  class PostcodeAnywhereUk < Base
+
+    def coordinates
+      [@data['Latitude'].to_f, @data['Longitude'].to_f]
+    end
+
+    def blank_result
+      ''
+    end
+    alias_method :state, :blank_result
+    alias_method :state_code, :blank_result
+    alias_method :postal_code, :blank_result
+
+    def address
+      @data['Location']
+    end
+
+    def city
+      # is this too big a jump to assume that the API always
+      # returns a City, County as the last elements?
+      city = @data['Location'].split(',')[-2] || blank_result
+      city.strip
+    end
+
+    def os_grid
+      @data['OsGrid']
+    end
+
+    # This is a UK only API; all results are UK specific and
+    # so ommitted from API response.
+    def country
+      'United Kingdom'
+    end
+
+    def country_code
+      'UK'
+    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

@@ -4,13 +4,30 @@ module Geocoder
   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|
+      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.each_key do |attr|
+          Test.add_result_attribute(attr)
+        end
+
+        super
+      end
     end
   end
 end

data/lib/geocoder/results/yandex.rb

@@ -12,9 +12,10 @@ module Geocoder::Result
     end
 
     def city
-      if state.empty? and address_details.has_key? 'Locality'
+      if state.empty? and address_details and address_details.has_key? 'Locality'
         address_details['Locality']['LocalityName']
-      elsif sub_state.empty?
+      elsif sub_state.empty? and address_details and address_details.has_key? 'AdministrativeArea' and
+          address_details['AdministrativeArea'].has_key? 'Locality'
         address_details['AdministrativeArea']['Locality']['LocalityName']
       elsif not sub_state_city.empty?
         sub_state_city
@@ -32,7 +33,7 @@ module Geocoder::Result
     end
 
     def state
-      if address_details['AdministrativeArea']
+      if address_details and address_details['AdministrativeArea']
         address_details['AdministrativeArea']['AdministrativeAreaName']
       else
         ""
@@ -40,7 +41,7 @@ module Geocoder::Result
     end
 
     def sub_state
-      if !state.empty? and address_details['AdministrativeArea']['SubAdministrativeArea']
+      if !state.empty? and address_details and address_details['AdministrativeArea']['SubAdministrativeArea']
         address_details['AdministrativeArea']['SubAdministrativeArea']['SubAdministrativeAreaName']
       else
         ""
@@ -59,10 +60,21 @@ module Geocoder::Result
       address_details['Locality']['Premise']['PremiseName']
     end
 
+    def kind
+      @data['GeoObject']['metaDataProperty']['GeocoderMetaData']['kind']
+    end
+
     def precision
       @data['GeoObject']['metaDataProperty']['GeocoderMetaData']['precision']
     end
 
+    def viewport
+      envelope = @data['GeoObject']['boundedBy']['Envelope'] || fail
+      east, north = envelope['upperCorner'].split(' ').map(&:to_f)
+      west, south = envelope['lowerCorner'].split(' ').map(&:to_f)
+      [south, west, north, east]
+    end
+
     private # ----------------------------------------------------------------
 
     def address_details
@@ -70,8 +82,8 @@ module Geocoder::Result
     end
 
     def sub_state_city
-      if sub_state && sub_state["Locality"]
-        sub_state['Locality']['LocalityName']          
+      if !sub_state.empty? and address_details and address_details['AdministrativeArea']['SubAdministrativeArea'].has_key? 'Locality'
+        address_details['AdministrativeArea']['SubAdministrativeArea']['Locality']['LocalityName'] || ""
       else
         ""
       end