googlemaps-services 1.2.0 → 1.2.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 79eb630dafebed0e332508c6dc831f9277c0265e
-  data.tar.gz: fe3a16fb698d040c80ad5cdedaf97234d3b6c3bf
+  metadata.gz: 18a00c19fa244488e45d19b1072506587f597e57
+  data.tar.gz: 1d4bf5cef38c7d6be03bd438d2e30278eef31ee3
 SHA512:
-  metadata.gz: 561e0cc11204546985cc8a970f95cbb6b4c90453af643b2f5edbd71525278e06f0a39be13f18927105462d250e407adc250acd2fa82041a900e31a4f1cec6e42
-  data.tar.gz: 1c6ae80c50a9038f2273b7da4f416bf0a759b9d6ba542a0359aa3e60f74d7404a0eb6e6ceb2a957ace35c7c4f45250322c7110cf9c1cd25c71cc2dbdf3b8c43f
+  metadata.gz: 99aa38b29add2f487377ceef2a6cba9e9881defa8c2b6c3a0303a69bdbee8c2cfa4fd94414dda0d40fa2a4bd6b3f5a15b155dea9e66121862cd8d252a4aad270
+  data.tar.gz: da2efaedd9b47501bc815b005ae47e7a2f97552fcfba47bf61c89b84d5c8e64309ad4b99426cf6b30eedf6fbfc38b77cf8190a6e90abc3fc20b70c1b7b59f781

data/lib/googlemaps/services/client.rb

@@ -1,9 +1,9 @@
-require "googlemaps/services/exceptions"
-require "googlemaps/services/version"
-require "googlemaps/services/util"
-require "nokogiri"
-require "net/http"
-require "json"
+require 'googlemaps/services/exceptions'
+require 'googlemaps/services/version'
+require 'googlemaps/services/util'
+require 'nokogiri'
+require 'net/http'
+require 'json'
 
 # Core functionality, common across all API requests.
 #
@@ -13,9 +13,9 @@ module GoogleMaps
   #
   # @since 1.0.0
   module Services
-    $USER_AGENT = "GoogleMapsRubyClient/" + VERSION
-    $DEFAULT_BASE_URL = "https://maps.googleapis.com"
-    $RETRIABLE_STATUSES = [500, 503, 504]
+    USER_AGENT = 'GoogleMapsRubyClient/' + VERSION
+    DEFAULT_BASE_URL = 'https://maps.googleapis.com'
+    RETRIABLE_STATUSES = [500, 503, 504]
 
     # Performs requests to the Google Maps API web services.
     class GoogleClient
@@ -43,30 +43,30 @@ module GoogleMaps
       attr_accessor :response_format
 
       def initialize(key:, client_id: nil, client_secret: nil, timeout: nil,
-                     connect_timeout: nil, read_timeout: nil,retry_timeout: 60, request_opts: nil,
+                     connect_timeout: nil, read_timeout: nil,retry_timeout: 60, request_opts: {},
                      queries_per_second: 10, channel: nil, response_format: :json)
         if !key && !(client_secret && client_id)
-          raise StandardError, "Must provide API key or enterprise credentials when creationg client."
+          raise StandardError, 'Must provide API key or enterprise credentials when creationg client.'
         end
 
-        if key && !key.start_with?("AIza")
-          raise StandardError, "Invalid API key provided."
+        if key && !key.start_with?('AIza')
+          raise StandardError, 'Invalid API key provided.'
         end
 
         if channel
-          if !client_id
-            raise StandardError, "The channel argument must be used with a client ID."
+          unless client_id
+            raise StandardError, 'The channel argument must be used with a client ID.'
           end
 
-          if !/^[a-zA-Z0-9._-]*$/.match(channel)
-            raise StandardError, "The channel argument must be an ASCII alphanumeric string. The period (.), underscore (_) and hyphen (-) characters are allowed."
+          unless /^[a-zA-Z0-9._-]*$/.match(channel)
+            raise StandardError, 'The channel argument must be an ASCII alphanumeric string. The period (.), underscore (_) and hyphen (-) characters are allowed.'
           end
         end
 
         self.key = key
 
         if timeout && (connect_timeout || read_timeout)
-          raise StandardError, "Specify either timeout, or connect_timeout and read_timeout."
+          raise StandardError, 'Specify either timeout, or connect_timeout and read_timeout.'
         end
 
         if connect_timeout && read_timeout
@@ -79,18 +79,16 @@ module GoogleMaps
         self.client_secret = client_secret
         self.channel = channel
         self.retry_timeout = retry_timeout
