mini-safe-gem 0.0.1

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

@@ -0,0 +1,121 @@
+require 'geocoder'
+require 'optparse'
+
+module Geocoder
+  class Cli
+
+    def self.run(args, out = STDOUT)
+      show_url  = false
+      show_json = false
+
+      # remove arguments that are probably coordinates so they are not
+      # processed as arguments (eg: -31.96047031,115.84274631)
+      coords = args.select{ |i| i.match(/^-\d/) }
+      args -= coords
+
+      OptionParser.new{ |opts|
+        opts.banner = "Usage:\n    geocode [options] <location>"
+        opts.separator "\nOptions: "
+
+        opts.on("-k <key>", "--key <key>",
+          "Key for geocoding API (usually optional). Enclose multi-part keys in quotes and separate parts by spaces") do |key|
+          if (key_parts = key.split(/\s+/)).size > 1
+            Geocoder.configure(:api_key => key_parts)
+          else
+            Geocoder.configure(:api_key => key)
+          end
+        end
+
+        opts.on("-l <language>", "--language <language>",
+          "Language of output (see API docs for valid choices)") do |language|
+          Geocoder.configure(:language => language)
+        end
+
+        opts.on("-p <proxy>", "--proxy <proxy>",
+          "HTTP proxy server to use (user:pass@host:port)") do |proxy|
+          Geocoder.configure(:http_proxy => proxy)
+        end
+
+        opts.on("-s <service>", Geocoder::Lookup.all_services_except_test, "--service <service>",
+          "Geocoding service: #{Geocoder::Lookup.all_services_except_test * ', '}") do |service|
+          Geocoder.configure(:lookup => service.to_sym)
+          Geocoder.configure(:ip_lookup => service.to_sym)
+        end
+
+        opts.on("-t <seconds>", "--timeout <seconds>",
+          "Maximum number of seconds to wait for API response") do |timeout|
+          Geocoder.configure(:timeout => timeout.to_i)
+        end
+
+        opts.on("-j", "--json", "Print API's raw JSON response") do
+          show_json = true
+        end
+
+        opts.on("-u", "--url", "Print URL for API query instead of result") do
+          show_url = true
+        end
+
+        opts.on_tail("-v", "--version", "Print version number") do
+          require "geocoder/version"
+          out << "Geocoder #{Geocoder::VERSION}\n"
+          exit
+        end
+
+        opts.on_tail("-h", "--help", "Print this help") do
+          out << "Look up geographic information about a location.\n\n"
+          out << opts
+          out << "\nCreated and maintained by Alex Reisner, available under the MIT License.\n"
+          out << "Report bugs and contribute at http://github.com/alexreisner/geocoder\n"
+          exit
+        end
+      }.parse!(args)
+
+      # concatenate args with coords that might have been removed
+      # before option processing
+      query = (args + coords).join(" ")
+
+      if query == ""
+        out << "Please specify a location (run `geocode -h` for more info).\n"
+        exit 1
+      end
+
+      if show_url and show_json
+        out << "You can only specify one of -j and -u.\n"
+        exit 2
+      end
+
+      if show_url
+        q = Geocoder::Query.new(query)
+        out << q.url + "\n"
+        exit 0
+      end
+
+      if show_json
+        q = Geocoder::Query.new(query)
+        out << q.lookup.send(:fetch_raw_data, q) + "\n"
+        exit 0
+      end
+
+      if (result = Geocoder.search(query).first)
+        nominatim = Geocoder::Lookup.get(:nominatim)
+        lines = [
+          ["Latitude",       result.latitude],
+          ["Longitude",      result.longitude],
+          ["Full address",   result.address],
+          ["City",           result.city],
+          ["State/province", result.state],
+          ["Postal code",    result.postal_code],
+          ["Country",        result.country],
+          ["Map",            nominatim.map_link_url(result.coordinates)],
+        ]
+        lines.each do |line|
+          out << (line[0] + ": ").ljust(18) + line[1].to_s + "\n"
+        end
+        exit 0
+      else
+        out << "Location '#{query}' not found.\n"
+        exit 1
+      end
+    end
+  end
+end

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

