turbot 0.1.36 → 0.2.3

data/lib/turbot/command/base.rb

@@ -1,19 +1,14 @@
-require "fileutils"
-require "turbot/auth"
-require "turbot/client/rendezvous"
-require "turbot/command"
-
 class Turbot::Command::Base
   include Turbot::Helpers
 
   def self.namespace
-    self.to_s.split("::").last.downcase
+    self.to_s.split('::').last.downcase
   end
 
   attr_reader :args
   attr_reader :options
 
-  def initialize(args=[], options={})
+  def initialize(args = [], options = {})
     @args = args
     @options = options
   end
@@ -21,24 +16,13 @@ class Turbot::Command::Base
   def bot
     @bot ||= if options[:bot].is_a?(String)
       options[:bot]
-    elsif ENV.has_key?('TURBOT_BOT')
+    elsif ENV['TURBOT_BOT']
       ENV['TURBOT_BOT']
-    elsif bot_from_manifest = extract_bot_from_manifest(Dir.pwd)
-      bot_from_manifest
-    else
-      # raise instead of using error command to enable rescuing when bot is optional
-      raise Turbot::Command::CommandFailed.new("No bot specified.\nRun this command from a bot folder containing a `manifest.json`,  or specify which bot to use with --bot BOT_ID.") unless options[:ignore_no_bot]
+    elsif manifest = parse_manifest
+      manifest['bot_id']
     end
   end
 
-  def api
-    Turbot::Auth.api
-  end
-
-  def turbot
-    Turbot::Auth.client
-  end
-
 protected
 
   def self.inherited(klass)
@@ -53,13 +37,13 @@ protected
   end
 
   def self.method_added(method)
-    return if self == Turbot::Command::Base
-    return if private_method_defined?(method)
-    return if protected_method_defined?(method)
+    if self == Turbot::Command::Base || private_method_defined?(method) || protected_method_defined?(method)
+      return
+    end
 
     help = extract_help_from_caller(caller.first)
     resolved_method = (method.to_s == "index") ? nil : method.to_s
-    command = [ self.namespace, resolved_method ].compact.join(":")
+    command = [self.namespace, resolved_method].compact.join(":")
     banner = extract_banner(help) || command
 
     Turbot::Command.register_command(
@@ -73,18 +57,10 @@ protected
       :description => extract_description(help),
       :options     => extract_options(help)
     )
-
-    alias_command command.gsub(/_/, '-'), command if command =~ /_/
-  end
-
-  def self.alias_command(new, old)
-    raise "no such command: #{old}" unless Turbot::Command.commands[old]
-    Turbot::Command.command_aliases[new] = old
   end
 
-  def extract_bot
-    output_with_bang "Command::Base#extract_bot has been deprecated. Please use Command::Base#bot instead.  #{caller.first}"
-    bot
+  def self.alias_command(command_alias, command)
+    Turbot::Command.command_aliases[command_alias] = command
   end
 
   #
@@ -113,7 +89,7 @@ protected
     buffer = []
     lines = Turbot::Command.files[file]
 
-    (line_number.to_i-2).downto(0) do |i|
+    (line_number.to_i - 2).downto(0) do |i|
       line = lines[i]
       case line[0..0]
         when ""
@@ -156,37 +132,22 @@ protected
     Turbot::Command.current_command
   end
 
-  def extract_option(key)
-    options[key.dup.gsub('-','_').to_sym]
-  end
-
-  def invalid_arguments
-    Turbot::Command.invalid_arguments
-  end
-
-  def shift_argument
-    Turbot::Command.shift_argument
-  end
-
   def validate_arguments!
     Turbot::Command.validate_arguments!
   end
 
-  def extract_bot_from_manifest(dir)
-    begin
-      config = JSON.load(open("#{dir}/manifest.json").read)
-      config && config["bot_id"]
-    rescue Errno::ENOENT
+  def parse_manifest
+    path = File.join(working_directory, 'manifest.json')
+    if File.exists?(path)
+      begin
+        JSON.load(File.read(path))
+      rescue JSON::ParserError => e
+        error "`manifest.json` is invalid JSON. Consider validating it at http://pro.jsonlint.com/"
+      end
     end
   end
 
-  def escape(value)
-    turbot.escape(value)
-  end
-end
-
-module Turbot::Command
-  unless const_defined?(:BaseWithApp)
-    BaseWithApp = Base
+  def working_directory
+    Dir.pwd
   end
 end

data/lib/turbot/command/bots.rb

