googlemaps-services 1.4.8 → 1.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: ab65f2d525a0036cdc6f0688361a1dc4a1a79ef4
-  data.tar.gz: a00bb9f146fe4f01c96fb2fc36dd5479c56f6628
+  metadata.gz: d66db18e76aaabbfda292e570796a06925b53d2c
+  data.tar.gz: 791a850530ab52c1cb6e886ee58f1658c5661773
 SHA512:
-  metadata.gz: 2e0ca5e6e0945688767ccbbf87f04e502614603625cdb9fbfeac29d88971e06745c32504f7855c7c1b3a2c22b8b9284023cd7c965b038927805e9122e5d4ea68
-  data.tar.gz: c810e59699689468f2fe40f1b09cb1d602a0af219de44456255cbaad9e37c10c8de632cdc349b7d64833c7575440cb8af0c8fe251328202f534b16f7e97b1f8f
+  metadata.gz: 01d9c0b8161bf737619fb1b463c52176087ae74d9c064bdc742a732266edc5ce90149406e3d4a2c2601b25a0a5d2e6c33a47535fd726348d1d2a1cd5bd5d97ef
+  data.tar.gz: 4169f501b2e62b6ad6729ef13f53c42aeb8ca008f32e1633d05e027e35c3bf9bfdbc5c2542c8f92d6535fe93973affa5a065c9c8ed0e27fac27ad51394f45898

data/lib/googlemaps/services/client.rb

@@ -38,16 +38,18 @@ module GoogleMaps
       attr_accessor :retry_timeout
       # @return [Symbol] HTTP headers per request.
       attr_accessor :request_headers
-      # @return [Symbol] number of queries per second permitted. If the rate limit is reached, the client will sleep for the appropriate amout of time before it runs the current query.
+      # @return [Symbol] Number of queries per second permitted. If the rate limit is reached, the client will sleep for the appropriate amount of time before it runs the current query.
       attr_accessor :queries_per_second
       # @return [Symbol] keeps track of sent queries.
       attr_accessor :sent_times
+      # @return [Symbol] Should retry request when exceeds the query rate limit.
+      attr_accessor :retry_over_query_limit
       # @return [Symbol] Response format. Either :json or :xml
       attr_accessor :response_format
 
       def initialize(key: nil, client_id: nil, client_secret: nil, write_timeout: 2,
                      connect_timeout: 5, read_timeout: 10, retry_timeout: 60, request_headers: {},
-                     queries_per_second: 10, channel: nil, response_format: :json)
+                     queries_per_second: 50, channel: nil, retry_over_query_limit: true, response_format: :json)
         unless key || (client_secret && client_id)
           raise StandardError, 'Must provide API key or enterprise credentials when creating client.'
         end
@@ -75,9 +77,10 @@ module GoogleMaps
         self.client_secret = client_secret
         self.channel = channel
         self.retry_timeout = retry_timeout
-        self.request_headers = request_headers.merge({ 'User-Agent' => Constants::USER_AGENT })
+        self.request_headers = request_headers.merge({'User-Agent' => Constants::USER_AGENT})
         self.queries_per_second = queries_per_second
         self.sent_times = Array.new
+        self.retry_over_query_limit = retry_over_query_limit
 
         if response_format
           raise StandardError, 'Unsupported response format. Should be either :json or :xml.' unless [:json, :xml].include? response_format
@@ -100,7 +103,7 @@ module GoogleMaps
       #
       # @return [Hash, Array, nil] response body (either in JSON or XML) or nil.
       def request(url:, params:, first_request_time: nil, retry_counter: 0, base_url: Constants::DEFAULT_BASE_URL,
-              accepts_clientid: true, extract_body: nil, request_headers: nil, post_json: nil)
+                  accepts_clientid: true, extract_body: nil, request_headers: nil, post_json: nil)
         first_request_time = Util.current_time unless first_request_time
 
         elapsed = Time.now - first_request_time
@@ -128,15 +131,16 @@ module GoogleMaps
 
         # Create the request, add the headers & timeouts
         req = HTTP.headers(request_headers)
