ultra-fast-mod 0.0.1

data/geocoder-1.8.6/lib/geocoder/esri_token.rb

@@ -0,0 +1,38 @@
+module Geocoder
+  class EsriToken
+    attr_accessor :value, :expires_at
+
+    def initialize(value, expires_at)
+      @value = value
+      @expires_at = expires_at
+    end
+
+    def to_s
+        @value
+    end
+
+    def active?
+      @expires_at > Time.now
+    end
+
+    def self.generate_token(client_id, client_secret, expires=1440)
+      # creates a new token that will expire in 1 day by default
+      getToken = Net::HTTP.post_form URI('https://www.arcgis.com/sharing/rest/oauth2/token'),
+        f: 'json',
+        client_id: client_id,
+        client_secret: client_secret,
+        grant_type: 'client_credentials',
+        expiration: expires # (minutes) max: 20160, default: 1 day
+
+      response = JSON.parse(getToken.body)
+
+      if response['error']
+        Geocoder.log(:warn, response['error'])
+      else
+        token_value = response['access_token']
+        expires_at = Time.now + (expires * 60)
+        new(token_value, expires_at)
+      end
+    end
+  end
+end

data/geocoder-1.8.6/lib/geocoder/exceptions.rb

@@ -0,0 +1,40 @@
+require 'timeout'
+
+module Geocoder
+
+  class Error < StandardError
+  end
+
+  class ConfigurationError < Error
+  end
+
+  class OverQueryLimitError < Error
+  end
+
+  class ResponseParseError < Error
+    attr_reader :response
+
+    def initialize(response)
+      @response = response
+    end
+  end
+
+  class RequestDenied < Error
+  end
+
+  class InvalidRequest < Error
+  end
+
+  class InvalidApiKey < Error
+  end
+
+  class ServiceUnavailable < Error
+  end
+
+  class LookupTimeout < ::Timeout::Error
+  end
+
+  class NetworkError < Error
+  end
+
+end

data/geocoder-1.8.6/lib/geocoder/ip_address.rb

@@ -0,0 +1,36 @@
+require 'resolv'
+module Geocoder
+  class IpAddress < String
+    PRIVATE_IPS = [
+      '10.0.0.0/8',
+      '172.16.0.0/12',
+      '192.168.0.0/16',
+    ].map { |ip| IPAddr.new(ip) }.freeze
+
+    def initialize(ip)
+      ip = ip.to_string if ip.is_a?(IPAddr)
+      if ip.is_a?(Hash)
+        super(**ip)
+      else
+        super(ip)
+      end
+    end
+
+    def internal?
+      loopback? || private?
+    end
+
+    def loopback?
+      valid? and !!(self == "0.0.0.0" or self.match(/\A127\./) or self == "::1")
+    end
+
+    def private?
+      valid? && PRIVATE_IPS.any? { |ip| ip.include?(self) }
+    end
+
+    def valid?
+      ip = self[/(?<=\[)(.*?)(?=\])/] || self
+      !!((ip =~ Resolv::IPv4::Regex) || (ip =~ Resolv::IPv6::Regex))
+    end
+  end
+end

data/geocoder-1.8.6/lib/geocoder/kernel_logger.rb

@@ -0,0 +1,25 @@
+module Geocoder
+  class KernelLogger
+    include Singleton
+
+    def add(level, message)
+      return unless log_message_at_level?(level)
+      case level
+        when ::Logger::DEBUG, ::Logger::INFO
+          puts message
+        when ::Logger::WARN
+          warn message
+        when ::Logger::ERROR
+          raise message
+        when ::Logger::FATAL
+          fail message
+      end
+    end
+
+    private # ----------------------------------------------------------------
+
+    def log_message_at_level?(level)
+      level >= Geocoder.config.kernel_logger_level
+    end
+  end
+end

data/geocoder-1.8.6/lib/geocoder/logger.rb

@@ -0,0 +1,47 @@
+require 'logger'
+
+module Geocoder
+
+  def self.log(level, message)
+    Logger.instance.log(level, message)
+  end
+
+  class Logger
+    include Singleton
+
+    SEVERITY = {
+      debug: ::Logger::DEBUG,
+      info: ::Logger::INFO,
+      warn: ::Logger::WARN,
+      error: ::Logger::ERROR,
+      fatal: ::Logger::FATAL
+    }
+
+    def log(level, message)
+      unless valid_level?(level)
+        raise StandardError, "Geocoder tried to log a message with an invalid log level."
+      end
+      if current_logger.respond_to? :add
+        current_logger.add(SEVERITY[level], message)
+      else
+        raise Geocoder::ConfigurationError, "Please specify valid logger for Geocoder. " +
+        "Logger specified must be :kernel or must respond to `add(level, message)`."
+      end
+      nil
+    end
+
+    private # ----------------------------------------------------------------
+
+    def current_logger
+      logger = Geocoder.config[:logger]
+      if logger == :kernel
+        logger = Geocoder::KernelLogger.instance
+      end
+      logger
+    end
+
+    def valid_level?(level)
+      SEVERITY.keys.include?(level)
+    end
+  end
+end

