bw-geocoder 1.2.5

data/lib/geocoder/lookups/geocoder_ca.rb

@@ -0,0 +1,54 @@
+require 'geocoder/lookups/base'
+require "geocoder/results/geocoder_ca"
+
+module Geocoder::Lookup
+  class GeocoderCa < Base
+
+    def name
+      "Geocoder.ca"
+    end
+
+    def query_url(query)
+      "#{protocol}://geocoder.ca/?" + url_query_string(query)
+    end
+
+    private # ---------------------------------------------------------------
+
+    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
+        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,39 @@
+require 'geocoder/lookups/base'
+require "geocoder/results/geocoder_us"
+
+module Geocoder::Lookup
+  class GeocoderUs < Base
+
+    def name
+      "Geocoder.us"
+    end
+
+    def query_url(query)
+      if configuration.api_key
+        "http://#{configuration.api_key}@geocoder.us/member/service/csv/geocode?" + url_query_string(query)
+      else
+        "http://geocoder.us/service/csv/geocode?" + url_query_string(query)
+      end
+    end
+
+    private
+
+    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 query_url(query)
+      path = query.reverse_geocode? ? "reverse" : "geocode"
+      "#{protocol}://api.geocod.io/v1/#{path}?#{url_query_string(query)}"
+    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) ||
+          warn("Geocodio service error: invalid API key.")
+      elsif doc['error'].match(/You have reached your daily maximum/)
+        raise_error(Geocoder::OverQueryLimitError, doc['error']) ||
+          warn("Geocodio service error: #{doc['error']}.")
+      else
+        raise_error(Geocoder::InvalidRequest, doc['error']) ||
+          warn("Geocodio service error: #{doc['error']}.")
+      end
+      []
+    end
+
+    private # ---------------------------------------------------------------
+
+    def query_url_params(query)
+      {
+        :api_key => configuration.api_key,
+        :q => query.sanitized_text
+      }.merge(super)
+    end
+  end
+end

data/lib/geocoder/lookups/google.rb

@@ -0,0 +1,67 @@
+require 'geocoder/lookups/base'
+require "geocoder/results/google"
+
+module Geocoder::Lookup
+  class Google < Base
+
+    def name
+      "Google"
+    end
+
+    def map_link_url(coordinates)
+      "http://maps.google.com/maps?q=#{coordinates.join(',')}"
+    end
+
+    def query_url(query)
+      "#{protocol}://maps.googleapis.com/maps/api/geocode/json?" + url_query_string(query)
+    end
+
+    private # ---------------------------------------------------------------
+
+    def valid_response?(response)
+      status = parse_json(response.body)["status"]
+      super(response) and ['OK', 'ZERO_RESULTS'].include?(status)
+    end
+
+    def results(query)
+      return [] unless doc = fetch_data(query)
+      case doc['status']; when "OK" # OK status implies >0 results
+        return doc['results']
+      when "OVER_QUERY_LIMIT"
+        raise_error(Geocoder::OverQueryLimitError) ||
+          warn("Google Geocoding API error: over query limit.")
+      when "REQUEST_DENIED"
+        raise_error(Geocoder::RequestDenied) ||
+          warn("Google Geocoding API error: request denied.")
+      when "INVALID_REQUEST"
+        raise_error(Geocoder::InvalidRequest) ||
+          warn("Google Geocoding API error: invalid request.")
+      end
+      return []
+    end
+
+    def query_url_google_params(query)
+      params = {
+        (query.reverse_geocode? ? :latlng : :address) => query.sanitized_text,
+        :sensor => "false",
+        :language => (query.language || configuration.language)
+      }
+      unless (bounds = query.options[:bounds]).nil?
+        params[:bounds] = bounds.map{ |point| "%f,%f" % point }.join('|')
+      end
+      unless (region = query.options[:region]).nil?
+        params[:region] = region
+      end
+      unless (components = query.options[:components]).nil?
+        params[:components] = components.is_a?(Array) ? components.join("|") : components
+      end
+      params
+    end
+
+    def query_url_params(query)
+      query_url_google_params(query).merge(
+        :key => configuration.api_key
+      ).merge(super)
+    end
+  end
+end

data/lib/geocoder/lookups/google_places_details.rb

