geocoder 1.5.1 → 1.6.7

data/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/lib/geocoder/lookups/ban_data_gouv_fr.rb

@@ -22,7 +22,7 @@ module Geocoder::Lookup
     end
 
     def any_result?(doc)
-      doc['features'].any?
+      doc['features'] and doc['features'].any?
     end
 
     def results(query)
@@ -86,6 +86,12 @@ module Geocoder::Lookup
       unless (citycode = query.options[:citycode]).nil? || !code_param_is_valid?(citycode)
         params[:citycode] = citycode.to_s
       end
+      unless (lat = query.options[:lat]).nil? || !latitude_is_valid?(lat)
+        params[:lat] = lat
+      end
+      unless (lon = query.options[:lon]).nil? || !longitude_is_valid?(lon)
+        params[:lon] = lon
+      end
       params
     end
 
@@ -126,5 +132,12 @@ module Geocoder::Lookup
       (1..99999).include?(param.to_i)
     end
 
+    def latitude_is_valid?(param)
+      param.to_f <= 90 && param.to_f >= -90
+    end
+
+    def longitude_is_valid?(param)
+      param.to_f <= 180 && param.to_f >= -180
+    end
   end
 end

data/lib/geocoder/lookups/base.rb

@@ -197,6 +197,8 @@ module Geocoder
         raise_error(err) or Geocoder.log(:warn, "Geocoding API connection cannot be established.")
       rescue Errno::ECONNREFUSED => err
         raise_error(err) or Geocoder.log(:warn, "Geocoding API connection refused.")
+      rescue Geocoder::NetworkError => err
+        raise_error(err) or Geocoder.log(:warn, "Geocoding API connection is either unreacheable or reset by the peer")
       rescue Timeout::Error => err
         raise_error(err) or Geocoder.log(:warn, "Geocoding API not responding fast enough " +
           "(use Geocoder.configure(:timeout => ...) to set limit).")

data/lib/geocoder/lookups/esri.rb

@@ -9,6 +9,10 @@ module Geocoder::Lookup
       "Esri"
     end
 
+      def supported_protocols
+        [:https]
+      end
+
     private # ---------------------------------------------------------------
 
     def base_query_url(query)
@@ -47,6 +51,8 @@ module Geocoder::Lookup
         params[:forStorage] = for_storage_value
       end
       params[:sourceCountry] = configuration[:source_country] if configuration[:source_country]
+      params[:preferredLabelValues] = configuration[:preferred_label_values] if configuration[:preferred_label_values]
+
       params.merge(super)
     end
 

data/lib/geocoder/lookups/freegeoip.rb

@@ -10,7 +10,7 @@ module Geocoder::Lookup
 
     def supported_protocols
       if configuration[:host]
-        [:http, :https]
+        [:https]
       else
         # use https for default host
         [:https]
@@ -44,8 +44,8 @@ module Geocoder::Lookup
         "city"         => "",
         "region_code"  => "",
         "region_name"  => "",
-        "metrocode"    => "",
-        "zipcode"      => "",
+        "metro_code"    => "",
+        "zip_code"      => "",
         "latitude"     => "0",
         "longitude"    => "0",
         "country_name" => "Reserved",
@@ -54,7 +54,7 @@ module Geocoder::Lookup
     end
 
     def host
-      configuration[:host] || "freegeoip.net"
+      configuration[:host] || "freegeoip.app"
     end
   end
 end

data/lib/geocoder/lookups/geocodio.rb

@@ -29,7 +29,7 @@ module Geocoder::Lookup
 
     def base_query_url(query)
       path = query.reverse_geocode? ? "reverse" : "geocode"
-      "#{protocol}://api.geocod.io/v1.3/#{path}?"
+      "#{protocol}://api.geocod.io/v1.6/#{path}?"
     end
 
     def query_url_params(query)

data/lib/geocoder/lookups/google.rb

@@ -44,10 +44,15 @@ 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.")

data/lib/geocoder/lookups/google_places_details.rb

@@ -22,21 +22,15 @@ module Geocoder
         "#{protocol}://maps.googleapis.com/maps/api/place/details/json?"
       end
 
+      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

@@ -18,16 +18,42 @@ module Geocoder
 
       private
 
+      def result_root_attr
+        'candidates'
+      end
+
       def base_query_url(query)
-        "#{protocol}://maps.googleapis.com/maps/api/place/textsearch/json?"
+        "#{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,10 @@ 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

data/lib/geocoder/lookups/here.rb

@@ -9,13 +9,17 @@ module Geocoder::Lookup
     end
 
     def required_api_key_parts
-      ["app_id", "app_code"]
+      ['api_key']
+    end
+
+    def supported_protocols
+      [:https]
     end
 
     private # ---------------------------------------------------------------
 
     def base_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?"
+      "#{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)
@@ -31,8 +35,7 @@ module Geocoder::Lookup
     def query_url_here_options(query, reverse_geocode)
       options = {
         gen: 9,
-        app_id: api_key,
-        app_code: api_code,
+        apikey: configuration.api_key,
         language: (query.language || configuration.language)
       }
       if reverse_geocode
@@ -61,17 +64,5 @@ module Geocoder::Lookup
         )
       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/ip2location.rb

@@ -19,11 +19,11 @@ module Geocoder::Lookup
     end
 
     def query_url_params(query)
-      {
-        key: configuration.api_key ? configuration.api_key : "demo",
-        format: "json",
-        ip: query.sanitized_text
-      }.merge(super)
+      params = super
+      if configuration.has_key?(:package)
+        params.merge!(package: configuration[:package])
+      end
+      params
     end
 
     def results(query)
@@ -63,13 +63,5 @@ module Geocoder::Lookup
       }
     end
 
-    def query_url_params(query)
-      params = super
-      if configuration.has_key?(:package)
-        params.merge!(package: configuration[:package])
-      end
-      params
-    end
-
   end
 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

data/lib/geocoder/lookups/ipregistry.rb

@@ -0,0 +1,68 @@
+require 'geocoder/lookups/base'
+require 'geocoder/results/ipregistry'
+
+module Geocoder::Lookup
+  class Ipregistry < Base
+
+    ERROR_CODES = {
+      400 => Geocoder::InvalidRequest,
+      401 => Geocoder::InvalidRequest,
+      402 => Geocoder::OverQueryLimitError,
+      403 => Geocoder::InvalidApiKey,
+      451 => Geocoder::RequestDenied,
+      500 => Geocoder::Error
+    }
+    ERROR_CODES.default = Geocoder::Error
+
+    def name
+      "Ipregistry"
+    end
+
+    def supported_protocols
+      [:https, :http]
+    end
+
+    private
+
+    def base_query_url(query)
+      "#{protocol}://#{host}/#{query.sanitized_text}?"
+    end
+
+    def cache_key(query)
+      query_url(query)
+    end
+
+    def host
+      configuration[:host] || "api.ipregistry.co"
+    end
+
+    def query_url_params(query)
+      {
+        key: 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?
+
+      return [] unless (doc = fetch_data(query))
+
+      if (error = doc['error'])
+        code = error['code']
+        msg = error['message']
+        raise_error(ERROR_CODES[code], msg ) || Geocoder.log(:warn, "Ipregistry API error: #{msg}")
+        return []
+      end
+      [doc]
+    end
+
+    def reserved_result(ip)
+      {
+        "ip"           => ip,
+        "country_name" => "Reserved",
+        "country_code" => "RD"
+      }
+    end
+  end
+end