geocoder 1.4.9 → 1.6.7

data/lib/geocoder/lookups/geocoder_ca.rb

@@ -8,12 +8,12 @@ module Geocoder::Lookup
       "Geocoder.ca"
     end
 
-    def query_url(query)
-      "#{protocol}://geocoder.ca/?" + url_query_string(query)
-    end
-
     private # ---------------------------------------------------------------
 
+    def base_query_url(query)
+      "#{protocol}://geocoder.ca/?"
+    end
+
     def results(query)
       return [] unless doc = fetch_data(query)
       if doc['error'].nil?

data/lib/geocoder/lookups/geocodio.rb

@@ -8,11 +8,6 @@ module Geocoder::Lookup
       "Geocodio"
     end
 
-    def query_url(query)
-      path = query.reverse_geocode? ? "reverse" : "geocode"
-      "#{protocol}://api.geocod.io/v1.3/#{path}?#{url_query_string(query)}"
-    end
-
     def results(query)
       return [] unless doc = fetch_data(query)
       return doc["results"] if doc['error'].nil?
@@ -32,6 +27,11 @@ module Geocoder::Lookup
 
     private # ---------------------------------------------------------------
 
+    def base_query_url(query)
+      path = query.reverse_geocode? ? "reverse" : "geocode"
+      "#{protocol}://api.geocod.io/v1.6/#{path}?"
+    end
+
     def query_url_params(query)
       {
         :api_key => configuration.api_key,

data/lib/geocoder/lookups/geoportail_lu.rb

@@ -9,14 +9,14 @@ module Geocoder
         "Geoportail.lu"
       end
 
-      def query_url(query)
-        url_base_path(query) + url_query_string(query)
-      end
-
-      private
+      private # ---------------------------------------------------------------
 
-      def url_base_path(query)
-        query.reverse_geocode? ? reverse_geocode_url_base_path : search_url_base_path
+      def base_query_url(query)
+        if query.reverse_geocode?
+          reverse_geocode_url_base_path
+        else
+          search_url_base_path
+        end
       end
 
       def search_url_base_path

data/lib/geocoder/lookups/google.rb

@@ -21,12 +21,12 @@ module Geocoder::Lookup
       end
     end
 
-    def query_url(query)
-      "#{protocol}://maps.googleapis.com/maps/api/geocode/json?" + url_query_string(query)
-    end
-
     private # ---------------------------------------------------------------
 
+    def base_query_url(query)
+      "#{protocol}://maps.googleapis.com/maps/api/geocode/json?"
+    end
+
     def configure_ssl!(client)
       client.instance_eval {
         @ssl_context = OpenSSL::SSL::SSLContext.new
@@ -44,19 +44,24 @@ module Geocoder::Lookup
       super(response) and ['OK', 'ZERO_RESULTS'].include?(status)
     end
 
+    def result_root_attr
+      'results'
+    end
+
     def results(query)
       return [] unless doc = fetch_data(query)
-      case doc['status']; when "OK" # OK status implies >0 results
-        return doc['results']
+      case doc['status']
+      when "OK" # OK status implies >0 results
+        return doc[result_root_attr]
       when "OVER_QUERY_LIMIT"
         raise_error(Geocoder::OverQueryLimitError) ||
           Geocoder.log(:warn, "#{name} API error: over query limit.")
       when "REQUEST_DENIED"
-        raise_error(Geocoder::RequestDenied) ||
-          Geocoder.log(:warn, "#{name} API error: request denied.")
+        raise_error(Geocoder::RequestDenied, doc['error_message']) ||
+          Geocoder.log(:warn, "#{name} API error: request denied (#{doc['error_message']}).")
       when "INVALID_REQUEST"
-        raise_error(Geocoder::InvalidRequest) ||
-          Geocoder.log(:warn, "#{name} API error: invalid request.")
+        raise_error(Geocoder::InvalidRequest, doc['error_message']) ||
+          Geocoder.log(:warn, "#{name} API error: invalid request (#{doc['error_message']}).")
       end
       return []
     end

data/lib/geocoder/lookups/google_places_details.rb

@@ -16,27 +16,21 @@ module Geocoder
         [:https]
       end
 
-      def query_url(query)
-        "#{protocol}://maps.googleapis.com/maps/api/place/details/json?#{url_query_string(query)}"
+      private
+
+      def base_query_url(query)
+        "#{protocol}://maps.googleapis.com/maps/api/place/details/json?"
       end
 
-      private
+      def result_root_attr
+        'result'
+      end
 
       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) || Geocoder.log(:warn, "Google Places Details API error: over query limit.")
-        when "REQUEST_DENIED"
-          raise_error(Geocoder::RequestDenied) || Geocoder.log(:warn, "Google Places Details API error: request denied.")
-        when "INVALID_REQUEST"
-          raise_error(Geocoder::InvalidRequest) || Geocoder.log(:warn, "Google Places Details API error: invalid request.")
-        end
-
-        []
+        result = super(query)
+        return [result] unless result.is_a? Array
+
+        result
       end
 
       def query_url_google_params(query)

data/lib/geocoder/lookups/google_places_search.rb

@@ -16,18 +16,44 @@ module Geocoder
         [:https]
       end
 
-      def query_url(query)
-        "#{protocol}://maps.googleapis.com/maps/api/place/textsearch/json?#{url_query_string(query)}"
+      private
+
+      def result_root_attr
+        'candidates'
       end
 
-      private
+      def base_query_url(query)
+        "#{protocol}://maps.googleapis.com/maps/api/place/findplacefromtext/json?"
+      end
 
       def query_url_google_params(query)
         {
-          query: query.text,
+          input: query.text,
+          inputtype: 'textquery',
+          fields: fields(query),
           language: query.language || configuration.language
         }
       end
+
+      def fields(query)
+        query_fields = query.options[:fields]
+        return format_fields(query_fields) if query_fields
+
+        default_fields
+      end
+
+      def default_fields
+        legacy = %w[id reference]
+        basic = %w[business_status formatted_address geometry icon name 
+          photos place_id plus_code types]
+        contact = %w[opening_hours]
+        atmosphere = %W[price_level rating user_ratings_total]
+        format_fields(legacy, basic, contact, atmosphere)
+      end
+
+      def format_fields(*fields)
+        fields.flatten.join(',')
+      end
     end
   end
 end

data/lib/geocoder/lookups/google_premier.rb

@@ -21,6 +21,20 @@ module Geocoder::Lookup
 
     private # ---------------------------------------------------------------
 
+    def result_root_attr
+      'results'
+    end
+
+    def cache_key(query)
+      "#{protocol}://maps.googleapis.com/maps/api/geocode/json?" + hash_to_query(cache_key_params(query))
+    end
+
+    def cache_key_params(query)
+      query_url_google_params(query).merge(super).reject do |k,v|
+        [:key, :client, :channel].include?(k)
+      end
+    end
+
     def query_url_params(query)
       query_url_google_params(query).merge(super).merge(
         :key => nil, # don't use param inherited from Google lookup

data/lib/geocoder/lookups/here.rb

@@ -9,15 +9,19 @@ module Geocoder::Lookup
     end
 
     def required_api_key_parts
-      ["app_id", "app_code"]
+      ['api_key']
     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)
+    def supported_protocols
+      [:https]
     end
 
     private # ---------------------------------------------------------------
 
+    def base_query_url(query)
+      "#{protocol}://#{if query.reverse_geocode? then 'reverse.' end}geocoder.ls.hereapi.com/6.2/#{if query.reverse_geocode? then 'reverse' end}geocode.json?"
+    end
+
     def results(query)
       return [] unless doc = fetch_data(query)
       return [] unless doc['Response'] && doc['Response']['View']
@@ -28,34 +32,36 @@ module Geocoder::Lookup
       []
     end
 
-    def query_url_params(query)
+    def query_url_here_options(query, reverse_geocode)
       options = {
-        :gen=>4,
-        :app_id=>api_key,
-        :app_code=>api_code
+        gen: 9,
+        apikey: configuration.api_key,
+        language: (query.language || configuration.language)
       }
+      if reverse_geocode
+        options[:mode] = :retrieveAddresses
+        return options
+      end
 
-      if query.reverse_geocode?
-        super.merge(options).merge(
-          :prox=>query.sanitized_text,
-          :mode=>:retrieveAddresses
-        )
-      else
-        super.merge(options).merge(
-          :searchtext=>query.sanitized_text
-        )
+      unless (country = query.options[:country]).nil?
+        options[:country] = country
       end
-    end
 
-    def api_key
-      if a=configuration.api_key
-        return a.first if a.is_a?(Array)
+      unless (mapview = query.options[:bounds]).nil?
+        options[:mapview] = mapview.map{ |point| "%f,%f" % point }.join(';')
       end
+      options
     end
 
-    def api_code
-      if a=configuration.api_key
-        return a.last if a.is_a?(Array)
+    def query_url_params(query)
+      if query.reverse_geocode?
+        super.merge(query_url_here_options(query, true)).merge(
+          prox: query.sanitized_text
+        )
+      else
+        super.merge(query_url_here_options(query, false)).merge(
+          searchtext: query.sanitized_text
+        )
       end
     end
   end

data/lib/geocoder/lookups/ip2location.rb

@@ -0,0 +1,67 @@
+require 'geocoder/lookups/base'
+require 'geocoder/results/ip2location'
+
+module Geocoder::Lookup
+  class Ip2location < Base
+
+    def name
+      "IP2LocationApi"
+    end
+
+    def supported_protocols
+      [:http, :https]
+    end
+
+    private # ----------------------------------------------------------------
+
+    def base_query_url(query)
+      "#{protocol}://api.ip2location.com/?"
+    end
+
+    def query_url_params(query)
+      params = super
+      if configuration.has_key?(:package)
+        params.merge!(package: configuration[:package])
+      end
+      params
+    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?
+      return [] unless doc = fetch_data(query)
+      if doc["response"] == "INVALID ACCOUNT"
+        raise_error(Geocoder::InvalidApiKey) || Geocoder.log(:warn, "INVALID ACCOUNT")
+        return []
+      else
+        return [doc]
+      end
+    end
+
+    def reserved_result(query)
+      {
+        "country_code"         => "INVALID IP ADDRESS",
+        "country_name"         => "INVALID IP ADDRESS",
+        "region_name"          => "INVALID IP ADDRESS",
+        "city_name"            => "INVALID IP ADDRESS",
+        "latitude"             => "INVALID IP ADDRESS",
+        "longitude"            => "INVALID IP ADDRESS",
+        "zip_code"             => "INVALID IP ADDRESS",
+        "time_zone"            => "INVALID IP ADDRESS",
+        "isp"                  => "INVALID IP ADDRESS",
+        "domain"               => "INVALID IP ADDRESS",
+        "net_speed"            => "INVALID IP ADDRESS",
+        "idd_code"             => "INVALID IP ADDRESS",
+        "area_code"            => "INVALID IP ADDRESS",
+        "weather_station_code" => "INVALID IP ADDRESS",
+        "weather_station_name" => "INVALID IP ADDRESS",
+        "mcc"                  => "INVALID IP ADDRESS",
+        "mnc"                  => "INVALID IP ADDRESS",
+        "mobile_brand"         => "INVALID IP ADDRESS",
+        "elevation"            => "INVALID IP ADDRESS",
+        "usage_type"           => "INVALID IP ADDRESS"
+      }
+    end
+
+  end
+end

data/lib/geocoder/lookups/ipapi_com.rb

@@ -8,17 +8,6 @@ module Geocoder::Lookup
       "ip-api.com"
     end
 
-    def query_url(query)
-      domain = configuration.api_key ? "pro.ip-api.com" : "ip-api.com"
-      url_ = "#{protocol}://#{domain}/json/#{query.sanitized_text}"
-
-      if (params = url_query_string(query)) && !params.empty?
-        url_ + "?" + params
-      else
-        url_
-      end
-    end
-
     def supported_protocols
       if configuration.api_key
         [:http, :https]
@@ -27,8 +16,14 @@ module Geocoder::Lookup
       end
     end
 
+    private # ----------------------------------------------------------------
 
-    private
+    def base_query_url(query)
+      domain = configuration.api_key ? "pro.ip-api.com" : "ip-api.com"
+      url = "#{protocol}://#{domain}/json/#{query.sanitized_text}"
+      url << "?" if not url_query_string(query).empty?
+      url
+    end
 
     def parse_raw_data(raw_data)
       if raw_data.chomp == "invalid key"
@@ -39,7 +34,8 @@ module Geocoder::Lookup
     end
 
     def results(query)
-      return [reserved_result(query.text)] if query.loopback_ip_address?
+      # don't look up a loopback or private address, just return the stored result
+      return [reserved_result(query.text)] if query.internal_ip_address?
 
       return [] unless doc = fetch_data(query)
 

data/lib/geocoder/lookups/ipdata_co.rb

@@ -13,15 +13,20 @@ module Geocoder::Lookup
     end
 
     def query_url(query)
-      "#{protocol}://#{host}/#{query.sanitized_text}"
+      # Ipdata.co requires that the API key be sent as a query parameter.
+      # It no longer supports API keys sent as headers.
+      "#{protocol}://#{host}/#{query.sanitized_text}?api-key=#{configuration.api_key}"
     end
 
     private # ---------------------------------------------------------------
 
+    def cache_key(query)
+      query_url(query)
+    end
+
     def results(query)
-      Geocoder.configure(:ipdata_co => {:http_headers => { "api-key" => configuration.api_key }}) if configuration.api_key
-      # don't look up a loopback address, just return the stored result
-      return [reserved_result(query.text)] if query.loopback_ip_address?
+      # don't look up a loopback or private address, just return the stored result
+      return [reserved_result(query.text)] if query.internal_ip_address?
       # note: Ipdata.co returns plain text on bad request
       (doc = fetch_data(query)) ? [doc] : []
     end

data/lib/geocoder/lookups/ipgeolocation.rb

@@ -0,0 +1,51 @@
+require 'geocoder/lookups/base'
+require 'geocoder/results/ipgeolocation'
+
+
+module Geocoder::Lookup
+  class Ipgeolocation < Base
+
+    ERROR_CODES = {
+      400 => Geocoder::RequestDenied, # subscription is paused
+      401 => Geocoder::InvalidApiKey, # missing/invalid API key
+      403 => Geocoder::InvalidRequest, # invalid IP address
+      404 => Geocoder::InvalidRequest, # not found
+      423 => Geocoder::InvalidRequest # bogon/reserved IP address
+    }
+    ERROR_CODES.default = Geocoder::Error
+
+    def name
+      "Ipgeolocation"
+    end
+
+    def supported_protocols
+      [:https]
+    end
+
+    private # ----------------------------------------------------------------
+
+    def base_query_url(query)
+      "#{protocol}://api.ipgeolocation.io/ipgeo?"
+    end
+    def query_url_params(query)
+      {
+          ip: query.sanitized_text,
+          apiKey: configuration.api_key
+      }.merge(super)
+    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?
+      [fetch_data(query)]
+    end
+
+    def reserved_result(ip)
+      {
+          "ip"           => ip,
+          "country_name" => "Reserved",
+          "country_code2" => "RD"
+      }
+    end
+  end
+end