really-broken-geocoder 1.5.1

data/lib/geocoder/lookups/bing.rb

@@ -0,0 +1,82 @@
+require 'geocoder/lookups/base'
+require "geocoder/results/bing"
+
+module Geocoder::Lookup
+  class Bing < Base
+
+    def name
+      "Bing"
+    end
+
+    def map_link_url(coordinates)
+      "http://www.bing.com/maps/default.aspx?cp=#{coordinates.join('~')}"
+    end
+
+    def required_api_key_parts
+      ["key"]
+    end
+
+    private # ---------------------------------------------------------------
+
+    def base_query_url(query)
+      text = CGI.escape(query.sanitized_text.strip)
+      url = "#{protocol}://dev.virtualearth.net/REST/v1/Locations/"
+      if query.reverse_geocode?
+        url + "#{text}?"
+      else
+        if r = query.options[:region]
+          url << "#{r}/"
+        end
+        # use the more forgiving 'unstructured' query format to allow special
+        # chars, newlines, brackets, typos.
+        url + "?q=#{text}&"
+      end
+    end
+
+    def results(query)
+      return [] unless doc = fetch_data(query)
+
+      if doc['statusCode'] == 200
+        return doc['resourceSets'].first['estimatedTotal'] > 0 ? doc['resourceSets'].first['resources'] : []
+      elsif doc['statusCode'] == 401 and doc["authenticationResultCode"] == "InvalidCredentials"
+        raise_error(Geocoder::InvalidApiKey) || Geocoder.log(:warn, "Invalid Bing API key.")
+      elsif doc['statusCode'] == 403
+        raise_error(Geocoder::RequestDenied) || Geocoder.log(:warn, "Bing Geocoding API error: Forbidden Request")
+      elsif [500, 503].include?(doc['statusCode'])
+        raise_error(Geocoder::ServiceUnavailable) ||
+          Geocoder.log(:warn, "Bing Geocoding API error: Service Unavailable")
+      else
+        Geocoder.log(:warn, "Bing Geocoding API error: #{doc['statusCode']} (#{doc['statusDescription']}).")
+      end
+      return []
+    end
+
+    def query_url_params(query)
+      {
+        key: configuration.api_key,
+        language: (query.language || configuration.language)
+      }.merge(super)
+    end
+
+    def check_response_for_errors!(response)
+      super
+      if server_overloaded?(response)
+        raise_error(Geocoder::ServiceUnavailable) ||
+          Geocoder.log(:warn, "Bing Geocoding API error: Service Unavailable")
+      end
+    end
+
+    def valid_response?(response)
+      super(response) and not server_overloaded?(response)
+    end
+
+    def server_overloaded?(response)
+      # Occasionally, the servers processing service requests can be overloaded,
+      # and you may receive some responses that contain no results for queries that
+      # you would normally receive a result. To identify this situation,
+      # check the HTTP headers of the response. If the HTTP header X-MS-BM-WS-INFO is set to 1,
+      # it is best to wait a few seconds and try again.
+      response['x-ms-bm-ws-info'].to_i == 1
+    end
+  end
+end

data/lib/geocoder/lookups/db_ip_com.rb

@@ -0,0 +1,52 @@
+require 'geocoder/lookups/base'
+require 'geocoder/results/db_ip_com'
+
+module Geocoder::Lookup
+  class DbIpCom < Base
+
+    def name
+      'DB-IP.com'
+    end
+
+    def supported_protocols
+      [:https, :http]
+    end
+
+    def required_api_key_parts
+      ['api_key']
+    end
+
+    private # ----------------------------------------------------------------
+
+    def base_query_url(query)
+      "#{protocol}://api.db-ip.com/v2/#{configuration.api_key}/#{query.sanitized_text}?"
+    end
+
+    ##
+    # Same as query_url but without the api key.
+    #
+    def cache_key(query)
+      "#{protocol}://api.db-ip.com/v2/#{query.sanitized_text}?" + hash_to_query(cache_key_params(query))
+    end
+
+    def results(query)
+      return [] unless (doc = fetch_data(query))
+
+      case doc['error']
+      when 'maximum number of queries per day exceeded'
+        raise_error Geocoder::OverQueryLimitError ||
+                    Geocoder.log(:warn, 'DB-API query limit exceeded.')
+
+      when 'invalid API key'
+        raise_error Geocoder::InvalidApiKey ||
+                    Geocoder.log(:warn, 'Invalid DB-IP API key.')
+      when nil
+        [doc]
+
+      else
+        raise_error Geocoder::Error ||
+                    Geocoder.log(:warn, "Request failed: #{doc['error']}")
+      end
+    end
+  end
+end

