turbot 0.1.36 → 0.2.3

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/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

data/lib/turbot/handlers/validation_handler.rb

@@ -0,0 +1,17 @@
+module Turbot
+  module Handlers
+    class ValidationHandler < BaseHandler
+      attr_reader :count
+
+      def initialize
+        @count = 0
+      end
+
+      # Implements `TurbotRunner::BaseHandler#handle_valid_record`.
+      def handle_valid_record(record, data_type)
+        @count += 1
+        STDOUT.write('.')
+      end
+    end
+  end
+end

data/lib/turbot/helpers.rb

@@ -1,368 +1,27 @@
-require "vendor/turbot/okjson"
-
 module Turbot
   module Helpers
+    DEFAULT_HOST = 'http://turbot.opencorporates.com'
 
     extend self
 
-    def home_directory
-      running_on_windows? ? ENV['USERPROFILE'].gsub("\\","/") : ENV['HOME']
-    end
-
-    def running_on_windows?
-      RUBY_PLATFORM =~ /mswin32|mingw32/
-    end
-
-    def running_on_a_mac?
-      RUBY_PLATFORM =~ /-darwin\d/
-    end
-
-    def display(msg="", new_line=true)
-      if new_line
-        puts(msg)
-      else
-        print(msg)
-      end
-      $stdout.flush
-    end
-
-    def redisplay(line, line_break = false)
-      display("\r\e[0K#{line}", line_break)
-    end
-
-    def deprecate(message)
-      display "WARNING: #{message}"
-    end
-
-    def confirm(message="Are you sure you wish to continue? (y/n)")
-      display("#{message} ", false)
-      ['y', 'yes'].include?(ask.downcase)
-    end
-
-    def confirm_command(bot_to_confirm = bot, message=nil)
-      if confirmed_bot = Turbot::Command.current_options[:confirm]
-        unless confirmed_bot == bot_to_confirm
-          raise(Turbot::Command::CommandFailed, "Confirmed bot #{confirmed_bot} did not match the selected bot #{bot_to_confirm}.")
-        end
-        return true
-      else
-        display
-        message ||= "WARNING: Destructive Action\nThis command will affect the bot: #{bot_to_confirm}"
-        message << "\nTo proceed, type \"#{bot_to_confirm}\" or re-run this command with --confirm #{bot_to_confirm}"
-        output_with_bang(message)
-        display
-        display "> ", false
-        if ask.downcase != bot_to_confirm
-          error("Confirmation did not match #{bot_to_confirm}. Aborted.")
-        else
-          true
-        end
-      end
-    end
-
-    def format_date(date)
-      date = Time.parse(date).utc if date.is_a?(String)
-      date.strftime("%Y-%m-%d %H:%M %Z").gsub('GMT', 'UTC')
-    end
-
-    def ask
-      $stdin.gets.to_s.strip
-    end
-
-    def shell(cmd)
-      FileUtils.cd(Dir.pwd) {|d| return `#{cmd}`}
-    end
-
-    def run_command(command, args=[])
-      Turbot::Command.run(command, args)
-    end
-
-    def retry_on_exception(*exceptions)
-      retry_count = 0
-      begin
-        yield
-      rescue *exceptions => ex
-        raise ex if retry_count >= 3
-        sleep 3
-        retry_count += 1
-        retry
-      end
-    end
-
-    def has_git?
-      %x{ git --version }
-      $?.success?
-    end
-
-    def git(args)
-      return "" unless has_git?
-      flattened_args = [args].flatten.compact.join(" ")
-      %x{ git #{flattened_args} 2>&1 }.strip
-    end
-
-    def time_ago(since)
-      if since.is_a?(String)
-        since = Time.parse(since)
-      end
-
-      elapsed = Time.now - since
-
-      message = since.strftime("%Y/%m/%d %H:%M:%S")
-      if elapsed <= 60
-        message << " (~ #{elapsed.floor}s ago)"
-      elsif elapsed <= (60 * 60)
-        message << " (~ #{(elapsed / 60).floor}m ago)"
-      elsif elapsed <= (60 * 60 * 25)
-        message << " (~ #{(elapsed / 60 / 60).floor}h ago)"
-      end
-      message
-    end
-
-    def truncate(text, length)
-      if text.size > length
-        text[0, length - 2] + '..'
-      else
-        text
-      end
-    end
-
-    @@kb = 1024
-    @@mb = 1024 * @@kb
-    @@gb = 1024 * @@mb
-    def format_bytes(amount)
-      amount = amount.to_i
-      return '(empty)' if amount == 0
-      return amount if amount < @@kb
-      return "#{(amount / @@kb).round}k" if amount < @@mb
-      return "#{(amount / @@mb).round}M" if amount < @@gb
-      return "#{(amount / @@gb).round}G"
-    end
-
-    def quantify(string, num)
-      "%d %s" % [ num, num.to_i == 1 ? string : "#{string}s" ]
-    end
-
-    def create_git_remote(remote, url)
-      return if git('remote').split("\n").include?(remote)
-      return unless File.exists?(".git")
-      git "remote add #{remote} #{url}"
-      display "Git remote #{remote} added"
-    end
-
-    def longest(items)
-      items.map { |i| i.to_s.length }.sort.last
-    end
-
-    def display_table(objects, columns, headers)
-      lengths = []
-      columns.each_with_index do |column, index|
-        header = headers[index]
-        lengths << longest([header].concat(objects.map { |o| o[column].to_s }))
-      end
-      lines = lengths.map {|length| "-" * length}
-      lengths[-1] = 0 # remove padding from last column
-      display_row headers, lengths
-      display_row lines, lengths
-      objects.each do |row|
-        display_row columns.map { |column| row[column] }, lengths
-      end
-    end
-
-    def display_row(row, lengths)
-      row_data = []
-      row.zip(lengths).each do |column, length|
-        format = column.is_a?(Fixnum) ? "%#{length}s" : "%-#{length}s"
-        row_data << format % column
-      end
-      display(row_data.join("  "))
-    end
-
-    def json_encode(object)
-      Turbot::OkJson.encode(object)
-    rescue Turbot::OkJson::Error
-      nil
-    end
-
-    def json_decode(json)
-      Turbot::OkJson.decode(json)
-    rescue Turbot::OkJson::Error
-      nil
-    end
-
-    def set_buffer(enable)
-      with_tty do
-        if enable
-          `stty icanon echo`
-        else
-          `stty -icanon -echo`
-        end
-      end
-    end
-
-    def with_tty(&block)
-      return unless $stdin.isatty
-      begin
-        yield
-      rescue
-        # fails on windows
-      end
-    end
-
-    def get_terminal_environment
-      { "TERM" => ENV["TERM"], "COLUMNS" => `tput cols`.strip, "LINES" => `tput lines`.strip }
-    rescue
-      { "TERM" => ENV["TERM"] }
-    end
-
-    def fail(message)
-      raise Turbot::Command::CommandFailed, message
-    end
-
-    ## DISPLAY HELPERS
-
-    def action(message, options={})
-      message = "#{message} in organzation #{org}" if options[:org]
-      display("#{message}... ", false)
-      Turbot::Helpers.error_with_failure = true
-      ret = yield
-      Turbot::Helpers.error_with_failure = false
-      display((options[:success] || "done"), false)
-      if @status
-        display(", #{@status}", false)
-        @status = nil
-      end
-      display
-      ret
-    end
-
-    def status(message)
-      @status = message
-    end
-
-    def format_with_bang(message)
-      return '' if message.to_s.strip == ""
-      " !    " + message.split("\n").join("\n !    ")
-    end
-
-    def output_with_bang(message="", new_line=true)
-      return if message.to_s.strip == ""
-      display(format_with_bang(message), new_line)
+    # Returns the base URL of the Turbot server.
+    #
+    # @return [String] the base URL of the Turbot server
+    def host
+      ENV['TURBOT_HOST'] || DEFAULT_HOST
     end
 
     def error(message)
-      if Turbot::Helpers.error_with_failure
-        display("failed")
-        Turbot::Helpers.error_with_failure = false
-      end
-      $stderr.puts(format_with_bang(message))
+      prefix = ' !    '
+      $stderr.puts(prefix + message.split("\n").join("\n#{prefix}"))
       exit(1)
     end
 
-    def self.error_with_failure
-      @@error_with_failure ||= false
-    end
-
-    def self.error_with_failure=(new_error_with_failure)
-      @@error_with_failure = new_error_with_failure
-    end
-
-    def self.included_into
-      @@included_into ||= []
-    end
-
-    def self.extended_into
-      @@extended_into ||= []
-    end
-
-    def self.included(base)
-      included_into << base
-    end
-
-    def self.extended(base)
-      extended_into << base
-    end
-
-    def display_header(message="", new_line=true)
-      return if message.to_s.strip == ""
-      display("=== " + message.to_s.split("\n").join("\n=== "), new_line)
-    end
-
-    def display_object(object)
-      case object
-      when Array
-        # list of objects
-        object.each do |item|
-          display_object(item)
-        end
-      when Hash
-        # if all values are arrays, it is a list with headers
-        # otherwise it is a single header with pairs of data
-        if object.values.all? {|value| value.is_a?(Array)}
-          object.keys.sort_by {|key| key.to_s}.each do |key|
-            display_header(key)
-            display_object(object[key])
-            hputs
-          end
-        end
-      else
-        hputs(object.to_s)
-      end
-    end
-
-    def hputs(string='')
-      Kernel.puts(string)
-    end
-
-    def hprint(string='')
-      Kernel.print(string)
-      $stdout.flush
-    end
-
-    def spinner(ticks)
-      %w(/ - \\ |)[ticks % 4]
-    end
-
-    def launchy(message, url)
-      action(message) do
-        require("launchy")
-        launchy = Launchy.open(url)
-        if launchy.respond_to?(:join)
-          launchy.join
-        end
-      end
-    end
-
-    # produces a printf formatter line for an array of items
-    # if an individual line item is an array, it will create columns
-    # that are lined-up
-    #
-    # line_formatter(["foo", "barbaz"])                 # => "%-6s"
-    # line_formatter(["foo", "barbaz"], ["bar", "qux"]) # => "%-3s   %-6s"
-    #
-    def line_formatter(array)
-      if array.any? {|item| item.is_a?(Array)}
-        cols = []
-        array.each do |item|
-          if item.is_a?(Array)
-            item.each_with_index { |val,idx| cols[idx] = [cols[idx]||0, (val || '').length].max }
-          end
-        end
-        cols.map { |col| "%-#{col}s" }.join("  ")
-      else
-        "%s"
-      end
-    end
-
-    def styled_array(array, options={})
-      fmt = line_formatter(array)
-      array = array.sort unless options[:sort] == false
-      array.each do |element|
-        display((fmt % element).rstrip)
-      end
-      display
+    def styled_error(error, message = 'Turbot client internal error.')
+      $stderr.puts(format_error(error, message))
     end
 
-    def format_error(error, message='Turbot client internal error.')
+    def format_error(error, message = 'Turbot client internal error.')
       formatted_error = []
       formatted_error << " !    #{message}"
       formatted_error << ' !    Report a bug at: https://github.com/openc/turbot-client/issues/new'
@@ -383,139 +42,12 @@ module Turbot
         end
       end.join(' ')
       formatted_error << "    Command:     turbot #{command}"
-      require 'turbot/auth'
-      unless Turbot::Auth.host == Turbot::Auth.default_host
-        formatted_error << "    Host:        #{Turbot::Auth.host}"
-      end
-      if http_proxy = ENV['http_proxy'] || ENV['HTTP_PROXY']
-        formatted_error << "    HTTP Proxy:  #{http_proxy}"
+      unless host == DEFAULT_HOST
+        formatted_error << "    Host:        #{host}"
       end
-      if https_proxy = ENV['https_proxy'] || ENV['HTTPS_PROXY']
-        formatted_error << "    HTTPS Proxy: #{https_proxy}"
-      end
-      plugins = Turbot::Plugin.list.sort
-      unless plugins.empty?
-        formatted_error << "    Plugins:     #{plugins.first}"
-        plugins[1..-1].each do |plugin|
-          formatted_error << "                 #{plugin}"
-        end
-        if plugins.length > 1
-          formatted_error << ''
-          $stderr.puts
-        end
-      end
-      formatted_error << "    Version:     #{Turbot.user_agent}"
+      formatted_error << "    Version:     #{Turbot::DEBUG_VERSION}"
       formatted_error << "\n"
       formatted_error.join("\n")
     end
-
-    def styled_error(error, message='Turbot client internal error.')
-      if Turbot::Helpers.error_with_failure
-        display("failed")
-        Turbot::Helpers.error_with_failure = false
-      end
-      $stderr.puts(format_error(error, message))
-    end
-
-    def styled_header(header)
-      display("=== #{header}")
-    end
-
-    def styled_hash(hash, keys=nil)
-      max_key_length = hash.keys.map {|key| key.to_s.length}.max + 2
-      keys ||= hash.keys.sort {|x,y| x.to_s <=> y.to_s}
-      keys.each do |key|
-        case value = hash[key]
-        when Array
-          if value.empty?
-            next
-          else
-            elements = value.sort {|x,y| x.to_s <=> y.to_s}
-            display("#{key}: ".ljust(max_key_length), false)
-            display(elements[0])
-            elements[1..-1].each do |element|
-              display("#{' ' * max_key_length}#{element}")
-            end
-            if elements.length > 1
-              display
-            end
-          end
-        when nil
-          next
-        else
-          display("#{key}: ".ljust(max_key_length), false)
-          display(value)
-        end
-      end
-    end
-
-    def string_distance(first, last)
-      distances = [] # 0x0s
-      0.upto(first.length) do |index|
-        distances << [index] + [0] * last.length
-      end
-      distances[0] = 0.upto(last.length).to_a
-      1.upto(last.length) do |last_index|
-        1.upto(first.length) do |first_index|
-          first_char = first[first_index - 1, 1]
-          last_char = last[last_index - 1, 1]
-          if first_char == last_char
-            distances[first_index][last_index] = distances[first_index - 1][last_index - 1] # noop
-          else
-            distances[first_index][last_index] = [
-              distances[first_index - 1][last_index],     # deletion
-              distances[first_index][last_index - 1],     # insertion
-              distances[first_index - 1][last_index - 1]  # substitution
-            ].min + 1 # cost
-            if first_index > 1 && last_index > 1
-              first_previous_char = first[first_index - 2, 1]
-              last_previous_char = last[last_index - 2, 1]
-              if first_char == last_previous_char && first_previous_char == last_char
-                distances[first_index][last_index] = [
-                  distances[first_index][last_index],
-                  distances[first_index - 2][last_index - 2] + 1 # transposition
-                ].min
-              end
-            end
-          end
-        end
-      end
-      distances[first.length][last.length]
-    end
-
-    def suggestion(actual, possibilities)
-      distances = Hash.new {|hash,key| hash[key] = []}
-      possibilities.each do |suggestion|
-        distances[string_distance(actual, suggestion)] << suggestion
-      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
-      else
-        nil
-      end
-    end
-
-    def org_host
-      ENV["TURBOT_ORG_HOST"] || default_org_host
-    end
-
-    def default_org_host
-      "turbotmanager.com"
-    end
-
-    def org? email
-      email =~ /^.*@#{org_host}$/
-    end
-
-    def bot_owner email
-      org?(email) ? email.gsub(/^(.*)@#{org_host}$/,'\1') : email
-    end
-
   end
 end