turbot 0.1.36 → 0.2.0

data/lib/turbot/command/help.rb

@@ -1,176 +1,123 @@
-require "turbot/command/base"
-require "turbot/deprecated/help"
-
-# list commands and display help
+#List commands and display help
 #
 class Turbot::Command::Help < Turbot::Command::Base
-
-  PRIMARY_NAMESPACES = %w( auth bots ps run addons config releases domains logs sharing )
-
-  include Turbot::Deprecated::Help
+  PRIMARY_NAMESPACES = Set.new(%w(auth bots))
 
   # help [COMMAND]
   #
-  # list available commands or display help for a specific command
+  #List available commands or display help for a specific command.
   #
   #Examples:
   #
-  # $ turbot help
-  # Usage: turbot COMMAND [--bot APP] [command-specific-options]
+  #  $ turbot help
+  #  Usage: turbot COMMAND [--bot APP] [command-specific-options]
   #
-  # Primary help topics, type "turbot help TOPIC" for more details:
+  #  Primary help topics, type "turbot help TOPIC" for more details:
   #
-  #   addons    #  manage addon resources
-  #   bots      #  manage bots (create, destroy)
-  #   ...
+  #    auth  #  Login or logout from Turbot
+  #    bots  #  Manage bots (generate skeleton, validate data, submit code)
   #
-  # Additional topics:
+  #  Additional topics:
   #
-  #   account      #  manage turbot account options
-  #   accounts     #  manage multiple turbot accounts
-  #   ...
+  #    help     #  List commands and display help
+  #    version  #  Display version
   #
-  # $ turbot help bots:create
-  # Usage: turbot bots:create [NAME]
+  #  $ turbot help auth:whoam
+  #  Usage: turbot auth:whoami
   #
-  #  create a new bot
+  #  Display your Turbot email address.
   #
-  #      --addons ADDONS        # a comma-delimited list of addons to install
-  #  -b, --buildpack BUILDPACK  # a buildpack url to use for this bot
-  #  -r, --remote REMOTE        # the git remote to create, default "turbot"
-  #  -s, --stack STACK          # the stack on which to create the bot
+  #  Example:
+  #
+  #   $ turbot auth:whoami
+  #   email@example.com
   #
   def index
-    if command = args.shift
+    command = args.shift
+    if command
       help_for_command(command)
     else
       help_for_root
     end
   end
-
-  alias_command "-h", "help"
-  alias_command "--help", "help"
+  alias_command '-h', 'help'
+  alias_command '--help', 'help'
 
 private
 