-                .timeout(:write => self.write_timeout, :connect => self.connect_timeout, :read => self.read_timeout)
+                  .timeout(:write => self.write_timeout, :connect => self.connect_timeout, :read => self.read_timeout)
 
         # Make the HTTP GET/POST request
         resp = post_json ? req.post(uri.to_s, :json => post_json) : req.get(uri.to_s)
 
         if Constants::RETRIABLE_STATUSES.include? resp.code.to_i
           # Retry request
-          self.request(url: url, params: params, first_request_time: first_request_time, retry_counter: retry_counter + 1, base_url: base_url,
-            accepts_clientid: accepts_clientid, extract_body: extract_body, request_headers: request_headers, post_json: post_json)
+          self.request(url: url, params: params, first_request_time: first_request_time, retry_counter: retry_counter + 1,
+                       base_url: base_url, accepts_clientid: accepts_clientid, extract_body: extract_body,
+                       request_headers: request_headers, post_json: post_json)
         end
 
         # Check if the time of the nth previous query (where n is queries_per_second)
@@ -166,10 +170,14 @@ module GoogleMaps
           end
           self.sent_times.push(Util.current_time)
           return result
-        rescue RetriableRequest
+        rescue RetriableRequest => e
+          if e.is_a?(OverQueryLimit) && !self.retry_over_query_limit
+            raise
+          end
           # Retry request
-          self.request(url: url, params: params, first_request_time: first_request_time, retry_counter: retry_counter + 1, base_url: base_url,
-            accepts_clientid: accepts_clientid, extract_body: extract_body, request_headers: request_headers, post_json: post_json)
+          self.request(url: url, params: params, first_request_time: first_request_time, retry_counter: retry_counter + 1,
+                       base_url: base_url, accepts_clientid: accepts_clientid, extract_body: extract_body,
+                       request_headers: request_headers, post_json: post_json)
         end
       end
 
@@ -212,7 +220,7 @@ module GoogleMaps
         end
 
         if api_status == 'OVER_QUERY_LIMIT'
-          raise RetriableRequest
+          raise OverQueryLimit
         end
 
         if body.key?('error_message')
@@ -236,7 +244,7 @@ module GoogleMaps
 
         # Parse the XML response body
         begin
-          doc = Nokogiri::XML(resp.body) { |config| config.strict }
+          doc = Nokogiri::XML(resp.body) {|config| config.strict}
         rescue
           raise APIError.new(status_code), 'Received a malformed XML response.'
         end
@@ -247,7 +255,7 @@ module GoogleMaps
         end
 
         if api_status == 'OVER_QUERY_LIMIT'
-          raise RetriableRequest
+          raise OverQueryLimit
         end
 
         error_message = doc.xpath('//error_message')
@@ -271,9 +279,9 @@ module GoogleMaps
         end
 
         {
-          :url => resp.uri.to_s,
-          :mime_type => resp.content_type.mime_type,
-          :image_data => Base64.encode64(resp.body).gsub(/\n/, '')
+            :url => resp.uri.to_s,
+            :mime_type => resp.content_type.mime_type,
+            :image_data => Base64.encode64(resp.body).gsub(/\n/, '')
         }
       end
 
@@ -286,7 +294,7 @@ module GoogleMaps
       # @param [TrueClass, FalseClass] accepts_clientid Flag whether to use a Client ID or not.
       #
       # @return [String] the final request path.
-      def generate_auth_url(path, params={}, accepts_clientid)
+      def generate_auth_url(path, params = {}, accepts_clientid)
         if accepts_clientid && self.client_id && self.client_secret
           if self.channel
             params['channel'] = self.channel

data/lib/googlemaps/services/directions.rb

@@ -116,9 +116,13 @@ module GoogleMaps
 
         case self.client.response_format
         when :xml
-          self.client.request(url: '/maps/api/directions/xml', params: params).xpath('//route')
+          self.client
+              .request(url: '/maps/api/directions/xml', params: params)
+              .xpath('//route')
         when :json
