geocoder-kb 1.2.6

data/lib/geocoder/configuration.rb

@@ -0,0 +1,124 @@
+require 'singleton'
+require 'geocoder/configuration_hash'
+
+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
+
+  class Configuration
+    include Singleton
+
+    OPTIONS = [
+      :timeout,
+      :lookup,
+      :ip_lookup,
+      :language,
+      :http_headers,
+      :use_https,
+      :http_proxy,
+      :https_proxy,
+      :api_key,
+      :cache,
+      :cache_prefix,
+      :always_raise,
+      :units,
+      :distances
+    ]
+
+    attr_accessor :data
+
+    def self.set_defaults
+      instance.set_defaults
+    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)
+      @data.rmerge!(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]       = :google     # name of street address geocoding service (symbol)
+      @data[:ip_lookup]    = :freegeoip  # 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[:cache]        = nil         # cache object (must respond to #[], #[]=, and #keys)
+      @data[:cache_prefix] = "geocoder:" # prefix (string) to use for all cache keys
+
+      # exceptions that should not be rescued by default
+      # (if you want to implement custom error handling);
+      # supports SocketError and TimeoutError
+      @data[:always_raise] = []
+
+      # calculation options
+      @data[:units]     = :mi      # :mi or :km
+      @data[:distances] = :linear  # :linear or :spherical
+    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/lib/geocoder/configuration_hash.rb

@@ -0,0 +1,11 @@
+require 'hash_recursive_merge'
+
+module Geocoder
+  class ConfigurationHash < Hash
+    include HashRecursiveMerge
+
+    def method_missing(meth, *args, &block)
+      has_key?(meth) ? self[meth] : super
+    end
+  end
+end

data/lib/geocoder/exceptions.rb

@@ -0,0 +1,21 @@
+module Geocoder
+
+  class Error < StandardError
+  end
+
+  class ConfigurationError < Error
+  end
+
+  class OverQueryLimitError < Error
+  end
+
+  class RequestDenied < Error
+  end
+
+  class InvalidRequest < Error
+  end
+
+  class InvalidApiKey < Error
+  end
+
+end

data/lib/geocoder/ip_address.rb

@@ -0,0 +1,21 @@
+module Geocoder
+  class IpAddress < String
+
+    def loopback?
+      valid? and (self == "0.0.0.0" or self.match(/\A127\./) or self == "::1")
+    end
+
+    def valid?
+      ipregex = %r{
+        \A(                                     # String Starts
+        ((::ffff:)?((\d{1,3})\.){3}\d{1,3})     # Check for IPv4
+        |                                       # .... Or
+        (\S+?(:\S+?){6}\S+)                     # Check for IPv6
+        |                                       # .... Or
+        (::1)                                   # IPv6 loopback
+        )\z                                     
+      }x
+      !!self.match(ipregex)
+    end
+  end
+end

data/lib/geocoder/lookup.rb

@@ -0,0 +1,102 @@
+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
+
+    ##
+    # All street address lookup services, default first.
+    #
+    def street_services
+      [
+        :dstk,
+        :esri,
+        :google,
+        :google_premier,
+        :google_places_details,
+        :yahoo,
+        :bing,
+        :geocoder_ca,
+        :geocoder_us,
+        :yandex,
+        :nominatim,
+        :mapquest,
+        :opencagedata,
+        :ovi,
+        :here,
+        :baidu,
+        :geocodio,
+        :smarty_streets,
+        :okf,
+        :postcode_anywhere_uk,
+        :test,
+        :amap
+      ]
+    end
+
+    ##
+    # All IP address lookup services, default first.
+    #
+    def ip_services
+      [
+        :baidu_ip,
+        :freegeoip,
+        :geoip2,
+        :maxmind,
+        :maxmind_local,
+        :telize,
+        :pointpin
+      ]
+    end
+
+    ##
+    # 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)
+        Geocoder::Lookup.const_get(classify_name(name)).new
+      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
+  end
+end
+
+Geocoder::Lookup.all_services.each do |name|
+  require "geocoder/lookups/#{name}"
+end