data/geocoder-1.8.6/lib/geocoder/lookup.rb

@@ -0,0 +1,155 @@
+require "geocoder/lookups/test"
+
+module Geocoder
+  module Lookup
+    extend self
+
+    ##
+    # Array of valid Lookup service names.
+    #
+    def all_services
+      street_services + ip_services
+    end
+
+    ##
+    # Array of valid Lookup service names, excluding :test.
+    #
+    def all_services_except_test
+      all_services - [:test]
+    end
+
+    ##
+    # Array of valid Lookup service names, excluding any that do not build their own HTTP requests.
+    # For example, Amazon Location Service uses the AWS gem, not HTTP REST requests, to fetch data.
+    #
+    def all_services_with_http_requests
+      all_services_except_test - [:amazon_location_service, :maxmind_local, :geoip2, :ip2location_lite]
+    end
+
+    ##
+    # All street address lookup services, default first.
+    #
+    def street_services
+      @street_services ||= [
+        :location_iq,
+        :azure,
+        :esri,
+        :google,
+        :google_premier,
+        :google_places_details,
+        :google_places_search,
+        :bing,
+        :geocoder_ca,
+        :yandex,
+        :nationaal_georegister_nl,
+        :nominatim,
+        :mapbox,
+        :mapquest,
+        :uk_ordnance_survey_names,
+        :opencagedata,
+        :pelias,
+        :pdok_nl,
+        :pickpoint,
+        :here,
+        :baidu,
+        :tencent,
+        :geocodio,
+        :smarty_streets,
+        :postcode_anywhere_uk,
+        :postcodes_io,
+        :geoportail_lu,
+        :ban_data_gouv_fr,
+        :test,
+        :latlon,
+        :amap,
+        :osmnames,
+        :melissa_street,
+        :amazon_location_service,
+        :geoapify,
+        :photon,
+        :twogis,
+        :pc_miler
+      ]
+    end
+
+    ##
+    # All IP address lookup services, default first.
+    #
+    def ip_services
+      @ip_services ||= [
+        :baidu_ip,
+        :abstract_api,
+        :freegeoip,
+        :geoip2,
+        :maxmind,
+        :maxmind_local,
+        :telize,
+        :pointpin,
+        :maxmind_geoip2,
+        :ipinfo_io,
+        :ipinfo_io_lite,
+        :ipregistry,
+        :ipapi_com,
+        :ipdata_co,
+        :db_ip_com,
+        :ipstack,
+        :ip2location,
+        :ipgeolocation,
+        :ipqualityscore,
+        :ipbase,
+        :ip2location_io,
+        :ip2location_lite
+      ]
+    end
+
+    attr_writer :street_services, :ip_services
+
+    ##
+    # Retrieve a Lookup object from the store.
+    # Use this instead of Geocoder::Lookup::X.new to get an
+    # already-configured Lookup object.
+    #
+    def get(name)
+      @services = {} unless defined?(@services)
+      @services[name] = spawn(name) unless @services.include?(name)
+      @services[name]
+    end
+
+
+    private # -----------------------------------------------------------------
+
+    ##
+    # Spawn a Lookup of the given name.
+    #
+    def spawn(name)
+      if all_services.include?(name)
+        name = name.to_s
+        instantiate_lookup(name)
+      else
+        valids = all_services.map(&:inspect).join(", ")
+        raise ConfigurationError, "Please specify a valid lookup for Geocoder " +
+          "(#{name.inspect} is not one of: #{valids})."
+      end
+    end
+
+    ##
+    # Convert an "underscore" version of a name into a "class" version.
+    #
+    def classify_name(filename)
+      filename.to_s.split("_").map{ |i| i[0...1].upcase + i[1..-1] }.join
+    end
+
+    ##
+    # Safely instantiate Lookup
+    #
+    def instantiate_lookup(name)
+      class_name = classify_name(name)
+      begin
+        Geocoder::Lookup.const_get(class_name, inherit=false)
+      rescue NameError
+        require "geocoder/lookups/#{name}"
+      end
+      Geocoder::Lookup.const_get(class_name).new
+    end
+  end
+end

