google-api-client 0.6.4 → 0.7.0

data/bin/google-api

@@ -1,391 +0,0 @@
-#!/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'
-require 'faraday'
-require 'faraday/utils'
-require 'webrick'
-require 'google/api_client/version'
-require 'google/api_client'
-require 'google/api_client/auth/installed_app'
-require 'irb'
-
-ARGV.unshift('--help') if ARGV.empty?
-
-module Google
-  class APIClient
-    class CLI
-
-      # 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-2-login   Log a user into an API with OAuth 2.0\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
-        require 'yaml'
-        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(
-          :application_name => 'Ruby CLI', 
-          :application_version => Google::APIClient::VERSION::STRING,
-          :authorization => authorization)
-
-        case authorization
-        when :oauth_1
-          STDERR.puts('OAuth 1 is deprecated. Please reauthorize with OAuth 2.')
-          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
-          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_2_login,
-        :list,
-        :execute,
-        :irb,
-      ]
-
-      def oauth_2_login
-        require 'signet/oauth_2/client'
-        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
-          flow = Google::APIClient::InstalledAppFlow.new(
-            :port => OAUTH_SERVER_PORT,
-            :client_id => options[:client_credential_key],
-            :client_secret => options[:client_credential_secret],
-            :scope => options[:scope]
-          )
-          
-          oauth_client = flow.authorize
-          if oauth_client
-            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)) }
-          end
-          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!
-          response = client.execute(:http_method => method, :uri => uri.to_str, 
-            :headers => headers, :body => request_body)
-          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 help
-        puts self.parser
-        exit(0)
-      end
-    end
-  end
-end
-
-Google::APIClient::CLI.new(ARGV).parse!