really-broken-geocoder 1.5.1

data/lib/geocoder/lookups/pointpin.rb

@@ -0,0 +1,69 @@
+require 'geocoder/lookups/base'
+require 'geocoder/results/pointpin'
+
+module Geocoder::Lookup
+  class Pointpin < Base
+
+    def name
+      "Pointpin"
+    end
+
+    def required_api_key_parts
+      ["key"]
+    end
+
+    def query_url(query)
+      "#{protocol}://geo.pointp.in/#{configuration.api_key}/json/#{query.sanitized_text}"
+    end
+
+    private # ----------------------------------------------------------------
+
+    def cache_key(query)
+      "#{protocol}://geo.pointp.in/json/#{query.sanitized_text}"
+    end
+
+    def results(query)
+      # don't look up a loopback or private address, just return the stored result
+      return [] if query.internal_ip_address?
+      doc = fetch_data(query)
+      if doc and doc.is_a?(Hash)
+        if !data_contains_error?(doc)
+          return [doc]
+        elsif doc['error']
+          case doc['error']
+          when "Invalid IP address"
+            raise_error(Geocoder::InvalidRequest) || Geocoder.log(:warn, "Invalid Pointpin request.")
+          when "Invalid API key"
+            raise_error(Geocoder::InvalidApiKey) || Geocoder.log(:warn, "Invalid Pointpin API key.")
+          when "Address not found"
+            Geocoder.log(:warn, "Address not found.")
+          end
+        else
+          raise_error(Geocoder::Error) || Geocoder.log(:warn, "Pointpin server error")
+        end
+      end
+
+      return []
+    end
+
+    def data_contains_error?(parsed_data)
+      parsed_data.keys.include?('error')
+    end
+
+    # TODO: replace this hash with what's actually returned by Pointpin
+    def reserved_result(ip)
+      {
+        "ip"           => ip,
+        "city"         => "",
+        "region_code"  => "",
+        "region_name"  => "",
+        "metrocode"    => "",
+        "zipcode"      => "",
+        "latitude"     => "0",
+        "longitude"    => "0",
+        "country_name" => "Reserved",
+        "country_code" => "RD"
+      }
+    end
+  end
+end

data/lib/geocoder/lookups/postcode_anywhere_uk.rb

@@ -0,0 +1,50 @@
+require 'geocoder/lookups/base'
+require 'geocoder/results/postcode_anywhere_uk'
+
+module Geocoder::Lookup
+  class PostcodeAnywhereUk < Base
+    # API documentation: http://www.postcodeanywhere.co.uk/Support/WebService/Geocoding/UK/Geocode/2/
+    DAILY_LIMIT_EXEEDED_ERROR_CODES = ['8', '17'] # api docs say these two codes are the same error
+    INVALID_API_KEY_ERROR_CODE = '2'
+
+    def name
+      'PostcodeAnywhereUk'
+    end
+
+    def required_api_key_parts
+      %w(key)
+    end
+
+    private # ----------------------------------------------------------------
+
+    def base_query_url(query)
+      "#{protocol}://services.postcodeanywhere.co.uk/Geocoding/UK/Geocode/v2.00/json.ws?"
+    end
+
+    def results(query)
+      response = fetch_data(query)
+      return [] if response.nil? || !response.is_a?(Array) || response.empty?
+
+      raise_exception_for_response(response[0]) if response[0]['Error']
+      response
+    end
+
+    def raise_exception_for_response(response)
+      case response['Error']
+      when *DAILY_LIMIT_EXEEDED_ERROR_CODES
+        raise_error(Geocoder::OverQueryLimitError, response['Cause']) || Geocoder.log(:warn, response['Cause'])
+      when INVALID_API_KEY_ERROR_CODE
+        raise_error(Geocoder::InvalidApiKey, response['Cause']) || Geocoder.log(:warn, response['Cause'])
+      else # anything else just raise general error with the api cause
+        raise_error(Geocoder::Error, response['Cause']) || Geocoder.log(:warn, response['Cause'])
+      end
+    end
+
+    def query_url_params(query)
+      {
+        :location => query.sanitized_text,
+        :key => configuration.api_key
+      }.merge(super)
+    end
+  end
+end

data/lib/geocoder/lookups/postcodes_io.rb