@@ -0,0 +1,151 @@
+require 'singleton'
+require 'geocoder/configuration_hash'
+require 'geocoder/util'
+
+module Geocoder
+
+  ##
+  # Configuration options should be set by passing a hash:
+  #
+  #   Geocoder.configure(
+  #     :timeout  => 5,
+  #     :lookup   => :yandex,
+  #     :api_key  => "2a9fsa983jaslfj982fjasd",
+  #     :units    => :km
+  #   )
+  #
+  def self.configure(options = nil, &block)
+    if !options.nil?
+      Configuration.instance.configure(options)
+    end
+  end
+
+  ##
+  # Read-only access to the singleton's config data.
+  #
+  def self.config
+    Configuration.instance.data
+  end
+
+  ##
+  # Read-only access to lookup-specific config data.
+  #
+  def self.config_for_lookup(lookup_name)
+    data = config.clone
+    data.reject!{ |key,value| !Configuration::OPTIONS.include?(key) }
+    if config.has_key?(lookup_name)
+      data.merge!(config[lookup_name])
+    end
+    data
+  end
+
+  ##
+  # Merge the given hash into a lookup's existing configuration.
+  #
+  def self.merge_into_lookup_config(lookup_name, options)
+    base = Geocoder.config[lookup_name]
+    Geocoder.configure(lookup_name => base.merge(options))
+  end
+
+  class Configuration
+    include Singleton
+
+    OPTIONS = [
+      :timeout,
+      :lookup,
+      :ip_lookup,
+      :language,
+      :host,
+      :http_headers,
+      :use_https,
+      :http_proxy,
+      :https_proxy,
+      :api_key,
+      :cache,
+      :always_raise,
+      :units,
+      :distances,
+      :basic_auth,
+      :logger,
+      :kernel_logger_level,
+      :cache_options
+    ]
+
+    attr_accessor :data
+
+    def self.set_defaults
+      instance.set_defaults
+    end
+
+    def self.initialize
+      instance.send(:initialize)
+    end
+
+    OPTIONS.each do |o|
+      define_method o do
+        @data[o]
+      end
+      define_method "#{o}=" do |value|
+        @data[o] = value
+      end
+    end
+
+    def configure(options)
+      Util.recursive_hash_merge(@data, options)
+    end
+
+    def initialize # :nodoc
+      @data = Geocoder::ConfigurationHash.new
+      set_defaults
+    end
+
+    def set_defaults
+
+      # geocoding options
+      @data[:timeout]      = 3           # geocoding service timeout (secs)
+      @data[:lookup]       = :nominatim  # name of street address geocoding service (symbol)
+      @data[:ip_lookup]    = :ipinfo_io  # name of IP address geocoding service (symbol)
+      @data[:language]     = :en         # ISO-639 language code
+      @data[:http_headers] = {}          # HTTP headers for lookup
+      @data[:use_https]    = false       # use HTTPS for lookup requests? (if supported)
+      @data[:http_proxy]   = nil         # HTTP proxy server (user:pass@host:port)
+      @data[:https_proxy]  = nil         # HTTPS proxy server (user:pass@host:port)
+      @data[:api_key]      = nil         # API key for geocoding service
+      @data[:basic_auth]   = {}          # user and password for basic auth ({:user => "user", :password => "password"})
+      @data[:logger]       = :kernel     # :kernel or Logger instance
+      @data[:kernel_logger_level] = ::Logger::WARN # log level, if kernel logger is used
+
+      # exceptions that should not be rescued by default
+      # (if you want to implement custom error handling);
+      # supports SocketError and Timeout::Error
+      @data[:always_raise] = []
+
+      # calculation options
+      @data[:units]     = :mi      # :mi or :km
+      @data[:distances] = :linear  # :linear or :spherical
+
+      # Set the default values for the caching mechanism
+      # By default, the cache keys will not expire as IP addresses and phyiscal
+      # addresses will rarely change.
+      @data[:cache]        = nil   # cache object (must respond to #[], #[]=, and optionally #keys)
+      @data[:cache_prefix] = nil   # - DEPRECATED - prefix (string) to use for all cache keys
+      @data[:cache_options] = {
+        prefix: 'geocoder:',
+        expiration: nil
+      }
+    end
+
+    instance_eval(OPTIONS.map do |option|
+      o = option.to_s
+      <<-EOS
+      def #{o}
+        instance.data[:#{o}]
+      end
+
+      def #{o}=(value)
+        instance.data[:#{o}] = value
+      end
+      EOS
+    end.join("\n\n"))
+  end
+end

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

@@ -0,0 +1,11 @@
+module Geocoder
+  class ConfigurationHash < Hash
+    def method_missing(meth, *args, &block)
+      has_key?(meth) ? self[meth] : super
+    end
+
+    def respond_to_missing?(meth, include_private = false)
+      has_key?(meth) || super
+    end
+  end
+end

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