turbot 0.1.36 → 0.2.3

data/lib/turbot/cli.rb

@@ -1,42 +1,25 @@
-load('turbot/helpers.rb') # reload helpers after possible inject_loadpath
-load('turbot/updater.rb') # reload updater after possible inject_loadpath
-
-require "turbot"
-require "turbot/command"
-require "turbot/helpers"
-
-# workaround for rescue/reraise to define errors in command.rb failing in 1.8.6
-if RUBY_VERSION =~ /^1.8.6/
-  require('turbot-api')
-  require('rest_client')
-end
-
 class Turbot::CLI
-
   extend Turbot::Helpers
 
   def self.start(*args)
     begin
-      if $stdin.isatty
-        $stdin.sync = true
-      end
-      if $stdout.isatty
-        $stdout.sync = true
-      end
-      command = args.shift.strip rescue "help"
-      Turbot::Command.load
-      trap "SIGINT" do
+      $stdout.sync = true
+      $stderr.sync = true
+
+      trap 'SIGINT' do
         # Script terminated by Control-C.
         exit 130
       end
+
+      Turbot::Command.load
+      command = args.shift.strip rescue 'help'
       Turbot::Command.run(command, args)
     rescue Interrupt
       `stty icanon echo`
-      error("Command cancelled.")
-    rescue => error
-      styled_error(error)
+      error 'Command cancelled.'
+    rescue => e
+      styled_error(e)
       exit(1)
     end
   end
-
 end

data/lib/turbot/command.rb

@@ -1,23 +1,20 @@
-require 'turbot/helpers'
-require 'turbot/plugin'
-require 'turbot/version'
-require "optparse"
-require 'excon'
-
 module Turbot
   module Command
-    class CommandFailed  < RuntimeError; end
-
     extend Turbot::Helpers
 
     def self.load
-      Dir[File.join(File.dirname(__FILE__), "command", "*.rb")].each do |file|
+      Dir[File.join(File.dirname(__FILE__), 'command', '*.rb')].each do |file|
         require file
       end
-      Turbot::Plugin.load!
       unregister_commands_made_private_after_the_fact
     end
 
+    def self.unregister_commands_made_private_after_the_fact
+      commands.values.
+        select { |c| c[:klass].private_method_defined? c[:method] }.
+        each { |c| commands.delete(c[:command]) }
+    end
+
     def self.commands
       @@commands ||= {}
     end
@@ -38,12 +35,6 @@ module Turbot
       commands[command[:command]] = command
     end
 
-    def self.unregister_commands_made_private_after_the_fact
-      commands.values \
-        .select { |c| c[:klass].private_method_defined? c[:method] } \
-        .each   { |c| commands.delete c[:command] }
-    end
-
     def self.register_namespace(namespace)
       namespaces[namespace[:name]] = namespace
     end
@@ -52,109 +43,36 @@ module Turbot
       @current_command
     end
 
-    def self.current_command=(new_current_command)
-      @current_command = new_current_command
-    end
-
-    def self.current_args
-      @current_args
-    end
-
-    def self.current_options
-      @current_options ||= {}
-    end
-
-    def self.global_options
-      @global_options ||= []
-    end
-
-    def self.invalid_arguments
-      @invalid_arguments
-    end
-
-    def self.shift_argument
-      # dup argument to get a non-frozen string
-      @invalid_arguments.shift.dup rescue nil
-    end
-
     def self.validate_arguments!
-      unless invalid_arguments.empty?
-        arguments = invalid_arguments.map {|arg| "\"#{arg}\""}
+      unless @invalid_arguments.empty?
+        arguments = @invalid_arguments.map(&:inspect)
         if arguments.length == 1
           message = "Invalid argument: #{arguments.first}"
-        elsif arguments.length > 1
-          message = "Invalid arguments: "
-          message << arguments[0...-1].join(", ")
-          message << " and "
-          message << arguments[-1]
+        else
+          message = "Invalid arguments: #{arguments[0...-1].join(', ')} and #{arguments[-1]}"
         end
-        $stderr.puts(format_with_bang(message))
-        run(current_command, ["--help"])
-        exit(1)
+        run('help', [current_command])
+        error message
       end
     end
 
