ghost_google-api-client 0.4.7.1

data/lib/google/api_client/batch.rb

@@ -0,0 +1,296 @@
+# Copyright 2012 Google Inc.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+require 'addressable/uri'
+require 'uuidtools'
+
+module Google
+  class APIClient
+
+    # Helper class to contain a response to an individual batched call.
+    class BatchedCallResponse
+      attr_reader :call_id
+      attr_accessor :status, :headers, :body
+
+      def initialize(call_id, status = nil, headers = nil, body = nil)
+        @call_id, @status, @headers, @body = call_id, status, headers, body
+      end
+    end
+
+    ##
+    # Wraps multiple API calls into a single over-the-wire HTTP request.
+    class BatchRequest
+
+      BATCH_BOUNDARY = "-----------RubyApiBatchRequest".freeze
+
+      attr_accessor :options
+      attr_reader :calls, :callbacks
+
+      ##
+      # Creates a new batch request.
+      #
+      # @param [Hash] options
+      #   Set of options for this request, the only important one being
+      #   :connection, which specifies an HTTP connection to use.
+      # @param [Proc] block
+      #   Callback for every call's response. Won't be called if a call defined
+      #   a callback of its own.
+      #
+      # @return [Google::APIClient::BatchRequest] The constructed object.
+      def initialize(options = {}, &block)
+        # Request options, ignoring method and parameters.
+        @options = options
+        # Batched calls to be made, indexed by call ID.
+        @calls = {}
+        # Callbacks per batched call, indexed by call ID.
+        @callbacks = {}
+        # Order for the call IDs, since Ruby 1.8 hashes are unordered.
+        @order = []
+        # Global callback to be used for every call. If a specific callback
+        # has been defined for a request, this won't be called.
+        @global_callback = block if block_given?
+        # The last auto generated ID.
+        @last_auto_id = 0
+        # Base ID for the batch request.
+        @base_id = nil
+      end
+
+      ##
+      # Add a new call to the batch request.
+      # Each call must have its own call ID; if not provided, one will
+      # automatically be generated, avoiding collisions. If duplicate call IDs
+      # are provided, an error will be thrown.
+      #
+      # @param [Hash, Google::APIClient::Reference] call: the call to be added.
+      # @param [String] call_id: the ID to be used for this call. Must be unique
+      # @param [Proc] block: callback for this call's response.
+      #
+      # @return [Google::APIClient::BatchRequest] The BatchRequest, for chaining
+      def add(call, call_id = nil, &block)
+        unless call.kind_of?(Google::APIClient::Reference)
+          call = Google::APIClient::Reference.new(call)
+        end
+        if call_id.nil?
+          call_id = new_id
+        end
+        if @calls.include?(call_id)
+          raise BatchError,
+              'A call with this ID already exists: %s' % call_id
+        end
+        @calls[call_id] = call
+        @order << call_id
+        if block_given?
+          @callbacks[call_id] = block
+        elsif @global_callback
+          @callbacks[call_id] = @global_callback
+        end
+        return self
+      end
+
+      ##
+      # Convert this batch request into an HTTP request.
+      #
+      # @return [Array<String, String, Hash, String>]
+      #   An array consisting of, in order: HTTP method, request path, request
+      #   headers and request body.
+      def to_http_request
+        return ['POST', request_uri, request_headers, request_body]
+      end
+
+      ##
+      # Processes the HTTP response to the batch request, issuing callbacks.
+      #
+      # @param [Faraday::Response] response: the HTTP response.
+      def process_response(response)
+        content_type = find_header('Content-Type', response.headers)
+        boundary = /.*boundary=(.+)/.match(content_type)[1]
+        parts = response.body.split(/--#{Regexp.escape(boundary)}/)
+        parts = parts[1...-1]
+        parts.each do |part|
+          call_response = deserialize_call_response(part)
+          callback = @callbacks[call_response.call_id]
+          call = @calls[call_response.call_id]
+          result = Google::APIClient::Result.new(call, nil, call_response)
+          callback.call(result) if callback
+        end
+      end
+
+      private
+
+      ##
+      # Helper method to find a header from its name, regardless of case.
+      #
+      # @param [String] name: The name of the header to find.
+      # @param [Hash] headers: The hash of headers and their values.
+      #
+      # @return [String] The value of the desired header.
+      def find_header(name, headers)
+        _, header = headers.detect do |h, v|
+          h.downcase == name.downcase
+        end
+        return header
+      end
+
+      ##
+      # Create a new call ID. Uses an auto-incrementing, conflict-avoiding ID.
+      #
+      # @return [String] the new, unique ID.
+      def new_id
+        @last_auto_id += 1
+        while @calls.include?(@last_auto_id)
+          @last_auto_id += 1
+        end
+        return @last_auto_id.to_s
+      end
+
+      ##
+      # Convert an id to a Content-ID header value.
+      #
+      # @param [String] call_id: identifier of individual call.
+      #
+      # @return [String]
+      #   A Content-ID header with the call_id encoded into it. A UUID is
+      #   prepended to the value because Content-ID headers are supposed to be
+      #   universally unique.
+      def id_to_header(call_id)
+        if @base_id.nil?
+          # TODO(sgomes): Use SecureRandom.uuid, drop UUIDTools when we drop 1.8
+          @base_id = UUIDTools::UUID.random_create.to_s
+        end
+
+        return '<%s+%s>' % [@base_id, Addressable::URI.encode(call_id)]
+      end
+
+      ##
+      # Convert a Content-ID header value to an id. Presumes the Content-ID
+      # header conforms to the format that id_to_header() returns.
+      #
+      # @param [String] header: Content-ID header value.
+      #
+      # @return [String] The extracted ID value.
+      def header_to_id(header)
+        if !header.start_with?('<') || !header.end_with?('>') ||
+            !header.include?('+')
+          raise BatchError, 'Invalid value for Content-ID: "%s"' % header
+        end
+
+        base, call_id = header[1...-1].split('+')
+        return Addressable::URI.unencode(call_id)
+      end
+
+      ##
+      # Convert a single batched call into a string.
+      #
+      # @param [Google::APIClient::Reference] call: the call to serialize.
+      #
+      # @return [String] The request as a string in application/http format.
+      def serialize_call(call)
+        http_request = call.to_request
+        method = http_request.method.to_s.upcase
+        path = http_request.path.to_s
+        status_line = method + " " + path + " HTTP/1.1"
+        serialized_call = status_line
+        if http_request.headers
+          http_request.headers.each do |header, value|
+            serialized_call << "\r\n%s: %s" % [header, value]
+          end
+        end
+        if http_request.body
+          serialized_call << "\r\n\r\n"
+          serialized_call << http_request.body
+        end
+        return serialized_call
+      end
+
+      ##
+      # Auxiliary method to split the headers from the body in an HTTP response.
+      #
+      # @param [String] response: the response to parse.
+      #
+      # @return [Array<Hash>, String] The headers and the body, separately.
+      def split_headers_and_body(response)
+        headers = {}
+        payload = response.lstrip
+        while payload
+          line, payload = payload.split("\n", 2)
+          line.sub!(/\s+\z/, '')
+          break if line.empty?
+          match = /\A([^:]+):\s*/.match(line)
+          if match
+            headers[match[1]] = match.post_match
+          else
+            raise BatchError, 'Invalid header line in response: %s' % line
+          end
+        end
+        return headers, payload
+      end
+
+      ##
+      # Convert a single batched response into a BatchedCallResponse object.
+      #
+      # @param [Google::APIClient::Reference] response:
+      #   the request to deserialize.
+      #
+      # @return [BatchedCallResponse] The parsed and converted response.
+      def deserialize_call_response(call_response)
+        outer_headers, outer_body = split_headers_and_body(call_response)
+        status_line, payload = outer_body.split("\n", 2)
+        protocol, status, reason = status_line.split(' ', 3)
+
+        headers, body = split_headers_and_body(payload)
+        content_id = find_header('Content-ID', outer_headers)
+        call_id = header_to_id(content_id)
+        return BatchedCallResponse.new(call_id, status.to_i, headers, body)
+      end
+
+      ##
+      # Return the request headers for the BatchRequest's HTTP request.
+      #
+      # @return [Hash] The HTTP headers.
+      def request_headers
+        return {
+          'Content-Type' => 'multipart/mixed; boundary=%s' % BATCH_BOUNDARY
+        }
+      end
+
+      ##
+      # Return the request path for the BatchRequest's HTTP request.
+      #
+      # @return [String] The request path.
+      def request_uri
+        if @calls.nil? || @calls.empty?
+          raise BatchError, 'Cannot make an empty batch request'
+        end
+        # All APIs have the same batch path, so just get the first one.
+        return @calls.first[1].api_method.api.batch_path
+      end
+
+      ##
+      # Return the request body for the BatchRequest's HTTP request.
+      #
+      # @return [String] The request body.
+      def request_body
+        body = ""
+        @order.each do |call_id|
+          body << "--" + BATCH_BOUNDARY + "\r\n"
+          body << "Content-Type: application/http\r\n"
+          body << "Content-ID: %s\r\n\r\n" % id_to_header(call_id)
+          body << serialize_call(@calls[call_id]) + "\r\n\r\n"
+        end
+        body << "--" + BATCH_BOUNDARY + "--"
+        return body
+      end
+    end
+  end
+end

data/lib/google/api_client/client_secrets.rb

@@ -0,0 +1,106 @@
+# Copyright 2010 Google Inc.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+
+require 'multi_json'
+require 'compat/multi_json'
+
+
+module Google
+  class APIClient
+    ##
+    # Manages the persistence of client configuration data and secrets.
+    class ClientSecrets
+      def self.load(filename=nil)
+        if filename && File.directory?(filename)
+          search_path = File.expand_path(filename)
+          filename = nil
+        end
+        while filename == nil
+          search_path ||= File.expand_path('.')
+          puts search_path
+          if File.exist?(File.join(search_path, 'client_secrets.json'))
+            filename = File.join(search_path, 'client_secrets.json')
+          elsif search_path == '/' || search_path =~ /[a-zA-Z]:[\/\\]/
+            raise ArgumentError,
+              'No client_secrets.json filename supplied ' +
+              'and/or could not be found in search path.'
+          else
+            search_path = File.expand_path(File.join(search_path, '..'))
+          end
+        end
+        data = File.open(filename, 'r') { |file| MultiJson.load(file.read) }
+        return self.new(data)
+      end
+
+      def initialize(options={})
+        # Client auth configuration
+        @flow = options[:flow] || options.keys.first.to_s || 'web'
+        fdata = options[@flow]
+        @client_id = fdata[:client_id] || fdata["client_id"]
+        @client_secret = fdata[:client_secret] || fdata["client_secret"]
+        @redirect_uris = fdata[:redirect_uris] || fdata["redirect_uris"]
+        @redirect_uris ||= [fdata[:redirect_uri]]
+        @javascript_origins = (
+          fdata[:javascript_origins] ||
+          fdata["javascript_origins"]
+        )
+        @javascript_origins ||= [fdata[:javascript_origin]]
+        @authorization_uri = fdata[:auth_uri] || fdata["auth_uri"]
+        @authorization_uri ||= fdata[:authorization_uri]
+        @token_credential_uri = fdata[:token_uri] || fdata["token_uri"]
+        @token_credential_uri ||= fdata[:token_credential_uri]
+
+        # Associated token info
+        @access_token = fdata[:access_token] || fdata["access_token"]
+        @refresh_token = fdata[:refresh_token] || fdata["refresh_token"]
+        @id_token = fdata[:id_token] || fdata["id_token"]
+        @expires_in = fdata[:expires_in] || fdata["expires_in"]
+        @expires_at = fdata[:expires_at] || fdata["expires_at"]
+        @issued_at = fdata[:issued_at] || fdata["issued_at"]
+      end
+
+      attr_reader(
+        :flow, :client_id, :client_secret, :redirect_uris, :javascript_origins,
+        :authorization_uri, :token_credential_uri, :access_token,
+        :refresh_token, :id_token, :expires_in, :expires_at, :issued_at
+      )
+
+      def to_json
+        return MultiJson.dump({
+          self.flow => ({
+            'client_id' => self.client_id,
+            'client_secret' => self.client_secret,
+            'redirect_uris' => self.redirect_uris,
+            'javascript_origins' => self.javascript_origins,
+            'auth_uri' => self.authorization_uri,
+            'token_uri' => self.token_credential_uri,
+            'access_token' => self.access_token,
+            'refresh_token' => self.refresh_token,
+            'id_token' => self.id_token,
+            'expires_in' => self.expires_in,
+            'expires_at' => self.expires_at,
+            'issued_at' => self.issued_at
+          }).inject({}) do |accu, (k, v)|
+            # Prunes empty values from JSON output.
+            unless v == nil || (v.respond_to?(:empty?) && v.empty?)
+              accu[k] = v
+            end
+            accu
+          end
+        })
+      end
+    end
+  end
+end

data/lib/google/api_client/discovery.rb

@@ -0,0 +1,19 @@
+# Copyright 2010 Google Inc.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+
+require 'google/api_client/discovery/api'
+require 'google/api_client/discovery/resource'
+require 'google/api_client/discovery/method'
+require 'google/api_client/discovery/schema'

data/lib/google/api_client/discovery/api.rb

@@ -0,0 +1,287 @@
+# Copyright 2010 Google Inc.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+
+require 'addressable/uri'
+
+require 'google/inflection'
+require 'google/api_client/discovery/resource'
+require 'google/api_client/discovery/method'
+require 'google/api_client/discovery/media'
+
+module Google
+  class APIClient
+    ##
+    # A service that has been described by a discovery document.
+    class API
+
+      ##
+      # Creates a description of a particular version of a service.
+      #
+      # @param [String] api
+      #   The identifier for the service.  Note that while this frequently
+      #   matches the first segment of all of the service's RPC names, this
+      #   should not be assumed.  There is no requirement that these match.
+      # @param [String] version
+      #   The identifier for the service version.
+      # @param [Hash] api_description
+      #   The section of the discovery document that applies to this service
+      #   version.
+      #
+      # @return [Google::APIClient::API] The constructed service object.
+      def initialize(document_base, discovery_document)
+        @document_base = Addressable::URI.parse(document_base)
+        @discovery_document = discovery_document
+        metaclass = (class << self; self; end)
+        self.discovered_resources.each do |resource|
+          method_name = Google::INFLECTOR.underscore(resource.name).to_sym
+          if !self.respond_to?(method_name)
+            metaclass.send(:define_method, method_name) { resource }
+          end
+        end
+        self.discovered_methods.each do |method|
+          method_name = Google::INFLECTOR.underscore(method.name).to_sym
+          if !self.respond_to?(method_name)
+            metaclass.send(:define_method, method_name) { method }
+          end
+        end
+      end
+
+      ##
+      # Returns the id of the service.
+      #
+      # @return [String] The service id.
+      def id
+        return (
+          @discovery_document['id'] ||
+          "#{self.name}:#{self.version}"
+        )
+      end
+
+      ##
+      # Returns the identifier for the service.
+      #
+      # @return [String] The service identifier.
+      def name
+        return @discovery_document['name']
+      end
+
+      ##
+      # Returns the version of the service.
+      #
+      # @return [String] The service version.
+      def version
+        return @discovery_document['version']
+      end
+
+      ##
+      # Returns a human-readable title for the API.
+      #
+      # @return [Hash] The API title.
+      def title
+        return @discovery_document['title']
+      end
+
+      ##
+      # Returns a human-readable description of the API.
+      #
+      # @return [Hash] The API description.
+      def description
+        return @discovery_document['description']
+      end
+
+      ##
+      # Returns a URI for the API documentation.
+      #
+      # @return [Hash] The API documentation.
+      def documentation
+        return Addressable::URI.parse(@discovery_document['documentationLink'])
+      end
+
+      ##
+      # Returns true if this is the preferred version of this API.
+      #
+      # @return [TrueClass, FalseClass]
+      #   Whether or not this is the preferred version of this API.
+      def preferred
+        return !!@discovery_document['preferred']
+      end
+
+      ##
+      # Returns the list of API features.
+      #
+      # @return [Array]
+      #   The features supported by this API.
+      def features
+        return @discovery_document['features'] || []
+      end
+
+      ##
+      # Returns true if this API uses a data wrapper.
+      #
+      # @return [TrueClass, FalseClass]
+      #   Whether or not this API uses a data wrapper.
+      def data_wrapper?
+        return self.features.include?('dataWrapper')
+      end
+
+      ##
+      # Returns the base URI for the discovery document.
+      #
+      # @return [Addressable::URI] The base URI.
+      attr_reader :document_base
+
+      ##
+      # Returns the base URI for this version of the service.
+      #
+      # @return [Addressable::URI] The base URI that methods are joined to.
+      def method_base
+        if @discovery_document['basePath']
+          return @method_base ||= (
+            self.document_base.join(Addressable::URI.parse(@discovery_document['basePath']))
+          ).normalize
+        else
+          return nil
+        end
+      end
+
+      ##
+      # Updates the hierarchy of resources and methods with the new base.
+      #
+      # @param [Addressable::URI, #to_str, String] new_base
+      #   The new base URI to use for the service.
+      def method_base=(new_method_base)
+        @method_base = Addressable::URI.parse(new_method_base)
+        self.discovered_resources.each do |resource|
+          resource.method_base = @method_base
+        end
+        self.discovered_methods.each do |method|
+          method.method_base = @method_base
+        end
+      end
+
+      ##
+      # Returns the base URI for batch calls to this service.
+      #
+      # @return [Addressable::URI] The base URI that methods are joined to.
+      def batch_path
+        if @discovery_document['batchPath']
+          return @batch_path ||= (
+            self.document_base.join(Addressable::URI.parse('/' +
+                @discovery_document['batchPath']))
+          ).normalize
+        else
+          return nil
+        end
+      end
+
+      ##
+      # A list of schemas available for this version of the API.
+      #
+      # @return [Hash] A list of {Google::APIClient::Schema} objects.
+      def schemas
+        return @schemas ||= (
+          (@discovery_document['schemas'] || []).inject({}) do |accu, (k, v)|
+            accu[k] = Google::APIClient::Schema.parse(self, v)
+            accu
+          end
+        )
+      end
+
+      ##
+      # Returns a schema for a kind value.
+      #
+      # @return [Google::APIClient::Schema] The associated Schema object.
+      def schema_for_kind(kind)
+        api_name, schema_name = kind.split('#', 2)
+        if api_name != self.name
+          raise ArgumentError,
+            "The kind does not match this API. " +
+            "Expected '#{self.name}', got '#{api_name}'."
+        end
+        for k, v in self.schemas
+          return v if k.downcase == schema_name.downcase
+        end
+        return nil
+      end
+
+      ##
+      # A list of resources available at the root level of this version of the
+      # API.
+      #
+      # @return [Array] A list of {Google::APIClient::Resource} objects.
+      def discovered_resources
+        return @discovered_resources ||= (
+          (@discovery_document['resources'] || []).inject([]) do |accu, (k, v)|
+            accu << Google::APIClient::Resource.new(
+              self, self.method_base, k, v
+            )
+            accu
+          end
+        )
+      end
+
+      ##
+      # A list of methods available at the root level of this version of the
+      # API.
+      #
+      # @return [Array] A list of {Google::APIClient::Method} objects.
+      def discovered_methods
+        return @discovered_methods ||= (
+          (@discovery_document['methods'] || []).inject([]) do |accu, (k, v)|
+            accu << Google::APIClient::Method.new(self, self.method_base, k, v)
+            accu
+          end
+        )
+      end
+
+      ##
+      # Allows deep inspection of the discovery document.
+      def [](key)
+        return @discovery_document[key]
+      end
+
+      ##
+      # Converts the service to a flat mapping of RPC names and method objects.
+      #
+      # @return [Hash] All methods available on the service.
+      #
+      # @example
+      #   # Discover available methods
+      #   method_names = client.discovered_api('buzz').to_h.keys
+      def to_h
+        return @hash ||= (begin
+          methods_hash = {}
+          self.discovered_methods.each do |method|
+            methods_hash[method.id] = method
+          end
+          self.discovered_resources.each do |resource|
+            methods_hash.merge!(resource.to_h)
+          end
+          methods_hash
+        end)
+      end
+
+      ##
+      # Returns a <code>String</code> representation of the service's state.
+      #
+      # @return [String] The service's state, as a <code>String</code>.
+      def inspect
+        sprintf(
+          "#<%s:%#0x ID:%s>", self.class.to_s, self.object_id, self.id
+        )
+      end
+    end
+  end
+end