data/geocoder-1.8.6/lib/geocoder/lookups/abstract_api.rb

@@ -0,0 +1,46 @@
+# encoding: utf-8
+
+require 'geocoder/lookups/base'
+require 'geocoder/results/abstract_api'
+
+module Geocoder::Lookup
+  class AbstractApi < Base
+
+    def name
+      "Abstract API"
+    end
+
+    def required_api_key_parts
+      ['api_key']
+    end
+
+    def supported_protocols
+      [:https]
+    end
+
+    private # ---------------------------------------------------------------
+
+    def base_query_url(query)
+      "#{protocol}://ipgeolocation.abstractapi.com/v1/?"
+    end
+
+    def query_url_params(query)
+      params = {api_key: configuration.api_key}
+
+      ip_address = query.sanitized_text
+      if ip_address.is_a?(String) && ip_address.length > 0
+        params[:ip_address] = ip_address
+      end
+
+      params.merge(super)
+    end
+
+    def results(query, reverse = false)
+      if doc = fetch_data(query)
+        [doc]
+      else
+        []
+      end
+    end
+  end
+end

data/geocoder-1.8.6/lib/geocoder/lookups/amap.rb

@@ -0,0 +1,63 @@
+require 'geocoder/lookups/base'
+require "geocoder/results/amap"
+
+module Geocoder::Lookup
+  class Amap < Base
+
+    def name
+      "AMap"
+    end
+
+    def required_api_key_parts
+      ["key"]
+    end
+
+    def supported_protocols
+      [:http]
+    end
+
+    private # ---------------------------------------------------------------
+
+    def base_query_url(query)
+      path = query.reverse_geocode? ? 'regeo' : 'geo'
+      "http://restapi.amap.com/v3/geocode/#{path}?"
+    end
+
+    def results(query, reverse = false)
+      return [] unless doc = fetch_data(query)
+      case [doc['status'], doc['info']]
+      when ['1', 'OK']
+        return doc['regeocodes'] unless doc['regeocodes'].blank?
+        return [doc['regeocode']] unless doc['regeocode'].blank?
+        return doc['geocodes'] unless doc['geocodes'].blank?
+      when ['0', 'INVALID_USER_KEY']
+        raise_error(Geocoder::InvalidApiKey, "invalid api key") ||
+          Geocoder.log(:warn, "#{self.name} Geocoding API error: invalid api key.")
+      else
+        raise_error(Geocoder::Error, "server error.") ||
+          Geocoder.log(:warn, "#{self.name} Geocoding API error: server error - [#{doc['info']}]")
+      end
+      return []
+    end
+
+    def query_url_params(query)
+      params = {
+        :key => configuration.api_key,
+        :output => "json"
+      }
+      if query.reverse_geocode?
+        params[:location] = revert_coordinates(query.text)
+        params[:extensions] = "all"
+        params[:coordsys] = "gps"
+      else
+        params[:address] = query.sanitized_text
+      end
+      params.merge(super)
+    end
+
+    def revert_coordinates(text)
+      [text[1],text[0]].join(",")
+    end
+
+  end
+end

data/geocoder-1.8.6/lib/geocoder/lookups/amazon_location_service.rb

@@ -0,0 +1,58 @@
+require 'geocoder/lookups/base'
+require 'geocoder/results/amazon_location_service'
+
+module Geocoder::Lookup
+  class AmazonLocationService < Base
+    def results(query)
+      params = query.options.dup
+
+      # index_name is required
+      # Aws::ParamValidator raises ArgumentError on missing required keys
+      params.merge!(index_name: configuration[:index_name])
+
+      # Aws::ParamValidator raises ArgumentError on unexpected keys
+      params.delete(:lookup)
+
+      # Inherit language from configuration
+      params.merge!(language: configuration[:language])
+
+      resp = if query.reverse_geocode?
+        client.search_place_index_for_position(params.merge(position: query.coordinates.reverse))
+      else
+        client.search_place_index_for_text(params.merge(text: query.text))
+      end
+
+      resp.results
+    end
+
+    private
+
+    def client
+      return @client if @client
+      require_sdk
+      keys = configuration.api_key
+      if keys
+        @client = Aws::LocationService::Client.new(**{
+          region: keys[:region],
+          access_key_id: keys[:access_key_id],
+          secret_access_key: keys[:secret_access_key]
+        }.compact)
+      else
+        @client = Aws::LocationService::Client.new
+      end
+    end
+
+    def require_sdk
+      begin
+        require 'aws-sdk-locationservice'
+      rescue LoadError
+        raise_error(Geocoder::ConfigurationError) ||
+          Geocoder.log(
+            :error,
+            "Couldn't load the Amazon Location Service SDK. " +
+            "Install it with: gem install aws-sdk-locationservice -v '~> 1.4'"
+          )
+      end
+    end
+  end
+end

