ghost_google-api-client 0.4.7.1

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

@@ -0,0 +1,119 @@
+# 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 'multi_json'
+require 'compat/multi_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'] && !data['$ref'].kind_of?(Hash)
+            if data['$ref'].respond_to?(:to_str)
+              reference = data['$ref'].to_str
+            else
+              raise TypeError, "Expected String, got #{data['$ref'].class}"
+            end
+            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('.', '_')
+          # This is for compatibility with Ruby 1.8.7.
+          # TODO(bobaman) Remove this when we eventually stop supporting 1.8.7.
+          args = []
+          args << false if Class.method(:const_defined?).arity != 1
+          if Google::APIClient::Schema.const_defined?(api_name_string, *args)
+            api_name = Google::APIClient::Schema.const_get(
+              api_name_string, *args
+            )
+          else
+            api_name = Google::APIClient::Schema.const_set(
+              api_name_string, Module.new
+            )
+          end
+          if api_name.const_defined?(api_version_string, *args)
+            api_version = api_name.const_get(api_version_string, *args)
+          else
+            api_version = api_name.const_set(api_version_string, Module.new)
+          end
+          if api_version.const_defined?(schema_name, *args)
+            schema_class = api_version.const_get(schema_name, *args)
+          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

@@ -0,0 +1,42 @@
+# 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.
+
+
+module Google
+  class APIClient
+    module ENV
+      OS_VERSION = begin
+        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`}"
+        elsif RUBY_PLATFORM == 'java'
+          # Get the information from java system properties to avoid spawning a
+          # sub-process, which is not friendly in some contexts (web servers).
+          require 'java'
+          name = java.lang.System.getProperty('os.name')
+          version = java.lang.System.getProperty('os.version')
+          "#{name}/#{version}"
+        else
+          `uname -sr`.sub(' ', '/')
+        end
+      rescue Exception
+        RUBY_PLATFORM
+      end
+    end
+  end
+end

data/lib/google/api_client/errors.rb

@@ -0,0 +1,49 @@
+# 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.
+
+
+module Google
+  class APIClient
+    ##
+    # An error which is raised when there is an unexpected response or other
+    # transport error that prevents an operation from succeeding.
+    class TransmissionError < StandardError
+    end
+
+    ##
+    # An exception that is raised if a method is called with missing or
+    # 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
+
+    ##
+    # An exception that is raised if an ID token could not be validated.
+    class InvalidIDTokenError < StandardError
+    end
+
+    # Error class for problems in batch requests.
+    class BatchError < StandardError
+    end
+  end
+end

data/lib/google/api_client/media.rb

@@ -0,0 +1,172 @@
+# 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.
+
+module Google
+  class APIClient
+    ##
+    # Uploadable media support.  Holds an IO stream & content type.
+    #
+    # @see Faraday::UploadIO
+    # @example
+    #   media = Google::APIClient::UploadIO.new('mymovie.m4v', 'video/mp4')
+    class UploadIO < Faraday::UploadIO      
+      ##
+      # Get the length of the stream
+      # @return [Integer]
+      #   Length of stream, in bytes
+      def length
+        io.respond_to?(:length) ? io.length : File.size(local_path)
+      end
+    end
+    
+    ##
+    # Resumable uploader.
+    #
+    class ResumableUpload
+      attr_reader :result
+      attr_accessor :client
+      attr_accessor :chunk_size
+      attr_accessor :media
+      attr_accessor :location
+  
+      ##
+      # Creates a new uploader.
+      #
+      # @param [Google::APIClient::Result] result
+      #   Result of the initial request that started the upload
+      # @param [Google::APIClient::UploadIO] media
+      #   Media to upload
+      # @param [String] location
+      #  URL to upload to    
+      def initialize(result, media, location)
+        self.media = media
+        self.location = location
+        self.chunk_size = 256 * 1024
+        
+        @api_method = result.reference.api_method
+        @result = result
+        @offset = 0
+        @complete = false
+      end
+      
+      ##
+      # Sends all remaining chunks to the server
+      #
+      # @param [Google::APIClient] api_client
+      #   API Client instance to use for sending
+      def send_all(api_client)
+        until complete?
+          send_chunk(api_client)
+          break unless result.status == 308
+        end
+        return result
+      end
+      
+      
+      ##
+      # Sends the next chunk to the server
+      #
+      # @param [Google::APIClient] api_client
+      #   API Client instance to use for sending
+      def send_chunk(api_client)
+        if @offset.nil?
+          return resync_range(api_client)
+        end
+
+        start_offset = @offset
+        self.media.io.pos = start_offset
+        chunk = self.media.io.read(chunk_size)
+        content_length = chunk.bytesize
+
+        end_offset = start_offset + content_length - 1
+        @result = api_client.execute(
+          :uri => self.location,
+          :http_method => :put,
+          :headers => {
+            'Content-Length' => "#{content_length}",
+            'Content-Type' => self.media.content_type, 
+            'Content-Range' => "bytes #{start_offset}-#{end_offset}/#{media.length}" },
+          :body => chunk)
+        return process_result(@result)
+      end
+
+      ##
+      # Check if upload is complete
+      #
+      # @return [TrueClass, FalseClass]
+      #   Whether or not the upload complete successfully
+      def complete?
+        return @complete
+      end
+
+      ##
+      # Check if the upload URL expired (upload not completed in alotted time.)
+      # Expired uploads must be restarted from the beginning
+      #
+      # @return [TrueClass, FalseClass]
+      #   Whether or not the upload has expired and can not be resumed
+      def expired?
+        return @result.status == 404 || @result.status == 410
+      end
+      
+      ##
+      # Get the last saved range from the server in case an error occurred 
+      # and the offset is not known.
+      #
+      # @param [Google::APIClient] api_client
+      #   API Client instance to use for sending
+      def resync_range(api_client)
+        r = api_client.execute(
+          :uri => self.location,
+          :http_method => :put,
+          :headers => { 
+            'Content-Length' => "0", 
+            'Content-Range' => "bytes */#{media.length}" })
+        return process_result(r)
+      end
+      
+      ##
+      # Check the result from the server, updating the offset and/or location
+      # if available.
+      #
+      # @param [Google::APIClient::Result] r
+      #  Result of a chunk upload or range query
+      def process_result(result)
+        case result.status
+        when 200...299
+          @complete = true
+          if @api_method
+            # Inject the original API method so data is parsed correctly
+            result.reference.api_method = @api_method
+          end
+          return result
+        when 308
+          range = result.headers['range']
+          if range
+            @offset = range.scan(/\d+/).collect{|x| Integer(x)}.last + 1
+          end
+          if result.headers['location']
+            self.location = result.headers['location']
+          end
+        when 500...599
+          # Invalidate the offset to mark it needs to be queried on the
+          # next request
+          @offset = nil
+        end
+        return nil
+      end
+      
+    end
+  end
+end

data/lib/google/api_client/reference.rb

@@ -0,0 +1,305 @@
+# 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.
+
+
+gem 'faraday', '~> 0.8.1'
+require 'faraday'
+require 'faraday/utils'
+require 'multi_json'
+require 'compat/multi_json'
+require 'addressable/uri'
+require 'stringio'
+require 'google/api_client/discovery'
+
+# TODO - needs some serious cleanup
+
+module Google
+  class APIClient
+    class Reference
+      MULTIPART_BOUNDARY = "-----------RubyApiMultipartPost".freeze
+
+      def initialize(options={})
+        # We only need this to do lookups on method ID String values
+        # It's optional, but method ID lookups will fail if the client is
+        # omitted.
+        @client = options[:client]
+        @version = options[:version] || 'v1'
+
+        self.connection = options[:connection] || Faraday.default_connection
+        self.authorization = options[:authorization]
+        self.api_method = options[:api_method]
+        self.parameters = options[:parameters] || {}
+        # These parameters are handled differently because they're not
+        # parameters to the API method, but rather to the API system.
+        if self.parameters.kind_of?(Array)
+          if options[:key]
+            self.parameters.reject! { |k, _| k == 'key' }
+            self.parameters << ['key', options[:key]]
+          end
+          if options[:user_ip]
+            self.parameters.reject! { |k, _| k == 'userIp' }
+            self.parameters << ['userIp', options[:user_ip]]
+          end
+        elsif self.parameters.kind_of?(Hash)
+          self.parameters['key'] ||= options[:key] if options[:key]
+          self.parameters['userIp'] ||= options[:user_ip] if options[:user_ip]
+          # Convert to Array, because they're easier to work with when
+          # repeated parameters are an issue.
+          self.parameters = self.parameters.to_a
+        else
+          raise TypeError,
+            "Expected Array or Hash, got #{self.parameters.class}."
+        end
+        self.headers = options[:headers] || {}
+        if options[:media]
+          self.media = options[:media]
+          upload_type = self.parameters.find { |(k, _)| ['uploadType', 'upload_type'].include?(k) }.last
+          case upload_type
+          when "media"
+            if options[:body] || options[:body_object]
+              raise ArgumentError,
+                "Can not specify body & body object for simple uploads."
+            end
+            self.headers['Content-Type'] ||= self.media.content_type
+            self.body = self.media
+          when "multipart"
+            unless options[:body_object]
+              raise ArgumentError, "Multipart requested but no body object."
+            end
+            # This is all a bit of a hack due to Signet requiring body to be a
+            # string. Ideally, update Signet to delay serialization so we can
+            # just pass streams all the way down through to the HTTP library.
+            metadata = StringIO.new(serialize_body(options[:body_object]))
+            env = {
+              :request_headers => {
+                'Content-Type' =>
+                  "multipart/related;boundary=#{MULTIPART_BOUNDARY}"
+              },
+              :request => {:boundary => MULTIPART_BOUNDARY}
+            }
+            multipart = Faraday::Request::Multipart.new
+            self.body = multipart.create_multipart(env, [
+              [nil, Faraday::UploadIO.new(
+                metadata, 'application/json', 'file.json'
+              )],
+              [nil, self.media]])
+            self.headers.update(env[:request_headers])
+          when "resumable"
+            file_length = self.media.length
+            self.headers['X-Upload-Content-Type'] = self.media.content_type
+            self.headers['X-Upload-Content-Length'] = file_length.to_s
+            if options[:body_object]
+              self.headers['Content-Type'] ||= 'application/json'
+              self.body = serialize_body(options[:body_object])
+            else
+              self.body = ''
+            end
+          else
+            raise ArgumentError, "Invalid uploadType for media."
+          end
+        elsif options[:body]
+          self.body = options[:body]
+        elsif options[:body_object]
+          self.headers['Content-Type'] ||= 'application/json'
+          self.body = serialize_body(options[:body_object])
+        else
+          self.body = ''
+        end
+        unless self.api_method
+          self.http_method = options[:http_method] || 'GET'
+          self.uri = options[:uri]
+          unless self.parameters.empty?
+            query_values = (self.uri.query_values(Array) || [])
+            self.uri.query = Addressable::URI.form_encode(
+              (query_values + self.parameters).sort
+            )
+            self.uri.query = nil if self.uri.query == ""
+          end
+        end
+      end
+
+      def serialize_body(body)
+        return body.to_json if body.respond_to?(:to_json)
+        return MultiJson.dump(options[:body_object].to_hash) if body.respond_to?(:to_hash)
+        raise TypeError, 'Could not convert body object to JSON.' +
+                         'Must respond to :to_json or :to_hash.'
+      end
+
+      def media
+        return @media
+      end
+
+      def media=(media)
+        @media = (media)
+      end
+
+      def authorization
+        return @authorization
+      end
+
+      def authorization=(new_authorization)
+        @authorization = new_authorization
+      end
+
+      def connection
+        return @connection
+      end
+
+      def connection=(new_connection)
+        if new_connection.kind_of?(Faraday::Connection)
+          @connection = new_connection
+        else
+          raise TypeError,
+            "Expected Faraday::Connection, got #{new_connection.class}."
+        end
+      end
+
+      def api_method
+        return @api_method
+      end
+
+      def api_method=(new_api_method)
+        if new_api_method.kind_of?(Google::APIClient::Method) ||
+            new_api_method == nil
+          @api_method = new_api_method
+        elsif new_api_method.respond_to?(:to_str) ||
+            new_api_method.kind_of?(Symbol)
+          unless @client
+            raise ArgumentError,
+              "API method lookup impossible without client instance."
+          end
+          new_api_method = new_api_method.to_s
+          # This method of guessing the API is unreliable. This will fail for
+          # APIs where the first segment of the RPC name does not match the
+          # service name. However, this is a fallback mechanism anyway.
+          # Developers should be passing in a reference to the method, rather
+          # than passing in a string or symbol. This should raise an error
+          # in the case of a mismatch.
+          api = new_api_method[/^([^.]+)\./, 1]
+          @api_method = @client.discovered_method(
+            new_api_method, api, @version
+          )
+          if @api_method
+            # Ditch the client reference, we won't need it again.
+            @client = nil
+          else
+            raise ArgumentError, "API method could not be found."
+          end
+        else
+          raise TypeError,
+            "Expected Google::APIClient::Method, got #{new_api_method.class}."
+        end
+      end
+
+      def parameters
+        return @parameters
+      end
+
+      def parameters=(new_parameters)
+        # No type-checking needed, the Method class handles this.
+        @parameters = new_parameters
+      end
+
+      def body
+        return @body
+      end
+
+      def body=(new_body)
+        if new_body.respond_to?(:to_str)
+          @body = new_body.to_str
+        elsif new_body.respond_to?(:read)
+          @body = new_body.read()
+        elsif new_body.respond_to?(:inject)
+          @body = (new_body.inject(StringIO.new) do |accu, chunk|
+            accu.write(chunk)
+            accu
+          end).string
+        else
+          raise TypeError,
+            "Expected body to be String, IO, or Enumerable chunks."
+        end
+      end
+
+      def headers
+        return @headers ||= {}
+      end
+
+      def headers=(new_headers)
+        if new_headers.kind_of?(Array) || new_headers.kind_of?(Hash)
+          @headers = new_headers
+        else
+          raise TypeError, "Expected Hash or Array, got #{new_headers.class}."
+        end
+      end
+
+      def http_method
+        return @http_method ||= self.api_method.http_method
+      end
+
+      def http_method=(new_http_method)
+        if new_http_method.kind_of?(Symbol)
+          @http_method = new_http_method.to_s.upcase
+        elsif new_http_method.respond_to?(:to_str)
+          @http_method = new_http_method.to_str.upcase
+        else
+          raise TypeError,
+            "Expected String or Symbol, got #{new_http_method.class}."
+        end
+      end
+
+      def uri
+        return @uri ||= self.api_method.generate_uri(self.parameters)
+      end
+
+      def uri=(new_uri)
+        @uri = Addressable::URI.parse(new_uri)
+      end
+
+      def to_request
+        if self.api_method
+          return self.api_method.generate_request(
+            self.parameters, self.body, self.headers,
+            :connection => self.connection
+          )
+        else
+          return self.connection.build_request(
+            self.http_method.to_s.downcase.to_sym
+          ) do |req|
+            req.url(Addressable::URI.parse(self.uri).normalize.to_s)
+            req.headers = Faraday::Utils::Headers.new(self.headers)
+            req.body = self.body
+          end
+        end
+      end
+
+      def to_hash
+        options = {}
+        if self.api_method
+          options[:api_method] = self.api_method
+          options[:parameters] = self.parameters
+        else
+          options[:http_method] = self.http_method
+          options[:uri] = self.uri
+        end
+        options[:headers] = self.headers
+        options[:body] = self.body
+        options[:connection] = self.connection
+        unless self.authorization.nil?
+          options[:authorization] = self.authorization
+        end
+        return options
+      end
+    end
+  end
+end