@@ -1,217 +1,267 @@
-require "turbot/command/base"
-require 'active_support/core_ext/object/blank'
-require 'active_support/core_ext/hash/slice'
-require 'zip'
-require 'open3'
-require 'base64'
-require 'shellwords'
-require 'turbot_runner'
-
-# manage bots (generate skeleton, validate data, submit code)
+#Manage bots (generate template, validate data, submit code)
 #
 class Turbot::Command::Bots < Turbot::Command::Base
+  BOT_ID_RE = /\A[A-Za-z0-9_-]+\z/.freeze
+
+  def initialize(*args)
+    super
+
+    require 'turbot_runner'
+    require 'turbot/handlers/base_handler'
+    require 'turbot/handlers/dump_handler'
+    require 'turbot/handlers/preview_handler'
+    require 'turbot/handlers/validation_handler'
+  end
 
   # bots
   #
-  # list your bots
+  #List your bots.
   #
   #Example:
   #
-  # $ turbot bots
-  # === My Bots
-  # example
-  # example2
+  #  $ turbot bots
+  #  example1
+  #  example2
   #
   def index
     validate_arguments!
-    bots = api.list_bots.data
-    unless bots.empty?
-      styled_header("Bots")
-      styled_array(bots.map{|bot| bot[:bot_id]})
+
+    response = api.list_bots
+    if response.is_a?(Turbot::API::SuccessResponse)
+      if response.data.empty?
+        puts 'You have no bots.'
+      else
+        response.data.each do |bot|
+          puts bot[:bot_id]
+        end
+      end
     else
-      display("You have no bots.")
+      error_message(response)
     end
   end
+  alias_command 'list', 'bots'
 
-  alias_command "list", "bots"
-
-  # bots:info
-  #
-  # show detailed bot information
+  # bots:info [--bot BOT]
   #
-  # -s, --shell  # output more shell friendly key/value pairs
+  #Show a bot's details.
   #
-  #Examples:
+  #  -b, --bot BOT # a bot ID
   #
-  # $ turbot bots:info
-  # === example
-  # Last run status: OK
-  # Last run ended: 2001/01/01
-  # ...
+  #Example:
   #
-  # $ turbot bots:info --shell
-  # last_run_status: OK
-  # last_run_ended: 2001/01/01
-  # ...
+  #  $ turbot bots:info --bot example
+  #  bot_id: example
+  #  created_at: 2010-01-01T00:00:00.000Z
+  #  updated_at: 2010-01-02T00:00:00.000Z
+  #  state: scheduled
   #
   def info
     validate_arguments!
-    bot_data = api.get_bot(bot)
-    unless options[:shell]
-      styled_header(bot_data["name"])
-    end
+    error_if_no_local_bot_found
 
-    if options[:shell]
-      bot_data.keys.sort_by { |a| a.to_s }.each do |key|
-        hputs("#{key}=#{bot_data[key]}")
+    response = api.show_bot(bot)
+    if response.is_a?(Turbot::API::SuccessResponse)
+      response.data.each do |key,value|
+        puts "#{key}: #{value}"
       end
     else
-      data = {}
-      if bot_data["last_run_status"]
-        data["Last run status"] = bot_data["last_run_status"]
-      end
-      if bot_data["last_run_ended"]
-        data["Last run ended"] = format_date(bot_data["last_run_ended"]) if bot_data["last_run_ended"]
-      end
-      data["Git URL"] = bot_data["git_url"]
-      data["Repo Size"] = format_bytes(bot_data["repo_size"]) if bot_data["repo_size"]
-      styled_hash(data)
+      error_message(response)
     end
   end
+  alias_command 'info', 'bots:info'
 
-  alias_command "info", "bots:info"
-
-
-  # bots:generate --bot name_of_bot
+  # bots:generate --bot BOT
   #
-  # Generate stub code for a bot in specified language
+  #Generate a bot template in the specified language.
+  #
+  #  -b, --bot BOT # a bot ID
+  #  -l, --language LANGUAGE # ruby (default) or python
+  #
+  #Example:
+  #
+  #  $ turbot bots:generate --bot my_amazing_bot --language ruby
+  #  Created new bot template for my_amazing_bot!
   #
-  #   -l, --language LANGUAGE # language to generate (currently `ruby` (default) or `python`)
-
-  # $ turbot bots:generate --language=ruby --bot my_amazing_bot
-  # Created new bot template at my_amazing_bot!
-
   def generate
     validate_arguments!