-        self.request_opts = request_opts || {}
-        self.request_opts.merge!({
-                                      :headers => {"User-Agent" => $USER_AGENT},
-                                      :timeout => self.timeout,
-                                      :verify => true
-                                    })
-
+        self.request_opts = request_opts.merge({
+                                                   :headers => {'User-Agent' => USER_AGENT},
+                                                   :timeout => self.timeout,
+                                                   :verify => true
+                                               })
         self.queries_per_second = queries_per_second
         self.sent_times = Array.new
 
         if response_format
-          raise StandardError, "Unsupported response format. Should be either :json or :xml." unless [:json, :xml].include? response_format
+          raise StandardError, 'Unsupported response format. Should be either :json or :xml.' unless [:json, :xml].include? response_format
           self.response_format = response_format
         end
       end
@@ -108,9 +106,9 @@ module GoogleMaps
       # @param [Hash] request_opts Additional options for the Net::HTTP client.
       #
       # @return [Hash, Array] response body, either in JSON or XML.
-      def get(url:, params:, first_request_time: nil, retry_counter: nil, base_url: $DEFAULT_BASE_URL,
+      def get(url:, params:, first_request_time: nil, retry_counter: nil, base_url: DEFAULT_BASE_URL,
               accepts_clientid: true, extract_body: nil, request_opts: nil)
-        if !first_request_time
+        unless first_request_time
           first_request_time = Util.current_time
         end
 
@@ -125,7 +123,7 @@ module GoogleMaps
           # at 1, so subtract that first.
           delay_seconds = 0.5 * 1.5 ** (retry_counter - 1)
           # Jitter this value by 50% and pause.
-          sleep(delay_seconds * (random.random() + 0.5))
+          sleep(delay_seconds * (random.random + 0.5))
         end
 
         authed_url = generate_auth_url(url, params, accepts_clientid)
@@ -143,7 +141,7 @@ module GoogleMaps
         request_opts[:headers].each { |header,value| req.add_field(header, value) }
 
         http = Net::HTTP.new(uri.host, uri.port)
-        http.use_ssl = (uri.scheme == "https")
+        http.use_ssl = (uri.scheme == 'https')
         # Get HTTP response
         resp = http.request(req)
 
@@ -152,10 +150,10 @@ module GoogleMaps
         when Net::HTTPRequestTimeOut
           raise Timeout
         when Exception
-          raise TransportError, "HTTP GET request failed."
+          raise TransportError, 'HTTP GET request failed.'
         end
 
-        if $RETRIABLE_STATUSES.include? resp.code.to_i
+        if RETRIABLE_STATUSES.include? resp.code.to_i
           # Retry request
           self.get(url, params, first_request_time, retry_counter + 1,
                    base_url, accepts_clientid, extract_body)
@@ -185,9 +183,8 @@ module GoogleMaps
           self.sent_times.push(Util.current_time)
           return result
         rescue RetriableRequest
-          # retry request
-          return self.get(url, params, first_request_time, retry_counter + 1,
-                          base_url, accepts_clientid, extract_body)
+          # Retry request
+          return self.get(url, params, first_request_time, retry_counter + 1, base_url, accepts_clientid, extract_body)
         end
       end
 
@@ -201,7 +198,7 @@ module GoogleMaps
       def get_json_body(resp)
         status_code = resp.code.to_i
         if status_code >= 300 && status_code < 400
-          return resp["location"]
+          return resp['location']
         end
 
         if status_code != 200
@@ -212,20 +209,20 @@ module GoogleMaps
         begin
           body = JSON.parse(resp.body)
         rescue JSON::ParserError
-          raise APIError.new(status_code), "Received a malformed JSON response."
+          raise APIError.new(status_code), 'Received a malformed JSON response.'
         end
 
-        api_status = body["status"]
-        if api_status == "OK" || api_status == "ZERO_RESULTS"
+        api_status = body['status']
+        if api_status == 'OK' || api_status == 'ZERO_RESULTS'
           return body
         end
 
-        if api_status == "OVER_QUERY_LIMIT"
+        if api_status == 'OVER_QUERY_LIMIT'
           raise RetriableRequest
         end
 
-        if body.key?("error_message")
-          raise APIError.new(api_status), body["error_message"]
+        if body.key?('error_message')
+          raise APIError.new(api_status), body['error_message']
         else
           raise APIError.new(api_status)
         end
@@ -241,7 +238,7 @@ module GoogleMaps
       def get_xml_body(resp)
         status_code = resp.code.to_i
         if status_code >= 300 && status_code < 400
-          return resp["location"]
+          return resp['location']
         end
 
         if status_code != 200
@@ -251,19 +248,19 @@ module GoogleMaps
         begin
           doc = Nokogiri::XML.parse(resp.body)
         rescue
-          raise APIError.new(status_code), "Received a malformed XML response."
+          raise APIError.new(status_code), 'Received a malformed XML response.'
         end
 
-        api_status = doc.xpath("//status").first.text
-        if api_status == "OK" || api_status == "ZERO_RESULTS"
+        api_status = doc.xpath('//status').first.text
+        if api_status == 'OK' || api_status == 'ZERO_RESULTS'
           return doc
         end
 
-        if api_status == "OVER_QUERY_LIMIT"
+        if api_status == 'OVER_QUERY_LIMIT'
           raise RetriableRequest
         end
 
-        error_message = doc.xpath("//error_message")
+        error_message = doc.xpath('//error_message')
         if error_message
           raise APIError.new(api_status), error_message.text
         else
@@ -283,21 +280,21 @@ module GoogleMaps
       def generate_auth_url(path, params={}, accepts_clientid)
         if accepts_clientid && self.client_id && self.client_secret
           if self.channel
-            params["channel"] = self.channel
+            params['channel'] = self.channel
           end
-          params["client"] = self.client_id
+          params['client'] = self.client_id
 
-          path = [path, Util.urlencode_params(params)].join("?")
+          path = [path, Util.urlencode_params(params)].join('?')
           sig = Util.sign_hmac(self.client_secret, path)
-          return path + "&signature=" + sig
+          return path + '&signature=' + sig
         end
 
         if self.key
-          params["key"] = self.key
-          return path + "?" + Util.urlencode_params(params)
+          params['key'] = self.key
+          return path + '?' + Util.urlencode_params(params)
         end
 
-        raise StandardError, "Must provide API key for this API. It does not accept enterprise credentials."
+        raise StandardError, 'Must provide API key for this API. It does not accept enterprise credentials.'
       end
 
       private :get_json_body, :get_xml_body, :generate_auth_url

data/lib/googlemaps/services/directions.rb

@@ -1,8 +1,8 @@
-require "googlemaps/services/util"
+require 'googlemaps/services/util'
 
 module GoogleMaps
   module Services
-    $TRAVEL_MODES = ["driving", "walking", "bicycling", "transit"]
+    TRAVEL_MODES = %w(driving walking bicycling transit)
 
     # Performs requests to the Google Maps Directions API.
     #
@@ -48,74 +48,74 @@ module GoogleMaps
                 arrival_time: nil, optimize_waypoints: false, transit_mode: nil,
                 transit_routing_preference: nil, traffic_model: nil)
         params = {
-          "origin" => Convert.to_latlng(origin),
-          "destination" => Convert.to_latlng(destination)
+            'origin' => Convert.to_latlng(origin),
+            'destination' => Convert.to_latlng(destination)
         }
 
         if mode
