googlemaps-services 1.2.5 → 1.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 18a00c19fa244488e45d19b1072506587f597e57
-  data.tar.gz: 1d4bf5cef38c7d6be03bd438d2e30278eef31ee3
+  metadata.gz: f9af6339c46954459057f1f720aa53f4275158c2
+  data.tar.gz: e167756c771106d77778d36284960c429cb9105f
 SHA512:
-  metadata.gz: 99aa38b29add2f487377ceef2a6cba9e9881defa8c2b6c3a0303a69bdbee8c2cfa4fd94414dda0d40fa2a4bd6b3f5a15b155dea9e66121862cd8d252a4aad270
-  data.tar.gz: da2efaedd9b47501bc815b005ae47e7a2f97552fcfba47bf61c89b84d5c8e64309ad4b99426cf6b30eedf6fbfc38b77cf8190a6e90abc3fc20b70c1b7b59f781
+  metadata.gz: dba8b6e7c27f3ddd0e90ef28d981930ab97c148a7202b3b98862a0bd18d8c80467b15df9751bb17827f596dbc3592eca30a0c988e5e7fdb31f1ce989f13d5c22
+  data.tar.gz: ab24f530bae29cf059851bfcea3682766b693909addb9dfa16e37e7d1379be0c4f8a59eecb1c271bb2cef2b0fee89ab5e5c28b2439b0ee9f5c7c5895c6f58b9e

data/lib/googlemaps/services/client.rb

@@ -1,9 +1,11 @@
+# coding: utf-8
 require 'googlemaps/services/exceptions'
 require 'googlemaps/services/version'
 require 'googlemaps/services/util'
 require 'nokogiri'
-require 'net/http'
+require 'base64'
 require 'json'
+require 'http'
 
 # Core functionality, common across all API requests.
 #
@@ -13,28 +15,33 @@ module GoogleMaps
   #
   # @since 1.0.0
   module Services
-    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
+      USER_AGENT = 'GoogleMapsRubyClient/' + VERSION
+      DEFAULT_BASE_URL = 'https://maps.googleapis.com'
+      RETRIABLE_STATUSES = [500, 503, 504]
+
       include GoogleMaps::Services::Exceptions
 
       # @return [Symbol] API key. Required, unless "client_id" and "client_secret" are set.
       attr_accessor :key
-      # @return [Symbol] timeout Combined connect and read timeout for HTTP requests, in seconds.
-      attr_accessor :timeout
+      # @return [Symbol] Write timeout for the HTTP request, in seconds.
+      attr_accessor :write_timeout
+      # @return [Symbol] Connect timeout for the HTTP request, in seconds.
+      attr_accessor :connect_timeout
+      # @return [Symbol] Read timeout for the HTTP request, in seconds.
+      attr_accessor :read_timeout
       # @return [Symbol] Client ID (for Maps API for Work).
       attr_accessor :client_id
-      # @return [Symbol] base64-encoded client secret (for Maps API for Work).
+      # @return [Symbol] Base64-encoded client secret (for Maps API for Work).
       attr_accessor :client_secret
-      # @return [Symbol] attribute used for tracking purposes. Can only be used with a Client ID.
+      # @return [Symbol] Attribute used for tracking purposes. Can only be used with a Client ID.
       attr_accessor :channel
-      # @return [Symbol] timeout across multiple retriable requests, in seconds.
+      # @return [Symbol] Timeout across multiple retriable requests, in seconds.
       attr_accessor :retry_timeout
-      # @return [Symbol] extra options for Net::HTTP client.
-      attr_accessor :request_opts
+      # @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.
       attr_accessor :queries_per_second
       # @return [Symbol] keeps track of sent queries.
@@ -42,10 +49,10 @@ module GoogleMaps
       # @return [Symbol] Response format. Either :json or :xml
       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: {},