-          self.client.request(url: '/maps/api/directions/json', params: params)['routes']
+          self.client
+              .request(url: '/maps/api/directions/json', params: params)
+              .fetch('routes', [])
         else
           raise StandardError, 'Unsupported response format. Should be either :json or :xml.'
         end

data/lib/googlemaps/services/distancematrix.rb

@@ -34,11 +34,11 @@ module GoogleMaps
       # @param [String] transit_routing_preference Specifies preferences for transit requests. Valid values are "less_walking" or "fewer_transfers".
       # @param [String] traffic_model Specifies the predictive travel time model to use. Valid values are "best_guess" or "optimistic" or "pessimistic".
       #                               The traffic_model parameter may only be specified for requests where the travel mode is driving, and where the request includes a departure_time.
+      # @param [String] region The region code, specified as a ccTLD (country code top-level domain) two-character value.
       #
       # @return [Hash, Nokogiri::XML::Document] Matrix of distances.
-      def query(origins:, destinations:, mode: nil, language: nil, avoid: nil,
-                units: nil, departure_time: nil, arrival_time: nil, transit_mode: nil,
-                transit_routing_preference: nil, traffic_model: nil)
+      def query(origins:, destinations:, mode: nil, language: nil, avoid: nil, units: nil, departure_time: nil,
+                arrival_time: nil, transit_mode: nil, transit_routing_preference: nil, traffic_model: nil, region: nil)
         params = {
             'origins' => Convert.piped_location(origins),
             'destinations' => Convert.piped_location(destinations)
@@ -86,6 +86,10 @@ module GoogleMaps
           params['traffic_model'] = traffic_model
         end
 
+        if region
+          params['region'] = region
+        end
+
         self.client.request(url: "/maps/api/distancematrix/#{self.client.response_format}", params: params)
       end
     end

data/lib/googlemaps/services/elevation.rb

@@ -42,7 +42,7 @@ module GoogleMaps
             raise TypeError, 'Path should be either a String or an Array.'
           end
 
-          params = {'path' => path, 'samples' => samples }
+          params = {'path' => path, 'samples' => samples}
         end
 
         if path && locations
@@ -51,9 +51,13 @@ module GoogleMaps
 
         case self.client.response_format
         when :xml
-          self.client.request(url: '/maps/api/elevation/xml', params: params).xpath('//result')
+          self.client
+              .request(url: '/maps/api/elevation/xml', params: params)
+              .xpath('//result')
         when :json
-          self.client.request(url: '/maps/api/elevation/json', params: params)['results']
+          self.client
+              .request(url: '/maps/api/elevation/json', params: params)
+              .fetch('results', [])
         else
           raise StandardError, 'Unsupported response format. Should be either :json or :xml.'
         end

data/lib/googlemaps/services/exceptions.rb

@@ -50,6 +50,12 @@ module GoogleMaps
       class RetriableRequest < Exception
       end
 
+      # Signifies that the request failed because the client exceeded its query rate limit.
+      # Normally we treat this as a retriable condition, but we allow the calling code to specify
+      # that these requests should not be retried.
+      class OverQueryLimit < RetriableRequest
+      end
+
     end
   end
 end

data/lib/googlemaps/services/geocoding.rb

@@ -55,9 +55,13 @@ module GoogleMaps
 
         case self.client.response_format
         when :xml
-          self.client.request(url: '/maps/api/geocode/xml', params: params).xpath('//result')
+          self.client
+              .request(url: '/maps/api/geocode/xml', params: params)
+              .xpath('//result')
         when :json
-          self.client.request(url: '/maps/api/geocode/json', params: params)['results']
+          self.client
+              .request(url: '/maps/api/geocode/json', params: params)
+              .fetch('results', [])
         else
           raise StandardError, 'Unsupported response format. Should be either :json or :xml.'
         end
@@ -107,9 +111,13 @@ module GoogleMaps
 
         case self.client.response_format
         when :xml
-          self.client.request(url: '/maps/api/geocode/xml', params: params).xpath('//result')
+          self.client
+              .request(url: '/maps/api/geocode/xml', params: params)
+              .xpath('//result')
         when :json
-          self.client.request(url: '/maps/api/geocode/json', params: params)['results']
+          self.client
+              .request(url: '/maps/api/geocode/json', params: params)
+              .fetch('results', [])
         else
           raise StandardError, 'Unsupported response format. Should be either :json or :xml.'
         end

data/lib/googlemaps/services/geolocation.rb

@@ -94,6 +94,12 @@ module GoogleMaps
         status_code = response.code.to_i
         begin
           body = JSON.parse(response.body)
+          if [200, 404].include? status_code
+            return body
+          end
+          if status_code == 403
+            raise OverQueryLimit
+          end
         rescue JSON::ParserError
           raise APIError.new(status_code), 'Received malformed response.'
         end
@@ -101,11 +107,7 @@ module GoogleMaps
         if body.key?('error')
           raise APIError.new(status_code), body['error']['errors'][0]['reason']
         end
-
-        if status_code != 200
-          raise HTTPError.new(status_code)
-        end
-        body
+        raise HTTPError.new(status_code)
       end
 
       private :_geolocation_extract

data/lib/googlemaps/services/places.rb

@@ -22,14 +22,15 @@ module GoogleMaps
       # @param [Integer] max_price Restricts results to only those places with no greater than this price level. Valid values are in the range from 0 (most affordable) to 4 (most expensive).
       # @param [TrueClass, FalseClass] open_now Return only those places that are open for business at the time the query is sent.
       # @param [String] type Restricts the results to places matching the specified type. The full list of supported types is available here: https://developers.google.com/places/supported_types
+      # @param [String] region The region code, specified as a ccTLD (country code top-level domain) two-character value.
       # @param [String] page_token Token from a previous search that when provided will returns the next page of results for the same search.
       #
       # @return [Hash, Nokogiri::XML::Document] Valid JSON or XML response.
       def search(query:, location: nil, radius: nil, language: nil, min_price: nil,
-                 max_price: nil, open_now: false, type: nil, page_token: nil)
+                 max_price: nil, open_now: false, type: nil, region: nil, page_token: nil)
         _places(url_part: 'text', query: query, location: location, radius: radius,
                 language: language, min_price: min_price, max_price: max_price,
-                open_now: open_now, type: type, page_token: page_token)
+                open_now: open_now, type: type, region: region, page_token: page_token)
       end
 
       # Performs nearby search for places.