@@ -0,0 +1,50 @@
+require "geocoder/lookups/google"
+require "geocoder/results/google_places_details"
+
+module Geocoder
+  module Lookup
+    class GooglePlacesDetails < Google
+      def name
+        "Google Places Details"
+      end
+
+      def required_api_key_parts
+        ["key"]
+      end
+
+      def use_ssl?
+        true
+      end
+
+      def query_url(query)
+        "#{protocol}://maps.googleapis.com/maps/api/place/details/json?#{url_query_string(query)}"
+      end
+
+      private
+
+      def results(query)
+        return [] unless doc = fetch_data(query)
+
+        case doc["status"]
+        when "OK"
+          return [doc["result"]]
+        when "OVER_QUERY_LIMIT"
+          raise_error(Geocoder::OverQueryLimitError) || warn("Google Places Details API error: over query limit.")
+        when "REQUEST_DENIED"
+          raise_error(Geocoder::RequestDenied) || warn("Google Places Details API error: request denied.")
+        when "INVALID_REQUEST"
+          raise_error(Geocoder::InvalidRequest) || warn("Google Places Details API error: invalid request.")
+        end
+
+        []
+      end
+
+      def query_url_google_params(query)
+        {
+          placeid: query.text,
+          language: query.language || configuration.language
+        }
+      end
+    end
+  end
+end

data/lib/geocoder/lookups/google_premier.rb

@@ -0,0 +1,47 @@
+require 'openssl'
+require 'base64'
+require 'geocoder/lookups/google'
+require 'geocoder/results/google_premier'
+
+module Geocoder::Lookup
+  class GooglePremier < Google
+
+    def name
+      "Google Premier"
+    end
+
+    def required_api_key_parts
+      ["private key", "client", "channel"]
+    end
+
+    def query_url(query)
+      path = "/maps/api/geocode/json?" + url_query_string(query)
+      "#{protocol}://maps.googleapis.com#{path}&signature=#{sign(path)}"
+    end
+
+    private # ---------------------------------------------------------------
+
+    def query_url_params(query)
+      query_url_google_params(query).merge(super).merge(
+        :key => nil, # don't use param inherited from Google lookup
+        :client => configuration.api_key[1],
+        :channel => configuration.api_key[2]
+      )
+    end
+
+    def sign(string)
+      raw_private_key = url_safe_base64_decode(configuration.api_key[0])
+      digest = OpenSSL::Digest.new('sha1')
+      raw_signature = OpenSSL::HMAC.digest(digest, raw_private_key, string)
+      url_safe_base64_encode(raw_signature)
+    end
+
+    def url_safe_base64_decode(base64_string)
+      Base64.decode64(base64_string.tr('-_', '+/'))
+    end
+
+    def url_safe_base64_encode(raw)
+      Base64.encode64(raw).tr('+/', '-_').strip
+    end
+  end
+end

data/lib/geocoder/lookups/here.rb

@@ -0,0 +1,62 @@
+require 'geocoder/lookups/base'
+require 'geocoder/results/here'
+
+module Geocoder::Lookup
+  class Here < Base
+
+    def name
+      "Here"
+    end
+
+    def required_api_key_parts
+      []
+    end
+
+    def query_url(query)
+      "#{protocol}://#{if query.reverse_geocode? then 'reverse.' end}geocoder.api.here.com/6.2/#{if query.reverse_geocode? then 'reverse' end}geocode.json?" + url_query_string(query)
+    end
+
+    private # ---------------------------------------------------------------
+
+    def results(query)
+      return [] unless doc = fetch_data(query)
+      return [] unless doc['Response'] && doc['Response']['View']
+      if r=doc['Response']['View']
+        return [] if r.nil? || !r.is_a?(Array) || r.empty?
+        return r.first['Result']
+      end
+      []
+    end
+
+    def query_url_params(query)
+      options = {
+        :gen=>4,
+        :app_id=>api_key,
+        :app_code=>api_code
+      }
+
+      if query.reverse_geocode?
+        super.merge(options).merge(
+          :prox=>query.sanitized_text,
+          :mode=>:retrieveAddresses
+        )
+      else
+        super.merge(options).merge(
+          :searchtext=>query.sanitized_text
+        )
+      end
+    end
+
+    def api_key
+      if a=configuration.api_key
+        return a.first if a.is_a?(Array)
+      end
+    end
+
+    def api_code
+      if a=configuration.api_key
+        return a.last if a.is_a?(Array)
+      end
+    end
+  end
+end

data/lib/geocoder/lookups/ip_address_labs.rb

