RubyGems - ghost_google-api-client - Versions diffs - 0.4.7.1 - Mend

ghost_google-api-client 0.4.7.1

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (40) hide show

data/CHANGELOG.md +77 -0
data/Gemfile +30 -0
data/Gemfile.lock +80 -0
data/LICENSE +202 -0
data/README.md +71 -0
data/Rakefile +42 -0
data/bin/google-api +545 -0
data/lib/compat/multi_json.rb +17 -0
data/lib/google/api_client.rb +802 -0
data/lib/google/api_client/batch.rb +296 -0
data/lib/google/api_client/client_secrets.rb +106 -0
data/lib/google/api_client/discovery.rb +19 -0
data/lib/google/api_client/discovery/api.rb +287 -0
data/lib/google/api_client/discovery/media.rb +77 -0
data/lib/google/api_client/discovery/method.rb +369 -0
data/lib/google/api_client/discovery/resource.rb +150 -0
data/lib/google/api_client/discovery/schema.rb +119 -0
data/lib/google/api_client/environment.rb +42 -0
data/lib/google/api_client/errors.rb +49 -0
data/lib/google/api_client/media.rb +172 -0
data/lib/google/api_client/reference.rb +305 -0
data/lib/google/api_client/result.rb +161 -0
data/lib/google/api_client/service_account.rb +134 -0
data/lib/google/api_client/version.rb +31 -0
data/lib/google/inflection.rb +28 -0
data/spec/fixtures/files/sample.txt +33 -0
data/spec/google/api_client/batch_spec.rb +241 -0
data/spec/google/api_client/discovery_spec.rb +670 -0
data/spec/google/api_client/media_spec.rb +143 -0
data/spec/google/api_client/result_spec.rb +185 -0
data/spec/google/api_client/service_account_spec.rb +58 -0
data/spec/google/api_client_spec.rb +139 -0
data/spec/spec_helper.rb +7 -0
data/tasks/gem.rake +97 -0
data/tasks/git.rake +45 -0
data/tasks/metrics.rake +22 -0
data/tasks/spec.rake +57 -0
data/tasks/wiki.rake +82 -0
data/tasks/yard.rake +29 -0
metadata +253 -0

data/Rakefile ADDED

@@ -0,0 +1,42 @@
+lib_dir = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib_dir)
+$LOAD_PATH.uniq!
+require 'rubygems'
+require 'rake'
+require File.join(File.dirname(__FILE__), 'lib/google/api_client', 'version')
+PKG_DISPLAY_NAME   = 'Google API Client'
+PKG_NAME           = PKG_DISPLAY_NAME.downcase.gsub(/\s/, '-')
+PKG_VERSION        = Google::APIClient::VERSION::STRING
+PKG_FILE_NAME      = "#{PKG_NAME}-#{PKG_VERSION}"
+PKG_HOMEPAGE       = 'http://code.google.com/p/google-api-ruby-client/'
+RELEASE_NAME       = "REL #{PKG_VERSION}"
+PKG_AUTHOR         = "Bob Aman"
+PKG_AUTHOR_EMAIL   = "bobaman@google.com"
+PKG_SUMMARY        = 'Package Summary'
+PKG_DESCRIPTION    = <<-TEXT
+The Google API Ruby Client makes it trivial to discover and access supported
+APIs.
+TEXT
+PKG_FILES = FileList[
+    'lib/**/*', 'spec/**/*', 'vendor/**/*',
+    'tasks/**/*', 'website/**/*',
+    '[A-Z]*', 'Rakefile'
+].exclude(/database\.yml/).exclude(/[_\.]git$/)
+RCOV_ENABLED = !!(RUBY_PLATFORM != 'java' && RUBY_VERSION =~ /^1\.8/)
+if RCOV_ENABLED
+  task :default => 'spec:rcov'
+else
+  task :default => 'spec'
+end
+WINDOWS = (RUBY_PLATFORM =~ /mswin|win32|mingw|bccwin|cygwin/) rescue false
+SUDO = WINDOWS ? '' : ('sudo' unless ENV['SUDOLESS'])
+Dir['tasks/**/*.rake'].each { |rake| load rake }

