class ParallelTests::CLI

def parse_options!(argv)
  options = {}
  OptionParser.new do |opts|
    opts.banner = <<-BANNER.gsub(/^          /, '')
      Run all tests in parallel, giving each process ENV['TEST_ENV_NUMBER'] ('', '2', '3', ...)
      [optional] Only run selected files & folders:
          parallel_test test/bar test/baz/xxx_text.rb
      Options are:
    BANNER
    opts.on("-n [PROCESSES]", Integer, "How many processes to use, default: available CPUs") { |n| options[:count] = n }
    opts.on("-p", "--pattern [PATTERN]", "run tests matching this pattern") { |pattern| options[:pattern] = /#{pattern}/ }
    opts.on("--group-by [TYPE]", <<-TEXT.gsub(/^          /, '')
      group tests by:
                found - order of finding files
                steps - number of cucumber/spinach steps
                scenarios - individual cucumber scenarios
                filesize - by size of the file
                runtime - info from runtime log
                default - runtime when runtime log is filled otherwise filesize
      TEXT
      ) { |type| options[:group_by] = type.to_sym }
    opts.on("-m [FLOAT]", "--multiply-processes [FLOAT]", Float, "use given number as a multiplier of processes to run") { |multiply| options[:multiply] = multiply }
    opts.on("-s [PATTERN]", "--single [PATTERN]",
      "Run all matching files in the same process") do |pattern|
      options[:single_process] ||= []
      options[:single_process] << /#{pattern}/
    end
    opts.on("-i", "--isolate",
      "Do not run any other tests in the group used by --single(-s)") do |pattern|
      options[:isolate] = true
    end
    opts.on("--only-group INT[, INT]", Array) { |groups| options[:only_group] = groups.map(&:to_i) }
    opts.on("-e", "--exec [COMMAND]", "execute this code parallel and with ENV['TEST_ENV_NUM']") { |path| options[:execute] = path }
    opts.on("-o", "--test-options '[OPTIONS]'", "execute test commands with those options") { |arg| options[:test_options] = arg }
    opts.on("-t", "--type [TYPE]", "test(default) / rspec / cucumber / spinach") do |type|
      begin
        @runner = load_runner(type)
      rescue NameError, LoadError => e
        puts "Runner for `#{type}` type has not been found! (#{e})"
        abort
      end
    end
    opts.on("--serialize-stdout", "Serialize stdout output, nothing will be written until everything is done") { options[:serialize_stdout] = true }
    opts.on("--combine-stderr", "Combine stderr into stdout, useful in conjunction with --serialize-stdout") { options[:combine_stderr] = true }
    opts.on("--non-parallel", "execute same commands but do not in parallel, needs --exec") { options[:non_parallel] = true }
    opts.on("--no-symlinks", "Do not traverse symbolic links to find test files") { options[:symlinks] = false }
    opts.on('--ignore-tags [PATTERN]', 'When counting steps ignore scenarios with tags that match this pattern')  { |arg| options[:ignore_tag_pattern] = arg }
    opts.on("--nice", "execute test commands with low priority.") { options[:nice] = true }
    opts.on("--runtime-log [PATH]", "Location of previously recorded test runtimes") { |path| options[:runtime_log] = path }
    opts.on("--verbose", "Print more output") { options[:verbose] = true }
    opts.on("-v", "--version", "Show Version") { puts ParallelTests::VERSION; exit }
    opts.on("-h", "--help", "Show this.") { puts opts; exit }
  end.parse!(argv)
  if options[:count] == 0
    options.delete(:count)
    options[:non_parallel] = true
  end
  abort "Pass files or folders to run" if argv.empty? && !options[:execute]
  options[:files] = argv
  options[:group_by] ||= :filesize if options[:only_group]
  raise "--group-by found and --single-process are not supported" if options[:group_by] == :found and options[:single_process]
  allowed = [:filesize, :runtime, :found]
  if !allowed.include?(options[:group_by]) && options[:only_group]
    raise "--group-by #{allowed.join(" or ")} is required for --only-group"
  end
  options
end