@@ -0,0 +1,43 @@
+require 'geocoder/lookups/base'
+require 'geocoder/results/ip_address_labs'
+require 'csv'
+
+module Geocoder::Lookup
+  class IpAddressLabs < Base
+
+    def name
+      "IpAddressLabs"
+    end
+
+    def query_url(query)
+      "#{protocol}://api.ipaddresslabs.com/iplocation/v1.7/locateip?key=#{configuration[:api_key]}&ip=#{query}&format=JSON"
+    end
+
+    def reserved_result
+      {
+        "city"         => "New York",
+        "region_code"  => "NY",
+        "latitude"     => 40.7127837,
+        "longitude"    => -74.0059413
+      }
+    end
+
+    private # ---------------------------------------------------------------
+
+
+    def results(query)
+      # don't look up a loopback address, just return the stored result
+      return [reserved_result] if query.loopback_ip_address?
+      doc = fetch_data(query)
+      status = doc["query_status"]["query_status_code"]
+      message = doc["query_status"]["query_status_description"]
+
+      if status == "OK"
+        return [ doc["geolocation_data"] ]
+      else
+        warn("IP Address Labs API Error: #{message}")
+        []
+      end
+    end
+  end
+end

data/lib/geocoder/lookups/mapquest.rb

@@ -0,0 +1,60 @@
+require 'cgi'
+require 'geocoder/lookups/base'
+require "geocoder/results/mapquest"
+
+module Geocoder::Lookup
+  class Mapquest < Base
+
+    def name
+      "Mapquest"
+    end
+
+    def required_api_key_parts
+      ["key"]
+    end
+
+    def query_url(query)
+      domain = configuration[:open] ? "open" : "www"
+      version = configuration[:version] || 1
+      url = "#{protocol}://#{domain}.mapquestapi.com/geocoding/v#{version}/#{search_type(query)}?"
+      url + url_query_string(query)
+    end
+
+    private # ---------------------------------------------------------------
+
+    def search_type(query)
+      query.reverse_geocode? ? "reverse" : "address"
+    end
+
+    def query_url_params(query)
+      params = { :location => query.sanitized_text }
+      if key = configuration.api_key
+        params[:key] = CGI.unescape(key)
+      end
+      params.merge(super)
+    end
+
+    # http://www.mapquestapi.com/geocoding/status_codes.html
+    # http://open.mapquestapi.com/geocoding/status_codes.html
+    def results(query)
+      return [] unless doc = fetch_data(query)
+      return doc["results"][0]['locations'] if doc['info']['statuscode'] == 0 # A successful geocode call
+
+      messages = doc['info']['messages'].join
+
+      case doc['info']['statuscode']
+      when 400 # Error with input
+        raise_error(Geocoder::InvalidRequest, messages) ||
+          warn("Mapquest Geocoding API error: #{messages}")
+      when 403 # Key related error
+        raise_error(Geocoder::InvalidApiKey, messages) ||
+          warn("Mapquest Geocoding API error: #{messages}")
+      when 500 # Unknown error
+        raise_error(Geocoder::Error, messages) ||
+          warn("Mapquest Geocoding API error: #{messages}")
+      end
+      []
+    end
+
+  end
+end

data/lib/geocoder/lookups/maxmind.rb

@@ -0,0 +1,90 @@
+require 'geocoder/lookups/base'
+require 'geocoder/results/maxmind'
+require 'csv'
+
+module Geocoder::Lookup
+  class Maxmind < Base
+
+    def name
+      "MaxMind"
+    end
+
+    def query_url(query)
+      "#{protocol}://geoip.maxmind.com/#{service_code}?" + url_query_string(query)
+    end
+
+    private # ---------------------------------------------------------------
+
+    ##
+    # Return the name of the configured service, or raise an exception.
+    #
+    def configured_service!
+      if s = configuration[:service] and services.keys.include?(s)
+        return s
+      else
+        raise(
+          Geocoder::ConfigurationError,
+          "When using MaxMind you MUST specify a service name: " +
+          "Geocoder.configure(:maxmind => {:service => ...}), " +
+          "where '...' is one of: #{services.keys.inspect}"
+        )
+      end
+    end
+
+    def service_code
+      services[configured_service!]
+    end
+
+    def service_response_fields_count
+      Geocoder::Result::Maxmind.field_names[configured_service!].size
+    end
+
+    def data_contains_error?(parsed_data)
+      # if all fields given then there is an error
+      parsed_data.size == service_response_fields_count and !parsed_data.last.nil?
+    end
+
+    ##
+    # Service names mapped to code used in URL.
+    #
+    def services
+      {
+        :country => "a",
+        :city => "b",
+        :city_isp_org => "f",
+        :omni => "e"
+      }
+    end
+
+    def results(query)
+      # don't look up a loopback address, just return the stored result
+      return [reserved_result] if query.loopback_ip_address?
+      doc = fetch_data(query)
+      if doc and doc.is_a?(Array)
+        if !data_contains_error?(doc)
+          return [doc]
+        elsif doc.last == "INVALID_LICENSE_KEY"
+          raise_error(Geocoder::InvalidApiKey) || warn("Invalid MaxMind API key.")
+        end
+      end
+      return []
+    end
+
+    def parse_raw_data(raw_data)
+      # Maxmind just returns text/plain as csv format but according to documentation,
+      # we get ISO-8859-1 encoded string. We need to convert it.
+      CSV.parse_line raw_data.force_encoding("ISO-8859-1").encode("UTF-8")
+    end
+
+    def reserved_result
+      ",,,,0,0,0,0,,,".split(",")
+    end
+
+    def query_url_params(query)
+      {
+        :l => configuration.api_key,
+        :i => query.sanitized_text
+      }.merge(super)
+    end
+  end
+end