-    def self.warnings
-      @warnings ||= []
-    end
-
-    def self.display_warnings
-      unless warnings.empty?
-        $stderr.puts(warnings.map {|warning| " !    #{warning}"}.join("\n"))
-      end
-    end
-
-    def self.global_option(name, *args, &blk)
-      # args.sort.reverse gives -l, --long order
-      global_options << { :name => name.to_s, :args => args.sort.reverse, :proc => blk }
-    end
-
-    global_option :bot, "-b", "--bot APP" do |bot|
-      raise OptionParser::InvalidOption.new(bot) if bot == "pp"
-    end
-
-    global_option :org, "-o", "--org ORG" do |org|
-      raise OptionParser::InvalidOption.new(org) if org == "rg"
-    end
-    global_option :personal, "-p", "--personal"
-
-    global_option :confirm, "--confirm APP"
-    global_option :help,    "-h", "--help"
-    global_option :remote,  "-r", "--remote REMOTE"
-
     def self.prepare_run(cmd, args=[])
-      command = parse(cmd)
-
-      if args.include?('-h') || args.include?('--help')
-        args.unshift(cmd) unless cmd =~ /^-.*/
-        cmd = 'help'
-        command = parse(cmd)
-      end
-
-      if cmd == '--version'
-        cmd = 'version'
-        command = parse(cmd)
-      end
-
+      command = commands[cmd] || commands[command_aliases[cmd]]
       @current_command = cmd
-      @anonymized_args, @normalized_args = [], []
 
       opts = {}
       invalid_options = []
 
       parser = OptionParser.new do |parser|
         # remove OptionParsers Officious['version'] to avoid conflicts
-        # see: https://github.com/ruby/ruby/blob/trunk/lib/optparse.rb#L814
+        # see: https://github.com/ruby/ruby/blob/6860034546808d4f67ba8f407f3d7aced0c54c5a/lib/optparse.rb#L989
         parser.base.long.delete('version')