@@ -0,0 +1,31 @@
+require 'geocoder/lookups/base'
+require 'geocoder/results/postcodes_io'
+
+module Geocoder::Lookup
+  class PostcodesIo < Base
+    def name
+      'Postcodes.io'
+    end
+
+    def query_url(query)
+      "#{protocol}://api.postcodes.io/postcodes/#{query.sanitized_text.gsub(/\s/, '')}"
+    end
+
+    def supported_protocols
+      [:https]
+    end
+
+    private # ----------------------------------------------------------------
+
+    def cache_key(query)
+      query_url(query)
+    end
+
+    def results(query)
+      response = fetch_data(query)
+      return [] if response.nil? || response['status'] != 200 || response.empty?
+
+      [response['result']]
+    end
+  end
+end

data/lib/geocoder/lookups/smarty_streets.rb

@@ -0,0 +1,63 @@
+require 'geocoder/lookups/base'
+require 'geocoder/results/smarty_streets'
+
+module Geocoder::Lookup
+  class SmartyStreets < Base
+    def name
+      "SmartyStreets"
+    end
+
+    def required_api_key_parts
+      %w(auth-id auth-token)
+    end
+
+    # required by API as of 26 March 2015
+    def supported_protocols
+      [:https]
+    end
+
+    private # ---------------------------------------------------------------
+
+    def base_query_url(query)
+      if international?(query)
+        "#{protocol}://international-street.api.smartystreets.com/verify?"
+      elsif zipcode_only?(query)
+        "#{protocol}://us-zipcode.api.smartystreets.com/lookup?"
+      else
+        "#{protocol}://us-street.api.smartystreets.com/street-address?"
+      end
+    end
+
+    def zipcode_only?(query)
+      !query.text.is_a?(Array) and query.to_s.strip =~ /\A\d{5}(-\d{4})?\Z/
+    end
+
+    def international?(query)
+      !query.options[:country].nil?
+    end
+
+    def query_url_params(query)
+      params = {}
+      if international?(query)
+        params[:freeform] = query.sanitized_text
+        params[:country] = query.options[:country]
+        params[:geocode] = true
+      elsif zipcode_only?(query)
+        params[:zipcode] = query.sanitized_text
+      else
+        params[:street] = query.sanitized_text
+      end
+      if configuration.api_key.is_a?(Array)
+        params[:"auth-id"] = configuration.api_key[0]
+        params[:"auth-token"] = configuration.api_key[1]
+      else
+        params[:"auth-token"] = configuration.api_key
+      end
+      params.merge(super)
+    end
+
+    def results(query)
+      fetch_data(query) || []
+    end
+  end
+end

data/lib/geocoder/lookups/telize.rb

@@ -0,0 +1,75 @@
+require 'geocoder/lookups/base'
+require 'geocoder/results/telize'
+
+module Geocoder::Lookup
+  class Telize < Base
+
+    def name
+      "Telize"
+    end
+
+    def required_api_key_parts
+      configuration[:host] ? [] : ["key"]
+    end
+
+    def query_url(query)
+      if configuration[:host]
+        "#{protocol}://#{configuration[:host]}/location/#{query.sanitized_text}"
+      else
+        "#{protocol}://telize-v1.p.mashape.com/location/#{query.sanitized_text}?mashape-key=#{api_key}"
+      end
+    end
+
+    def supported_protocols
+      [].tap do |array|
+        array << :https
+        array << :http if configuration[:host]
+      end
+    end
+
+    private # ---------------------------------------------------------------
+
+    def cache_key(query)
+      query_url(query)[/(.*)\?.*/, 1]
+    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?
+      if (doc = fetch_data(query)).nil? or doc['code'] == 401 or empty_result?(doc)
+        []
+      else
+        [doc]
+      end
+    end
+
+    def empty_result?(doc)
+      !doc.is_a?(Hash) or doc.keys == ["ip"]
+    end
+
+    def reserved_result(ip)
+      {
+        "ip" => ip,
+        "latitude" => 0,
+        "longitude" => 0,
+        "city" => "",
+        "timezone" => "",
+        "asn" => 0,
+        "region" => "",
+        "offset" => 0,
+        "organization" => "",
+        "country_code" => "",
+        "country_code3" => "",
+        "postal_code" => "",
+        "continent_code" => "",
+        "country" => "",
+        "region_code" => ""
+      }
+    end
+
+    def api_key
+      configuration.api_key
+    end
+
+  end
+end

data/lib/geocoder/lookups/tencent.rb