@@ -47,8 +48,11 @@ module GoogleMaps
       # @param [String] page_token Token from a previous search that when provided will returns the next page of results for the same search.
       #
       # @return [Hash, Nokogiri::XML::Document] Valid JSON or XML response.
-      def nearby(location:, radius: nil, keyword: nil, language: nil, min_price: nil,
+      def nearby(location: nil, radius: nil, keyword: nil, language: nil, min_price: nil,
                  max_price: nil, name: nil, open_now: false, rank_by: nil, type: nil, page_token: nil)
+        if !location && !page_token
+          raise StandardError, 'either a location or page_token is required.'
+        end
         if rank_by == 'distance'
           if !(keyword || name || type)
             raise StandardError, 'either a keyword, name or type arg is required when rank_by is set to distance.'
@@ -75,7 +79,8 @@ module GoogleMaps
       #
       # @return [Hash, Nokogiri::XML::Document] Valid JSON or XML response.
       def radar(location:, radius:, keyword: nil, min_price: nil,
-                     max_price: nil, name: nil, open_now: false, type: nil)
+                max_price: nil, name: nil, open_now: false, type: nil)
+        warn '[DEPRECATION] Places Radar is deprecated as of June 30, 2018. After that time, this feature will no longer be available.'
         raise StandardError, 'either a keyword, name, or type arg is required.' unless (keyword || name || type)
 
         _places(url_part: 'radar', location: location, radius: radius,
@@ -87,8 +92,8 @@ module GoogleMaps
       # @private
       def _places(url_part:, query: nil, location: nil, radius: nil, keyword: nil, language: nil,
                   min_price: 0, max_price: 4, name: nil, open_now: false, rank_by: nil, type: nil,
-                  page_token: nil)
-        params = {'minprice' => min_price, 'maxprice' => max_price }
+                  region: nil, page_token: nil)
+        params = {'minprice' => min_price, 'maxprice' => max_price}
 
         if query
           params['query'] = query