-          if !$TRAVEL_MODES.include? mode
-            raise StandardError, "invalid travel mode."
+          unless TRAVEL_MODES.include? mode
+            raise StandardError, 'invalid travel mode.'
           end
-          params["mode"] = mode
+          params['mode'] = mode
         end
 
         if waypoints
           waypoints = Convert.piped_location(waypoints)
           if optimize_waypoints
-            waypoints = "optimize:true|" + waypoints
+            waypoints = 'optimize:true|' + waypoints
           end
-          params["waypoints"] = waypoints
+          params['waypoints'] = waypoints
         end
 
         if alternatives
-          params["alternatives"] = true
+          params['alternatives'] = true
         end
 
         if avoid
-          params["avoid"] = Convert.join_array("|", avoid)
+          params['avoid'] = Convert.join_array('|', avoid)
         end
 
         if language
-          params["language"] = language
+          params['language'] = language
         end
 
         if units
-          params["units"] = units
+          params['units'] = units
         end
 
         if region
-          params["region"] = region
+          params['region'] = region
         end
 
         if departure_time
-          params["departure_time"] = Convert.unix_time(departure_time)
+          params['departure_time'] = Convert.unix_time(departure_time)
         end
 
         if arrival_time
-          params["arrival_time"] = Convert.unix_time(arrival_time)
+          params['arrival_time'] = Convert.unix_time(arrival_time)
         end
 
         if departure_time && arrival_time
-          raise StandardError, "should not specify both departure_time and arrival_time."
+          raise StandardError, 'should not specify both departure_time and arrival_time.'
         end
 
         if transit_mode