+      def initialize(key: nil, client_id: nil, client_secret: nil, write_timeout: 1,
+                     connect_timeout: 1, read_timeout: 1,retry_timeout: 60, request_headers: {},
                      queries_per_second: 10, channel: nil, response_format: :json)
-        if !key && !(client_secret && client_id)
+        unless key || (client_secret && client_id)
           raise StandardError, 'Must provide API key or enterprise credentials when creationg client.'
         end
 
@@ -54,9 +61,8 @@ module GoogleMaps
         end
 
         if channel
-          unless client_id
-            raise StandardError, 'The channel argument must be used with a client ID.'
-          end
+          raise StandardError, 'The channel argument must be used with a client ID.' unless client_id
+
 
           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.'
@@ -65,25 +71,16 @@ module GoogleMaps
 
         self.key = key
 
-        if timeout && (connect_timeout || read_timeout)
-          raise StandardError, 'Specify either timeout, or connect_timeout and read_timeout.'
-        end
-
-        if connect_timeout && read_timeout
-          self.timeout = { :connect_timeout => connect_timeout, :read_timeout => read_timeout }
-        else
-          self.timeout = timeout
-        end
+        # Set the timeout for write/connect/read calls
+        self.write_timeout = write_timeout
+        self.connect_timeout = connect_timeout
+        self.read_timeout = read_timeout
 
         self.client_id = client_id
         self.client_secret = client_secret
         self.channel = channel
         self.retry_timeout = retry_timeout
-        self.request_opts = request_opts.merge({
-                                                   :headers => {'User-Agent' => USER_AGENT},
-                                                   :timeout => self.timeout,
-                                                   :verify => true
-                                               })
+        self.request_headers = request_headers.merge({ 'User-Agent' => USER_AGENT })
         self.queries_per_second = queries_per_second
         self.sent_times = Array.new
 
@@ -93,7 +90,7 @@ module GoogleMaps
         end
       end
 
-      # Performs HTTP GET requests with credentials, returning the body as JSON or XML
+      # Performs HTTP GET requests with credentials, returning the body as JSON or XML.
       #
       # @param [String] url URL path for the request. Should begin with a slash.
       # @param [Hash] params HTTP GET parameters.
@@ -102,12 +99,12 @@ module GoogleMaps
       # @param [String] base_url The base URL for the request. Defaults to the Google Maps API server. Should not have a trailing slash.
       # @param [TrueClass, FalseClass] accepts_clientid Flag whether this call supports the client/signature params. Some APIs require API keys (e.g. Roads).
       # @param [Proc] extract_body A function that extracts the body from the request. If the request was not successful, the function should raise a
-      #               GoogleMaps::Services::Exceptions::HTTËrror or GoogleMaps::Services::Exceptions::APIError as appropriate.
-      # @param [Hash] request_opts Additional options for the Net::HTTP client.
+      #               GoogleMaps::Services::Exceptions::HTTPError or GoogleMaps::Services::Exceptions::APIError as appropriate.
+      # @param [Hash] request_headers HTTP headers per request.
       #
-      # @return [Hash, Array] response body, either in JSON or XML.
+      # @return [Hash, Array, nil] response body (either in JSON or XML) or nil.
       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)
+              accepts_clientid: true, extract_body: nil, request_headers: nil)
         unless first_request_time
           first_request_time = Util.current_time
         end
@@ -128,35 +125,21 @@ module GoogleMaps
 
         authed_url = generate_auth_url(url, params, accepts_clientid)
 
-        # Default to the client-level self.request_opts, with method-level
-        # request_opts arg overriding.
-        request_opts = self.request_opts.merge(request_opts || {})
+        # Default to the client-level self.request_headers, with method-level
+        # request_headers arg overriding.
+        request_headers = self.request_headers.merge(request_headers || {})
 
         # Construct the Request URI
