google-api-client 0.2.0 → 0.3.0

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

@@ -0,0 +1,149 @@
+# 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/method'
+
+module Google
+  class APIClient
+    ##
+    # A resource that has been described by a discovery document.
+    class Resource
+
+      ##
+      # Creates a description of a particular version of a resource.
+      #
+      # @param [Addressable::URI] base
+      #   The base URI for the service.
+      # @param [String] resource_name
+      #   The identifier for the resource.
+      # @param [Hash] resource_description
+      #   The section of the discovery document that applies to this resource.
+      #
+      # @return [Google::APIClient::Resource] The constructed resource object.
+      def initialize(api, method_base, resource_name, discovery_document)
+        @api = api
+        @method_base = method_base
+        @name = resource_name
+        @discovery_document = discovery_document
+        metaclass = (class <<self; self; end)
+        self.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.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 identifier for the resource.
+      #
+      # @return [String] The resource identifier.
+      attr_reader :name
+
+      ##
+      # Returns the parsed section of the discovery document that applies to
+      # this resource.
+      #
+      # @return [Hash] The resource description.
+      attr_reader :description
+
+      ##
+      # Returns the base URI for this resource.
+      #
+      # @return [Addressable::URI] The base URI that methods are joined to.
+      attr_reader :method_base
+
+      ##
+      # 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 resource.
+      def method_base=(new_method_base)
+        @method_base = Addressable::URI.parse(new_method_base)
+        self.resources.each do |resource|
+          resource.method_base = @method_base
+        end
+        self.methods.each do |method|
+          method.method_base = @method_base
+        end
+      end
+
+      ##
+      # A list of sub-resources available on this resource.
+      #
+      # @return [Array] A list of {Google::APIClient::Resource} objects.
+      def resources
+        return @resources ||= (
+          (@discovery_document['resources'] || []).inject([]) do |accu, (k, v)|
+            accu << Google::APIClient::Resource.new(
+              @api, self.method_base, k, v
+            )
+            accu
+          end
+        )
+      end
+
+      ##
+      # A list of methods available on this resource.
+      #
+      # @return [Array] A list of {Google::APIClient::Method} objects.
+      def methods
+        return @methods ||= (
+          (@discovery_document['methods'] || []).inject([]) do |accu, (k, v)|
+            accu << Google::APIClient::Method.new(@api, self.method_base, k, v)
+            accu
+          end
+        )
+      end
+
+      ##
+      # Converts the resource to a flat mapping of RPC names and method
+      # objects.
+      #
+      # @return [Hash] All methods available on the resource.
+      def to_h
+        return @hash ||= (begin
+          methods_hash = {}
+          self.methods.each do |method|
+            methods_hash[method.id] = 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.
+      #
+      # @return [String] The resource's state, as a <code>String</code>.
+      def inspect
+        sprintf(
+          "#<%s:%#0x NAME:%s>", self.class.to_s, self.object_id, self.name
+        )
+      end
+    end
+  end
+end

data/lib/google/api_client/discovery/schema.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 'time'
+require 'json'
+require 'base64'
+require 'autoparse'
+require 'addressable/uri'
+require 'addressable/template'
+
+require 'google/inflection'
+require 'google/api_client/errors'
+
+module Google
+  class APIClient
+    module Schema
+      def self.parse(api, schema_data)
+        # This method is super-long, but hard to break up due to the
+        # unavoidable dependence on closures and execution context.
+        schema_name = schema_data['id']
+
+        # Due to an oversight, schema IDs may not be URI references.
+        # TODO(bobaman): Remove this code once this has been resolved.
+        schema_uri = (
+          api.document_base +
+          (schema_name[0..0] != '#' ? '#' + schema_name : schema_name)
+        )
+        # puts schema_uri
+
+        # Due to an oversight, schema IDs may not be URI references.
+        # TODO(bobaman): Remove this whole lambda once this has been resolved.
+        reformat_references = lambda do |data|
+          # This code is not particularly efficient due to recursive traversal
+          # and excess object creation, but this hopefully shouldn't be an
+          # issue since it should only be called only once per schema per
+          # process.
+          if data.kind_of?(Hash) && data['$ref']
+            reference = data['$ref']
+            reference = '#' + reference if reference[0..0] != '#'
+            data.merge({
+              '$ref' => reference
+            })
+          elsif data.kind_of?(Hash)
+            data.inject({}) do |accu, (key, value)|
+              if value.kind_of?(Hash)
+                accu[key] = reformat_references.call(value)
+              else
+                accu[key] = value
+              end
+              accu
+            end
+          else
+            data
+          end
+        end
+        schema_data = reformat_references.call(schema_data)
+        # puts schema_data.inspect
+
+        if schema_name
+          api_name_string =
+            Google::INFLECTOR.camelize(api.name)
+          api_version_string =
+            Google::INFLECTOR.camelize(api.version).gsub('.', '_')
+          if Google::APIClient::Schema.const_defined?(api_name_string)
+            api_name = Google::APIClient::Schema.const_get(api_name_string)
+          else
+            api_name = Google::APIClient::Schema.const_set(
+              api_name_string, Module.new
+            )
+          end
+          if api_name.const_defined?(api_version_string)
+            api_version = api_name.const_get(api_version_string)
+          else
+            api_version = api_name.const_set(api_version_string, Module.new)
+          end
+          if api_version.const_defined?(schema_name)
+            schema_class = api_version.const_get(schema_name)
+          end
+        end
+
+        # It's possible the schema has already been defined. If so, don't
+        # redefine it. This means that reloading a schema which has already
+        # been loaded into memory is not possible.
+        unless schema_class
+          schema_class = AutoParse.generate(schema_data, :uri => schema_uri)
+          if schema_name
+            api_version.const_set(schema_name, schema_class)
+          end
+        end
+        return schema_class
+      end
+    end
+  end
+end

data/lib/google/api_client/environment.rb

@@ -1,8 +1,11 @@
 module Google
   class APIClient
     module ENV
-      OS_VERSION = if RUBY_PLATFORM =~ /win32/
-        `ver`.sub(/\s*\[Version\s*/, '/').sub(']', '')
+      OS_VERSION = if RUBY_PLATFORM =~ /mswin|win32|mingw|bccwin|cygwin/
+        # TODO(bobaman)
+        # Confirm that all of these Windows environments actually have access
+        # to the `ver` command.
+        `ver`.sub(/\s*\[Version\s*/, '/').sub(']', '').strip
       elsif RUBY_PLATFORM =~ /darwin/i
         "Mac OS X/#{`sw_vers -productVersion`}"
       else

data/lib/google/api_client/errors.rb

@@ -26,5 +26,15 @@ module Google
     # invalid parameter values.
     class ValidationError < StandardError
     end
+
+    ##
+    # A 4xx class HTTP error occurred.
+    class ClientError < TransmissionError
+    end
+
+    ##
+    # A 5xx class HTTP error occurred.
+    class ServerError < TransmissionError
+    end
   end
 end

data/lib/google/api_client/parser.rb

@@ -0,0 +1,59 @@
+# 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 'json'
+
+module Google
+  class APIClient
+    module Parser
+      def content_type(content_type)
+        @@content_type_mapping ||= {}
+        @@content_type_mapping[content_type] = self
+      end
+
+      def self.match_content_type(content_type)
+        # TODO(bobaman): Do this more efficiently.
+        mime_type_regexp = /^([^\/]+)(?:\/([^+]+\+)?([^;]+))?(?:;.*)?$/
+        if @@content_type_mapping[content_type]
+          # Exact match
+          return @@content_type_mapping[content_type]
+        else
+          media_type, extension, sub_type =
+            content_type.scan(mime_type_regexp)[0]
+          for pattern, parser in @@content_type_mapping
+            # We want to match on subtype first
+            pattern_media_type, pattern_extension, pattern_sub_type =
+              pattern.scan(mime_type_regexp)[0]
+            next if pattern_extension != nil
+            if media_type == pattern_media_type && sub_type == pattern_sub_type
+              return parser
+            end
+          end
+          for pattern, parser in @@content_type_mapping
+            # We failed to match on the subtype
+            # Try to match only on the media type
+            pattern_media_type, pattern_extension, pattern_sub_type =
+              pattern.scan(mime_type_regexp)[0]
+            next if pattern_extension != nil || pattern_sub_type != nil
+            if media_type == pattern_media_type
+              return parser
+            end
+          end
+        end
+        return nil
+      end
+    end
+  end
+end

data/lib/google/api_client/parsers/json/error_parser.rb

@@ -0,0 +1,34 @@
+# 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/parsers/json_parser'
+
+module Google
+  class APIClient
+    module JSON
+      ##
+      # A module which provides a parser for error responses.
+      class ErrorParser
+        include Google::APIClient::JSONParser
+
+        matches_fields 'error'
+
+        def error
+          return self['error']['message']
+        end
+      end
+    end
+  end
+end

data/lib/google/api_client/parsers/json/pagination.rb

@@ -0,0 +1,40 @@
+# 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/parsers/json_parser'
+
+module Google
+  class APIClient
+    module JSON
+      ##
+      # A module which provides a paginated parser.
+      module Pagination
+        def self.included(parser)
+          parser.class_eval do
+            include Google::APIClient::JSONParser
+          end
+        end
+
+        def next_page_token
+          return self["nextPageToken"]
+        end
+
+        def prev_page_token
+          return self["prevPageToken"]
+        end
+      end
+    end
+  end
+end

data/lib/google/api_client/parsers/json_parser.rb

@@ -14,27 +14,105 @@
 
 
 require 'json'
+require 'google/api_client/parser'
 
 module Google
   class APIClient
     ##
-    # Provides a consistent interface by which to parse request and response
-    # content.
-    # TODO(mattpok): ensure floats, URLs, dates are parsed correctly
+    # Provides a module which all other parsers should include.
     module JSONParser
+      extend Parser
+      content_type 'application/json'
 
-      def self.serialize(hash)
-        # JSON parser used can accept arrays as well, but we will limit
-        # to only allow hash to JSON string parsing to keep a simple interface
-        unless hash.instance_of? Hash
-          raise ArgumentError,
-            "JSON generate expected a Hash but got a #{hash.class}."
+      module Matcher
+        def conditions
+          @conditions ||= []
+        end
+
+        def matches_kind(kind)
+          self.matches_field_value(:kind, kind)
+        end
+
+        def matches_fields(fields)
+          self.conditions << [:fields, fields]
+        end
+
+        def matches_field_value(field, value)
+          self.conditions << [:field_value, field, value]
         end
-        return JSON.generate(hash)
       end
 
-      def self.parse(json_string)
-        return JSON.parse(json_string)
+      def self.parsers
+        @parsers ||= []
+      end
+
+      ##
+      # This method ensures that all parsers auto-register themselves.
+      def self.included(parser)
+        self.parsers << parser
+        parser.extend(Matcher)
+      end
+
+      def initialize(data)
+        @data = data.kind_of?(Hash) ? data : ::JSON.parse(data)
+      end
+
+      def [](key)
+        return self.json[key]
+      end
+
+      def json
+        if @data
+          data = @data
+        elsif self.respond_to?(:data)
+          data = self.data
+        else
+          raise TypeError, "Parser did not provide access to raw data."
+        end
+        return data
+      end
+
+      ##
+      # Matches a parser to the data.
+      def self.match(data)
+        for parser in self.parsers
+          conditions_met = true
+          for condition in (parser.conditions.sort_by { |c| c.size }).reverse
+            condition_type, *params = condition
+            case condition_type
+            when :fields
+              for field in params
+                if !data.has_key?(field)
+                  conditions_met = false
+                  break
+                end
+              end
+            when :field_values
+              field, value = params
+              if data[field] != value
+                conditions_met = false
+                break
+              end
+            else
+              raise ArgumentError, "Unknown condition type: #{condition_type}"
+            end
+            break if !conditions_met
+          end
+          if conditions_met
+            return parser
+          end
+        end
+        return nil
+      end
+
+      def self.parse(json)
+        data = json.kind_of?(Hash) ? json : ::JSON.parse(json)
+        parser = self.match(data)
+        if parser
+          return parser.new(data)
+        else
+          return data
+        end
       end
     end
   end