broken-geocoder 1.3.4

data/lib/geocoder/results/geoip2.rb

@@ -0,0 +1,62 @@
+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
+        %w[latitude longitude].map do |l|
+          data.fetch('location', {}).fetch(l, 0.0)
+        end
+      end
+
+      def city
+        data.fetch('city', {}).fetch('names', {}).fetch(locale, '')
+      end
+
+      def state
+        data.fetch('subdivisions', []).fetch(0, {}).fetch('names', {}).fetch(locale, '')
+      end
+
+      def state_code
+        data.fetch('subdivisions', []).fetch(0, {}).fetch('iso_code', '')
+      end
+
+      def country
+        data.fetch('country', {}).fetch('names', {}).fetch(locale, '')
+      end
+
+      def country_code
+        data.fetch('country', {}).fetch('iso_code', '')
+      end
+
+      def postal_code
+        data.fetch('postal', {}).fetch('code', '')
+      end
+
+      def self.response_attributes
+        %w[ip]
+      end
+
+      response_attributes.each do |a|
+        define_method a do
+          @data[a]
+        end
+      end
+
+      private
+
+      def data
+        @data.to_hash
+      end
+
+      def locale
+        @locale ||= Geocoder.config[:language].to_s
+      end
+    end
+  end
+end

data/lib/geocoder/results/geoportail_lu.rb

@@ -0,0 +1,69 @@
+require 'geocoder/results/base'
+
+module Geocoder::Result
+  class GeoportailLu < Base
+
+    def coordinates
+      geomlonlat['coordinates'].reverse if geolocalized?
+    end
+
+    def address
+      full_address
+    end
+
+    def city
+      try_to_extract 'locality', detailled_address
+    end
+
+    def state
+      'Luxembourg'
+    end
+
+    def state_code
+      'LU'
+    end
+
+    def postal_code
+      try_to_extract 'zip', detailled_address
+    end
+
+    def street_address
+      [street_number, street].compact.join(' ')
+    end
+
+    def street_number
+      try_to_extract 'postnumber', detailled_address
+    end
+
+    def street
+      try_to_extract 'street', detailled_address
+    end
+
+    def full_address
+      data['address']
+    end
+
+    def geomlonlat
+      data['geomlonlat']
+    end
+
+    def detailled_address
+      data['AddressDetails']
+    end
+
+    alias_method :country, :state
+    alias_method :province, :state
+    alias_method :country_code, :state_code
+    alias_method :province_code, :state_code
+
+    private
+
+    def geolocalized?
+      try_to_extract('coordinates', geomlonlat).present?
+    end
+
+    def try_to_extract(key, nullable_hash)
+      nullable_hash.try(:[], key)
+    end
+  end
+end

data/lib/geocoder/results/google.rb

@@ -0,0 +1,139 @@
+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_adadress
+    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
+    
+    def partial_match
+      @data['partial_match']
+    end
+    
+    def place_id
+      @data['place_id']
+    end  
+
+    def viewport
+      viewport = geometry['viewport'] || fail
+      south, west = %w(lat lng).map { |c| viewport['southwest'][c] }
+      north, east = %w(lat lng).map { |c| viewport['northeast'][c] }
+      [south, west, north, east]
+    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,71 @@
+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
+
+    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['Location']['Address'] || fail
+    end
+  end
+end

data/lib/geocoder/results/ipapi_com.rb

@@ -0,0 +1,45 @@
+require 'geocoder/results/base'
+
+module Geocoder::Result
+  class IpapiCom < Base
+
+    def coordinates
+      [lat, lon]
+    end
+
+    def address
+      "#{city}, #{state_code} #{postal_code}, #{country}".sub(/^[ ,]*/, "")
+    end
+
+    def state
+      region_name
+    end
+
+    def state_code
+      region
+    end
+
+    def postal_code
+      zip
+    end
+
+    def country_code
+      @data['countryCode']
+    end
+
+    def region_name
+      @data['regionName']
+    end
+
+    def self.response_attributes
+      %w[country region city zip timezone isp org as reverse query status message mobile proxy lat lon]
+    end
+
+    response_attributes.each do |attribute|
+      define_method attribute do
+        @data[attribute]
+      end
+    end
+
+  end
+end

data/lib/geocoder/results/ipinfo_io.rb

@@ -0,0 +1,48 @@
+require 'geocoder/results/base'
+
+module Geocoder::Result
+  class IpinfoIo < Base
+
+    def address(format = :full)
+      "#{city} #{postal_code}, #{country}".sub(/^[ ,]*/, "")
+    end
+
+    def coordinates
+      @data['loc'].split(",").map(&:to_f)
+    end
+
+    def city
+      @data['city']
+    end
+
+    def state
+      @data['region']
+    end
+
+    def country
+      @data['country']
+    end
+
+    def postal_code
+      @data['postal']
+    end
+
+    def country_code
+      @data.fetch('country', '')
+    end
+
+    def state_code
+      @data.fetch('region_code', '')
+    end
+
+    def self.response_attributes
+      %w['ip', 'region', 'postal']
+    end
+
+    response_attributes.each do |a|
+      define_method a do
+        @data[a]
+      end
+    end
+  end
+end