-        uri = URI.parse(base_url + authed_url)
-
-        # Add request headers
-        req = Net::HTTP::Get.new(uri.to_s)
-
-        request_opts[:headers].each { |header,value| req.add_field(header, value) }
+        uri = HTTP::URI.parse(base_url + authed_url)
 
-        http = Net::HTTP.new(uri.host, uri.port)
-        http.use_ssl = (uri.scheme == 'https')
-        # Get HTTP response
-        resp = http.request(req)
-
-        # Handle response errors
-        case resp
-        when Net::HTTPRequestTimeOut
-          raise Timeout
-        when Exception
-          raise TransportError, 'HTTP GET request failed.'
-        end
+        # Create the request, add the headers and make the GET request
+        resp = HTTP.headers(request_headers)
+                   .timeout(:write => self.write_timeout, :connect => self.connect_timeout, :read => self.read_timeout)
+                   .get(uri.to_s)
 
         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)
+          self.get(url, params, first_request_time, retry_counter + 1, base_url, accepts_clientid, extract_body)
         end
 
         # Check if the time of the nth previous query (where n is queries_per_second)
@@ -173,11 +156,15 @@ module GoogleMaps
           if extract_body
             result = extract_body.call(resp)
           else
-            case self.response_format
-            when :xml # XML response
+            case resp.content_type.mime_type
+            when 'application/xml'
               result = get_xml_body(resp)
-            else # JSON response
+            when 'application/json'
               result = get_json_body(resp)
+            when 'text/html'
+              result = get_redirection_url(resp)
+            else
+              result = get_map_image(resp)
             end
           end
           self.sent_times.push(Util.current_time)
@@ -188,6 +175,18 @@ module GoogleMaps
         end
       end
 
+      # Returns the redirection URL from the Response in case of 3XX status code.
+      #
+      # @private
+      #
+      # @param [Net::HTTPResponse] resp HTTP response object.
+      #
+      # @return [String] Redirection URL.
+      def get_redirection_url(resp)
+        status_code = resp.code.to_i
+        (status_code >= 300 && status_code < 400) ? resp['location'] : nil
+      end
+
       # Extracts the JSON body of the HTTP response.
       #
       # @private
@@ -197,15 +196,12 @@ module GoogleMaps
       # @return [Hash, Array] Valid JSON response.
       def get_json_body(resp)
         status_code = resp.code.to_i
-        if status_code >= 300 && status_code < 400
-          return resp['location']
-        end
 
         if status_code != 200
-          raise HTTPError.new(resp.code)
+          raise HTTPError.new(status_code)
         end
 
-        # Parse the response body
+        # Parse the JSON response body
         begin
           body = JSON.parse(resp.body)
         rescue JSON::ParserError
@@ -237,16 +233,14 @@ module GoogleMaps
       # @return [Nokogiri::XML::Document] Valid XML document.
       def get_xml_body(resp)
         status_code = resp.code.to_i
-        if status_code >= 300 && status_code < 400
-          return resp['location']
-        end
 
         if status_code != 200
-          raise HTTPError.new(resp.code)
+          raise HTTPError.new(status_code)
         end
 
+        # Parse the XML response body
         begin
-          doc = Nokogiri::XML.parse(resp.body)
+          doc = Nokogiri::XML(resp.body) { |config| config.strict }
         rescue
           raise APIError.new(status_code), 'Received a malformed XML response.'
         end
@@ -268,6 +262,27 @@ module GoogleMaps
         end
       end
 
+      # Extracts the static map image from the HTTP response.
+      #
+      # @private
+      #
+      # @param [Net::HTTPResponse] resp HTTP response object.
+      #
+      # @return [Hash] Hash with image URL, MIME type and its base64-encoded value.
+      def get_map_image(resp)
+        status_code = resp.code.to_i
+
+        if status_code != 200
+          raise HTTPError.new(status_code)
+        end
+
+        {
+          :url => resp.uri.to_s,
+          :mime_type => resp.content_type.mime_type,
+          :image_data => Base64.encode64(resp.body).gsub(/\n/, '')
+        }
+      end
+
       # Returns the path and query string portion of the request URL, first adding any necessary parameters.
       #
       # @private