data/geocoder-1.8.6/lib/geocoder/lookups/azure.rb

@@ -0,0 +1,56 @@
+require 'geocoder/lookups/base'
+require 'geocoder/results/azure'
+
+module Geocoder::Lookup
+  class Azure < Base
+    def name
+      'Azure'
+    end
+
+    def required_api_key_parts
+      ['api_key']
+    end
+
+    def supported_protocols
+      [:https]
+    end
+
+    private
+
+    def base_query_url(query)
+      host = 'atlas.microsoft.com/search/address'
+
+      if query.reverse_geocode?
+        "#{protocol}://#{host}/reverse/json?"
+      else
+        "#{protocol}://#{host}/json?"
+      end
+    end
+
+    def query_url_params(query)
+      params = {
+        'api-version' => 1.0,
+        'language' => query.options[:language] || 'en',
+        'limit' => configuration[:limit] || 10,
+        'query' => query.sanitized_text,
+        'subscription-key' => configuration.api_key
+      }
+
+      params.merge(super)
+    end
+
+    def results(query)
+      return [] unless (doc = fetch_data(query))
+
+      return doc if doc['error']
+
+      if doc['results']&.any?
+        doc['results']
+      elsif doc['addresses']&.any?
+        doc['addresses']
+      else
+        []
+      end
+    end
+  end
+end

data/geocoder-1.8.6/lib/geocoder/lookups/baidu.rb

@@ -0,0 +1,63 @@
+require 'geocoder/lookups/base'
+require "geocoder/results/baidu"
+
+module Geocoder::Lookup
+  class Baidu < Base
+
+    def name
+      "Baidu"
+    end
+
+    def required_api_key_parts
+      ["key"]
+    end
+
+    # HTTP only
+    def supported_protocols
+      [:http]
+    end
+
+    private # ---------------------------------------------------------------
+
+    def base_query_url(query)
+      "#{protocol}://api.map.baidu.com/geocoder/v2/?"
+    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]] unless doc[content_key].blank?
+      when 1, 3, 4
+        raise_error(Geocoder::Error, "server error.") ||
+          Geocoder.log(:warn, "#{name} Geocoding API error: server error.")
+      when 2
+        raise_error(Geocoder::InvalidRequest, "invalid request.") ||
+          Geocoder.log(:warn, "#{name} Geocoding API error: invalid request.")
+      when 5
+        raise_error(Geocoder::InvalidApiKey, "invalid api key") ||
+          Geocoder.log(:warn, "#{name} Geocoding API error: invalid api key.")
+      when 101, 102, 200..299
+        raise_error(Geocoder::RequestDenied, "request denied") ||
+          Geocoder.log(:warn, "#{name} Geocoding API error: request denied.")
+      when 300..399
+        raise_error(Geocoder::OverQueryLimitError, "over query limit.") ||
+          Geocoder.log(:warn, "#{name} Geocoding API error: over query limit.")
+      end
+      return []
+    end
+
+    def query_url_params(query)
+      {
+        (query.reverse_geocode? ? :location : :address) => query.sanitized_text,
+        :ak => configuration.api_key,
+        :output => "json"
+      }.merge(super)
+    end
+
+  end
+end

data/geocoder-1.8.6/lib/geocoder/lookups/baidu_ip.rb

@@ -0,0 +1,30 @@
+require 'geocoder/lookups/baidu'
+require 'geocoder/results/baidu_ip'
+
+module Geocoder::Lookup
+  class BaiduIp < Baidu
+
+    def name
+      "Baidu IP"
+    end
+
+    private # ---------------------------------------------------------------
+
+    def base_query_url(query)
+      "#{protocol}://api.map.baidu.com/location/ip?"
+    end
+
+    def content_key
+      'content'
+    end
+
+    def query_url_params(query)
+      {
+        :ip => query.sanitized_text,
+        :ak => configuration.api_key,
+        :coor => "bd09ll"
+      }.merge(super)
+    end
+
+  end
+end