data/lib/geocoder/lookups/amap.rb

@@ -0,0 +1,55 @@
+require 'geocoder/lookups/base'
+require "geocoder/results/amap"
+
+module Geocoder::Lookup
+  class Amap < Base
+
+    def name
+      "AutoNavi"
+    end
+
+    def required_api_key_parts
+      ["key"]
+    end
+
+    def query_url(query)
+      path = query.reverse_geocode? ? 'regeo' : 'geo'
+      "http://restapi.amap.com/v3/geocode/#{path}?" + url_query_string(query)
+    end
+
+    private # ---------------------------------------------------------------
+
+    def results(query, reverse = false)
+      return [] unless doc = fetch_data(query)
+      case doc['status']
+      when "1"
+        return [doc['regeocode']] unless doc['regeocode'].blank?
+      else
+        raise_error(Geocoder::Error, "server error.") ||
+          warn("#{self.name} Geocoding API error: server error.")
+      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/lib/geocoder/lookups/baidu.rb

@@ -0,0 +1,55 @@
+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
+
+    def query_url(query)
+      "http://api.map.baidu.com/geocoder/v2/?" + url_query_string(query)
+    end
+
+    private # ---------------------------------------------------------------
+
+    def results(query, reverse = false)
+      return [] unless doc = fetch_data(query)
+      case doc['status']
+      when 0
+        return [doc['result']] unless doc['result'].blank?
+      when 1, 3, 4
+        raise_error(Geocoder::Error, "server error.") ||
+          warn("Baidu Geocoding API error: server error.")
+      when 2
+        raise_error(Geocoder::InvalidRequest, "invalid request.") ||
+          warn("Baidu Geocoding API error: invalid request.")
+      when 5
+        raise_error(Geocoder::InvalidApiKey, "invalid api key") ||
+          warn("Baidu Geocoding API error: invalid api key.")
+      when 101, 102, 200..299
+        raise_error(Geocoder::RequestDenied, "request denied") ||
+          warn("Baidu Geocoding API error: request denied.")
+      when 300..399
+        raise_error(Geocoder::OverQueryLimitError, "over query limit.") ||
+          warn("Baidu 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/lib/geocoder/lookups/baidu_ip.rb

@@ -0,0 +1,54 @@
+require 'geocoder/lookups/base'
+require 'geocoder/results/baidu_ip'
+
+module Geocoder::Lookup
+  class BaiduIp < Base
+
+    def name
+      "Baidu IP"
+    end
+
+    def required_api_key_parts
+      ["key"]
+    end
+
+    def query_url(query)
+      "http://api.map.baidu.com/location/ip?" + url_query_string(query)
+    end
+
+    private # ---------------------------------------------------------------
+
+    def results(query, reverse = false)
+      return [] unless doc = fetch_data(query)
+      case doc['status']
+      when 0
+        return [doc['content']] unless doc['content'].blank?
+      when 1, 3, 4
+        raise_error(Geocoder::Error, "server error.") ||
+          warn("Baidu IP Geocoding API error: server error.")
+      when 2
+        raise_error(Geocoder::InvalidRequest, "invalid request.") ||
+          warn("Baidu IP Geocoding API error: invalid request.")
+      when 5
+        raise_error(Geocoder::InvalidApiKey, "invalid api key.") ||
+          warn("Baidu IP Geocoding API error: invalid api key.")
+      when 101, 102, 200..299
+        raise_error(Geocoder::RequestDenied, "request denied.") ||
+          warn("Baidu IP Geocoding API error: request denied.")
+      when 300..399
+        raise_error(Geocoder::OverQueryLimitError, "over query limit") ||
+          warn("Baidu IP Geocoding API error: over query limit.")
+      end
+      return []
+    end
+
+    def query_url_params(query)
+      {
+        :ip => query.sanitized_text,
+        :ak => configuration.api_key,
+        :coor => "bd09ll"
+      }.merge(super)
+    end
+
+  end
+end