@@ -297,7 +312,7 @@ module GoogleMaps
         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
+      private :get_json_body, :get_xml_body, :get_map_image, :get_redirection_url, :generate_auth_url
     end
 
   end

data/lib/googlemaps/services/directions.rb

@@ -2,14 +2,15 @@ require 'googlemaps/services/util'
 
 module GoogleMaps
   module Services
-    TRAVEL_MODES = %w(driving walking bicycling transit)
-
     # Performs requests to the Google Maps Directions API.
     #
     # @example
     #   directions = GoogleMaps::Services::Directions.new(client)
     #   result = directions.query(origin: "Brussels", destination: {:lat => 52.520645, :lng => 13.409779})
     class Directions
+      TRAVEL_MODES = %w(driving walking bicycling transit)
+      AVOID_FEATURES = %w(tolls highways ferries indoor)
+
       # @return [Symbol] The HTTP client.
       attr_accessor :client
 
@@ -72,6 +73,9 @@ module GoogleMaps
         end
 
         if avoid
+          unless ArrayBox.contains_all?(AVOID_FEATURES, avoid)
+            raise StandardError, 'invalid avoid feature.'
+          end
           params['avoid'] = Convert.join_array('|', avoid)
         end
 
@@ -114,8 +118,10 @@ module GoogleMaps
         case self.client.response_format
         when :xml
           self.client.get(url: '/maps/api/directions/xml', params: params).xpath('//route')
-        else
+        when :json
           self.client.get(url: '/maps/api/directions/json', params: params)['routes']
+        else
+          raise StandardError, 'Unsupported response format. Should be either :json or :xml.'
         end
       end
     end

data/lib/googlemaps/services/distancematrix.rb

@@ -2,14 +2,15 @@ require 'googlemaps/services/util'
 
 module GoogleMaps
   module Services
-    AVOIDS = %w(tolls highways ferries)
-
     # Performs requests to the Google Maps Distance Matrix API.
     #
     # @example
-    #   distancematrix = GoogleMaps::Services::DistanceMatrix(client)
+    #   distancematrix = GoogleMaps::Services::DistanceMatrix.new(client)
     #   result = distancematrix.query(origins: ["Brussels", "Ghent"], destinations: ["Bruges"])
     class DistanceMatrix
+      AVOIDS = %w(tolls highways ferries)
+      TRAVEL_MODES = %w(driving walking bicycling transit)
+
       # @return [Symbol] the HTTP client.
       attr_accessor :client
 

data/lib/googlemaps/services/elevation.rb

@@ -7,9 +7,11 @@ module GoogleMaps
     # Performs requests to the Google Maps Elevation API.
     #
     # @example
-    #   elevation = GoogleMaps::Services::Elevation(client)
+    #   elevation = GoogleMaps::Services::Elevation.new(client)
     #   result = elevation.query(locations: [{:lat => 52.520645, :lng => 13.409779}, "Brussels"])
     class Elevation
+
+      # @return [Symbol] The HTTP client.
       attr_accessor :client
 
       def initialize(client)
@@ -25,22 +27,17 @@ module GoogleMaps
       # @param [Integer] samples The number of sample points along a path for which to return elevation data.
       #
       # @return [Array, Nokogiri::XML::NodeSet] Valid JSON or XML response.
-      def query(locations: [], path: nil, samples: 0)
+      def query(locations: nil, path: nil, samples: 0)
         params = {}
 
-        if path && locations
-          raise StandardError, 'Should not specify both path and locations.'
-        end
-
         if locations
           params['locations'] = Convert.shortest_path(locations)
         end
 
         if path
-          case path.class
-          when String
+          if path.instance_of? String
             path = "enc:#{path}"