-        (global_options + (command && command[:options] || [])).each do |option|
-          parser.on(*option[:args]) do |value|
-            if option[:proc]
-              option[:proc].call(value)
+        if command && command[:options]
+          command[:options].each do |option|
+            parser.on(*option[:args]) do |value|
+              opts[option[:name].gsub('-', '_').to_sym] = value
+              ARGV.join(' ') =~ /(#{option[:args].map {|arg| arg.split(' ', 2).first}.join('|')})/
             end
-            opts[option[:name].gsub('-', '_').to_sym] = value
-            ARGV.join(' ') =~ /(#{option[:args].map {|arg| arg.split(' ', 2).first}.join('|')})/
-            @anonymized_args << "#{$1} _"
-            @normalized_args << "#{option[:args].last.split(' ', 2).first} _"
           end
         end
       end
@@ -162,144 +80,73 @@ module Turbot
       begin
         parser.order!(args) do |nonopt|
           invalid_options << nonopt
-          @anonymized_args << '!'
-          @normalized_args << '!'
         end
-      rescue OptionParser::InvalidOption => ex
-        invalid_options << ex.args.first
-        @anonymized_args << '!'
-        @normalized_args << '!'
+      rescue OptionParser::InvalidOption => e
+        invalid_options << e.args.first
         retry
       end
 
       args.concat(invalid_options)
-
-      @current_args = args
-      @current_options = opts
       @invalid_arguments = invalid_options
 
-      @anonymous_command = [ARGV.first, *@anonymized_args].join(' ')
-      begin
-        usage_directory = "#{home_directory}/.turbot/usage"
-        FileUtils.mkdir_p(usage_directory)
-        usage_file = usage_directory << "/#{Turbot::VERSION}"
-        usage = if File.exists?(usage_file)
-          json_decode(File.read(usage_file))
-        else
-          {}
-        end
-        usage[@anonymous_command] ||= 0
-        usage[@anonymous_command] += 1
-        File.write(usage_file, json_encode(usage) + "\n")
-      rescue
-        # usage writing is not important, allow failures
-      end
-
       if command
         command_instance = command[:klass].new(args.dup, opts.dup)
-
-        if !@normalized_args.include?('--bot _') && (implied_bot = command_instance.bot rescue nil)
-          @normalized_args << '--bot _'
-        end
-        @normalized_command = [ARGV.first, @normalized_args.sort_by {|arg| arg.gsub('-', '')}].join(' ')
-
-        [ command_instance, command[:method] ]
+        [command_instance, command[:method]]
       else
         error([
           "`#{cmd}` is not a turbot command.",
           suggestion(cmd, commands.keys + command_aliases.keys),
-          "See `turbot help` for a list of available commands."
+          'See `turbot help` for a list of available commands.'
         ].compact.join("\n"))
       end
     end
 
-    def self.run(cmd, arguments=[])
-      begin
-        object, method = prepare_run(cmd, arguments.dup)
-        object.send(method)
-      rescue Interrupt, StandardError, SystemExit => error
-        # load likely error classes, as they may not be loaded yet due to defered loads
-        require 'rest_client'
-        raise(error)
-      end
-    rescue Turbot::API::Errors::Unauthorized, RestClient::Unauthorized
-      puts "Authentication failure"
-      if ENV['TURBOT_API_KEY']
-        exit 1
+    def self.run(command, arguments=[])
+      object, method = prepare_run(command, arguments.dup)
+      object.send(method)
+    rescue SocketError => e
+      error 'Unable to connect to Turbot API, please check internet connectivity and try again.'
+    rescue OptionParser::ParseError
+      if commands[command]
+        run('help', [command])
       else
-        run "login"
-        retry
-      end
-    rescue Turbot::API::Errors::NotFound => e
-      error extract_error(e.response.body) {
-        e.response.body =~ /^([\w\s]+ not found).?$/ ? $1 : "Resource not found"
-      }
-    rescue RestClient::ResourceNotFound => e
-      error extract_error(e.http_body) {
-        e.http_body =~ /^([\w\s]+ not found).?$/ ? $1 : "Resource not found"
-      }
-    rescue Turbot::API::Errors::Locked => e
-      bot = e.response.headers[:x_confirmation_required]
-      if confirm_command(bot, extract_error(e.response.body))
-        arguments << '--confirm' << bot
-        retry
-      end
-    rescue RestClient::Locked => e
-      bot = e.response.headers[:x_confirmation_required]
-      if confirm_command(bot, extract_error(e.http_body))
-        arguments << '--confirm' << bot
-        retry
+        run('help')
       end
-    rescue RestClient::PaymentRequired => e
-      # We've repurposed a 402 as a general error
-      error extract_error(e.http_body)
-    rescue Turbot::API::Errors::Timeout, RestClient::RequestTimeout
-      error "API request timed out. Please try again, or contact support@turbot.com if this issue persists."
-    rescue Turbot::API::Errors::ErrorWithResponse => e
-      error extract_error(e.response.body)
-    rescue RestClient::RequestFailed => e
-      error extract_error(e.http_body)
-    rescue CommandFailed => e
-      error e.message
-    rescue OptionParser::ParseError
-      commands[cmd] ? run("help", [cmd]) : run("help")
-    rescue Excon::Errors::SocketError, SocketError => e
-      error("Unable to connect to Turbot API, please check internet connectivity and try again.")
-    ensure
-      display_warnings
     end
 
-    def self.parse(cmd)
-      commands[cmd] || commands[command_aliases[cmd]]
-    end
-
-    def self.extract_error(body, options={})
-      default_error = block_given? ? yield : "Internal server error.\nRun `turbot status` to check for known platform issues."
-      parse_error_xml(body) || parse_error_json(body) || parse_error_plain(body) || default_error
-    end
-
-    def self.parse_error_xml(body)
-      xml_errors = REXML::Document.new(body).elements.to_a("//errors/error")
-      msg = xml_errors.map { |a| a.text }.join(" / ")
-      return msg unless msg.empty?
-    rescue Exception
+    def self.extract_error(body, options = {})
+      if block_given?
+        default_error = yield
+      else
+        default_error = 'Internal server error'
+      end
+      parse_error_json(body) || default_error
     end
 
     def self.parse_error_json(body)
-      json = json_decode(body.to_s) rescue false
-      case json
-      when Array
-        json.first.join(' ') # message like [['base', 'message']]
-      when Hash
-        json['error'] || json['error_message'] || json['message'] # message like {'error' => 'message'}
-      else
+      begin
+        JSON.load(body.to_s)['message']
+      rescue JSON::ParserError
         nil
       end
     end
 
-    def self.parse_error_plain(body)
-      return unless body.respond_to?(:headers) && body.headers[:content_type].to_s.include?("text/plain")
-      body.to_s
+  private
+
+    def self.suggestion(actual, possibilities)
+      distances = Hash.new { |hash,key| hash[key] = [] }
+      possibilities.each do |possibility|
+        distances[Text::Levenshtein.distance(actual, possibility, 4)] << possibility
+      end
+      minimum_distance = distances.keys.min
+      if minimum_distance < 4
+        suggestions = distances[minimum_distance].sort
+        if suggestions.length == 1
+          "Perhaps you meant `#{suggestions.first}`."
+        else
+          "Perhaps you meant #{suggestions[0...-1].map { |suggestion| "`#{suggestion}`" }.join(', ')} or `#{suggestions.last}`."
+        end
+      end
     end
   end
 end

data/lib/turbot/command/auth.rb

@@ -1,85 +1,123 @@
-require "turbot/command/base"
-
-# authentication (login, logout)
+#Login or logout from Turbot
 #
 class Turbot::Command::Auth < Turbot::Command::Base
-
   # auth
   #
-  # Authenticate, display token and current user
+  #Login or logout. Display your Turbot API token or email address.
   def index
     validate_arguments!
-
     Turbot::Command::Help.new.send(:help_for_command, current_command)
   end
 
   # auth:login
   #
-  # log in with your turbot credentials
+  #Login to Turbot and save your Turbot credentials.
   #
   #Example:
   #
-  # $ turbot auth:login
-  # Enter your Turbot credentials:
-  # Email: email@example.com
-  # Password (typing will be hidden):
-  # Authentication successful.
+  #  $ turbot auth:login
+  #  Enter your Turbot email and password:
+  #  Email: email@example.com
+  #  Password (typing will be hidden):
+  #  Logged in. Saved Turbot API key.
   #
   def login
     validate_arguments!
-
-    Turbot::Auth.login
-    display "Authentication successful."
+    email_address, api_key = ask_for_email_address_and_password
+    if api_key.empty?
+      error 'Authentication failed.'
+    end
+    save_netrc_entry(email_address, api_key)
+    puts 'Authentication successful.'
   end
-
-  alias_command "login", "auth:login"
+  alias_command 'login', 'auth:login'
 
   # auth:logout
   #
-  # clear local authentication credentials
+  #Delete your Turbot credentials.
   #
   #Example:
   #
-  # $ turbot auth:logout
-  # Local credentials cleared.
+  #  $ turbot auth:logout
+  #  Deleted Turbot credentials.
   #
   def logout
     validate_arguments!
-
-    Turbot::Auth.logout
-    display "Local credentials cleared."
+    delete_netrc_entry
+    puts 'Deleted Turbot credentials.'
   end
-
-  alias_command "logout", "auth:logout"
+  alias_command 'logout', 'auth:logout'
 
   # auth:token
   #
-  # display your api token
+  #Display your Turbot API token.
   #
   #Example:
   #
-  # $ turbot auth:token
-  # ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789ABCD
+  #  $ turbot auth:token
+  #  93a5c45595ed37dc9d040116
   #
   def token
     validate_arguments!
-
-    display Turbot::Auth.api_key
+    result = email_address_and_api_key[1]
+    if result
+      puts result
+    else
+      error 'not logged in'
+    end
   end
 
   # auth:whoami
   #
-  # display your turbot email address
+  #Display your Turbot email address.
   #
   #Example:
   #
-  # $ turbot auth:whoami
-  # email@example.com
+  #  $ turbot auth:whoami
+  #  email@example.com
   #
   def whoami
     validate_arguments!
+    result = email_address_and_api_key[0]
+    if result
+      puts result
+    else
+      error 'not logged in'
+    end
+  end
+
+private
+
+  ### Shell-related
 
-    display Turbot::Auth.user
+  # Prompts the user for an email address and password, and returns the email
+  # address and the user's API key.
+  #
+  # @return [Array<String>] the user's email address and API key
+  def ask_for_email_address_and_password
+    puts 'Enter your Turbot email and password.'
+
+    print 'Email: '
+    email_address = ask
+
+    print 'Password (typing will be hidden): '
+    password = running_on_windows? ? ask_for_password_on_windows : ask_for_password
+
+    puts
+
+    [email_address, get_api_key(email_address, password)]
   end
 
+  def running_on_windows?
+    RUBY_PLATFORM =~ /mswin32|mingw32/
+  end
+
+  ### API-related
+
+  # Gets the user's API key.
+  #
+  # @return [String] the API key, or the empty string if authentication fails
+  def get_api_key(email_address, password)
+    api.get_api_key_for_credentials(email_address, password)['api_key']
+  end
 end