-  def commands_for_namespace(name)
-    Turbot::Command.commands.values.select do |command|
-      command[:namespace] == name && command[:command] != name
-    end
-  end
-
-  def namespaces
-    namespaces = Turbot::Command.namespaces
-    namespaces.delete("bot")
-    namespaces
-  end
-
-  def commands
-    Turbot::Command.commands
-  end
-
-  def legacy_help_for_namespace(namespace)
-    instance = Turbot::Command::Help.groups.map do |group|
-      [ group.title, group.select { |c| c.first =~ /^#{namespace}/ }.length ]
-    end.sort_by { |l| l.last }.last
-    return nil unless instance
-    return nil if instance.last.zero?
-    instance.first
-  end
-
-  def legacy_help_for_command(command)
-    Turbot::Command::Help.groups.each do |group|
-      group.each do |cmd, description|
-        return description if cmd.split(" ").first == command
-      end
+  def help_for(items, name_key, description_key)
+    size = items.map { |namespace| namespace[name_key].size }.max
+    items.sort_by { |namespace| namespace[name_key] }.each do |namespace|
+      puts "  %-#{size}s  # %s" % [ namespace[name_key], namespace[description_key] ]
     end
-    nil
   end
 
-  def skip_namespace?(ns)
-    return true if ns[:description] =~ /DEPRECATED:/
-    return true if ns[:description] =~ /HIDDEN:/
-    false
-  end
+  ### Root
 
-  def skip_command?(command)
-    return true if command[:help] =~ /DEPRECATED:/
-    return true if command[:help] =~ /^ HIDDEN:/
-    false
+  def namespaces
+    Turbot::Command.namespaces
   end
 
   def primary_namespaces
-    PRIMARY_NAMESPACES.map { |name| namespaces[name] }.compact
+    namespaces.select { |name,_| PRIMARY_NAMESPACES.include?(name) }.values
   end
 
   def additional_namespaces
-    (namespaces.values - primary_namespaces)
+    namespaces.reject { |name,_| PRIMARY_NAMESPACES.include?(name) }.values
   end
 
   def summary_for_namespaces(namespaces)
-    size = longest(namespaces.map { |n| n[:name] })
-    namespaces.sort_by {|namespace| namespace[:name]}.each do |namespace|
-      next if skip_namespace?(namespace)
-      name = namespace[:name]
-      namespace[:description] ||= legacy_help_for_namespace(name)
-      puts "  %-#{size}s  # %s" % [ name, namespace[:description] ]
-    end
+    help_for(namespaces, :name, :description)
   end
 
   def help_for_root
-    puts "Usage: turbot COMMAND [--bot APP] [command-specific-options]"
+    puts 'Usage: turbot COMMAND [--bot APP] [command-specific-options]'
     puts
-    puts "Primary help topics, type \"turbot help TOPIC\" for more details:"
+    puts 'Primary help topics, type "turbot help TOPIC" for more details:'
     puts
     summary_for_namespaces(primary_namespaces)
     puts
-    puts "Additional topics:"
+    puts 'Additional topics:'
     puts
     summary_for_namespaces(additional_namespaces)
     puts
   end
 
-  def help_for_namespace(name)
-    namespace_commands = commands_for_namespace(name)
+  ### Command
+
+  def commands
+    Turbot::Command.commands
+  end
 
-    unless namespace_commands.empty?
-      size = longest(namespace_commands.map { |c| c[:banner] })
-      namespace_commands.sort_by { |c| c[:banner].to_s }.each do |command|
-        next if skip_command?(command)
-        command[:summary] ||= legacy_help_for_command(command[:command])
-        puts "  %-#{size}s  # %s" % [ command[:banner], command[:summary] ]
-      end
+  def commands_for_namespace(name)
+    commands.values.select do |command|
+      command[:namespace] == name && command[:command] != name
     end
   end
 
+  def help_for_namespace(namespace_commands)
+    help_for(namespace_commands, :banner, :summary)
+  end
+
   def help_for_command(name)
-    if command_alias = Turbot::Command.command_aliases[name]
-      display("Alias: #{name} redirects to #{command_alias}")
+    command_alias = Turbot::Command.command_aliases[name]
+    if command_alias
+      puts "Alias: #{name} redirects to #{command_alias}"
       name = command_alias
     end
-    if command = commands[name]
-      puts "Usage: turbot #{command[:banner]}"
 
-      if command[:help].strip.length > 0
-        help = command[:help].split("\n").reject do |line|
-          line =~ /HIDDEN/
-        end
-        puts help[1..-1].join("\n")
-      else
-        puts
-        puts " " + legacy_help_for_command(name).to_s
-      end
+    command = commands[name]
+    if command
+      puts "Usage: turbot #{command[:banner]}"
+      puts command[:help].split("\n").drop(1).join("\n")
       puts
     end
 
-    namespace_commands = commands_for_namespace(name).reject do |command|
-      command[:help] =~ /DEPRECATED/
-    end
-
+    namespace_commands = commands_for_namespace(name)
     if !namespace_commands.empty?
-      puts "Additional commands, type \"turbot help COMMAND\" for more details:"
+      puts 'Additional commands, type "turbot help COMMAND" for more details:'
       puts
-      help_for_namespace(name)
+      help_for_namespace(namespace_commands)
       puts
     elsif command.nil?
       error "#{name} is not a turbot command. See `turbot help`."

data/lib/turbot/command/version.rb

@@ -1,23 +1,19 @@
-require "turbot/command/base"
-require "turbot/version"
-
-# display version
+#Display version
 #
 class Turbot::Command::Version < Turbot::Command::Base
 
   # version
   #
-  # show turbot client version
+  #Show the Turbot client's version.
   #
   #Example:
   #
-  # $ turbot version
-  # turbot-toolbelt/1.2.3 (x86_64-darwin11.2.0) ruby/1.9.3
+  #  $ turbot version
+  #  turbot-gem/0.1.36 (x86_64-darwin14) ruby/2.2.0
   #
   def index
     validate_arguments!
-
-    display(Turbot.user_agent)
+    puts "#{Turbot::DEBUG_VERSION}"
   end
-
+  alias_command '--version', 'version'
 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,92 +43,23 @@ 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)
-      end
-    end
-
-    def self.warnings
-      @warnings ||= []
-    end
-
-    def self.display_warnings
-      unless warnings.empty?
-        $stderr.puts(warnings.map {|warning| " !    #{warning}"}.join("\n"))
+        run('help', [current_command])
+        error message
       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
-
       @current_command = cmd
-      @anonymized_args, @normalized_args = [], []
 
       opts = {}
       invalid_options = []
@@ -146,15 +68,10 @@ module Turbot
         # remove OptionParsers Officious['version'] to avoid conflicts
         # see: https://github.com/ruby/ruby/blob/trunk/lib/optparse.rb#L814
         parser.base.long.delete('version')
-        (global_options + (command && command[:options] || [])).each do |option|
+        (command && command[:options] || []).each do |option|
           parser.on(*option[:args]) do |value|
-            if option[:proc]
-              option[:proc].call(value)
-            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 +79,84 @@ 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] ]
       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=[])