-          when Array
+          elsif path.instance_of? Array
             path = Convert.shortest_path(path)
           else
             raise TypeError, 'Path should be either a String or an Array.'
@@ -49,11 +46,17 @@ module GoogleMaps
           params = {'path' => path, 'samples' => samples }
         end
 
+        if path && locations
+          raise StandardError, 'Should not specify both path and locations.'
+        end
+
         case self.client.response_format
         when :xml
           self.client.get(url: '/maps/api/elevation/xml', params: params).xpath('//result')
-        else
+        when :json
           self.client.get(url: '/maps/api/elevation/json', params: params)['results']
+        else
+          raise StandardError, 'Unsupported response format. Should be either :json or :xml.'
         end
       end
     end

data/lib/googlemaps/services/geocoding.rb

@@ -56,8 +56,10 @@ module GoogleMaps
         case self.client.response_format
         when :xml
           self.client.get(url: '/maps/api/geocode/xml', params: params).xpath('//result')
-        else
+        when :json
           self.client.get(url: '/maps/api/geocode/json', params: params)['results']
+        else
+          raise StandardError, 'Unsupported response format. Should be either :json or :xml.'
         end
       end
     end
@@ -85,7 +87,7 @@ module GoogleMaps
       def query(latlng:, result_type: nil, location_type: nil, language: nil)
         # 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?("'")
+        if latlng.is_a?(String) && !latlng.include?(",")
           params = {'place_id' => latlng}
         else
           params = {'latlng' => Convert.to_latlng(latlng)}
@@ -106,8 +108,10 @@ module GoogleMaps
         case self.client.response_format
         when :xml
           self.client.get(url: '/maps/api/geocode/xml', params: params).xpath('//result')
-        else
+        when :json
           self.client.get(url: '/maps/api/geocode/json', params: params)['results']
+        else
+          raise StandardError, 'Unsupported response format. Should be either :json or :xml.'
         end
       end
     end

data/lib/googlemaps/services/places.rb

@@ -62,7 +62,7 @@ module GoogleMaps
                 type: type, page_token: page_token)
       end
 
-      # Performs radar search for places
+      # Performs radar search for places.
       #
       # @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.
@@ -71,14 +71,12 @@ 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 [Array] name One or more terms to be matched against the names of places.
       # @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] 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
       #
       # @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)