-    response = api.show_bot(bot)
-    if response.is_a? Turbot::API::SuccessResponse
-      error("There's already a bot called #{bot} registered with Turbot. Bot names must be unique.")
-    end
+    error_if_bot_exists_in_turbot
 
-    language = options[:language] || "ruby"
-    scraper_template = File.expand_path("../../../../templates/#{language}", __FILE__)
-    error("unsupported language #{language}") if !File.exists?(scraper_template)
+    # Check the bot name.
+    unless bot[BOT_ID_RE]
+      error "The bot name #{bot} is invalid. Bot names must contain only lowercase letters (a-z), numbers (0-9), underscore (_) or hyphen (-)."
+    end
 
-    manifest_template = File.expand_path("../../../../templates/manifest.json", __FILE__)
-    license_template = File.expand_path("../../../../templates/LICENSE.txt", __FILE__)
-    manifest = open(manifest_template).read.sub("{{bot_id}}", bot)
-    scraper_name = case language
-      when "ruby"
-        "scraper.rb"
-      when "python"
-        "scraper.py"
-      end
+    # Check collision with existing directory.
+    bot_directory = File.join(working_directory, bot)
+    if File.exists?(bot_directory)
+      error "There's already a directory named #{bot}. Move it, delete it, change directory, or try another name."
+    end
 
-    manifest = manifest.sub("{{scraper_name}}", scraper_name)
-    manifest = manifest.sub("{{language}}", language)
+    language = (options[:language] || 'ruby').downcase
+    scraper_template = File.expand_path("../../../../data/templates/#{language}", __FILE__)
 
-    # Language-specific stuff
-    # Language-specific stuff:
-    if File.exists? bot
-      error("There's already a folder called #{bot}; move it out the way or try a different name")
+    # Check language.
+    unless File.exists?(scraper_template)
+      error "The language #{language} is unsupported."
     end
-    FileUtils.mkdir(bot)
-    FileUtils.cp_r(Dir["#{scraper_template}/*"], bot)
 
-    # Same for all languages
-    FileUtils.cp(license_template, "#{bot}/LICENSE.txt")
-    open("#{bot}/manifest.json", "w") do |f|
-      f.write(JSON.pretty_generate(JSON.parse(manifest)))
+    scraper_name = case language
+    when 'ruby'
+      'scraper.rb'
+    when 'python'
+      'scraper.py'
     end
 
-    response = api.create_bot(bot, JSON.parse(manifest))
-    if response.is_a? Turbot::API::SuccessResponse
-      puts "Created new bot template at #{bot}!"
-    else
-      error(response.message)
+    # Create the scraper.
+    FileUtils.mkdir(bot_directory)
+    FileUtils.cp(File.join(scraper_template, scraper_name), File.join(bot_directory, scraper_name))
+
+    # Create the license.
+    license_template = File.expand_path('../../../../data/templates/LICENSE.txt', __FILE__)
+    FileUtils.cp(license_template, File.join(bot_directory, 'LICENSE.txt'))
+
+    # Create the manifest.
+    manifest_template = File.expand_path('../../../../data/templates/manifest.json', __FILE__)
+    manifest = File.read(manifest_template).
+      sub('{{bot_id}}', bot).
+      sub('{{scraper_name}}', scraper_name).
+      sub('{{language}}', language)
+    File.open(File.join(bot_directory, 'manifest.json'), 'w') do |f|
+      f.write(JSON.pretty_generate(JSON.load(manifest)))
     end
-  end
 
+    puts "Created new bot template for #{bot}!"
+  end
 
   # bots:register
   #
-  # Register a bot with turbot. Must be run from a folder containing scraper and manifest.json
-
-  # $ turbot bots:register
-  # Registered my_amazing_bot!
-
+  #Register a bot with Turbot. Must be run from a bot directory containing a `manifest.json` file.
+  #
+  #Example:
+  #
+  #  $ turbot bots:register
+  #  Registered my_amazing_bot!
+  #
   def register
-    response = api.show_bot(bot)
-    if response.is_a? Turbot::API::SuccessResponse
-      error("There's already a bot called #{bot} registered with Turbot. Bot names must be unique.")
-    end
+    validate_arguments!
+    error_if_no_local_bot_found
+    error_if_bot_exists_in_turbot
 
-    manifest = parsed_manifest(working_directory)
-    response = api.create_bot(bot, manifest)
-    if response.is_a? Turbot::API::FailureResponse
-      error(response.message)
-    else
+    response = api.create_bot(bot, parse_manifest)
+    if response.is_a?(Turbot::API::SuccessResponse)
       puts "Registered #{bot}!"
