google-api-client 0.8.7 → 0.9.pre1

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

@@ -1,156 +0,0 @@
-# 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 'active_support/inflector'
-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 [Google::APIClient::API] api
-      #   The API this resource belongs to.
-      # @param [Addressable::URI] method_base
-      #   The base URI for the service.
-      # @param [String] resource_name
-      #   The identifier for the resource.
-      # @param [Hash] discovery_document
-      #   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.discovered_resources.each do |resource|
-          method_name = ActiveSupport::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 = ActiveSupport::Inflector.underscore(method.name).to_sym
-          if !self.respond_to?(method_name)
-            metaclass.send(:define_method, method_name) { method }
-          end
-        end
-      end
-
-      # @return [String] unparsed discovery document for the resource
-      attr_reader :discovery_document
-
-      ##
-      # Returns the identifier for the resource.
-      #
-      # @return [String] The resource identifier.
-      attr_reader :name
-
-      ##
-      # Returns the base URI for this resource.
-      #
-      # @return [Addressable::URI] The base URI that methods are joined to.
-      attr_reader :method_base
-
-      ##
-      # Returns a human-readable description of the resource.
-      #
-      # @return [Hash] The API description.
-      def description
-        return @discovery_document['description']
-      end
-
-      ##
-      # Updates the hierarchy of resources and methods with the new base.
-      #
-      # @param [Addressable::URI, #to_str, String] new_method_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.discovered_resources.each do |resource|
-          resource.method_base = @method_base
-        end
-        self.discovered_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 discovered_resources
-        return @discovered_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 discovered_methods
-        return @discovered_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.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 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

@@ -1,117 +0,0 @@
-# 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 'active_support/inflector'
-require 'google/api_client/errors'
-
-
-module Google
-  class APIClient
-    ##
-    # @api private
-    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)
-        )
-
-        # 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)
-
-        if schema_name
-          api_name_string = ActiveSupport::Inflector.camelize(api.name)
-          api_version_string = ActiveSupport::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

@@ -1,42 +0,0 @@
-# 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/gzip.rb

@@ -1,28 +0,0 @@
-require 'faraday'
-require 'zlib'
- 
-module Google
-  class APIClient
-    class Gzip < Faraday::Response::Middleware
-      include Google::APIClient::Logging
- 
-      def on_complete(env)
-        encoding = env[:response_headers]['content-encoding'].to_s.downcase
-        case encoding
-        when 'gzip'
-          logger.debug { "Decompressing gzip encoded response (#{env[:body].length} bytes)" }        
-          env[:body] = Zlib::GzipReader.new(StringIO.new(env[:body])).read
-          env[:response_headers].delete('content-encoding')
-          logger.debug { "Decompressed (#{env[:body].length} bytes)" }        
-        when 'deflate'
-          logger.debug{ "Decompressing deflate encoded response (#{env[:body].length} bytes)" }        
-          env[:body] = Zlib::Inflate.inflate(env[:body])
-          env[:response_headers].delete('content-encoding')
-          logger.debug { "Decompressed (#{env[:body].length} bytes)" }        
-        end
-      end
-    end
-  end
-end
- 
-Faraday::Response.register_middleware :gzip => Google::APIClient::Gzip

data/lib/google/api_client/logging.rb

@@ -1,32 +0,0 @@
-require 'logger'
-
-module Google
-  class APIClient
-    
-    class << self
-      ##
-      # Logger for the API client
-      #
-      # @return [Logger] logger instance.
-      attr_accessor :logger
-    end
-
-    self.logger = Logger.new(STDOUT)
-    self.logger.level = Logger::WARN  
-
-    ##
-    # Module to make accessing the logger simpler
-    module Logging
-      ##
-      # Logger for the API client
-      #
-      # @return [Logger] logger instance.
-      def logger
-        Google::APIClient.logger
-      end
-    end
-
-  end
-  
-  
-end

data/lib/google/api_client/media.rb