-        unless keyword || name || type
-          raise StandardError, 'either a keyword, name, or type arg is required.'
-        end
+        raise StandardError, 'either a keyword, name, or type arg is required.' unless (keyword || name || type)
 
         _places(url_part: 'radar', location: location, radius: radius,
                 keyword: keyword, min_price: min_price, max_price: max_price,
@@ -152,15 +150,13 @@ module GoogleMaps
 
       # Downloads a photo from the Places API.
       #
-      # @param [String] photo_reference: A string identifier that uniquely identifies a photo, as provided by either a Places search or Places detail request.
-      # @param [Integer] max_width: Specifies the maximum desired width, in pixels.
-      # @param [Integer] max_height: Specifies the maximum desired height, in pixels.
+      # @param [String] photo_reference A string identifier that uniquely identifies a photo, as provided by either a Places search or Places detail request.
+      # @param [Integer] max_width Specifies the maximum desired width, in pixels.
+      # @param [Integer] max_height Specifies the maximum desired height, in pixels.
       #
       # @return [String] URL of the photo.
       def place_photo(photo_reference:, max_width: nil, max_height: nil)
-        unless max_width || max_height
-          raise StandardError, 'a max_width or max_height arg is required'
-        end
+        raise StandardError, 'a max_width or max_height arg is required' unless (max_width || max_height)
 
         params = {'photoreference' => photo_reference}
 
@@ -238,8 +234,10 @@ module GoogleMaps
         case self.client.response_format
         when :xml
           self.client.get(url: "/maps/api/place/#{url_part}autocomplete/xml", params: params).xpath('//prediction')
-        else
+        when :json
           self.client.get(url: "/maps/api/place/#{url_part}autocomplete/json", params: params)['predictions']
+        else
+          raise StandardError, 'Unsupported response format. Should be either :json or :xml.'
         end
       end
 

data/lib/googlemaps/services/roads.rb

@@ -10,36 +10,6 @@ module GoogleMaps
     class Roads
       include GoogleMaps::Services::Exceptions
 
-      # Extracts a result from a Roads API HTTP response.
-      @@_roads_extract = Proc.new { |resp|
-        status_code = resp.code.to_i
-        begin
-          body = JSON.parse(resp.body)
-        rescue JSON::ParserError
-          raise APIError.new(status_code), 'Received malformed response.'
-        end
-
-        if body.key?('error')
-          error = body['error']
-          status = error['status']
-
-          if status == 'RESOURCE_EXHAUSTED'
-            raise RetriableRequest
-          end
-
-          if error.key?('message')
-            raise APIError.new(status), error['message']
-          else
-            raise APIError.new(status)
-          end
-        end
-
-        if status_code != 200
-          raise HTTPError.new(status_code)
-        end
-        body
-      }
-
       # @return [Symbol] the HTTP client.
       attr_accessor :client
 
@@ -65,7 +35,7 @@ module GoogleMaps
         end
 
         self.client.get(url: '/v1/snapToRoads', params: params, base_url: ROADS_BASE_URL,
-                        accepts_clientid: false, extract_body: @@_roads_extract)['snappedPoints']
+                        accepts_clientid: false, extract_body: lambda(&method(:_roads_extract)))['snappedPoints']
       end
 
       # Returns the posted speed limit (in km/h) for given road segments.
@@ -80,7 +50,7 @@ module GoogleMaps
         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']
+                        accepts_clientid: false, extract_body: lambda(&method(:_roads_extract)))['speedLimits']
       end
 
       # Returns the posted speed limit (in km/h) for given road segments.
@@ -93,7 +63,7 @@ module GoogleMaps
         params = {'path' => Convert.piped_location(path)}
 
         self.client.get(url: '/v1/speedLimits', params: params, base_url: ROADS_BASE_URL,
-                        accepts_clientid: false, extract_body: @@_roads_extract)
+                        accepts_clientid: false, extract_body: lambda(&method(:_roads_extract)))
       end
 
       # Find the closest road segments for each point.
@@ -107,9 +77,46 @@ module GoogleMaps
         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']
+                        accepts_clientid: false, extract_body: lambda(&method(:_roads_extract)))['snappedPoints']
       end
-    end
 
+      # Extracts a result from a Roads API HTTP response.
+      #
+      # @private
+      #
+      # @param [Net::HTTPResponse] resp HTTP response object.
+      #
+      # @return [Hash, Array] Valid JSON response.
+      def _roads_extract(resp)
+        status_code = resp.code.to_i
+        begin
+          body = JSON.parse(resp.body)
+        rescue JSON::ParserError
+          raise APIError.new(status_code), 'Received malformed response.'
+        end
+
+        if body.key?('error')
+          error = body['error']
+          status = error['status']
+
+          if status == 'RESOURCE_EXHAUSTED'
+            raise RetriableRequest
+          end
+
+          if error.respond_to?(:key?) && error.key?('message')
+            raise APIError.new(status), error['message']
+          else
+            raise APIError.new(status)
+          end
+        end
+
+        if status_code != 200
+          raise HTTPError.new(status_code)
+        end
+        body
+      end
+
+      private :_roads_extract
+    end
   end
 end

data/lib/googlemaps/services/staticmap.rb

