really-broken-geocoder 1.5.1

data/lib/geocoder/results/ip2location.rb

@@ -0,0 +1,22 @@
+require 'geocoder/results/base'
+
+module Geocoder::Result
+  class Ip2location < Base
+
+    def address(format = :full)
+      "#{city_name} #{zip_code}, #{country_name}".sub(/^[ ,]*/, '')
+    end
+
+    def self.response_attributes
+      %w[country_code country_name region_name city_name latitude longitude
+        zip_code time_zone isp domain net_speed idd_code area_code usage_type
+        weather_station_code weather_station_name mcc mnc mobile_brand elevation]
+    end
+
+    response_attributes.each do |attr|
+      define_method attr do
+        @data[attr] || ""
+      end
+    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/ipdata_co.rb

@@ -0,0 +1,40 @@
+require 'geocoder/results/base'
+
+module Geocoder::Result
+  class IpdataCo < Base
+
+    def city
+      @data['city']
+    end
+
+    def state
+      @data['region']
+    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['postal']
+    end
+
+    def self.response_attributes
+      %w[ip asn organisation currency currency_symbol calling_code flag time_zone is_eu]
+    end
+
+    response_attributes.each do |a|
+      define_method a do
+        @data[a]
+      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'].to_s.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

data/lib/geocoder/results/ipstack.rb

@@ -0,0 +1,60 @@
+require 'geocoder/results/base'
+
+module Geocoder::Result
+  class Ipstack < Base
+
+    def address(format = :full)
+      s = region_code.empty? ? "" : ", #{region_code}"
+      "#{city}#{s} #{zip}, #{country_name}".sub(/^[ ,]*/, "")
+    end
+
+    def state
+      @data['region_name']
+    end
+
+    def state_code
+      @data['region_code']
+    end
+
+    def country
+      @data['country_name']
+    end
+
+    def postal_code
+      @data['zip'] || @data['zipcode'] || @data['zip_code']
+    end
+
+    def self.response_attributes
+      [
+        ['ip', ''],
+        ['hostname', ''],
+        ['continent_code', ''],
+        ['continent_name', ''],
+        ['country_code', ''],
+        ['country_name', ''],
+        ['region_code', ''],
+        ['region_name', ''],
+        ['city', ''],
+        ['zip', ''],
+        ['latitude', 0],
+        ['longitude', 0],
+        ['location', {}],
+        ['time_zone', {}],
+        ['currency', {}],
+        ['connection', {}],
+        ['security', {}],
+      ]
+    end
+
+    response_attributes.each do |attr, default|
+      define_method attr do
+        @data[attr] || default
+      end
+    end
+
+    def metro_code
+      Geocoder.log(:warn, "Ipstack does not implement `metro_code` in api results.  Please discontinue use.")
+      0 # no longer implemented by ipstack
+    end
+  end
+end

data/lib/geocoder/results/latlon.rb

@@ -0,0 +1,71 @@
+require 'geocoder/results/base'
+
+module Geocoder::Result
+  class Latlon < Base
+
+    def city
+      address_components["city"]
+    end
+
+    def coordinates
+      [@data['lat'].to_f, @data['lon'].to_f]
+    end
+
+    def country
+      "United States" # LatLon.io only supports the US
+    end
+
+    def country_code
+      "US" # LatLon.io only supports the US
+    end
+
+    def formatted_address(format = :full)
+      address_components["address"]
+    end
+    alias_method :address, :formatted_address
+
+    def number
+      address_components["number"]
+    end
+
+    def prefix
+      address_components["prefix"]
+    end
+
+    def state
+      address_components["state"]
+    end
+    alias_method :state_code, :state
+
+    def street
+      [street_name, street_type].compact.join(' ')
+    end
+
+    def street_name
+      address_components["street_name"]
+    end
+
+    def street_type
+      address_components["street_type"]
+    end
+
+    def suffix
+      address_components["suffix"]
+    end
+
+    def unit
+      address_components["unit"]
+    end
+
+    def zip
+      address_components["zip"]
+    end
+    alias_method :postal_code, :zip
+
+    private
+
+    def address_components
+      @data["address"] || {}
+    end
+  end
+end

data/lib/geocoder/results/location_iq.rb

@@ -0,0 +1,6 @@
+require 'geocoder/results/nominatim'
+
+module Geocoder::Result
+  class LocationIq < Nominatim
+  end
+end

data/lib/geocoder/results/mapbox.rb

@@ -0,0 +1,57 @@
+require 'geocoder/results/base'
+
+module Geocoder::Result
+  class Mapbox < Base
+
+    def coordinates
+      data['geometry']['coordinates'].reverse.map(&:to_f)
+    end
+
+    def place_name
+      data['text']
+    end
+
+    def street
+      data['properties']['address']
+    end
+
+    def city
+      context_part('place')
+    end
+
+    def state
+      context_part('region')
+    end
+
+    alias_method :state_code, :state
+
+    def postal_code
+      context_part('postcode')
+    end
+
+    def country
+      context_part('country')
+    end
+
+    alias_method :country_code, :country
+
+    def neighborhood
+      context_part('neighborhood')
+    end
+
+    def address
+      [place_name, street, city, state, postal_code, country].compact.join(', ')
+    end
+
+    private
+
+    def context_part(name)
+      context.map { |c| c['text'] if c['id'] =~ Regexp.new(name) }.compact.first
+    end
+
+    def context
+      Array(data['context'])
+    end
+  end
+end
+

data/lib/geocoder/results/mapquest.rb

@@ -0,0 +1,48 @@
+require 'geocoder/results/base'
+
+module Geocoder::Result
+  class Mapquest < Base
+
+    def coordinates
+      %w[lat lng].map{ |l| @data["latLng"][l] }
+    end
+
+    def city
+      @data['adminArea5']
+    end
+
+    def street
+      @data['street']
+    end
+
+    def state
+      @data['adminArea3']
+    end
+
+    def county
+      @data['adminArea4']
+    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/geocoder/results/maxmind.rb

@@ -0,0 +1,130 @@
+require 'geocoder/results/base'
+
+module Geocoder::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/geocoder/issues/396)
+      Geocoder.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 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