-          params["transit_mode"] = Convert.join_array("|", transit_mode)
+          params['transit_mode'] = Convert.join_array('|', transit_mode)
         end
 
         if transit_routing_preference
-          params["transit_routing_preference"] = transit_routing_preference
+          params['transit_routing_preference'] = transit_routing_preference
         end
 
         if traffic_model
-          params["traffic_model"] = traffic_model
+          params['traffic_model'] = traffic_model
         end
 
         case self.client.response_format
         when :xml
-          self.client.get(url: "/maps/api/directions/xml", params: params).xpath("//route")
+          self.client.get(url: '/maps/api/directions/xml', params: params).xpath('//route')
         else
-          self.client.get(url: "/maps/api/directions/json", params: params)["routes"]
+          self.client.get(url: '/maps/api/directions/json', params: params)['routes']
         end
       end
     end

data/lib/googlemaps/services/distancematrix.rb

@@ -1,9 +1,8 @@
-require "googlemaps/services/util"
+require 'googlemaps/services/util'
 
 module GoogleMaps
   module Services
-
-    $AVOIDS = ["tolls", "highways", "ferries"]
+    AVOIDS = %w(tolls highways ferries)
 
     # Performs requests to the Google Maps Distance Matrix API.
     #
@@ -41,57 +40,53 @@ module GoogleMaps
                 units: nil, departure_time: nil, arrival_time: nil, transit_mode: nil,
                 transit_routing_preference: nil, traffic_model: nil)
         params = {
-          "origins" => Convert.piped_location(origins),
-          "destinations" => Convert.piped_location(destinations)
+            'origins' => Convert.piped_location(origins),
+            'destinations' => Convert.piped_location(destinations)
         }
 
         if mode
-          if !$TRAVEL_MODES.include? mode
-            raise StandardError, "Invalid travel mode."
-          end
-          params["mode"] = mode
+          raise StandardError, 'Invalid travel mode.' unless TRAVEL_MODES.include? mode
+          params['mode'] = mode
         end
 
         if language
-          params["language"] = language
+          params['language'] = language
         end
 
         if avoid
-          if !$AVOIDS.include? avoid
-            raise StandardError, "Invalid route restriction."
-          end
-          params["avoid"] = avoid
+          raise StandardError, 'Invalid route restriction.' unless AVOIDS.include? avoid
+          params['avoid'] = avoid
         end
 
         if units
-          params["units"] = units
+          params['units'] = units
         end
 
         if departure_time
-          params["departure_time"] = Convert.unix_time(departure_time)
+          params['departure_time'] = Convert.unix_time(departure_time)
         end
 
         if arrival_time
-          params["arrival_time"] = Convert.unix_time(arrival_time)
+          params['arrival_time'] = Convert.unix_time(arrival_time)
         end
 
         if departure_time && arrival_time
-          raise StandardError, "Should not specify both departure_time and arrival_time."
+          raise StandardError, 'Should not specify both departure_time and arrival_time.'
         end
 
         if transit_mode
-          params["transit_mode"] = Convert.join_arrayt("|", transit_mode)
+          params['transit_mode'] = Convert.join_array('|', transit_mode)
         end
 
         if transit_routing_preference
-          params["transit_routing_preference"] = transit_routing_preference
+          params['transit_routing_preference'] = transit_routing_preference
         end
 
         if traffic_model
-          params["traffic_model"] = traffic_model
+          params['traffic_model'] = traffic_model
         end
 
-        self.client.get(url: "/maps/api/distancematrix/#{self.client.response_format}", params: params).class
+        self.client.get(url: "/maps/api/distancematrix/#{self.client.response_format}", params: params)
       end
     end
   end

data/lib/googlemaps/services/elevation.rb

@@ -1,4 +1,4 @@
-require "googlemaps/services/util"
+require 'googlemaps/services/util'
 
 
 module GoogleMaps
@@ -29,30 +29,31 @@ module GoogleMaps
         params = {}
 
         if path && locations
-          raise StandardError, "Should not specify both path and locations."
+          raise StandardError, 'Should not specify both path and locations.'
         end
 
         if locations
-          params["locations"] = Convert.shortest_path(locations)
+          params['locations'] = Convert.shortest_path(locations)
         end
 
         if path
-          if path.is_a? String
+          case path.class
+          when String
             path = "enc:#{path}"
-          elsif path.is_a? Array
+          when Array
             path = Convert.shortest_path(path)
           else
-            raise TypeError, "Path should be either a String or an Array."
+            raise TypeError, 'Path should be either a String or an Array.'
           end
 
-          params = { "path" => path, "samples" => samples }
+          params = {'path' => path, 'samples' => samples }
         end
 
         case self.client.response_format
         when :xml