@@ -0,0 +1,99 @@
+require 'googlemaps/services/util'
+
+module GoogleMaps
+  module Services
+    ALLOWED_SCALES = [2, 4]
+    SUPPORTED_IMG_FORMATS = ["png32", "gif", "jpg", "jpg-baseline"]
+    SUPPORTED_MAP_TYPES = ["satellite", "hybrid", "terrain"]
+
+    # Performs requests to the Google Static Map API.
+    #
+    # @example Get static map image
+    #   staticmap = GoogleMaps::Services::StaticMap.new(client)
+    #   map_img = staticmap.query(size: {:length => 640, :width => 400},
+    #                             center: "50.8449925,4.362961",
+    #                             maptype: "hybrid",
+    #                             zoom: 16)
+    #   # {
+    #   #     :url => "https://maps.googleapis.com/maps/api/staticmap?size=640x400&center=50.8449925%2C4.362961&zoom=16&maptype=hybrid",
+    #   #     :mime_type => "image/png",
+    #   #     :image_data => "iVBORw0KGgoAAAANSUhEUgAAAoAAAAGQCAMAAAAJLSEXAAADAFBMVEU..."
+    #   # }
+    class StaticMap
+
+      # @return [Symbol] The HTTP client.
+      attr_accessor :client
+
+      def initialize(client)
+        self.client = client
+      end
+
+      # Get the static map image.
+      #
+      # @param [Hash] size The rectangular dimensions of the map image.
+      # @param [String, Hash] center The address or lat/lng value of the map's center.
+      # @param [Integer] zoom The magnification level of the map.
+      # @param [Integer] scale The scale of the map. This affects the number of pixels that are returned.
+      # @param [String] format The format of the resulting image. Defaults to "png8" or "png".
+      # @param [String] maptype The type of map to construct. Defaults to "roadmap".
+      # @param [String] language The language to use for display of labels on map tiles.
+      # @param [String] region The region code specified as a two-character ccTLD ('top-level domain') value.
+      # @param [String, Array] markers One or more markers to attach to the image at specified locations.
+      # @param [String, Array] path The single path of two or more connected points to overlay in the image at the specified locations.
+      # @param [String, Array] visible One or more locations that should remain visible on the map.
+      # @param [String] style A custom style to alter the presentation of a specific feature (roads, parks, and other features) of the map.
+      def query(size:, center: nil, zoom: nil, scale: 1, format: "png", maptype: "roadmap",
+                language: nil, region: nil, markers: nil, path: nil, visible: nil, style: nil)
+        params = { 'size' => Convert.rectangular_dimensions(size) }
+
+        if markers
+          params['markers'] = markers
+        else
+          raise StandardError, "both center and zoom are required if markers not present." unless (center && zoom)
+
+          params['center'] = Convert.to_latlng(center)
+          params['zoom'] = zoom
+        end
+
+        if scale != 1
+          raise StandardError, "invalid scale value." unless ALLOWED_SCALES.include? scale
+          params['scale'] = scale
+        end
+
+        if format != "png"
+          raise StandardError, "invalid image format." unless SUPPORTED_IMG_FORMATS.include? format
+          params['format'] = format
+        end
+
+        if maptype != "roadmap"
+          raise StandardError, "invalid maptype value." unless SUPPORTED_MAP_TYPES.include? maptype
+          params['maptype'] = maptype
+        end
+
+        if language
+          params['language'] = language
+        end
+
+        if region
+          params['region'] = region
+        end
+
+        if path
+          params['path'] = path
+        end
+
+        if visible
+          params['visible'] = visible
+        end
+
+        if style
+          params['style'] = style
+        end
+
+        self.client.get(url: "/maps/api/staticmap", params: params)
+      end
+
+    end
+
+  end
+end

data/lib/googlemaps/services/timezone.rb

@@ -6,7 +6,7 @@ module GoogleMaps
     # Performs requests to the Google Maps Timezone API.
     #
     # @example
-    #   timezone = GoogleMaps::Services::Timezone(client)
+    #   timezone = GoogleMaps::Services::Timezone.new(client)
     #   result = timezone.query(location: "38.908133,-77.047119")
     class Timezone
       # @return [Symbol] The HTTP client.