data/lib/geocoder/lookups/maxmind_local.rb

@@ -0,0 +1,58 @@
+require 'ipaddr'
+require 'geocoder/lookups/base'
+require 'geocoder/results/maxmind_local'
+
+module Geocoder::Lookup
+  class MaxmindLocal < Base
+
+    def initialize
+      if !configuration[:file].nil?
+        begin
+          gem = RUBY_PLATFORM == 'java' ? 'jgeoip' : 'geoip'
+          require gem
+        rescue LoadError
+          raise "Could not load geoip dependency. To use MaxMind Local lookup you must add the #{gem} gem to your Gemfile or have it installed in your system."
+        end
+      end
+      super
+    end
+
+    def name
+      "MaxMind Local"
+    end
+
+    def required_api_key_parts
+      []
+    end
+
+    private
+
+    def results(query)
+      if configuration[:file]
+        geoip_class = RUBY_PLATFORM == "java" ? JGeoIP : GeoIP
+        result = geoip_class.new(configuration[:file]).city(query.to_s)
+        result.nil? ? [] : [result.to_hash]
+      elsif configuration[:package] == :city
+        addr = IPAddr.new(query.text).to_i
+        q = "SELECT l.country, l.region, l.city, l.latitude, l.longitude
+          FROM maxmind_geolite_city_location l WHERE l.loc_id = (SELECT b.loc_id FROM maxmind_geolite_city_blocks b
+          WHERE b.start_ip_num <= #{addr} AND #{addr} <= b.end_ip_num LIMIT 1)"
+        format_result(q, [:country_name, :region_name, :city_name, :latitude, :longitude])
+      elsif configuration[:package] == :country
+        addr = IPAddr.new(query.text).to_i
+        q = "SELECT country, country_code FROM maxmind_geolite_country
+          WHERE start_ip_num <= #{addr} AND #{addr} <= end_ip_num"
+        format_result(q, [:country_name, :country_code2])
+      end
+    end
+
+    def format_result(query, attr_names)
+      if r = ActiveRecord::Base.connection.execute(query).first
+        r = r.values if r.is_a?(Hash) # some db adapters return Hash, some Array
+        [Hash[*attr_names.zip(r).flatten]]
+      else
+        []
+      end
+    end
+  end
+end

data/lib/geocoder/lookups/nominatim.rb

@@ -0,0 +1,52 @@
+require 'geocoder/lookups/base'
+require "geocoder/results/nominatim"
+
+module Geocoder::Lookup
+  class Nominatim < Base
+
+    def name
+      "Nominatim"
+    end
+
+    def map_link_url(coordinates)
+      "http://www.openstreetmap.org/?lat=#{coordinates[0]}&lon=#{coordinates[1]}&zoom=15&layers=M"
+    end
+
+    def query_url(query)
+      method = query.reverse_geocode? ? "reverse" : "search"
+      host = configuration[:host] || "nominatim.openstreetmap.org"
+      "#{protocol}://#{host}/#{method}?" + url_query_string(query)
+    end
+
+    private # ---------------------------------------------------------------
+
+    def results(query)
+      return [] unless doc = fetch_data(query)
+      doc.is_a?(Array) ? doc : [doc]
+    end
+
+    def parse_raw_data(raw_data)
+      if raw_data.include?("Bandwidth limit exceeded")
+        raise_error(Geocoder::OverQueryLimitError) || warn("Over API query limit.")
+      else
+        super(raw_data)
+      end
+    end
+
+    def query_url_params(query)
+      params = {
+        :format => "json",
+        :addressdetails => "1",
+        :"accept-language" => (query.language || configuration.language)
+      }.merge(super)
+      if query.reverse_geocode?
+        lat,lon = query.coordinates
+        params[:lat] = lat
+        params[:lon] = lon
+      else
+        params[:q] = query.sanitized_text
+      end
+      params
+    end
+  end
+end