@@ -1,259 +0,0 @@
-# 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/reference'
-
-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
-      
-      # @return [Fixnum] Size of chunks to upload. Default is nil, meaning upload the entire file in a single request
-      attr_accessor :chunk_size
-            
-      ##
-      # Get the length of the stream
-      #
-      # @return [Fixnum]
-      #   Length of stream, in bytes
-      def length
-        io.respond_to?(:length) ? io.length : File.size(local_path)
-      end
-    end
-    
-    ##
-    # Wraps an input stream and limits data to a given range
-    #
-    # @example
-    #   chunk = Google::APIClient::RangedIO.new(io, 0, 1000)
-    class RangedIO 
-      ##
-      # Bind an input stream to a specific range.
-      #
-      # @param [IO] io
-      #   Source input stream
-      # @param [Fixnum] offset
-      #   Starting offset of the range
-      # @param [Fixnum] length
-      #   Length of range
-      def initialize(io, offset, length)
-        @io = io
-        @offset = offset
-        @length = length
-        self.rewind
-      end
-      
-      ##
-      # @see IO#read
-      def read(amount = nil, buf = nil)
-        buffer = buf || ''
-        if amount.nil?
-          size = @length - @pos
-          done = ''
-        elsif amount == 0
-          size = 0
-          done = ''
-        else 
-          size = [@length - @pos, amount].min
-          done = nil
-        end
-
-        if size > 0
-          result = @io.read(size)
-          result.force_encoding("BINARY") if result.respond_to?(:force_encoding)
-          buffer << result if result
-          @pos = @pos + size
-        end
-
-        if buffer.length > 0
-          buffer
-        else
-          done
-        end
-      end
-
-      ##
-      # @see IO#rewind
-      def rewind
-        self.pos = 0
-      end
-
-      ##
-      # @see IO#pos
-      def pos
-        @pos
-      end
-
-      ##
-      # @see IO#pos=
-      def pos=(pos)
-        @pos = pos
-        @io.pos = @offset + pos
-      end
-    end
-    
-    ##
-    # Resumable uploader.
-    #
-    class ResumableUpload < Request
-      # @return [Fixnum] Max bytes to send in a single request
-      attr_accessor :chunk_size
-  
-      ##
-      # Creates a new uploader.
-      #
-      # @param [Hash] options
-      #   Request options
-      def initialize(options={})
-        super options
-        self.uri = options[:uri]
-        self.http_method = :put
-        @offset = options[:offset] || 0
-        @complete = false
-        @expired = false
-      end
-      
-      ##
-      # Sends all remaining chunks to the server
-      #
-      # @deprecated Pass the instance to {Google::APIClient#execute} instead
-      #
-      # @param [Google::APIClient] api_client
-      #   API Client instance to use for sending
-      def send_all(api_client)
-        result = nil
-        until complete?
-          result = send_chunk(api_client)
-          break unless result.status == 308
-        end
-        return result
-      end
-      
-      
-      ##
-      # Sends the next chunk to the server
-      #
-      # @deprecated Pass the instance to {Google::APIClient#execute} instead
-      #
-      # @param [Google::APIClient] api_client
-      #   API Client instance to use for sending
-      def send_chunk(api_client)
-        return api_client.execute(self)
-      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 @expired
-      end
-      
-      ##
-      # Check if upload is resumable. That is, neither complete nor expired
-      #
-      # @return [TrueClass, FalseClass] True if upload can be resumed
-      def resumable?
-        return !(self.complete? or self.expired?)
-      end
-      
-      ##
-      # Convert to an HTTP request. Returns components in order of method, URI,
-      # request headers, and body
-      #
-      # @api private
-      #
-      # @return [Array<(Symbol, Addressable::URI, Hash, [#read,#to_str])>]
-      def to_http_request
-        if @complete
-          raise Google::APIClient::ClientError, "Upload already complete"
-        elsif @offset.nil?
-          self.headers.update({ 
-            'Content-Length' => "0", 
-            'Content-Range' => "bytes */#{media.length}" })
-        else
-          start_offset = @offset
-          remaining = self.media.length - start_offset
-          chunk_size = self.media.chunk_size || self.chunk_size || self.media.length
-          content_length = [remaining, chunk_size].min
-          chunk = RangedIO.new(self.media.io, start_offset, content_length)
-          end_offset = start_offset + content_length - 1
-          self.headers.update({
-            'Content-Length' => "#{content_length}",
-            'Content-Type' => self.media.content_type, 
-            'Content-Range' => "bytes #{start_offset}-#{end_offset}/#{media.length}" })
-          self.body = chunk
-        end
-        super
-      end
-      
-      ##
-      # Check the result from the server, updating the offset and/or location
-      # if available.
-      #
-      # @api private
-      #
-      # @param [Faraday::Response] response
-      #   HTTP response
-      #
-      # @return [Google::APIClient::Result]
-      #   Processed API response
-      def process_http_response(response)
-        case response.status
-        when 200...299
-          @complete = true
-        when 308
-          range = response.headers['range']
-          if range
-            @offset = range.scan(/\d+/).collect{|x| Integer(x)}.last + 1
-          end
-          if response.headers['location']
-            self.uri = response.headers['location']
-          end
-        when 400...499
-          @expired = true
-        when 500...599
-          # Invalidate the offset to mark it needs to be queried on the
-          # next request
-          @offset = nil
-        end
-        return Google::APIClient::Result.new(self, response)
-      end
-      
-      ##
-      # Hashified verison of the API request
-      #
-      # @return [Hash]
-      def to_hash
-        super.merge(:offset => @offset)
-      end
-      
-    end
-  end
-end