@@ -0,0 +1,59 @@
+require 'geocoder/lookups/base'
+require "geocoder/results/tencent"
+
+module Geocoder::Lookup
+  class Tencent < Base
+
+    def name
+      "Tencent"
+    end
+
+    def required_api_key_parts
+      ["key"]
+    end
+
+    def supported_protocols
+      [:https]
+    end
+
+    private # ---------------------------------------------------------------
+
+    def base_query_url(query)
+      "#{protocol}://apis.map.qq.com/ws/geocoder/v1/?"
+    end
+
+    def content_key
+      'result'
+    end
+
+    def results(query, reverse = false)
+      return [] unless doc = fetch_data(query)
+      case doc['status']
+      when 0
+        return [doc[content_key]]
+      when 199
+        raise error(Geocoder::InvalidApiKey, "invalid api key") ||
+        Geocoder.log(:warn, "#{name} Geocoding API error: key is not enabled for web service usage.")
+      when 311
+        raise_error(Geocoder::RequestDenied, "request denied") ||
+          Geocoder.log(:warn, "#{name} Geocoding API error: request denied.")
+      when 310, 306
+        raise_error(Geocoder::InvalidRequest, "invalid request.") ||
+          Geocoder.log(:warn, "#{name} Geocoding API error: invalid request.")
+      when 311
+        raise_error(Geocoder::InvalidApiKey, "invalid api key") ||
+          Geocoder.log(:warn, "#{name} Geocoding API error: invalid api key.")
+      end
+      return []
+    end
+
+    def query_url_params(query)
+      {
+        (query.reverse_geocode? ? :location : :address) => query.sanitized_text,
+        :key => configuration.api_key,
+        :output => "json"
+      }.merge(super)
+    end
+
+  end
+end

data/lib/geocoder/lookups/test.rb

@@ -0,0 +1,44 @@
+require 'geocoder/lookups/base'
+require 'geocoder/results/test'
+
+module Geocoder
+  module Lookup
+    class Test < Base
+
+      def name
+        "Test"
+      end
+
+      def self.add_stub(query_text, results)
+        stubs[query_text] = results
+      end
+
+      def self.set_default_stub(results)
+        @default_stub = results
+      end
+
+      def self.read_stub(query_text)
+        stubs.fetch(query_text) {
+          return @default_stub unless @default_stub.nil?
+          raise ArgumentError, "unknown stub request #{query_text}"
+        }
+      end
+
+      def self.stubs
+        @stubs ||= {}
+      end
+
+      def self.reset
+        @stubs = {}
+        @default_stub = nil
+      end
+
+      private
+
+      def results(query)
+        Geocoder::Lookup::Test.read_stub(query.text)
+      end
+
+    end
+  end
+end

data/lib/geocoder/lookups/yandex.rb

@@ -0,0 +1,62 @@
+require 'geocoder/lookups/base'
+require "geocoder/results/yandex"
+
+module Geocoder::Lookup
+  class Yandex < Base
+
+    def name
+      "Yandex"
+    end
+
+    def map_link_url(coordinates)
+      "http://maps.yandex.ru/?ll=#{coordinates.reverse.join(',')}"
+    end
+
+    def supported_protocols
+      [:https]
+    end
+
+    private # ---------------------------------------------------------------
+
+    def base_query_url(query)
+      "#{protocol}://geocode-maps.yandex.ru/1.x/?"
+    end
+
+    def results(query)
+      return [] unless doc = fetch_data(query)
+      if err = doc['error']
+        if err["status"] == 401 and err["message"] == "invalid key"
+          raise_error(Geocoder::InvalidApiKey) || Geocoder.log(:warn, "Invalid API key.")
+        else
+          Geocoder.log(:warn, "Yandex Geocoding API error: #{err['status']} (#{err['message']}).")
+        end
+        return []
+      end
+      if doc = doc['response']['GeoObjectCollection']
+        meta = doc['metaDataProperty']['GeocoderResponseMetaData']
+        return meta['found'].to_i > 0 ? doc['featureMember'] : []
+      else
+        Geocoder.log(:warn, "Yandex Geocoding API error: unexpected response format.")
+        return []
+      end
+    end
+
+    def query_url_params(query)
+      if query.reverse_geocode?
+        q = query.coordinates.reverse.join(",")
+      else
+        q = query.sanitized_text
+      end
+      params = {
+        :geocode => q,
+        :format => "json",
+        :plng => "#{query.language || configuration.language}", # supports ru, uk, be
+        :key => configuration.api_key
+      }
+      unless (bounds = query.options[:bounds]).nil?
+        params[:bbox] = bounds.map{ |point| "%f,%f" % point }.join('~')
+      end
+      params.merge(super)
+    end
+  end
+end