google_maps_service 0.3.0 → 0.4.0

data/lib/google_maps_service/{roads.rb → apis/roads.rb}

@@ -1,8 +1,8 @@
 require 'multi_json'
 
-module GoogleMapsService
+module GoogleMapsService::Apis
 
-  # Performs requests to the Google Maps Roads API."""
+  # Performs requests to the Google Maps Roads API.
   module Roads
 
     # Base URL of Google Maps Roads API
@@ -14,28 +14,37 @@ module GoogleMapsService
     # set of data with the points snapped to the most likely roads the vehicle
     # was traveling along.
     #
-    # @param [] path The path to be snapped. A list of latitude/longitude tuples.
-    # :type path: list
+    # @example Single point snap
+    #   results = client.snap_to_roads([40.714728, -73.998672])
     #
-    # @param [] interpolate Whether to interpolate a path to include all points
+    # @example Multi points snap
+    #   path = [
+    #       [-33.8671, 151.20714],
+    #       [-33.86708, 151.20683000000002],
+    #       [-33.867070000000005, 151.20674000000002],
+    #       [-33.86703, 151.20625]
+    #   ]
+    #   results = client.snap_to_roads(path, interpolate: true)
+    #
+    # @param [Array] path The path to be snapped. Array of latitude/longitude pairs.
+    # @param [Boolean] interpolate Whether to interpolate a path to include all points
     #         forming the full road-geometry. When true, additional interpolated
     #         points will also be returned, resulting in a path that smoothly
     #         follows the geometry of the road, even around corners and through
     #         tunnels.  Interpolated paths may contain more points than the
     #         original path.
-    # :type interpolate: bool
     #
-    # :rtype: A list of snapped points.
-    def snap_to_roads(path: nil, interpolate: false)
+    # @return [Array] Array of snapped points.
+    def snap_to_roads(path, interpolate: false)
       path = GoogleMapsService::Convert.waypoints(path)
 
       params = {
         path: path
       }
 
-      params[:interpolate] = "true" if interpolate
+      params[:interpolate] = 'true' if interpolate
 