data/lib/geocoder/lookups/dstk.rb

@@ -0,0 +1,22 @@
+# More information about the Data Science Toolkit can be found at:
+# http://www.datasciencetoolkit.org/. The provided APIs mimic the
+# Google geocoding api.
+
+require 'geocoder/lookups/google'
+require 'geocoder/results/dstk'
+
+module Geocoder::Lookup
+  class Dstk < Google
+
+    def name
+      "Data Science Toolkit"
+    end
+
+    private # ----------------------------------------------------------------
+
+    def base_query_url(query)
+      host = configuration[:host] || "www.datasciencetoolkit.org"
+      "#{protocol}://#{host}/maps/api/geocode/json?"
+    end
+  end
+end

data/lib/geocoder/lookups/esri.rb

@@ -0,0 +1,95 @@
+require 'geocoder/lookups/base'
+require "geocoder/results/esri"
+require 'geocoder/esri_token'
+
+module Geocoder::Lookup
+  class Esri < Base
+
+    def name
+      "Esri"
+    end
+
+    private # ---------------------------------------------------------------
+
+    def base_query_url(query)
+      action = query.reverse_geocode? ? "reverseGeocode" : "find"
+      "#{protocol}://geocode.arcgis.com/arcgis/rest/services/World/GeocodeServer/#{action}?"
+    end
+
+    def results(query)
+      return [] unless doc = fetch_data(query)
+
+      if (!query.reverse_geocode?)
+        return [] if !doc['locations'] || doc['locations'].empty?
+      end
+
+      if (doc['error'].nil?)
+        return [ doc ]
+      else
+        return []
+      end
+    end
+
+    def query_url_params(query)
+      params = {
+        :f => "pjson",
+        :outFields => "*"
+      }
+      if query.reverse_geocode?
+        params[:location] = query.coordinates.reverse.join(',')
+      else
+        params[:text] = query.sanitized_text
+      end
+
+      params[:token] = token(query)
+
+      if for_storage_value = for_storage(query)
+        params[:forStorage] = for_storage_value
+      end
+      params[:sourceCountry] = configuration[:source_country] if configuration[:source_country]
+      params.merge(super)
+    end
+
+    def for_storage(query)
+      if query.options.has_key?(:for_storage)
+        query.options[:for_storage]
+      else
+        configuration[:for_storage]
+      end
+    end
+
+    def token(query)
+      token_instance = if query.options[:token]
+                         query.options[:token]
+                       else
+                         configuration[:token]
+                       end
+
+      if !valid_token_configured?(token_instance) && configuration.api_key
+        token_instance = create_and_save_token!(query)
+      end
+
+      token_instance.to_s unless token_instance.nil?
+    end
+
+    def valid_token_configured?(token_instance)
+      !token_instance.nil? && token_instance.active?
+    end
+
+    def create_and_save_token!(query)
+      token_instance = create_token
+
+      if query.options[:token]
+        query.options[:token] = token_instance
+      else
+        Geocoder.merge_into_lookup_config(:esri, token: token_instance)
+      end
+
+      token_instance
+    end
+
+    def create_token
+      Geocoder::EsriToken.generate_token(*configuration.api_key)
+    end
+  end
+end

data/lib/geocoder/lookups/freegeoip.rb

@@ -0,0 +1,60 @@
+require 'geocoder/lookups/base'
+require 'geocoder/results/freegeoip'
+
+module Geocoder::Lookup
+  class Freegeoip < Base
+
+    def name
+      "FreeGeoIP"
+    end
+
+    def supported_protocols
+      if configuration[:host]
+        [:http, :https]
+      else
+        # use https for default host
+        [:https]
+      end
+    end
+
+    def query_url(query)
+      "#{protocol}://#{host}/json/#{query.sanitized_text}"
+    end
+
+    private # ---------------------------------------------------------------
+
+    def cache_key(query)
+      query_url(query)
+    end
+
+    def parse_raw_data(raw_data)
+      raw_data.match(/^<html><title>404/) ? nil : super(raw_data)
+    end
+
+    def results(query)
+      # don't look up a loopback or private address, just return the stored result
+      return [reserved_result(query.text)] if query.internal_ip_address?
+      # note: Freegeoip.net returns plain text "Not Found" on bad request
+      (doc = fetch_data(query)) ? [doc] : []
+    end
+
+    def reserved_result(ip)
+      {
+        "ip"           => ip,
+        "city"         => "",
+        "region_code"  => "",
+        "region_name"  => "",
+        "metrocode"    => "",
+        "zipcode"      => "",
+        "latitude"     => "0",
+        "longitude"    => "0",
+        "country_name" => "Reserved",
+        "country_code" => "RD"
+      }
+    end
+
+    def host
+      configuration[:host] || "freegeoip.net"
+    end
+  end
+end