@@ -126,6 +131,10 @@ module GoogleMaps
           params['type'] = type
         end
 
+        if region
+          params['region'] = region
+        end
+
         if page_token
           params['pagetoken'] = page_token
         end
@@ -140,7 +149,7 @@ module GoogleMaps
       #
       # @return [Hash, Nokogiri::XML::Document] Valid JSON or XML response.
       def place_details(place_id:, language: nil)
-        params = {'placeid' => place_id }
+        params = {'placeid' => place_id}
         if language
           params['language'] = language
         end
@@ -178,13 +187,15 @@ module GoogleMaps
       # @param [String, Hash] location The latitude/longitude value for which you wish to obtain the closest, human-readable address.
       # @param [Integer] radius Distance in meters within which to bias results.
       # @param [String] language The language in which to return results.
-      # @param [String] type Restricts the results to places matching the specified type. The full list of supported types is available here: https://developers.google.com/places/web-service/autocomplete#place_types
-      # @param [Hash] components A component filter for which you wish to obtain a geocode, e.g. "{'administrative_area': 'TX','country': 'US'}"
+      # @param [String] types Restricts the results to places matching the specified type. The full list of supported types is available here: https://developers.google.com/places/web-service/autocomplete#place_types
+      # @param [Hash] components A grouping of places to which you would like to restrict your results. Currently, you can use components to filter by up to 5 countries for example: {'country': ['US', 'AU']}
+      # @param [TrueClass,FalseClass] strict_bounds Returns only those places that are strictly within the region defined by location and radius.
       #
       # @return [Array, Nokogiri::XML::NodeSet] Array of predictions.
-      def autocomplete(input_text:, offset: nil, location: nil, radius: nil, language: nil, type: nil, components: nil)
-        _autocomplete(url_part: "", input_text: input_text, offset: offset, location: location,
-                      radius: radius, language: language, type: type, components: components)
+      def autocomplete(input_text:, offset: nil, location: nil, radius: nil, language: nil,
+                       types: nil, components: nil, strict_bounds: false)
+        _autocomplete(url_part: "", input_text: input_text, offset: offset, location: location, radius: radius,
+                      language: language, types: types, components: components, strict_bounds: strict_bounds)
       end
 
       # Returns Place predictions given a textual search query, such as "pizza near Brussels", and optional geographic bounds.
@@ -203,9 +214,9 @@ module GoogleMaps
 
       # Handler for "autocomplete" and "autocomplete_query" queries.
       # @private
-      def _autocomplete(url_part:, input_text:, offset: nil, location: nil,
-                       radius: nil, language: nil, type: nil, components: nil)
-        params = {'input' => input_text }
+      def _autocomplete(url_part:, input_text:, offset: nil, location: nil, radius: nil,
+                        language: nil, types: nil, components: nil, strict_bounds: false)
+        params = {'input' => input_text}
 
         if offset
           params['offset'] = offset
@@ -223,19 +234,30 @@ module GoogleMaps
           params['language'] = language
         end
 
-        if type
-          params['type'] = type
+        if types
+          params['types'] = types
         end
 
         if components
+          if components.size != 1 || components.keys[0] != 'country'
+            raise StandardError, 'Only country components are supported.'
+          end
           params['components'] = Convert.components(components)
         end
 
+        if strict_bounds
+          params['strictbounds'] = 'true'
+        end
+
         case self.client.response_format
         when :xml
-          self.client.request(url: "/maps/api/place/#{url_part}autocomplete/xml", params: params).xpath('//prediction')
+          self.client
+              .request(url: "/maps/api/place/#{url_part}autocomplete/xml", params: params)
+              .xpath('//prediction')
         when :json