-          self.client.get(url: "/maps/api/elevation/xml", params: params).xpath("//result")
+          self.client.get(url: '/maps/api/elevation/xml', params: params).xpath('//result')
         else
-          self.client.get(url: "/maps/api/elevation/json", params: params)["results"]
+          self.client.get(url: '/maps/api/elevation/json', params: params)['results']
         end
       end
     end

data/lib/googlemaps/services/exceptions.rb

@@ -42,7 +42,7 @@ module GoogleMaps
         #
         # @return [String] Human-readable error string.
         def to_s
-          "The request timed out."
+          'The request timed out.'
         end
       end
 

data/lib/googlemaps/services/geocoding.rb

@@ -1,4 +1,4 @@
-require "googlemaps/services/util"
+require 'googlemaps/services/util'
 
 
 module GoogleMaps
@@ -34,30 +34,30 @@ module GoogleMaps
         params = {}
 
         if address
-          params["address"] = address
+          params['address'] = address
         end
 
         if components
-          params["components"] = Convert.components(components)
+          params['components'] = Convert.components(components)
         end
 
         if bounds
-          params["bounds"] = Convert.bounds(bounds)
+          params['bounds'] = Convert.bounds(bounds)
         end
 
         if region
-          params["region"] = region
+          params['region'] = region
         end
 
         if language
-          params["language"] = language
+          params['language'] = language
         end
 
         case self.client.response_format
         when :xml
-          self.client.get(url: "/maps/api/geocode/xml", params: params).xpath("//result")
+          self.client.get(url: '/maps/api/geocode/xml', params: params).xpath('//result')
         else
-          self.client.get(url: "/maps/api/geocode/json", params: params)["results"]
+          self.client.get(url: '/maps/api/geocode/json', params: params)['results']
         end
       end
     end
@@ -86,28 +86,28 @@ module GoogleMaps
         # Check if latlng param is a place_id string.
         # 'place_id' strings do not contain commas; latlng strings do.
         if latlng.is_a?(String) && !latlng.include?("'")
-          params = {"place_id" => latlng}
+          params = {'place_id' => latlng}
         else
-          params = {"latlng" => Convert.to_latlng(latlng)}
+          params = {'latlng' => Convert.to_latlng(latlng)}
         end
 
         if result_type
-          params["result_type"] = Convert.join_array("|", result_type)
+          params['result_type'] = Convert.join_array('|', result_type)
         end
 
         if location_type
-          params["location_type"] = Convert.join_array("|", location_type)
+          params['location_type'] = Convert.join_array('|', location_type)
         end
 
         if language
-          params["language"] = language
+          params['language'] = language
         end
 
         case self.client.response_format
         when :xml
-          self.client.get(url: "/maps/api/geocode/xml", params: params).xpath("//result")
+          self.client.get(url: '/maps/api/geocode/xml', params: params).xpath('//result')
         else
-          self.client.get(url: "/maps/api/geocode/json", params: params)["results"]
+          self.client.get(url: '/maps/api/geocode/json', params: params)['results']
         end
       end
     end

data/lib/googlemaps/services/places.rb

@@ -1,4 +1,4 @@
-require "googlemaps/services/util"
+require 'googlemaps/services/util'
 
 module GoogleMaps
   module Services
@@ -27,8 +27,8 @@ module GoogleMaps
       # @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)
-        _places(url_part: "text", query: query, location: location, radius: radius,
-                language: language, min_price: min_price,  max_price: max_price,
+        _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)
       end
 
@@ -49,15 +49,15 @@ module GoogleMaps
       # @return [Hash, Nokogiri::XML::Document] Valid JSON or XML response.
       def nearby(location:, 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 rank_by == "distance"
+        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."
+            raise StandardError, 'either a keyword, name or type arg is required when rank_by is set to distance.'
           elsif radius
-            raise StandardError, "radius cannot be specified when rank_by is set to distance."
+            raise StandardError, 'radius cannot be specified when rank_by is set to distance.'
           end
         end
 
-        _places(url_part: "nearby", location: location, radius: radius, keyword: keyword, language: language,
+        _places(url_part: 'nearby', location: location, radius: radius, keyword: keyword, language: language,
                 min_price: min_price, max_price: max_price, name: name, open_now: open_now, rank_by: rank_by,
                 type: type, page_token: page_token)
       end
@@ -76,13 +76,13 @@ 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)
-        if !(keyword || name || type)
-          raise StandardError, "either a keyword, name, or type arg is required."
+        unless keyword || name || type
+          raise StandardError, 'either a keyword, name, or type arg is required.'
         end
 
-        _places(url_part: "radar", location: location, radius: radius,
-                       keyword: keyword, min_price: min_price, max_price: max_price,
-                       name: name, open_now: open_now, type: type)
+        _places(url_part: 'radar', location: location, radius: radius,
+                keyword: keyword, min_price: min_price, max_price: max_price,
+                name: name, open_now: open_now, type: type)
       end
 
       # Handler for "places", "places_nearby" and "places_radar" queries.
@@ -90,52 +90,51 @@ module GoogleMaps
       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 }