-      return get("/v1/snapToRoads", params,
+      return get('/v1/snapToRoads', params,
                  base_url: ROADS_BASE_URL,
                  accepts_client_id: false,
                  custom_response_decoder: method(:extract_roads_body))[:snappedPoints]
@@ -43,37 +52,53 @@ module GoogleMapsService
 
     # Returns the posted speed limit (in km/h) for given road segments.
     #
+    # @example Multi places snap
+    #   place_ids = [
+    #     'ChIJ0wawjUCuEmsRgfqC5Wd9ARM',
+    #     'ChIJ6cs2kkCuEmsRUfqC5Wd9ARM'
+    #   ]
+    #   results = client.speed_limits(place_ids)
+    #
     # @param [String, Array<String>] place_ids The Place ID of the road segment. Place IDs are returned
     #         by the snap_to_roads function. You can pass up to 100 Place IDs.
-    # @return Array of speed limits.
-    def speed_limits(place_ids: nil)
-      params = GoogleMapsService::Convert.as_list(place_ids).map { |place_id| ["placeId", place_id] }
+    #
+    # @return [Array] Array of speed limits.
+    def speed_limits(place_ids)
+      params = GoogleMapsService::Convert.as_list(place_ids).map { |place_id| ['placeId', place_id] }
 
-      return get("/v1/speedLimits", params,
+      return get('/v1/speedLimits', params,
                  base_url: ROADS_BASE_URL,
                  accepts_client_id: false,
                  custom_response_decoder: method(:extract_roads_body))[:speedLimits]
     end
 
-
     # Returns the posted speed limit (in km/h) for given road segments.
     #
     # The provided points will first be snapped to the most likely roads the
     # vehicle was traveling along.
     #
+    # @example Multi points snap
+    #   path = [
+    #       [-33.8671, 151.20714],
+    #       [-33.86708, 151.20683000000002],
+    #       [-33.867070000000005, 151.20674000000002],
+    #       [-33.86703, 151.20625]
+    #   ]
+    #   results = client.snapped_speed_limits(path)
+    #
     # @param [Hash, Array] path The path of points to be snapped. A list of (or single)
     #         latitude/longitude tuples.
     #
-    # @return [Hash] a dict with both a list of speed limits and a list of the snapped
+    # @return [Hash] A hash with both a list of speed limits and a list of the snapped
     #         points.
-    def snapped_speed_limits(path: nil)
+    def snapped_speed_limits(path)
       path = GoogleMapsService::Convert.waypoints(path)
 
       params = {
         path: path
       }
 
-      return get("/v1/speedLimits", params,
+      return get('/v1/speedLimits', params,
                  base_url: ROADS_BASE_URL,
                  accepts_client_id: false,
                  custom_response_decoder: method(:extract_roads_body))
@@ -88,33 +113,38 @@ module GoogleMapsService
           unless response.status_code == 200
             check_response_status_code(response)
           end
-          raise GoogleMapsService::Error::ApiError.new(response), "Received a malformed response."
+          raise GoogleMapsService::Error::ApiError.new(response), 'Received a malformed response.'
         end
 
-        if body.has_key?(:error)
-          error = body[:error]
-          status = error[:status]
-
-          case status
-            when 'INVALID_ARGUMENT'
-              if error[:message] == 'The provided API key is invalid.'
-                raise GoogleMapsService::Error::RequestDeniedError.new(response), error[:message]
-              end
-              raise GoogleMapsService::Error::InvalidRequestError.new(response), error[:message]
-            when 'PERMISSION_DENIED'
-              raise GoogleMapsService::Error::RequestDeniedError.new(response), error[:message]
-            when 'RESOURCE_EXHAUSTED'
-              raise GoogleMapsService::Error::RateLimitError.new(response), error[:message]
-            else
-              raise GoogleMapsService::Error::ApiError.new(response), error[:message]
-          end
-        end
+        check_roads_body_error(response, body)
 
         unless response.status_code == 200
           raise GoogleMapsService::Error::ApiError.new(response)
         end
-
         return body
       end
+
+      # Check response body for error status.
+      #
+      # @param [Hurley::Response] body Response object.
+      # @param [Hash] body Response body.
+      def check_roads_body_error(response, body)
+        error = body[:error]
+        return unless error
+
+        case error[:status]
+          when 'INVALID_ARGUMENT'
+            if error[:message] == 'The provided API key is invalid.'
+              raise GoogleMapsService::Error::RequestDeniedError.new(response), error[:message]
+            end
+            raise GoogleMapsService::Error::InvalidRequestError.new(response), error[:message]
+          when 'PERMISSION_DENIED'
+            raise GoogleMapsService::Error::RequestDeniedError.new(response), error[:message]
+          when 'RESOURCE_EXHAUSTED'
+            raise GoogleMapsService::Error::RateLimitError.new(response), error[:message]
+          else
+            raise GoogleMapsService::Error::ApiError.new(response), error[:message]
+        end
+      end
   end
 end

data/lib/google_maps_service/{time_zone.rb → apis/time_zone.rb}

@@ -1,6 +1,6 @@
 require 'date'
 
-module GoogleMapsService
+module GoogleMapsService::Apis
 
   # Performs requests to the Google Maps TimeZone API."""
   module TimeZone
@@ -8,20 +8,25 @@ module GoogleMapsService
     # Get time zone for a location on the earth, as well as that location's
     # time offset from UTC.
     #
+    # @example Current time zone
+    #   timezone = client.timezone([39.603481, -119.682251])
+    #
+    # @example Time zone at certain time
+    #   timezone = client.timezone([39.603481, -119.682251], timestamp: Time.at(1608))
+    #
     # @param [Hash, Array] location The latitude/longitude value representing the location to
     #     look up.
     # @param [Integer, DateTime] timestamp Timestamp specifies the desired time as seconds since
     #     midnight, January 1, 1970 UTC. The Time Zone API uses the timestamp to
     #     determine whether or not Daylight Savings should be applied. Times
     #     before 1970 can be expressed as negative values. Optional. Defaults to
-    #     ``Time.now``.
+    #     `Time.now`.
     # @param [String] language The language in which to return results.
     #
-    # @return [Hash]
-    def timezone(location: nil,
-                 timestamp: nil, language: nil)
+    # @return [Hash] Time zone object.
+    def timezone(location, timestamp: Time.now, language: nil)
       location = GoogleMapsService::Convert.latlng(location)
-      timestamp = GoogleMapsService::Convert.time(timestamp || Time.now)
+      timestamp = GoogleMapsService::Convert.time(timestamp)
 
       params = {
         location: location,
@@ -30,7 +35,7 @@ module GoogleMapsService
 
       params[:language] = language if language
 
-      return get( "/maps/api/timezone/json", params)
+      return get('/maps/api/timezone/json', params)
     end
   end
 end

data/lib/google_maps_service/client.rb

@@ -1,48 +1,52 @@
-require 'uri'
 require 'hurley'
 require 'multi_json'
 require 'retriable'
 require 'thread'
 
+require 'google_maps_service/errors'
+require 'google_maps_service/convert'
+require 'google_maps_service/url'
+require 'google_maps_service/apis/directions'
+require 'google_maps_service/apis/distance_matrix'
+require 'google_maps_service/apis/elevation'
+require 'google_maps_service/apis/geocoding'
+require 'google_maps_service/apis/roads'
+require 'google_maps_service/apis/time_zone'
+
 module GoogleMapsService
+
+  # Core client functionality, common across all API requests (including performing
+  # HTTP requests).
   class Client
-    USER_AGENT = "GoogleGeoApiClientRuby/#{GoogleMapsService::VERSION}"
-    DEFAULT_BASE_URL = "https://maps.googleapis.com"
+    # Default Google Maps Web Service base endpoints
+    DEFAULT_BASE_URL = 'https://maps.googleapis.com'
+
+    # Errors those could be retriable.
     RETRIABLE_ERRORS = [GoogleMapsService::Error::ServerError, GoogleMapsService::Error::RateLimitError]
 
-    include GoogleMapsService::Directions
-    include GoogleMapsService::DistanceMatrix
-    include GoogleMapsService::Elevation
-    include GoogleMapsService::Geocoding
-    include GoogleMapsService::Roads
-    include GoogleMapsService::TimeZone
+    include GoogleMapsService::Apis::Directions
+    include GoogleMapsService::Apis::DistanceMatrix
+    include GoogleMapsService::Apis::Elevation
+    include GoogleMapsService::Apis::Geocoding
+    include GoogleMapsService::Apis::Roads
+    include GoogleMapsService::Apis::TimeZone
 
     # Secret key for accessing Google Maps Web Service.
-    # Can be obtained at https://developers.google.com/maps/documentation/geocoding/get-api-key#key
+    # Can be obtained at https://developers.google.com/maps/documentation/geocoding/get-api-key#key.
     # @return [String]
-    attr_reader :key
+    attr_accessor :key
 
     # Client id for using Maps API for Work services.
     # @return [String]
-    attr_reader :client_id
+    attr_accessor :client_id
 
     # Client secret for using Maps API for Work services.
     # @return [String]
-    attr_reader :client_secret
-
-    # Connection timeout for HTTP requests, in seconds.
-    # You should specify read_timeout in addition to this option.
-    # @return [Integer]
-    attr_reader :connect_timeout
-
-    # Read timeout for HTTP requests, in seconds.
-    # You should specify connect_timeout in addition to this
-    # @return [Integer]
-    attr_reader :read_timeout
+    attr_accessor :client_secret
 
     # Timeout across multiple retriable requests, in seconds.
     # @return [Integer]
-    attr_reader :retry_timeout
+    attr_accessor :retry_timeout
 
     # Number of queries per second permitted.
     # If the rate limit is reached, the client will sleep for
@@ -50,25 +54,77 @@ module GoogleMapsService
     # @return [Integer]
     attr_reader :queries_per_second
 
-    def initialize(options={})
+    # Construct Google Maps Web Service API client.
+    #
+    # This gem uses [Hurley](https://github.com/lostisland/hurley) as internal HTTP client.
+    # You can configure `Hurley::Client` through `request_options` and `ssl_options` parameters.
+    # You can also directly get the `Hurley::Client` object via {#client} method.
+    #
+    # @example Setup API keys
+    #   gmaps = GoogleMapsService::Client.new(key: 'Add your key here')
+    #
+    # @example Setup client IDs
+    #   gmaps = GoogleMapsService::Client.new(
+    #       client_id: 'Add your client id here',
+    #       client_secret: 'Add your client secret here'
+    #   )
+    #
+    # @example Setup time out and QPS limit
+    #   gmaps = GoogleMapsService::Client.new(
+    #       key: 'Add your key here',
+    #       retry_timeout: 20,
+    #       queries_per_second: 10
+    #   )
+    #
+    # @example Request behind proxy
+    #   request_options = Hurley::RequestOptions.new
+    #   request_options.proxy = Hurley::Url.parse 'http://user:password@proxy.example.com:3128'
+    #
+    #   gmaps = GoogleMapsService::Client.new(
+    #       key: 'Add your key here',
+    #       request_options: request_options
+    #   )
+    #
+    # @example Using Excon and Http Cache
+    #  require 'hurley-excon'       # https://github.com/lostisland/hurley-excon
+    #  require 'hurley/http_cache'  # https://github.com/plataformatec/hurley-http-cache
+    #
+    #  gmaps = GoogleMapsService::Client.new(
+    #      key: 'Add your key here',
+    #      connection: Hurley::HttpCache.new(HurleyExcon::Connection.new)
+    #  )
+    #
+    #
+    #
+    # @option options [String] :key Secret key for accessing Google Maps Web Service.
+    #   Can be obtained at https://developers.google.com/maps/documentation/geocoding/get-api-key#key.
+    # @option options [String] :client_id Client id for using Maps API for Work services.
+    # @option options [String] :client_secret Client secret for using Maps API for Work services.
+    # @option options [Integer] :retry_timeout Timeout across multiple retriable requests, in seconds.
+    # @option options [Integer] :queries_per_second Number of queries per second permitted.
+    #
+    # @option options [Hurley::RequestOptions] :request_options HTTP client request options.
+    #     See https://github.com/lostisland/hurley/blob/master/lib/hurley/options.rb.
+    # @option options [Hurley::SslOptions] :ssl_options HTTP client SSL options.
+    #     See https://github.com/lostisland/hurley/blob/master/lib/hurley/options.rb.
+    # @option options [Object] :connection HTTP client connection.
+    #     By default, the default Hurley's HTTP client connection (Net::Http) will be used.
+    #     See https://github.com/lostisland/hurley/blob/master/README.md#connections.
+    def initialize(**options)
       @key = options[:key] || GoogleMapsService.key
       @client_id = options[:client_id] || GoogleMapsService.client_id
       @client_secret = options[:client_secret] || GoogleMapsService.client_secret
-      @connect_timeout = options[:connect_timeout] || GoogleMapsService.connect_timeout
-      @read_timeout = options[:read_timeout] || GoogleMapsService.read_timeout
       @retry_timeout = options[:retry_timeout] || GoogleMapsService.retry_timeout || 60
       @queries_per_second = options[:queries_per_second] || GoogleMapsService.queries_per_second
+      @request_options = options[:request_options] || GoogleMapsService.request_options
+      @ssl_options = options[:ssl_options] || GoogleMapsService.ssl_options
+      @connection = options[:connection] || GoogleMapsService.connection
 
-      # Prepare "tickets" for calling API
-      if @queries_per_second
-        @sent_times = SizedQueue.new @queries_per_second
-        @queries_per_second.times do
-          @sent_times << 0
-        end
-      end
+      #
+      initialize_qps if @queries_per_second
     end
 
-    # Get the current HTTP client
+    # Get the current HTTP client.
     # @return [Hurley::Client]
     def client
       @client ||= new_client
@@ -76,92 +132,68 @@ module GoogleMapsService
 
     protected
 
-    # Create a new HTTP client
+    # Initialize QPS queue. QPS queue is a "tickets" for calling API
+    def initialize_qps
+      @qps_queue = SizedQueue.new @queries_per_second
+      @queries_per_second.times do
+        @qps_queue << 0
+      end
+    end
+
+    # Create a new HTTP client.
     # @return [Hurley::Client]
     def new_client
       client = Hurley::Client.new
+
+      client.connection = @connection if @connection
+      @request_options.each_pair {|key, value| client.request_options[key] = value } if @request_options
+      @ssl_options.each_pair {|key, value| client.ssl_options[key] = value } if @ssl_options
+
       client.request_options.query_class = Hurley::Query::Flat
-      client.request_options.timeout = @read_timeout if @read_timeout
-      client.request_options.open_timeout = @connect_timeout if @connect_timeout
-      client.header[:user_agent] = USER_AGENT
+      client.header[:user_agent] = user_agent
       client
     end
 
+    # Build the user agent header
+    # @return [String]
+    def user_agent
+      sprintf('google-maps-services-ruby/%s %s',
+              GoogleMapsService::VERSION,
+              GoogleMapsService::OS_VERSION)
+    end
+
+    # Make API call.
+    #
+    # @param [String] path Url path.
+    # @param [String] params Request parameters.
+    # @param [String] base_url Base Google Maps Web Service API endpoint url.
+    # @param [Boolean] accepts_client_id Sign the request using API {#keys} instead of {#client_id}.
+    # @param [Method] custom_response_decoder Custom method to decode raw API response.
+    #
+    # @return [Object] Decoded response body.
     def get(path, params, base_url: DEFAULT_BASE_URL, accepts_client_id: true, custom_response_decoder: nil)
       url = base_url + generate_auth_url(path, params, accepts_client_id)
 
       Retriable.retriable timeout: @retry_timeout, on: RETRIABLE_ERRORS do |try|
         # Get/wait the request "ticket" if QPS is configured
         # Check for previous request time, it must be more than a second ago before calling new request
-        if @sent_times
-          elapsed_since_earliest = Time.now - @sent_times.pop
+        if @qps_queue
+          elapsed_since_earliest = Time.now - @qps_queue.pop
           sleep(1 - elapsed_since_earliest) if elapsed_since_earliest.to_f < 1
         end
 
-        response = client.get url
-
-        # Release request "ticket"
-        @sent_times << Time.now if @sent_times
+        begin
+          response = client.get url
+        ensure
+          # Release request "ticket"
+          @qps_queue << Time.now if @qps_queue
+        end
 
         return custom_response_decoder.call(response) if custom_response_decoder
         decode_response_body(response)
       end
     end
 
-    # Extract and parse body response as hash. Throw an error if there is something wrong with the response.
-    #
-    # @param [Hurley::Response] response Web API response.
-    #
-    # @return [Hash] Response body as hash. The hash key will be symbolized.
-    #
-    # @raise [GoogleMapsService::Error::RedirectError] The response redirects to another URL.
-    # @raise [GoogleMapsService::Error::RequestDeniedError] The credential (key or client id pair) is not valid.
-    # @raise [GoogleMapsService::Error::ClientError] The request is invalid and should not be retried without modification.
-    # @raise [GoogleMapsService::Error::ServerError] An error occurred on the server and the request can be retried.
-    # @raise [GoogleMapsService::Error::TransmissionError] Unknown response status code.
-    # @raise [GoogleMapsService::Error::RateLimitError] The quota for the credential is already pass the limit.
-    # @raise [GoogleMapsService::Error::ApiError] The Web API error.
-    def decode_response_body(response)
-      check_response_status_code(response)
-
-      body = MultiJson.load(response.body, :symbolize_keys => true)
-
-      case body[:status]
-      when 'OK', 'ZERO_RESULTS'
-        return body
-      when 'OVER_QUERY_LIMIT'
-        raise GoogleMapsService::Error::RateLimitError.new(response), body[:error_message]
-      when 'REQUEST_DENIED'
-        raise GoogleMapsService::Error::RequestDeniedError.new(response), body[:error_message]
-      when 'INVALID_REQUEST'
-        raise GoogleMapsService::Error::InvalidRequestError.new(response), body[:error_message]
-      else
-        raise GoogleMapsService::Error::ApiError.new(response), body[:error_message]
-      end
-    end
-
-    def check_response_status_code(response)
-      case response.status_code
-      when 200..300
-        # Do-nothing
-      when 301, 302, 303, 307
-        message = sprintf('Redirect to %s', response.header[:location])
-        raise GoogleMapsService::Error::RedirectError.new(response), message
-      when 401
-        message = 'Unauthorized'
-        raise GoogleMapsService::Error::ClientError.new(response), message
-      when 304, 400, 402...500
-        message = 'Invalid request'
-        raise GoogleMapsService::Error::ClientError.new(response), message
-      when 500..600
-        message = 'Server error'
-        raise GoogleMapsService::Error::ServerError.new(response), message
-      else
-        message = 'Unknown error'
-        raise GoogleMapsService::Error::Error.new(response), message
-      end
-    end
-
     # Returns the path and query string portion of the request URL,
     # first adding any necessary parameters.
     #
@@ -181,83 +213,68 @@ module GoogleMapsService
       if accepts_client_id and @client_id and @client_secret
         params << ["client", @client_id]
 
-        path = [path, self.class.urlencode_params(params)].join("?")
-        sig = self.class.sign_hmac(@client_secret, path)
+        path = [path, GoogleMapsService::Url.urlencode_params(params)].join("?")
+        sig = GoogleMapsService::Url.sign_hmac(@client_secret, path)
         return path + "&signature=" + sig
       end
 
       if @key
         params << ["key", @key]
-        return path + "?" + self.class.urlencode_params(params)
+        return path + "?" + GoogleMapsService::Url.urlencode_params(params)
       end
 
       raise ArgumentError, "Must provide API key for this API. It does not accept enterprise credentials."
     end
 
-    # Returns a base64-encoded HMAC-SHA1 signature of a given string.
+    # Extract and parse body response as hash. Throw an error if there is something wrong with the response.
     #
-    # @param [String] secret The key used for the signature, base64 encoded.
-    # @param [String] payload The payload to sign.
+    # @param [Hurley::Response] response Web API response.
     #
-    # @return [String]
-    def self.sign_hmac(secret, payload)
-      require 'base64'
-      require 'hmac'
-      require 'hmac-sha1'
-
-      secret = secret.encode('ASCII')
-      payload = payload.encode('ASCII')
-
-      # Decode the private key
-      raw_key = Base64.urlsafe_decode64(secret)
-
-      # Create a signature using the private key and the URL
-      sha1 = HMAC::SHA1.new(raw_key)
-      sha1 << payload
-      raw_signature = sha1.digest()
-
-      # Encode the signature into base64 for url use form.
-      signature =  Base64.urlsafe_encode64(raw_signature)
-      return signature
+    # @return [Hash] Response body as hash. The hash key will be symbolized.
+    def decode_response_body(response)
+      check_response_status_code(response)
+      body = MultiJson.load(response.body, :symbolize_keys => true)
+      check_body_error(response, body)
+      body
     end
 
-    # URL encodes the parameters.
-    # @param [Hash, Array<Array>] params The parameters
-    # @return [String]
-    def self.urlencode_params(params)
-      unquote_unreserved(URI.encode_www_form(params))
+    # Check HTTP response status code. Raise error if the status is not 2xx.
+    #
+    # @param [Hurley::Response] response Web API response.
+    def check_response_status_code(response)
+      case response.status_code
+      when 200..300
+        # Do-nothing
+      when 301, 302, 303, 307
+        raise GoogleMapsService::Error::RedirectError.new(response), sprintf('Redirect to %s', response.header[:location])
+      when 401
+        raise GoogleMapsService::Error::ClientError.new(response), 'Unauthorized'
+      when 304, 400, 402...500
+        raise GoogleMapsService::Error::ClientError.new(response), 'Invalid request'
+      when 500..600
+        raise GoogleMapsService::Error::ServerError.new(response), 'Server error'
+      else
+        raise ArgumentError, 'Invalid response status code'
+      end
     end
 
-    # The unreserved URI characters (RFC 3986)
-    UNRESERVED_SET = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-._~"
-
-    # Un-escape any percent-escape sequences in a URI that are unreserved
-    # characters. This leaves all reserved, illegal and non-ASCII bytes encoded.
+    # Check response body for error status.
     #
-    # @param [String] uri
-    #
-    # @return [String]
-    def self.unquote_unreserved(uri)
-      parts = uri.split('%')
-
-      (1..parts.length-1).each do |i|
-        h = parts[i][0..1]
-
-        if h.length == 2 and !h.match(/[^A-Za-z0-9]/)
-          c = h.to_i(16).chr
-
-          if UNRESERVED_SET.include?(c)
-            parts[i] = c + parts[i][2..-1]
-          else
-            parts[i] = "%#{parts[i]}"
-          end
-        else
-          parts[i] = "%#{parts[i]}"
-        end
+    # @param [Hurley::Response] body Response object.
+    # @param [Hash] body Response body.
+    def check_body_error(response, body)
+      case body[:status]
+      when 'OK', 'ZERO_RESULTS'
+        # Do-nothing
+      when 'OVER_QUERY_LIMIT'
+        raise GoogleMapsService::Error::RateLimitError.new(response), body[:error_message]
+      when 'REQUEST_DENIED'
+        raise GoogleMapsService::Error::RequestDeniedError.new(response), body[:error_message]
+      when 'INVALID_REQUEST'
+        raise GoogleMapsService::Error::InvalidRequestError.new(response), body[:error_message]
+      else
+        raise GoogleMapsService::Error::ApiError.new(response), body[:error_message]
       end
-
-      return parts.join
     end
-
   end
 end