+    else
+      error_message(response)
     end
   end
 
   # bots:push
   #
-  # Push bot code to the turbot server. Must be run from a local bot checkout.
+  #Push the bot's code to Turbot. Must be run from a bot directory containing a `manifest.json` file.
+  #
+  #  -y, --yes # skip confirmation
+  #
+  #Example:
+  #
+  #  $ turbot bots:push
+  #  This will submit your bot and its data for review.
+  #  Are you happy your bot produces valid data (e.g. with `turbot bots:validate`)? [Y/n]
+  #  Your bot has been pushed to Turbot and will be reviewed for inclusion as soon as we can. THANK YOU!
   #
-  # $ turbot bots:push
-  # Your bot has been pushed to Turbot and will be reviewed for inclusion as soon as we can. THANKYOU!
-
   def push
     validate_arguments!
-    puts "This will submit your bot and its data for review."
-    puts "Are you happy your bot produces valid data (e.g. with `turbot bots:validate`)? [Y/n]"
-    confirmed = ask
-    error("Aborting push") if !confirmed.downcase.empty? && confirmed.downcase != "y"
-    manifest = parsed_manifest(working_directory)
-    archive = Tempfile.new(bot)
-    archive_path = "#{archive.path}.zip"
-    create_zip_archive(archive_path, working_directory, manifest['files'] + ['manifest.json'])
-
-    response = File.open(archive_path) {|file| api.update_code(bot, file)}
-    case response
-    when Turbot::API::SuccessResponse
-      puts "Your bot has been pushed to Turbot and will be reviewed for inclusion as soon as we can. THANK YOU!"
-    when Turbot::API::FailureResponse
-      error(response.message)
+    error_if_no_local_bot_found
+
+    unless options[:yes]
+      puts 'This will submit your bot and its data for review.'
+      puts 'Are you happy your bot produces valid data (e.g. with `turbot bots:validate`)? [Y/n]'
+      answer = ask
+      unless ['', 'y'].include?(answer.downcase.strip)
+        error 'Aborted.'
+      end
+    end
+
+    # TODO Validate the manifest.json file.
+
+    manifest = parse_manifest
+    tempfile = Tempfile.new(bot)
+    tempfile.close # Windows will raise Errno::EACCES on Zip::File.open below
+    archive_path = "#{tempfile.path}.zip"
+    create_zip_archive(archive_path, manifest['files'] + ['manifest.json'])
+
+    response = File.open(archive_path) do |f|
+      api.update_code(bot, f)
+    end
+    if response.is_a?(Turbot::API::SuccessResponse)
+      puts 'Your bot has been pushed to Turbot and will be reviewed for inclusion as soon as we can. THANK YOU!'
+    else
+      error_message(response)
     end
   end
+  alias_command 'push', 'bots:push'
 
-  alias_command "push", "bots:push"
 
   # bots:validate
   #
-  # Validate bot output against its schema
+  #Validate the `manifest.json` file and validate the bot's output against its schema.
+  #
+  #Example:
+  #
+  #  $ turbot bots:validate
+  #  Validated 2 records!
   #
-  # $ turbot bots:validate
-  # Validating example... done
-
   def validate
-    scraper_path    = shift_argument || scraper_file(working_directory)
     validate_arguments!
-    config = parsed_manifest(working_directory)
+    error_if_no_local_bot_found
+
+    manifest = parse_manifest
 
-    %w(bot_id data_type identifying_fields files language publisher).each do |key|
-      error("Manifest is missing #{key}") unless config.has_key?(key)
+    { 'allow_duplicates' => 'duplicates_allowed',
+      'author' => 'publisher',
+      'incremental' => 'manually_end_run',
+      'public_repository' => 'public_repo_url',
+    }.each do |deprecated,field|
+      if manifest[deprecated]
+        puts %(WARNING: "#{deprecated}" is deprecated. Use "#{field}" instead.)
+      end
+    end
+
+    schema = JSON.load(File.read(File.expand_path('../../../../data/schema.json', __FILE__)))
+    validator = JSON::Validator.new(schema, manifest, {
+      clear_cache: false,
+      parse_data: false,
+      record_errors: true,
+      errors_as_objects: true,
+    })
+
+    errors = validator.validate
+    if errors.any?
+      messages = ['`manifest.json` is invalid. Please correct the errors:']
+      errors.each do |error|
+        messages << "* #{error.fetch(:message).sub(/ in schema \S+\z/, '')}"
+      end
+      error messages.join("\n")
     end
 