data/bin/google-api ADDED

@@ -0,0 +1,545 @@
+#!/usr/bin/env ruby
+bin_dir = File.expand_path("..", __FILE__)
+lib_dir = File.expand_path("../lib", bin_dir)
+$LOAD_PATH.unshift(lib_dir)
+$LOAD_PATH.uniq!
+OAUTH_SERVER_PORT = 12736
+require 'rubygems'
+require 'optparse'
+gem 'faraday', '~> 0.8.1'
+require 'faraday'
+require 'faraday/utils'
+require 'webrick'
+require 'google/api_client/version'
+require 'google/api_client'
+ARGV.unshift('--help') if ARGV.empty?
+module Google
+  class APIClient
+    class CLI
+      # Used for oauth login
+      class OAuthVerifierServlet < WEBrick::HTTPServlet::AbstractServlet
+        attr_reader :verifier
+        def do_GET(request, response)
+          $verifier ||= Addressable::URI.unencode_component(
+            request.request_uri.to_s[/\?.*oauth_verifier=([^&$]+)(&|$)/, 1] ||
+            request.request_uri.to_s[/\?.*code=([^&$]+)(&|$)/, 1]
+          )
+          response.status = WEBrick::HTTPStatus::RC_ACCEPTED
+          # This javascript will auto-close the tab after the
+          # verifier is obtained.
+          response.body = <<-HTML
+<html>
+  <head>
+    <script>
+      function closeWindow() {
+        window.open('', '_self', '');
+        window.close();
+      }
+      setTimeout(closeWindow, 10);
+    </script>
+  </head>
+  <body>
+    You may close this window.
+  </body>
+</html>
+HTML
+          # Eww, hack!
+          server = self.instance_variable_get('@server')
+          server.stop if server
+        end
+      end
+      # Initialize with default parameter values
+      def initialize(argv)
+        @options = {
+          :command => 'execute',
+          :rpcname => nil,
+          :verbose => false
+        }
+        @argv = argv.clone
+        if @argv.first =~ /^[a-z0-9][a-z0-9_-]*$/i
+          self.options[:command] = @argv.shift
+        end
+        if @argv.first =~ /^[a-z0-9_-]+\.[a-z0-9_\.-]+$/i
+          self.options[:rpcname] = @argv.shift
+        end
+      end
+      attr_reader :options
+      attr_reader :argv
+      def command
+        return self.options[:command]
+      end
+      def rpcname
+        return self.options[:rpcname]
+      end
+      def parser
+        @parser ||= OptionParser.new do |opts|
+          opts.banner = "Usage: google-api " +
+            "(execute <rpcname> | [command]) [options] [-- <parameters>]"
+          opts.separator "\nAvailable options:"
+          opts.on(
+              "--scope <scope>", String, "Set the OAuth scope") do |s|
+            options[:scope] = s
+          end
+          opts.on(
+              "--client-id <key>", String,
+                "Set the OAuth client id or key") do |k|
+            options[:client_credential_key] = k
+          end
+          opts.on(
+              "--client-secret <secret>", String,
+                "Set the OAuth client secret") do |s|
+            options[:client_credential_secret] = s
+          end
+          opts.on(
+              "--api <name>", String,
+              "Perform discovery on API") do |s|
+            options[:api] = s
+          end
+          opts.on(
+              "--api-version <id>", String,
+              "Select api version") do |id|
+            options[:version] = id
+          end
+          opts.on(
+              "--content-type <format>", String,
+              "Content-Type for request") do |f|
+            # Resolve content type shortcuts
+            case f
+            when 'json'
+              f = 'application/json'
+            when 'xml'
+              f = 'application/xml'
+            when 'atom'
+              f = 'application/atom+xml'
+            when 'rss'
+              f = 'application/rss+xml'
+            end
+            options[:content_type] = f
+          end
+          opts.on(
+              "-u", "--uri <uri>", String,
+              "Sets the URI to perform a request against") do |u|
+            options[:uri] = u
+          end
+          opts.on(
+              "--discovery-uri <uri>", String,
+              "Sets the URI to perform discovery") do |u|
+            options[:discovery_uri] = u
+          end
+          opts.on(
+              "-m", "--method <method>", String,
+              "Sets the HTTP method to use for the request") do |m|
+            options[:http_method] = m
+          end
+          opts.on(
+              "--requestor-id <email>", String,
+              "Sets the email address of the requestor") do |e|
+            options[:requestor_id] = e
+          end
+          opts.on("-v", "--verbose", "Run verbosely") do |v|
+            options[:verbose] = v
+          end
+          opts.on("-h", "--help", "Show this message") do
+            puts opts
+            exit
+          end
+          opts.on("--version", "Show version") do
+            puts "google-api-client (#{Google::APIClient::VERSION::STRING})"
+            exit
+          end
+          opts.separator(
+            "\nAvailable commands:\n" +
+            "    oauth-1-login   Log a user into an API with OAuth 1.0a\n" +
+            "    oauth-2-login   Log a user into an API with OAuth 2.0 d10\n" +
+            "    list            List the methods available for an API\n" +
+            "    execute         Execute a method on the API\n" +
+            "    irb             Start an interactive client session"
+          )
+        end
+      end
+      def parse!
+        self.parser.parse!(self.argv)
+        symbol = self.command.gsub(/-/, "_").to_sym
+        if !COMMANDS.include?(symbol)
+          STDERR.puts("Invalid command: #{self.command}")
+          exit(1)
+        end
+        self.send(symbol)
+      end
+      def client
+        gem 'signet', '~> 0.4.0'
+        require 'signet/oauth_1/client'
+        require 'yaml'
+        require 'irb'
+        config_file = File.expand_path('~/.google-api.yaml')
+        authorization = nil
+        if File.exist?(config_file)
+          config = open(config_file, 'r') { |file| YAML.load(file.read) }
+        else
+          config = {}
+        end
+        if config["mechanism"]
+          authorization = config["mechanism"].to_sym
+        end
+        client = Google::APIClient.new(:authorization => authorization)
+        case authorization
+        when :oauth_1
+          if client.authorization &&
+              !client.authorization.kind_of?(Signet::OAuth1::Client)
+            STDERR.puts(
+              "Unexpected authorization mechanism: " +
+              "#{client.authorization.class}"
+            )
+            exit(1)
+          end
+          config = open(config_file, 'r') { |file| YAML.load(file.read) }
+          client.authorization.client_credential_key =
+            config["client_credential_key"]
+          client.authorization.client_credential_secret =
+            config["client_credential_secret"]
+          client.authorization.token_credential_key =
+            config["token_credential_key"]
+          client.authorization.token_credential_secret =
+            config["token_credential_secret"]
+        when :oauth_2
+          if client.authorization &&
+              !client.authorization.kind_of?(Signet::OAuth2::Client)
+            STDERR.puts(
+              "Unexpected authorization mechanism: " +
+              "#{client.authorization.class}"
+            )
+            exit(1)
+          end
+          config = open(config_file, 'r') { |file| YAML.load(file.read) }
+          client.authorization.scope = options[:scope]
+          client.authorization.client_id = config["client_id"]
+          client.authorization.client_secret = config["client_secret"]
+          client.authorization.access_token = config["access_token"]
+          client.authorization.refresh_token = config["refresh_token"]
+        else
+          # Dunno?
+        end
+        if options[:discovery_uri]
+          if options[:api] && options[:version]
+            client.register_discovery_uri(
+              options[:api], options[:version], options[:discovery_uri]
+            )
+          else
+            STDERR.puts(
+              'Cannot register a discovery URI without ' +
+              'specifying an API and version.'
+            )
+            exit(1)
+          end
+        end
+        return client
+      end
+      def api_version(api_name, version)
+        v = version
+        if !version
+          if client.preferred_version(api_name)
+            v = client.preferred_version(api_name).version
+          else
+            v = 'v1'
+          end
+        end
+        return v
+      end
+      COMMANDS = [
+        :oauth_1_login,
+        :oauth_2_login,
+        :list,
+        :execute,
+        :irb,
+        :fuzz
+      ]
+      def oauth_1_login
+        gem 'signet', '~> 0.4.0'
+        require 'signet/oauth_1/client'
+        require 'launchy'
+        require 'yaml'
+        if options[:client_credential_key] &&
+            options[:client_credential_secret]
+          config = {
+            "mechanism" => "oauth_1",
+            "scope" => options[:scope],
+            "client_credential_key" => options[:client_credential_key],
+            "client_credential_secret" => options[:client_credential_secret],
+            "token_credential_key" => nil,
+            "token_credential_secret" => nil
+          }
+          config_file = File.expand_path('~/.google-api.yaml')
+          open(config_file, 'w') { |file| file.write(YAML.dump(config)) }
+          exit(0)
+        else
+          $verifier = nil
+          server = WEBrick::HTTPServer.new(
+            :Port => OAUTH_SERVER_PORT,
+            :Logger => WEBrick::Log.new,
+            :AccessLog => WEBrick::Log.new
+          )
+          server.logger.level = 0
+          trap("INT") { server.shutdown }
+          server.mount("/", OAuthVerifierServlet)
+          oauth_client = Signet::OAuth1::Client.new(
+            :temporary_credential_uri =>
+              'https://www.google.com/accounts/OAuthGetRequestToken',
+            :authorization_uri =>
+              'https://www.google.com/accounts/OAuthAuthorizeToken',
+            :token_credential_uri =>
+              'https://www.google.com/accounts/OAuthGetAccessToken',
+            :client_credential_key => 'anonymous',
+            :client_credential_secret => 'anonymous',
+            :callback => "http://localhost:#{OAUTH_SERVER_PORT}/"
+          )
+          oauth_client.fetch_temporary_credential!(:additional_parameters => {
+            :scope => options[:scope],
+            :xoauth_displayname => 'Google API Client'
+          })
+          # Launch browser
+          Launchy::Browser.run(oauth_client.authorization_uri.to_s)
+          server.start
+          oauth_client.fetch_token_credential!(:verifier => $verifier)
+          config = {
+            "scope" => options[:scope],
+            "client_credential_key" =>
+              oauth_client.client_credential_key,
+            "client_credential_secret" =>
+              oauth_client.client_credential_secret,
+            "token_credential_key" =>
+              oauth_client.token_credential_key,
+            "token_credential_secret" =>
+              oauth_client.token_credential_secret
+          }
+          config_file = File.expand_path('~/.google-api.yaml')
+          open(config_file, 'w') { |file| file.write(YAML.dump(config)) }
+          exit(0)
+        end
+      end
+      def oauth_2_login
+        gem 'signet', '~> 0.4.0'
+        require 'signet/oauth_2/client'
+        require 'launchy'
+        require 'yaml'
+        if !options[:client_credential_key] ||
+            !options[:client_credential_secret]
+          STDERR.puts('No client ID and secret supplied.')
+          exit(1)
+        end
+        if options[:access_token]
+          config = {
+            "mechanism" => "oauth_2",
+            "scope" => options[:scope],
+            "client_id" => options[:client_credential_key],
+            "client_secret" => options[:client_credential_secret],
+            "access_token" => options[:access_token],
+            "refresh_token" => options[:refresh_token]
+          }
+          config_file = File.expand_path('~/.google-api.yaml')
+          open(config_file, 'w') { |file| file.write(YAML.dump(config)) }
+          exit(0)
+        else
+          $verifier = nil
+          logger = WEBrick::Log.new
+          logger.level = 0
+          server = WEBrick::HTTPServer.new(
+            :Port => OAUTH_SERVER_PORT,
+            :Logger => logger,
+            :AccessLog => logger
+          )
+          trap("INT") { server.shutdown }
+          server.mount("/", OAuthVerifierServlet)
+          oauth_client = Signet::OAuth2::Client.new(
+            :authorization_uri =>
+              'https://www.google.com/accounts/o8/oauth2/authorization',
+            :token_credential_uri =>
+              'https://www.google.com/accounts/o8/oauth2/token',
+            :client_id => options[:client_credential_key],
+            :client_secret => options[:client_credential_secret],
+            :redirect_uri => "http://localhost:#{OAUTH_SERVER_PORT}/",
+            :scope => options[:scope]
+          )
+          # Launch browser
+          Launchy.open(oauth_client.authorization_uri.to_s)
+          server.start
+          oauth_client.code = $verifier
+          oauth_client.fetch_access_token!
+          config = {
+            "mechanism" => "oauth_2",
+            "scope" => options[:scope],
+            "client_id" => oauth_client.client_id,
+            "client_secret" => oauth_client.client_secret,
+            "access_token" => oauth_client.access_token,
+            "refresh_token" => oauth_client.refresh_token
+          }
+          config_file = File.expand_path('~/.google-api.yaml')
+          open(config_file, 'w') { |file| file.write(YAML.dump(config)) }
+          exit(0)
+        end
+      end
+      def list
+        api_name = options[:api]
+        unless api_name
+          STDERR.puts('No API name supplied.')
+          exit(1)
+        end
+        client = Google::APIClient.new(:authorization => nil)
+        if options[:discovery_uri]
+          if options[:api] && options[:version]
+            client.register_discovery_uri(
+              options[:api], options[:version], options[:discovery_uri]
+            )
+          else
+            STDERR.puts(
+              'Cannot register a discovery URI without ' +
+              'specifying an API and version.'
+            )
+            exit(1)
+          end
+        end
+        version = api_version(api_name, options[:version])
+        api = client.discovered_api(api_name, version)
+        rpcnames = api.to_h.keys
+        puts rpcnames.sort.join("\n")
+        exit(0)
+      end
+      def execute
+        client = self.client
+        # Setup HTTP request data
+        request_body = ''
+        input_streams, _, _ = IO.select([STDIN], [], [], 0)
+        request_body = STDIN.read || '' if input_streams
+        headers = []
+        if options[:content_type]
+          headers << ['Content-Type', options[:content_type]]
+        elsif request_body
+          # Default to JSON
+          headers << ['Content-Type', 'application/json']
+        end
+        if options[:uri]
+          # Make request with URI manually specified
+          uri = Addressable::URI.parse(options[:uri])
+          if uri.relative?
+            STDERR.puts('URI may not be relative.')
+            exit(1)
+          end
+          if options[:requestor_id]
+            uri.query_values = uri.query_values.merge(
+              'xoauth_requestor_id' => options[:requestor_id]
+            )
+          end
+          method = options[:http_method]
+          method ||= request_body == '' ? 'GET' : 'POST'
+          method.upcase!
+          request = [method, uri.to_str, headers, [request_body]]
+          request = client.generate_authenticated_request(:request => request)
+          response = client.transmit(request)
+          puts response.body
+          exit(0)
+        else
+          # Make request with URI generated from template and parameters
+          if !self.rpcname
+            STDERR.puts('No rpcname supplied.')
+            exit(1)
+          end
+          api_name = options[:api] || self.rpcname[/^([^\.]+)\./, 1]
+          version = api_version(api_name, options[:version])
+          api = client.discovered_api(api_name, version)
+          method = api.to_h[self.rpcname]
+          if !method
+            STDERR.puts(
+              "Method #{self.rpcname} does not exist for " +
+              "#{api_name}-#{version}."
+            )
+            exit(1)
+          end
+          parameters = self.argv.inject({}) do |accu, pair|
+            name, value = pair.split('=', 2)
+            accu[name] = value
+            accu
+          end
+          if options[:requestor_id]
+            parameters['xoauth_requestor_id'] = options[:requestor_id]
+          end
+          begin
+            result = client.execute(
+              :api_method => method,
+              :parameters => parameters,
+              :merged_body => request_body,
+              :headers => headers
+            )
+            puts result.response.body
+            exit(0)
+          rescue ArgumentError => e
+            puts e.message
+            exit(1)
+          end
+        end
+      end
+      def irb
+        $client = self.client
+        # Otherwise IRB will misinterpret command-line options
+        ARGV.clear
+        IRB.start(__FILE__)
+      end
+      def fuzz
+        STDERR.puts('API fuzzing not yet supported.')
+        if self.rpcname
+          # Fuzz just one method
+        else
+          # Fuzz the entire API
+        end
+        exit(1)
+      end
+      def help
+        puts self.parser
+        exit(0)
+      end
+    end
+  end
+end
+Google::APIClient::CLI.new(ARGV).parse!