+    def self.run(command, arguments=[])
       begin
-        object, method = prepare_run(cmd, arguments.dup)
+        object, method = prepare_run(command, 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
+    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
+        run('help')
       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
-      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]]
+    def self.parse(command)
+      commands[command] || commands[command_aliases[command]]
     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/handlers/base_handler.rb

@@ -0,0 +1,21 @@
+module Turbot
+  module Handlers
+    class BaseHandler < TurbotRunner::BaseHandler
+      # Implements `TurbotRunner::BaseHandler#handle_invalid_record`.
+      def handle_invalid_record(record, data_type, error_message)
+        puts
+        puts 'The following record is invalid:'
+        puts record.to_json
+        puts " * #{error_message}"
+        puts
+      end
+
+      # Implements `TurbotRunner::BaseHandler#handle_invalid_json`.
+      def handle_invalid_json(line)
+        puts
+        puts 'The following line was not valid JSON:'
+        puts line
+      end
+    end
+  end
+end

data/lib/turbot/handlers/dump_handler.rb

@@ -0,0 +1,10 @@
+module Turbot
+  module Handlers
+    class DumpHandler < BaseHandler
+      # Implements `TurbotRunner::BaseHandler#handle_valid_record`.
+      def handle_valid_record(record, data_type)
+        puts record.to_json
+      end
+    end
+  end
+end

data/lib/turbot/handlers/preview_handler.rb

@@ -0,0 +1,30 @@
+module Turbot
+  module Handlers
+    class PreviewHandler < BaseHandler
+      attr_reader :count
+
+      def initialize(bot_name, api)
+        @bot_name = bot_name
+        @api = api
+        @count = 0
+        @batch = []
+      end
+
+      # Implements `TurbotRunner::BaseHandler#handle_valid_record`.
+      def handle_valid_record(record, data_type)
+        @count += 1
+        STDOUT.write('.')
+        @batch << record.merge(:data_type => data_type)
+        if @count % 20 == 0
+          submit_batch
+        end
+      end
+
+      def submit_batch
+        result = @api.create_draft_data(@bot_name, @batch.to_json)
+        @batch = []
+        result
+      end
+    end
+  end
+end