-    type = config["data_type"]
+    if manifest['transformers']
+      difference = manifest['transformers'].map { |transformer| transformer['file'] } - manifest['files']
+      if difference.any?
+        messages = ['`manifest.json` is invalid. Please correct the errors:']
+        messages << "* Some transformer files are not listed in the top-level files: #{difference.join(', ')}"
+        error messages.join("\n")
+      end
+    end
 
-    handler = ValidationHandler.new
+    handler = Turbot::Handlers::ValidationHandler.new
     runner = TurbotRunner::Runner.new(working_directory, :record_handler => handler)
-    rc = runner.run
+    begin
+      rc = runner.run
+    rescue TurbotRunner::InvalidDataType
+      messages = ['`manifest.json` is invalid. Please correct the errors:']
+      messages << %(* The property '#/data_type' value "#{manifest['data_type']}" is not a supported data type.)
+      error messages.join("\n")
+    end
 
-    puts
     if rc == TurbotRunner::Runner::RC_OK
       puts "Validated #{handler.count} records!"
     else
@@ -221,216 +271,117 @@ class Turbot::Command::Bots < Turbot::Command::Base
 
   # bots:dump
   #
-  # Execute bot locally (writes to STDOUT)
+  #Execute the bot locally and write the bot's output to STDOUT.
+  #
+  #  -q, --quiet # only output validation errors
+  #
+  #Example:
+  #
+  #  $ turbot bots:dump
+  #  {'foo': 'bar'}
+  #  {'foo2': 'bar2'}
   #
-  # $ turbot bots:dump
-  # {'foo': 'bar'}
-  # {'foo2': 'bar2'}
-
   def dump
     validate_arguments!
+    error_if_no_local_bot_found
 
-    handler = DumpHandler.new
+    if options[:quiet]
+      handler = Turbot::Handlers::BaseHandler.new
+    else
+      handler = Turbot::Handlers::DumpHandler.new
+    end
     runner = TurbotRunner::Runner.new(working_directory, :record_handler => handler)
     rc = runner.run
 
-    puts
     if rc == TurbotRunner::Runner::RC_OK
-      puts "Bot ran successfully!"
+      puts 'Bot ran successfully!'
     else
-      puts "Bot failed!"
+      puts 'Bot failed!'
     end
   end
 
-#  # bots:single
-#  #
-#  # Execute bot in same way as OpenCorporates single-record update
-#  #
-#  # $ turbot bots:single
-#  # Enter argument (as JSON object):
-#  # {"id": "frob123"}
-#  # {"id": "frob123", "stuff": "updated-data-for-this-record"}
-#
-#  def single
-#    # This will need to be language-aware, eventually
-#    scraper_path    = shift_argument || scraper_file(working_directory)
-#    validate_arguments!
-#    print 'Arguments (as JSON object, e.g. {"id":"ABC123"}: '
-#    arg = ask
-#    count = 0
-#    run_scraper_each_line("#{scraper_path} #{bot} #{Shellwords.shellescape(arg)}") do |line|
-#      raise "Your scraper returned more than one value!" if count > 1
-#      puts line
-#      count += 1
-#    end
-#  end
-
-
   # bots:preview
   #
-  # Send bot data to Turbot for remote previewing / sharing
+  #Send bot data to Turbot for remote previewing or sharing.
+  #
+  #Example:
+  #
+  #  $ turbot bots:preview
+  #  Sending to Turbot...
+  #  Submitted 2 records to Turbot.
+  #  View your records at http://turbot.opencorporates.com/..
   #
-  # Sending example to turbot... done
   def preview
     validate_arguments!
+    error_if_no_local_bot_found
 
-    config = parsed_manifest(working_directory)
-
-    response = api.update_bot(bot, parsed_manifest(working_directory))
-    if !response.is_a? Turbot::API::SuccessResponse
-      error(response.message)
+    response = api.update_bot(bot, parse_manifest)
+    if response.is_a?(Turbot::API::FailureResponse)
+      error_message(response)
     end
 
     response = api.destroy_draft_data(bot)
-    if !response.is_a? Turbot::API::SuccessResponse
-      error(response.message)
+    if response.is_a?(Turbot::API::FailureResponse)
+      error_message(response)
     end
 
-    puts "Sending to turbot... "
+    puts 'Sending to Turbot...'
 
