Signed requests can now be generated and transmitted by the client.

Example code:
    require 'google/api_client'
    client = Google::APIClient.new(:service => 'buzz')
    client.authorization.fetch_temporary_credential!(
      :additional_parameters => {
        'scope' => 'https://www.googleapis.com/auth/buzz'
      }
    )
    client.authorization.authorization_uri
    # Redirect user here
    client.authorization.fetch_token_credential!(:verifier => '12345')
    response = client.execute(
      'buzz.activities.list',
      'scope' => '@self', 'userId' => '@me', 'alt' => 'json'
    )
    status, headers, body = response

git-svn-id: https://google-api-ruby-client.googlecode.com/svn/trunk@34 c1d61fac-ed7f-fcc1-18f7-ff78120a04ef

lib/google/api_client/discovery/service.rb

@@ -66,6 +66,19 @@ module Google #:nodoc:
         )
       end
 
+      def to_h
+        return @hash ||= (begin
+          methods_hash = {}
+          self.methods.each do |method|
+            methods_hash[method.rpc_name] = method
+          end
+          self.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.
       #
@@ -117,6 +130,19 @@ module Google #:nodoc:
         )
       end
 
+      def to_h
+        return @hash ||= (begin
+          methods_hash = {}
+          self.methods.each do |method|
+            methods_hash[method.rpc_name] = method
+          end
+          self.resources.each do |resource|
+            methods_hash.merge!(resource.to_h)
+          end
+          methods_hash
+        end)
+      end
+
       ##
       # Returns a <code>String</code> representation of the resource's state.
       #
@@ -137,27 +163,38 @@ module Google #:nodoc:
 
       attr_reader :name, :description, :base
 
+      def rpc_name
+        return self.description['rpcName']
+      end
+
       def uri_template
-        return Addressable::Template.new(base + self.description['pathUrl'])
+        return @uri_template ||=
+          Addressable::Template.new(base + self.description['pathUrl'])
+      end
+
+      def normalize_parameters(parameters={})
+        # Convert keys to Strings when appropriate
+        if parameters.kind_of?(Hash) || parameters.kind_of?(Array)
+          parameters = parameters.inject({}) do |accu, (k, v)|
+            k = k.to_s if k.kind_of?(Symbol)
+            k = k.to_str if k.respond_to?(:to_str)
+            unless k.kind_of?(String)
+              raise TypeError, "Expected String, got #{k.class}."
+            end
+            accu[k] = v
+            accu
+          end
+        else
+          raise TypeError,
+            "Expected Hash or Array, got #{parameters.class}."
+        end
+        return parameters
       end
 
       def generate_uri(parameters={})
-        # Convert keys to Strings when appropriate
-        parameters = parameters.inject({}) do |accu, (k, v)|
-          k = k.to_s if k.kind_of?(Symbol)
-          k = k.to_str if k.respond_to?(:to_str)
-          unless k.kind_of?(String)
-            raise TypeError, "Expected String, got #{k.class}."
-          end
-          accu[k] = v
-          accu
-        end
+        parameters = self.normalize_parameters(parameters)
+        self.validate_parameters(parameters)
         template_variables = self.uri_template.variables
-        missing_variables = template_variables - parameters.keys
-        if missing_variables.size > 0
-          raise ArgumentError,
-            "Missing required parameters: #{missing_variables.join(', ')}."
-        end
         uri = self.uri_template.expand(parameters)
         query_parameters = parameters.reject do |k, v|
           template_variables.include?(k)
@@ -170,13 +207,46 @@ module Google #:nodoc:
         return uri.normalize
       end
 
+      def generate_request(parameters={}, body='', headers=[])
+        method = self.description['httpMethod'] || 'GET'
+        uri = self.generate_uri(parameters)
+        return [method, uri.to_str, headers, [body]]
+      end
+
+      def validate_parameters(parameters={})
+        parameters = self.normalize_parameters(parameters)
+        parameter_description = self.description['parameters'] || {}
+        required_variables = Hash[parameter_description.select do |k, v|
+          v['required']
+        end].keys
+        missing_variables = required_variables - parameters.keys
+        if missing_variables.size > 0
+          raise ArgumentError,
+            "Missing required parameters: #{missing_variables.join(', ')}."
+        end
+        parameters.each do |k, v|
+          if parameter_description[k]
+            pattern = parameter_description[k]['pattern']
+            if pattern
+              regexp = Regexp.new("^#{pattern}$")
+              if v !~ regexp
+                raise ArgumentError,
+                  "Parameter '#{k}' has an invalid value: #{v}. " +
+                  "Must match: /^#{pattern}$/."
+              end
+            end
+          end
+        end
+        return nil
+      end
+
       ##
       # Returns a <code>String</code> representation of the method's state.
       #
       # @return [String] The method's state, as a <code>String</code>.
       def inspect
         sprintf(
-          "#<%s:%#0x NAME:%s>", self.class.to_s, self.object_id, self.name
+          "#<%s:%#0x NAME:%s>", self.class.to_s, self.object_id, self.rpc_name
         )
       end
     end