data/lib/geocoder/lookups/geocoder_ca.rb

@@ -0,0 +1,53 @@
+require 'geocoder/lookups/base'
+require "geocoder/results/geocoder_ca"
+
+module Geocoder::Lookup
+  class GeocoderCa < Base
+
+    def name
+      "Geocoder.ca"
+    end
+
+    private # ---------------------------------------------------------------
+
+    def base_query_url(query)
+      "#{protocol}://geocoder.ca/?"
+    end
+
+    def results(query)
+      return [] unless doc = fetch_data(query)
+      if doc['error'].nil?
+        return [doc]
+      elsif doc['error']['code'] == "005"
+        # "Postal Code is not in the proper Format" => no results, just shut up
+      else
+        Geocoder.log(:warn, "Geocoder.ca service error: #{doc['error']['code']} (#{doc['error']['description']}).")
+      end
+      return []
+    end
+
+    def query_url_params(query)
+      params = {
+        :geoit    => "xml",
+        :jsonp    => 1,
+        :callback => "test",
+        :auth     => configuration.api_key
+      }.merge(super)
+      if query.reverse_geocode?
+        lat,lon = query.coordinates
+        params[:latt] = lat
+        params[:longt] = lon
+        params[:corner] = 1
+        params[:reverse] = 1
+      else
+        params[:locate] = query.sanitized_text
+        params[:showpostal] = 1
+      end
+      params
+    end
+
+    def parse_raw_data(raw_data)
+      super raw_data[/^test\((.*)\)\;\s*$/, 1]
+    end
+  end
+end

data/lib/geocoder/lookups/geocoder_us.rb

@@ -0,0 +1,51 @@
+require 'geocoder/lookups/base'
+require "geocoder/results/geocoder_us"
+
+module Geocoder::Lookup
+  class GeocoderUs < Base
+
+    def name
+      "Geocoder.us"
+    end
+
+    def supported_protocols
+      [:http]
+    end
+
+    private # ----------------------------------------------------------------
+
+    def base_query_url(query)
+      base_query_url_with_optional_key(configuration.api_key)
+    end
+
+    def cache_key(query)
+      base_query_url_with_optional_key(nil) + url_query_string(query)
+    end
+
+    def base_query_url_with_optional_key(key = nil)
+      base = "#{protocol}://"
+      if configuration.api_key
+        base << "#{configuration.api_key}@"
+      end
+      base + "geocoder.us/member/service/csv/geocode?"
+    end
+
+    def results(query)
+      return [] unless doc = fetch_data(query)
+      if doc[0].to_s =~ /^(\d+)\:/
+        return []
+      else
+        return [doc.size == 5 ? ((doc[0..1] << nil) + doc[2..4]) : doc]
+      end
+    end
+
+    def query_url_params(query)
+      (query.text =~ /^\d{5}(?:-\d{4})?$/ ? {:zip => query} : {:address => query.sanitized_text}).merge(super)
+    end
+
+    def parse_raw_data(raw_data)
+      raw_data.chomp.split(',')
+    end
+  end
+end
+

data/lib/geocoder/lookups/geocodio.rb

@@ -0,0 +1,42 @@
+require 'geocoder/lookups/base'
+require "geocoder/results/geocodio"
+
+module Geocoder::Lookup
+  class Geocodio < Base
+
+    def name
+      "Geocodio"
+    end
+
+    def results(query)
+      return [] unless doc = fetch_data(query)
+      return doc["results"] if doc['error'].nil?
+      
+      if doc['error'] == 'Invalid API key'
+        raise_error(Geocoder::InvalidApiKey) ||
+          Geocoder.log(:warn, "Geocodio service error: invalid API key.")
+      elsif doc['error'].match(/You have reached your daily maximum/)
+        raise_error(Geocoder::OverQueryLimitError, doc['error']) ||
+          Geocoder.log(:warn, "Geocodio service error: #{doc['error']}.")
+      else
+        raise_error(Geocoder::InvalidRequest, doc['error']) ||
+          Geocoder.log(:warn, "Geocodio service error: #{doc['error']}.")
+      end
+      []
+    end
+
+    private # ---------------------------------------------------------------
+
+    def base_query_url(query)
+      path = query.reverse_geocode? ? "reverse" : "geocode"
+      "#{protocol}://api.geocod.io/v1.3/#{path}?"
+    end
+
+    def query_url_params(query)
+      {
+        :api_key => configuration.api_key,
+        :q => query.sanitized_text
+      }.merge(super)
+    end
+  end
+end