+        params = {'minprice' => min_price, 'maxprice' => max_price }
 
         if query
-          params["query"] = query
+          params['query'] = query
         end
 
         if location
-          params["location"] = Convert.to_latlng(location)
+          params['location'] = Convert.to_latlng(location)
         end
 
         if radius
-          params["radius"] = radius
+          params['radius'] = radius
         end
 
         if keyword
-          params["keyword"] = keyword
+          params['keyword'] = keyword
         end
 
         if language
-          params["language"] = language
+          params['language'] = language
         end
 
         if name
-          params["name"] = Convert.join_array(" ", name)
+          params['name'] = Convert.join_array(' ', name)
         end
 
         if open_now
-          params["opennow"] = "true"
+          params['opennow'] = 'true'
         end
 
         if rank_by
-          params["rankby"] = rank_by
+          params['rankby'] = rank_by
         end
 
         if type
-          params["type"] = type
+          params['type'] = type
         end
 
         if page_token
-          params["pagetoken"] = page_token
+          params['pagetoken'] = page_token
         end
 
         self.client.get(url: "/maps/api/place/#{url_part}search/#{self.client.response_format}", params: params)
       end
 
-
       # Comprehensive details for an individual place.
       #
       # @param [String] place_id A textual identifier that uniquely identifies a place, returned from a Places search.
@@ -143,9 +142,9 @@ 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
+          params['language'] = language
         end
 
         self.client.get(url: "/maps/api/place/details/#{self.client.response_format}", params: params)
@@ -159,21 +158,21 @@ module GoogleMaps
       #
       # @return [String] URL of the photo.
       def place_photo(photo_reference:, max_width: nil, max_height: nil)
-        if !(max_width || max_height)
-          raise StandardError, "a max_width or max_height arg is required"
+        unless max_width || max_height
+          raise StandardError, 'a max_width or max_height arg is required'
         end
 
-        params = {"photoreference" => photo_reference}
+        params = {'photoreference' => photo_reference}
 
         if max_width
-          params["maxwidth"] = max_width
+          params['maxwidth'] = max_width
         end
 
         if max_height
-          params["maxheight"] = max_height
+          params['maxheight'] = max_height
         end
 
-        self.client.get(url: "/maps/api/place/photo", params: params)
+        self.client.get(url: '/maps/api/place/photo', params: params)
       end
 
       # Returns Place predictions given a textual search string and optional geographic bounds.
@@ -202,7 +201,7 @@ module GoogleMaps
       #
       # @return [Array, Nokogiri::XML::NodeSet] Array of predictions.
       def autocomplete_query(input_text:, offset: nil, location: nil, radius: nil, language: nil)
