Refactor CLI

Move all binary functionality to a Cmdline class (closes #113)
Tidy up output into a clear directory structure (closes #148)
Add path expansion of all file paths and some more logging.

Author: blahah

bin/transrate

@@ -1,16 +1,7 @@
 #!/usr/bin/env ruby
-
-require 'trollop'
 require 'transrate'
-require 'csv'
-require 'bindeps'
-require 'colorize'
-
 include Transrate
 
-# Show the help message if no arguments provided
-ARGV[0] = "--help" if ARGV.length() == 0
-
 # We want clean error messages through the logger, no ugly backtraces
 # because the user doesn't care about them, unless they specifically ask for
 # them with --loglevel debug
@@ -28,369 +19,5 @@ module Kernel
   end
 end
 
-txp = '░▓▓▓^▓▓▓░'
-toptxp = txp.green
-midtxp = txp.yellow
-bottxp = txp.red
-
-opts = Trollop::options do
-  version Transrate::VERSION::STRING.dup
-  banner <<-EOS
-           _                                        _
-          | |_  _ __  __ _  _ __   ___  _ __  __ _ | |_  ___
-#{toptxp} | __|| '__|/ _` || '_ \\ / __|| '__|/ _` || __|/ _ \\ #{toptxp}
-#{midtxp} | |_ | |  | (_| || | | |\\__ \\| |  | (_| || |_|  __/ #{midtxp}
-#{bottxp}  \\__||_|   \\__,_||_| |_||___/|_|   \\__,_| \\__|\\___| #{bottxp}
-
-  Transrate v#{Transrate::VERSION::STRING.dup}
-  by Richard Smith-Unna, Chris Boursnell, Rob Patro,
-     Julian Hibberd, and Steve Kelly
-
-  DESCRIPTION:
-  Analyse a de-novo transcriptome assembly using three kinds of metrics:
-
-  1. sequence based (if --assembly is given)
-  2. read mapping based (if --left and --right are given)
-  3. reference based (if --reference is given)
-
-  Documentation at http://hibberdlab.com/transrate
-
-  USAGE:
-  transrate <options>
-
-  OPTIONS:
-
-  EOS
-  opt :assembly, "Assembly file(s) in FASTA format, comma-separated",
-      :type => String
-  opt :left, "Left reads file in FASTQ format",
-      :type => String
-  opt :right, "Right reads file in FASTQ format",
-      :type => String
-  opt :reference, "Reference proteome or transcriptome file in FASTA format",
-      :type => String
-  opt :threads, "Number of threads to use",
-      :default => 8,
-      :type => Integer
-  opt :merge_assemblies, "Merge best contigs from multiple assemblies into file",
-      :type => String
-  opt :outfile, "Prefix filename to use for CSV output",
-      :default => 'transrate'
-  opt :loglevel, "Log level. " +
-                 "One of [error, info, warn, debug]",
-      :default => 'info'
-  opt :install_deps, "Install any missing dependencies. One of [all, read, ref]",
-      :type => String, :default => nil
-  opt :examples, "Show some example commands with explanations"
-end
-
-if opts.examples
-  puts <<-EOS
-
-  Transrate v#{Transrate::VERSION::STRING.dup}
-
-  EXAMPLE COMMANDS:
-
-  # check dependencies and install any that are missing
-  transrate --install-deps
-
-  # get the transrate score for the assembly and each contig
-  transrate --assembly contigs.fa --left left.fq --right right.fq
-
-  # basic assembly metrics only
-  transrate --assembly contigs.fa
-
-  # basic and reference-based metrics with 8 threads
-  transrate --assembly contigs.fa --reference ref.fa --threads 8
-
-  # contig and read-based metrics for two assemblies with 32 threads
-  transrate --assembly one.fa,two.fa --left l.fq --right r.fq --threads 32
-
-  EOS
-  exit(0)
-end
-
-# Check dependencies if they are relevant to the command issued,
-# and handle any commands to install missing ones
-gem_dir = Gem.loaded_specs['transrate'].full_gem_path
-gem_deps = File.join(gem_dir, 'deps', 'deps.yaml')
-blast_dep = File.join(gem_dir, 'deps', 'blast.yaml')
-
-deps, read_deps, ref_deps = nil
-unless opts.install_deps.nil?
-
-  unless %w[all read ref].include? opts.install_deps
-    raise TransrateError.new "install-deps #{opts.install_deps} is not valid. " +
-    "You must specify one of: all, read, ref."
-  end
-
-  deps = opts.install_deps == 'all'
-  read_deps = opts.install_deps == 'read'
-  ref_deps = opts.install_deps == 'ref'
-end
-
-if deps || read_deps || ref_deps
-  # user has requested dependency installation
-  puts "Checking dependencies"
-
-  missing = []
-  if deps || read_deps
-    Bindeps.require gem_deps
-    missing += Bindeps.missing gem_deps
-  end
-
-  if deps || ref_deps
-    Bindeps.require blast_dep
-    missing += Bindeps.missing blast_dep
-  end
-
-  unless missing.empty?
-    list = missing.collect {|i| "#{i.name}:#{i.version}"}.join("\n - ")
-    msg = "Failed to install: \n - #{list}"
-    raise TransrateError.new msg
-  end
-
-  puts "All dependencies installed"
-  exit
-
-else
-  # no dependency installation requested, but check dependencies
-  # for the commands provided are installed
-  missing = []
-  missing = Bindeps.missing gem_deps if opts.left
-  blast_missing = []
-  blast_missing = Bindeps.missing blast_dep if opts.reference
-
-  if missing.length + blast_missing.length > 0
-    puts "Dependencies are missing:"
-
-    missing.each do |dep|
-      puts "  - #{dep.name} (#{dep.version})"
-    end
-
-    blast_missing.each do |dep|
-      puts "  - #{dep.name} (#{dep.version})"
-    end
-
-    puts "To install all missing dependencies, run:"
-    puts "  transrate --install-deps a;;"
-    puts "If you only want the read-metrics dependencies:"
-    puts "  transrate --install-deps read"
-    puts "Or if you only want the reference-metrics dependencies: "
-    puts "  transrate --install-deps ref"
-
-    exit 1
-  end
-
-end
-
-# Handle commands
-unless %w[error info warn debug].include? opts.loglevel
-  raise TransrateError.new "Loglevel #{opts.loglevel} is not valid. " +
-  "It must be one of: error, info, warn, debug."
-end
-
-logger.level = Yell::Level.new opts.loglevel.to_sym
-
-if opts.assembly
-  opts.assembly.split(',').each do |assembly_file|
-    unless File.exist?(assembly_file)
-      raise TransrateIOError.new "Assembly fasta file does not exist: " +
-                                 " #{assembly_file}"
-    end
-  end
-else
-  raise TransrateArgError.new "Option --assembly must be specified. " +
-                              "Try --help for help."
-end
-
-if opts.reference && !File.exist?(opts.reference)
-  raise TransrateIOError.new "Reference fasta file does not exist: " +
-                             " #{opts.reference}"
-end
-
-if opts.left and opts.right
-  if opts.left.split(",").length != opts.right.split(",").length
-    msg = "Please provide the same number of left reads as right reads"
-    raise TransrateArgError.new msg
-  end
-  opts.left.split(",").zip(opts.right.split(",")).each do |left,right|
-    if !File.exist?(left)
-      raise TransrateIOError.new "Left read fastq file does not exist: #{left}"
-    end
-    if !File.exist?(right)
-      raise TransrateIOError.new "Right read fastq file does not exist: #{right}"
-    end
-  end
-end
-
-def pretty_print_hash hash, width, round=2
-  hash.map do |k, v|
-    # show as float if there are any decimal places
-    if v.to_f.round(round).to_s.split('.').last.to_i > 0
-      v = v.to_f.round(round)
-    end
-    if v.is_a? Float
-      v = v.round(round)
-    end
-    pad = (width - (k.to_s.length + v.to_s.length))
-    pad = [pad, 0].max
-    logger.info "#{k.to_s.split('_').join(' ')}" +
-    "#{" " * pad}" +
-    "#{v}"
-  end
-end
-
-r = opts.reference ? Assembly.new(opts.reference) : nil
-report_width = 35
-
-# loop through the assemblies, storing their outputs in an array of hashes
-all = []
-
-assemblies=opts.assembly
-if opts.merge_assemblies
-  merged_file = opts.merge_assemblies
-  merged = {}
-  assemblies.split(",").each do |file|
-    Bio::FastaFormat.open(file).each do |entry|
-      contig_name = "#{File.basename(file,File.extname(file))}:"
-      contig_name << "#{entry.entry_id}"
-      merged[contig_name] = entry.seq
-    end
-  end
-  logger.info "Merging assemblies into one file...'#{merged_file}'"
-  File.open(merged_file, "wb") do |out|
-    merged.each do |name, seq|
-      out.write ">#{name}\n"
-      out.write "#{seq}\n"
-    end
-  end
-
-  assemblies = merged_file
-end
-
-assemblies.split(',').each do |assembly|
-
-  logger.info "Loading assembly: #{assembly}"
-
-  a = Assembly.new assembly
-  transrater = Transrater.new(a, r, threads: opts.threads)
-
-  logger.info "Analysing assembly: #{assembly}"
-
-  contig_results = {}
-
-  logger.info "Calculating contig metrics..."
-  t0 = Time.now
-  contig_results = transrater.assembly_metrics.basic_stats
-  contig_results.merge! transrater.assembly.contig_metrics.results
-  if contig_results
-    logger.info "Contig metrics:"
-    logger.info "-" *  report_width
-    pretty_print_hash(contig_results, report_width)
-  end
-
-  logger.info "Contig metrics done in #{(Time.now - t0).round} seconds"
-
-  read_results = {}
-
-  if (opts.left && opts.right)
-    logger.info "Calculating read diagnostics..."
-    t0 = Time.now
-    read_results = transrater.read_metrics(opts.left, opts.right).read_stats
-
-    if read_results
-      logger.info "Read mapping metrics:"
-      logger.info "-" *  report_width
-      pretty_print_hash(read_results, report_width)
-    end
-
-    logger.info "Read metrics done in #{(Time.now - t0).round} seconds"
-  else
-    logger.info "No reads provided, skipping read diagnostics"
-  end
-
-  comparative_results={}
-
-  if opts.reference
-    logger.info "Calculating comparative metrics..."
-    t0 = Time.now
-    comparative_metrics = transrater.comparative_metrics
-    comparative_results = comparative_metrics.comp_stats
-
-    if comparative_results
-      logger.info "Comparative metrics:"
-      logger.info "-" *  report_width
-      pretty_print_hash(comparative_results, report_width)
-    end
-
-    logger.info "Comparative metrics done in #{(Time.now - t0).round} seconds"
-
-    logger.info "-" * report_width
-  else
-    logger.info "No reference provided, skipping comparative diagnostics"
-  end
-
-  prefix = "#{opts.outfile}_#{File.basename(assembly)}"
-
-  if (opts.left && opts.right)
-    score = transrater.assembly_score
-
-    optimal, cutoff = transrater.assembly_optimal_score prefix
-    unless score.nil?
-      pretty_print_hash({:TRANSRATE_ASSEMBLY_SCORE => score}, report_width, 4)
-      logger.info "-" * report_width
-      pretty_print_hash({:TRANSRATE_OPTIMAL_SCORE => optimal}, report_width, 4)
-      pretty_print_hash({:TRANSRATE_OPTIMAL_CUTOFF => cutoff}, report_width, 4)
-      pretty_print_hash(transrater.good_contigs, report_width)
-    end
-  end
-
-  # write contig metrics to file for each contig
-  outfile = "#{prefix}_contigs.csv"
-  logger.info "Writing contig metrics for each contig to #{outfile}"
-  # have option to turn off, default on
-  first=true
-  CSV.open(outfile, 'wb') do |csv|
-    a.each do |name, contig|
-      basic_metrics = {:contig_name => name}.merge(contig.basic_metrics)
-      if opts.reference
-        comp_metrics = contig.comparative_metrics
-        basic_metrics.merge!(comp_metrics)
-      end
-      if opts.left and opts.right
-        read_metrics = contig.read_metrics
-        basic_metrics.merge!(read_metrics)
-      end
-      if first
-        csv << basic_metrics.keys
-        first = false
-      end
-      csv << basic_metrics.values.map{ |x| x.is_a?(Float) ? x.round(6) : x }
-    end
-  end
-
-  all << contig_results.merge(read_results)
-                       .merge(comparative_results)
-                       .merge({ :assembly => assembly })
-                       .merge({ :score => score })
-                       .merge({ :optimal_score => optimal })
-                       .merge({ :cutoff => cutoff })
-
-end
-
-# write out all resuls to .csv
-outfile = "#{opts.outfile}_assemblies.csv"
-logger.info "Writing analysis results to #{outfile}"
-CSV.open(outfile, 'wb') do |file|
-  keys = all[0].keys
-  keys.delete(:assembly)
-  head = [:assembly] + keys
-  file << head
-  all.each do |row|
-    file << head.map { |x|
-      entry = row[x]
-      entry.is_a?(Float) ? entry.round(5) : entry
-    }
-  end
-end
+cmdline = Cmdline.new ARGV
+cmdline.run

lib/transrate.rb

@@ -38,3 +38,4 @@ class TransrateArgError < TransrateError; end
 require 'transrate/comparative_metrics'
 require 'transrate/contig_metrics'
 require 'transrate/cmd'
+require 'transrate/cmdline'