-          self.client.request(url: "/maps/api/place/#{url_part}autocomplete/json", params: params)['predictions']
+          self.client
+              .request(url: "/maps/api/place/#{url_part}autocomplete/json", params: params)
+              .fetch('predictions', [])
         else
           raise StandardError, 'Unsupported response format. Should be either :json or :xml.'
         end

data/lib/googlemaps/services/roads.rb

@@ -28,14 +28,16 @@ module GoogleMaps
       #
       # @return [Array] Array of snapped points.
       def snap_to_roads(path:, interpolate: false)
-        params = {'path' => Convert.piped_location(path) }
+        params = {'path' => Convert.piped_location(path)}
 
         if interpolate
           params['interpolate'] = 'true'
         end
 
-        self.client.request(url: '/v1/snapToRoads', params: params, base_url: Constants::ROADS_BASE_URL,
-                        accepts_clientid: false, extract_body: lambda(&method(:_roads_extract)))['snappedPoints']
+        self.client
+            .request(url: '/v1/snapToRoads', params: params, base_url: Constants::ROADS_BASE_URL, accepts_clientid: false,
+                     extract_body: lambda(&method(:_roads_extract)))
+            .fetch('snappedPoints', [])
       end
 
       # Returns the posted speed limit (in km/h) for given road segments.
@@ -49,8 +51,10 @@ module GoogleMaps
 
         params = {'placeId' => place_ids}
 
-        self.client.request(url: '/v1/speedLimits', params: params, base_url: Constants::ROADS_BASE_URL,
-                        accepts_clientid: false, extract_body: lambda(&method(:_roads_extract)))['speedLimits']
+        self.client
+            .request(url: '/v1/speedLimits', params: params, base_url: Constants::ROADS_BASE_URL, accepts_clientid: false,
+                     extract_body: lambda(&method(:_roads_extract)))
+            .fetch('speedLimits', [])
       end
 
       # Returns the posted speed limit (in km/h) for given road segments.
@@ -62,8 +66,9 @@ module GoogleMaps
       def snapped_speed_limits(path:)
         params = {'path' => Convert.piped_location(path)}
 
-        self.client.request(url: '/v1/speedLimits', params: params, base_url: Constants::ROADS_BASE_URL,
-                        accepts_clientid: false, extract_body: lambda(&method(:_roads_extract)))
+        self.client
+            .request(url: '/v1/speedLimits', params: params, base_url: Constants::ROADS_BASE_URL,
+                     accepts_clientid: false, extract_body: lambda(&method(:_roads_extract)))
       end
 
       # Find the closest road segments for each point.
@@ -76,8 +81,10 @@ module GoogleMaps
       def nearest_roads(points:)
         params = {'points' => Convert.piped_location(points)}
 
-        self.client.request(url: '/v1/nearestRoads', params: params, base_url: Constants::ROADS_BASE_URL,
-                        accepts_clientid: false, extract_body: lambda(&method(:_roads_extract)))['snappedPoints']
+        self.client
+            .request(url: '/v1/nearestRoads', params: params, base_url: Constants::ROADS_BASE_URL, accepts_clientid: false,
+                     extract_body: lambda(&method(:_roads_extract)))
+            .fetch('snappedPoints', [])
       end
 
       # Extracts result from the Roads API HTTP response.
@@ -100,7 +107,7 @@ module GoogleMaps
           status = error['status']
 
           if status == 'RESOURCE_EXHAUSTED'
-            raise RetriableRequest
+            raise OverQueryLimit
           end
 
           if error.respond_to?(:key?) && error.key?('message')

data/lib/googlemaps/services/version.rb

@@ -1,5 +1,5 @@
 module GoogleMaps
   module Services
-    VERSION = '1.4.8'.freeze
+    VERSION = '1.5.0'.freeze
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: googlemaps-services
 version: !ruby/object:Gem::Version
-  version: 1.4.8
+  version: 1.5.0
 platform: ruby
 authors:
 - Faissal Elamraoui
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-03-19 00:00:00.000000000 Z
+date: 2018-05-19 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: nokogiri