-        _autocomplete(url_part: "query", input_text: input_text, offset: offset,
+        _autocomplete(url_part: 'query', input_text: input_text, offset: offset,
                       location: location, radius: radius, language: language)
       end
 
@@ -210,37 +209,37 @@ module GoogleMaps
       # @private
       def _autocomplete(url_part:, input_text:, offset: nil, location: nil,
                        radius: nil, language: nil, type: nil, components: nil)
-        params = { "input" => input_text }
+        params = {'input' => input_text }
 
         if offset
-          params["offset"] = offset
+          params['offset'] = offset
         end
 
         if location
-          params["location"] = Convert.to_latlng(location)
+          params['location'] = Convert.to_latlng(location)
         end
 
         if radius
-          params["radius"] = radius
+          params['radius'] = radius
         end
 
         if language
-          params["language"] = language
+          params['language'] = language
         end
 
         if type
-          params["type"] = type
+          params['type'] = type
         end
 
         if components
-          params["components"] = Convert.components(components)
+          params['components'] = Convert.components(components)
         end
 
         case self.client.response_format
         when :xml
-          self.client.get(url: "/maps/api/place/#{url_part}autocomplete/xml", params: params).xpath("//prediction")
+          self.client.get(url: "/maps/api/place/#{url_part}autocomplete/xml", params: params).xpath('//prediction')
         else
-          self.client.get(url: "/maps/api/place/#{url_part}autocomplete/json", params: params)["predictions"]
+          self.client.get(url: "/maps/api/place/#{url_part}autocomplete/json", params: params)['predictions']
         end
       end
 

data/lib/googlemaps/services/roads.rb

@@ -1,11 +1,10 @@
-require "googlemaps/services/exceptions"
-require "googlemaps/services/util"
-require "json"
+require 'googlemaps/services/exceptions'
+require 'googlemaps/services/util'
+require 'json'
 
 module GoogleMaps
   module Services
-
-    $ROADS_BASE_URL = "https://roads.googleapis.com"
+    ROADS_BASE_URL = 'https://roads.googleapis.com'
 
     # Performs requests to the Google Maps Roads API.
     class Roads
@@ -17,19 +16,19 @@ module GoogleMaps
         begin
           body = JSON.parse(resp.body)
         rescue JSON::ParserError
-          raise APIError.new(status_code), "Received malformed response."
+          raise APIError.new(status_code), 'Received malformed response.'
         end
 
-        if body.key?("error")
-          error = body["error"]
-          status = error["status"]
+        if body.key?('error')
+          error = body['error']
+          status = error['status']
 
-          if status == "RESOURCE_EXHAUSTED"
+          if status == 'RESOURCE_EXHAUSTED'
             raise RetriableRequest
           end
 
-          if error.key?("message")
-            raise APIError.new(status), error["message"]
+          if error.key?('message')
+            raise APIError.new(status), error['message']
           else
             raise APIError.new(status)
           end
@@ -59,14 +58,14 @@ 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"
+          params['interpolate'] = 'true'
         end
 
-        self.client.get(url: "/v1/snapToRoads", params: params, base_url: $ROADS_BASE_URL,
-                        accepts_clientid: false, extract_body: @@_roads_extract)["snappedPoints"]
+        self.client.get(url: '/v1/snapToRoads', params: params, base_url: ROADS_BASE_URL,
+                        accepts_clientid: false, extract_body: @@_roads_extract)['snappedPoints']
       end
 
       # Returns the posted speed limit (in km/h) for given road segments.
@@ -78,10 +77,10 @@ module GoogleMaps
       def speed_limits(place_ids:)
         raise StandardError, "#{__method__.to_s} expected an Array for place_ids." unless place_ids.is_a? Array
 
-        params = { "placeId" => place_ids }
+        params = {'placeId' => place_ids}
 
-        self.client.get(url: "/v1/speedLimits", params: params, base_url: $ROADS_BASE_URL,
-                        accepts_clientid: false, extract_body: @@_roads_extract)["speedLimits"]
+        self.client.get(url: '/v1/speedLimits', params: params, base_url: ROADS_BASE_URL,
+                        accepts_clientid: false, extract_body: @@_roads_extract)['speedLimits']
       end
 
       # Returns the posted speed limit (in km/h) for given road segments.
@@ -91,9 +90,9 @@ module GoogleMaps
       #
       # @return [Hash] Hash with an array of speed limits and an array of the snapped points.
       def snapped_speed_limits(path:)
-        params = { "path" => Convert.piped_location(path) }
+        params = {'path' => Convert.piped_location(path)}
 
-        self.client.get(url: "/v1/speedLimits", params: params, base_url: $ROADS_BASE_URL,
+        self.client.get(url: '/v1/speedLimits', params: params, base_url: ROADS_BASE_URL,
                         accepts_clientid: false, extract_body: @@_roads_extract)
       end
 
@@ -105,11 +104,12 @@ module GoogleMaps
       #
       # @return [Array] An array of snapped points.
       def nearest_roads(points:)
-        params = { "points" => Convert.piped_location(points) }
+        params = {'points' => Convert.piped_location(points)}
 
-        self.client.get(url: "/v1/nearestRoads", params: params, base_url: $ROADS_BASE_URL,
-                        accepts_clientid: false, extract_body: @@_roads_extract)["snappedPoints"]
+        self.client.get(url: '/v1/nearestRoads', params: params, base_url: ROADS_BASE_URL,
+                        accepts_clientid: false, extract_body: @@_roads_extract)['snappedPoints']
       end
     end
+
   end
 end

data/lib/googlemaps/services/timezone.rb

@@ -1,4 +1,4 @@
-require "googlemaps/services/util"
+require 'googlemaps/services/util'
 
 module GoogleMaps
   module Services
@@ -27,12 +27,12 @@ module GoogleMaps
       # @return [Hash] Valid JSON or XML response.
       def query(location:, timestamp: nil, language: nil)
         params = {
-          "location" => Convert.to_latlng(location),
-          "timestamp" => Convert.unix_time(timestamp || Util.current_utctime)
+            'location' => Convert.to_latlng(location),
+            'timestamp' => Convert.unix_time(timestamp || Util.current_utctime)
         }
 
         if language
-          params["language"] = language
+          params['language'] = language
         end
 
         self.client.get(url: "/maps/api/timezone/#{self.client.response_format}", params: params)

data/lib/googlemaps/services/util.rb

@@ -1,8 +1,8 @@
-require "net/http"
-require "openssl"
-require "base64"
-require "date"
-require "erb"
+require 'net/http'
+require 'openssl'
+require 'base64'
+require 'date'
+require 'erb'
 
 module GoogleMaps
   module Services
@@ -12,7 +12,7 @@ module GoogleMaps
         if has_key?(meth.to_s)
           self[meth.to_s]
         else
-          raise NoMethodError, 'undefined method #{meth} for #{self}'
+          raise NoMethodError, "undefined method #{meth} for #{self}"
         end
       end
     end
@@ -102,11 +102,12 @@ module GoogleMaps
       #
       # @return [String] seconds since unix epoch.
       def self.unix_time(val)
-        if val.is_a? Integer
+        case val
+        when Integer
           val.to_s
-        elsif val.is_a? Time
+        when Time
           val.to_i.to_s
-        elsif val.is_a? Date
+        when Date
           val.to_time.to_i.to_s
         else
           raise TypeError, "#{__method__.to_s} expected value to be Integer, Time or Date."
@@ -123,9 +124,10 @@ module GoogleMaps
       #
       # @return [String] comma-separated string.
       def self.to_latlng(arg)
-        if arg.is_a? String
+        case arg
+        when String
           arg
-        elsif arg.is_a? Hash
+        when Hash
           "#{self.format_float(arg[:lat])},#{self.format_float(arg[:lng])}"
         else
           raise TypeError, "#{__method__.to_s} expected location to be String or Hash."
@@ -140,7 +142,7 @@ module GoogleMaps
       #
       # @return [String] formatted value of lat or lng float
       def self.format_float(arg)
-        arg.to_s.chomp("0").chomp(".")
+        arg.to_s.chomp('0').chomp('.')
       end
 
       # Joins an array of locations into a pipe separated string, handling
@@ -153,8 +155,8 @@ module GoogleMaps
       #
       # @return [String] pipe-separated string.
       def self.piped_location(arg)
-        raise TypeError, "#{__method__.to_s} expected argument to be an Array." unless arg.instance_of? ::Array
-        arg.map { |location| to_latlng(location) }.join("|")
+        raise TypeError, "#{__method__.to_s} expected argument to be an Array." unless arg.instance_of? Array
+        arg.map { |location| to_latlng(location) }.join('|')
       end
 
       # If arg is array-like, then joins it with sep
@@ -179,9 +181,8 @@ module GoogleMaps
         raise TypeError, "#{__method__.to_s} expected a Hash of components." unless arg.is_a? Hash
 
         arg.map { |c, val|
-          ArrayBox.wrap(val).map {|elem| "#{c}:#{elem}"}
-                            .sort_by(&:downcase)
-        }.join("|")
+          ArrayBox.wrap(val).map {|elem| "#{c}:#{elem}"}.sort_by(&:downcase)
+        }.join('|')
       end
 
       # Converts a lat/lng bounds to a comma- and pipe-separated string.
@@ -212,7 +213,7 @@ module GoogleMaps
       def self.encode_polyline(points)
         raise TypeError, "#{__method__.to_s} expected an Array of points." unless points.is_a? Array
         last_lat, last_lng = 0, 0
-        result = ""
+        result = ''
         points.each { |point|
           lat = (point[:lat] * 1e5).round.to_i
           lng = (point[:lng] * 1e5).round.to_i

data/lib/googlemaps/services/version.rb

@@ -1,5 +1,5 @@
 module GoogleMaps
   module Services
-    VERSION = "1.2.0"
+    VERSION = '1.2.5'
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: googlemaps-services
 version: !ruby/object:Gem::Version
-  version: 1.2.0
+  version: 1.2.5
 platform: ruby
 authors:
 - Faissal Elamraoui
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-09-28 00:00:00.000000000 Z
+date: 2016-11-01 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: nokogiri
@@ -111,7 +111,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.6.6
+rubygems_version: 2.5.1
 signing_key: 
 specification_version: 4
 summary: Ruby Client library for Google Maps API Web Services