geocoder-kb 1.2.6

data/lib/geocoder/results/bing.rb

@@ -0,0 +1,48 @@
+require 'geocoder/results/base'
+
+module Geocoder::Result
+  class Bing < Base
+
+    def address(format = :full)
+      @data['address']['formattedAddress']
+    end
+
+    def city
+      @data['address']['locality']
+    end
+
+    def state_code
+      @data['address']['adminDistrict']
+    end
+
+    alias_method :state, :state_code
+
+    def country
+      @data['address']['countryRegion']
+    end
+
+    alias_method :country_code, :country
+
+    def postal_code
+      @data['address']['postalCode']
+    end
+
+    def coordinates
+      @data['point']['coordinates']
+    end
+
+    def address_data
+      @data['address']
+    end
+
+    def self.response_attributes
+      %w[bbox name confidence entityType]
+    end
+
+    response_attributes.each do |a|
+      define_method a do
+        @data[a]
+      end
+    end
+  end
+end

data/lib/geocoder/results/dstk.rb

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

data/lib/geocoder/results/esri.rb

@@ -0,0 +1,51 @@
+require 'geocoder/results/base'
+
+module Geocoder::Result
+  class Esri < Base
+
+    def address
+      address = reverse_geocode? ? 'Address' : 'Match_addr'
+      attributes[address]
+    end
+
+    def city
+      attributes['City']
+    end
+
+    def state_code
+      attributes['Region']
+    end
+
+    alias_method :state, :state_code
+
+    def country
+      country = reverse_geocode? ? "CountryCode" : "Country"
+      attributes[country]
+    end
+
+    alias_method :country_code, :country
+
+    def postal_code
+      attributes['Postal']
+    end
+
+    def coordinates
+      [geometry["y"], geometry["x"]]
+    end
+
+    private
+
+    def attributes
+      reverse_geocode? ? @data['address'] : @data['locations'].first['feature']['attributes']
+    end
+
+    def geometry
+      reverse_geocode? ? @data["location"] : @data['locations'].first['feature']["geometry"]
+    end
+
+    def reverse_geocode?
+      @data['locations'].nil?
+    end
+
+  end
+end

data/lib/geocoder/results/freegeoip.rb

@@ -0,0 +1,45 @@
+require 'geocoder/results/base'
+
+module Geocoder::Result
+  class Freegeoip < 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_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['zipcode']
+    end
+
+    def self.response_attributes
+      %w[metrocode ip]
+    end
+
+    response_attributes.each do |a|
+      define_method a do
+        @data[a]
+      end
+    end
+  end
+end

data/lib/geocoder/results/geocoder_ca.rb

@@ -0,0 +1,60 @@
+require 'geocoder/results/base'
+
+module Geocoder::Result
+  class GeocoderCa < Base
+
+    def coordinates
+      [@data['latt'].to_f, @data['longt'].to_f]
+    end
+
+    def address(format = :full)
+      "#{street_address}, #{city}, #{state} #{postal_code}, #{country}".sub(/^[ ,]*/, "")
+    end
+
+    def street_address
+      "#{@data['stnumber']} #{@data['staddress']}"
+    end
+
+    def city
+      @data['city']
+    end
+
+    def state
+      @data['prov']
+    end
+
+    alias_method :state_code, :state
+
+    def postal_code
+      @data['postal']
+    end
+
+    def country
+      country_code == 'CA' ? 'Canada' : 'United States'
+    end
+
+    def country_code
+      return nil if state.nil? || state == ""
+      canadian_province_abbreviations.include?(state) ? "CA" : "US"
+    end
+
+    def self.response_attributes
+      %w[latt longt inlatt inlongt distance stnumber staddress prov
+        NearRoad NearRoadDistance betweenRoad1 betweenRoad2
+        intersection major_intersection]
+    end
+
+    response_attributes.each do |a|
+      define_method a do
+        @data[a]
+      end
+    end
+
+
+    private # ----------------------------------------------------------------
+
+    def canadian_province_abbreviations
+      %w[ON QC NS NB MB BC PE SK AB NL]
+    end
+  end
+end

data/lib/geocoder/results/geocoder_us.rb

@@ -0,0 +1,39 @@
+require 'geocoder/results/base'
+
+module Geocoder::Result
+  class GeocoderUs < Base
+    def coordinates
+      [@data[0].to_f, @data[1].to_f]
+    end
+
+    def address(format = :full)
+      "#{street_address}, #{city}, #{state} #{postal_code}, #{country}".sub(/^[ ,]*/, "")
+    end
+
+    def street_address
+      @data[2]
+    end
+
+    def city
+      @data[3]
+    end
+
+    def state
+      @data[4]
+    end
+
+    alias_method :state_code, :state
+
+    def postal_code
+      @data[5]
+    end
+
+    def country
+      'United States'
+    end
+
+    def country_code
+      'US'
+    end
+  end
+end

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/geoip2.rb

@@ -0,0 +1,64 @@
+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
+        [latitude, longitude]
+      end
+
+      def latitude
+        return 0.0 unless @data['location']
+        @data['location']['latitude'].to_f
+      end
+
+      def longitude
+        return 0.0 unless @data['location']
+        @data['location']['longitude'].to_f
+      end
+
+      def city
+        return '' unless @data['city']
+        @data['city']['names']['en']
+      end
+
+      def state
+        return '' unless @data['subdivisions']
+        @data['subdivisions'][0]['names']['en']
+      end
+
+      def state_code
+        return '' unless @data['subdivisions']
+        @data['subdivisions'][0]['iso_code']
+      end
+
+      def country
+        @data['country']['names']['en']
+      end
+
+      def country_code
+        @data['country']['iso_code']
+      end
+
+      def postal_code
+        return '' unless @data['postal']
+        @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
+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