-    handler = PreviewHandler.new(bot, api)
+    handler = Turbot::Handlers::PreviewHandler.new(bot, api)
     runner = TurbotRunner::Runner.new(working_directory, :record_handler => handler)
     rc = runner.run
 
-    puts
-
     if rc == TurbotRunner::Runner::RC_OK
       response = handler.submit_batch
-      if response.is_a? Turbot::API::SuccessResponse
+      if response.is_a?(Turbot::API::SuccessResponse)
         if handler.count > 0
-          puts "Submitted #{handler.count} records to turbot"
-          puts "View your records at #{response.data[:url]}"
+          puts "Submitted #{handler.count} records to Turbot.\nView your records at #{response.data[:url]}"
         else
-          puts "No records sent"
+          puts 'No records sent.'
         end
       else
-        error(response.message)
+        error_message(response)
       end
     else
-      puts
-      puts "Bot failed!"
+      puts 'Bot failed!'
     end
   end
 
-  private
-  def spinner(p)
-    parts = "\|/-" * 2
-    print parts[p % parts.length] + "\r"
-  end
+private
 
-  def parsed_manifest(dir)
-    begin
-      JSON.parse(open(manifest_path).read)
-    rescue Errno::ENOENT
-      raise "This command must be run from a directory including `manifest.json`"
+  def error_if_no_local_bot_found
+    unless bot
+      error "No bot specified.\nRun this command from a bot directory containing a `manifest.json` file, or specify the bot with --bot BOT."
     end
   end
 
-  def scraper_file(dir)
-    Dir.glob("scraper*").reject{|n| !n.match(/(rb|py)$/)}.first
-  end
-
-  def working_directory
-    Dir.pwd
+  def error_if_bot_exists_in_turbot
+    if api.show_bot(bot).is_a?(Turbot::API::SuccessResponse)
+      error "There's already a bot named #{bot} in Turbot. Try another name."
+    end
   end
 
-  def manifest_path
-    File.join(working_directory, 'manifest.json')
+  def error_message(response)
+    suffix = response.error_code && ": #{response.error_code}"
+    error "#{response.message} (HTTP #{response.code}#{suffix})"
   end
 
-  def create_zip_archive(archive_path, basepath, subpaths)
+  def create_zip_archive(archive_path, basenames)
     Zip.continue_on_exists_proc = true
+
     Zip::File.open(archive_path, Zip::File::CREATE) do |zipfile|
-      subpaths.each do |subpath|
-        path = File.join(basepath, subpath)
+      basenames.each do |basename|
+        filename = File.join(working_directory, basename)
 
-        if File.directory?(path)
-          Dir["#{path}/**/*"].each do |path1|
-            subpath1 = Pathname.new(path1).relative_path_from(Pathname.new(basepath))
-            zipfile.add(subpath1, path1)
+        if File.directory?(filename)
+          Dir["#{filename}/**/*"].each do |filename1|
+            basename1 = Pathname.new(filename1).relative_path_from(Pathname.new(working_directory))
+            zipfile.add(basename1, filename1)
           end
         else
-          zipfile.add(subpath, path)
+          zipfile.add(basename, filename)
         end
       end
     end
   end
 end
-
-class TurbotClientHandler < TurbotRunner::BaseHandler
-  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
-
-  def handle_non_json_output(line)
-    puts
-    puts "The following line was not valid JSON:"
-    puts line
-  end
-end
-
-
-class DumpHandler < TurbotClientHandler
-  def handle_valid_record(record, data_type)
-    puts record.to_json
-  end
-end
-
-
-class ValidationHandler < TurbotClientHandler
-  attr_reader :count
-
-  def initialize(*)
-    @count = 0
-    super
-  end
-
-  def handle_valid_record(record, data_type)
-    @count += 1
-    STDOUT.write('.')
-  end
-
-  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
-
-  def handle_invalid_json(line)
-    puts
-    puts "The following line was not valid JSON:"
-    puts line
-  end
-end
-
-
-class PreviewHandler < TurbotClientHandler
-  attr_reader :count
-
-  def initialize(bot_name, api)
-    @bot_name = bot_name
-    @api = api
-    @batch = []
-    @count = 0
-    super()
-  end
-
-  def handle_valid_record(record, data_type)
-    @count += 1
-    STDOUT.write('.')
-    @batch << record.merge(:data_type => data_type)
-    submit_batch if @count % 20 == 0
-  end
-
-  def submit_batch
-    result = @api.create_draft_data(@bot_name, @batch.to_json)
-    @batch = []
-    result
-  end
-end