data/lib/googlemaps/services/util.rb

@@ -1,4 +1,3 @@
-require 'net/http'
 require 'openssl'
 require 'base64'
 require 'date'
@@ -8,12 +7,14 @@ module GoogleMaps
   module Services
 
     module HashDot
-      def method_missing(meth, *args, &block)
-        if has_key?(meth.to_s)
-          self[meth.to_s]
-        else
-          raise NoMethodError, "undefined method #{meth} for #{self}"
+      def method_missing(method, *opts)
+        m = method.to_s
+        if self.has_key?(m)
+          return self[m]
+        elsif self.has_key?(m.to_sym)
+          return self[m.to_sym]
         end
+        super
       end
     end
 
@@ -37,6 +38,25 @@ module GoogleMaps
           [object]
         end
       end
+
+      # Determines if one array contains all elements of another array.
+      #
+      # @param [Array] arr target array.
+      # @param [Array] other array to look for in the target array.
+      # @example
+      #   myarr = ["hello", "world"]
+      #   ArrayBox.contains_all? myarr, ["hello"] # true
+      #
+      # @return [TrueClass, FalseClass] a boolean.
+      def self.contains_all?(arr, other)
+        h = arr.inject(Hash.new(0)) {|h, i| h[i] += 1; h}
+        other.each do |i|
+          return false unless h.has_key?(i)
+          return false if h[i].zero?
+          h[i] -= 1
+        end
+        return true
+      end
     end
 
     # Set of utility methods.
@@ -295,6 +315,28 @@ module GoogleMaps
         unencoded = piped_location(locations)
         encoded.length < unencoded.length ? encoded : unencoded
       end
+
+      # Returns the MIME type from the given header value.
+      #
+      # @param [String] content_type The Content-Type header value.
+      #
+      # @return [String] the MIME type value.
+      def self.get_mime_type(content_type)
+        content_type.split(';').first
+      end
+
+      # Returns the rectangular dimensions in the form {horizontal_value}x{vertical_value}.
+      #
+      # @example
+      #   Convert.rectangular_dimensions({:length => 500, :width => 400}) # "500x400"
+      #
+      # @param [Hash] size The size hash.
+      #
+      # @return [String] a string value in the form "lengthxwidth".
+      def self.rectangular_dimensions(size)
+        raise TypeError, "#{__method__.to_s} expected a Hash." unless size.is_a? Hash
+        "#{size[:length]}x#{size[:width]}"
+      end
     end
 
   end

data/lib/googlemaps/services/version.rb

@@ -1,5 +1,5 @@
 module GoogleMaps
   module Services
-    VERSION = '1.2.5'
+    VERSION = '1.3.0'.freeze
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: googlemaps-services
 version: !ruby/object:Gem::Version
-  version: 1.2.5
+  version: 1.3.0
 platform: ruby
 authors:
 - Faissal Elamraoui
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-11-01 00:00:00.000000000 Z
+date: 2017-01-18 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: nokogiri
@@ -16,20 +16,40 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.6'
+        version: '1.7'
     - - ">="
       - !ruby/object:Gem::Version
-        version: 1.6.8
+        version: 1.7.0.1
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.6'
+        version: '1.7'
     - - ">="
       - !ruby/object:Gem::Version
-        version: 1.6.8
+        version: 1.7.0.1
+- !ruby/object:Gem::Dependency
+  name: http
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.1'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 2.1.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.1'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 2.1.0
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
@@ -88,6 +108,7 @@ files:
 - lib/googlemaps/services/geocoding.rb
 - lib/googlemaps/services/places.rb
 - lib/googlemaps/services/roads.rb
+- lib/googlemaps/services/staticmap.rb
 - lib/googlemaps/services/timezone.rb
 - lib/googlemaps/services/util.rb
 - lib/googlemaps/services/version.rb