miga-base 0.6.1.0 → 0.6.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1b7ff73c17fe13dbe5952bb607981bba291cf29d34c372157281339061036157
-  data.tar.gz: d5af6ded80c32042dbc3463fab085f2bc5c58ea9fc8755224baeb8d08f527ff1
+  metadata.gz: 2c317237c4cd2f049b56af6021272208c206f1810052dde4b1b5b41394f37139
+  data.tar.gz: '066558242d9bcc1a96f166349815398296cdb976190853a18ca52bdafe84c263'
 SHA512:
-  metadata.gz: b178fdfbe3ee23519fa7a6c23d15e6a9f393c1bea610124fa1ccf8245edbb3b95bb8ae9b46382eae3ca2e2664b1dd536fdd7a7c2b34c23cba35fb4e82c8a4123
-  data.tar.gz: 96e1ff434584528ae8dcf0b6435cc1dbe74a312eb9a1a1dbab86d7464dfe50eb38bced778caf0ef46446c11864495af4b8902ab76ac9700716f5d82ddf8370d9
+  metadata.gz: 50b395740f68543e7aa79bf0e3631cb86248fffbcd9aac942e2d30681579a42e528d552638701f153605f68ea9da389762b6d068455e9b67cbfd9b66cde879c0
+  data.tar.gz: d20fd84e71bd4d7a8ebf5ff1060e12096d78477b662098e013b88ea9a19e54b4665a71bbfa0e49fd57df47a61b3a0780ed469fcb004b1384dd4e4f2304320666

data/lib/miga/cli/action/daemon.rb

@@ -74,9 +74,8 @@ class MiGA::Cli::Action::Daemon < MiGA::Cli::Action
   def perform
     p = cli.load_project
     d = MiGA::Daemon.new(p, cli[:json])
-    [:latency, :maxjobs, :nodelist, :ppn, :shutdown_when_done].each do |k|
-      d.runopts(k, cli[k]) unless cli[k].nil?
-    end
+    dopts = %i[latency maxjobs nodelist ppn shutdown_when_done]
+    dopts.each { |k| d.runopts(k, cli[k]) }
     d.daemon(cli.operation, cli[:daemon_opts])
   end
 end

data/lib/miga/daemon.rb

@@ -22,15 +22,15 @@ class MiGA::Daemon < MiGA::MiGA
   # Array of all spawned daemons.
   $_MIGA_DAEMON_LAIR = []
 
-  # MiGA::Project in which the daemon is running.
+  # MiGA::Project in which the daemon is running
   attr_reader :project
-  # Options used to setup the daemon.
+  # Options used to setup the daemon
   attr_reader :options
-  # Array of jobs next to be executed.
+  # Array of jobs next to be executed
   attr_reader :jobs_to_run
-  # Array of jobs currently running.
+  # Array of jobs currently running
   attr_reader :jobs_running
-  # Integer indicating the current iteration.
+  # Integer indicating the current iteration
   attr_reader :loop_i
 
   ##
@@ -47,7 +47,7 @@ class MiGA::Daemon < MiGA::MiGA
     MiGA::Json.parse(
       json, default: File.expand_path('.miga_daemon.json', ENV['MIGA_HOME'])
     ).each { |k,v| runopts(k, v) }
-    update_format_0 unless runopts(:format_version)
+    update_format_0
     @jobs_to_run = []
     @jobs_running = []
     @loop_i = -1
@@ -68,21 +68,22 @@ class MiGA::Daemon < MiGA::MiGA
   end
 
   ##
-  # Launches the +task+ with options +opts+ (as command-line arguments).
-  # Supported tasks include: start, stop, restart, status.
-  def daemon(task, opts=[])
+  # Launches the +task+ with options +opts+ (as command-line arguments) and
+  # returns the process ID as an Integer. If +wait+ it waits for the process to
+  # complete, immediately returns otherwise.
+  # Supported tasks: start, stop, restart, status.
+  def daemon(task, opts = [], wait = true)
     MiGA.DEBUG "Daemon.daemon #{task} #{opts}"
     options = default_options
-    opts.unshift(task)
+    opts.unshift(task.to_s)
     options[:ARGV] = opts
     # This additional degree of separation below was introduced so the Daemons
     # package doesn't kill the parent process in workflows.
     pid = fork do 
-      Daemons.run_proc("MiGA:#{project.name}", options) do
-        loop { break unless in_loop }
-      end
+      Daemons.run_proc("MiGA:#{project.name}", options) { while in_loop; end }
     end
-    Process.wait pid
+    Process.wait(pid) if wait
+    pid
   end
 
   ##
@@ -130,13 +131,8 @@ class MiGA::Daemon < MiGA::MiGA
   # Traverse datasets
   def check_datasets
     project.each_dataset do |n, ds|
-      if ds.nil?
-        say "Warning: Dataset #{n} listed but not loaded, reloading project"
-        project.load
-      else
-        to_run = ds.next_preprocessing(false)
-        queue_job(:d, ds) unless to_run.nil?
-      end
+      to_run = ds.next_preprocessing(false)
+      queue_job(:d, ds) unless to_run.nil?
     end
   end
 
@@ -202,9 +198,9 @@ class MiGA::Daemon < MiGA::MiGA
     @jobs_running.select! do |job|
       ongoing = case job[:job].to_s
       when 'd'
-        not job[:ds].next_preprocessing(false).nil?
+        !job[:ds].next_preprocessing(false).nil?
       when 'p'
-        not project.next_task(nil, false).nil?
+        !project.next_task(nil, false).nil?
       else
         (job[:ds].nil? ? project : job[:ds]).add_result(job[:job], false).nil?
       end
@@ -221,16 +217,13 @@ class MiGA::Daemon < MiGA::MiGA
   end
 
   ##
-  # Retrieves the host index of an available node (if any), nil otherwise. If
-  # #nodelist is not set, returns true as long as #maxjobs is not reached
+  # In SSH daemons, retrieve the host index of an available node, nil if none.
+  # In any other daemons, returns true as long as #maxjobs is not reached
   def next_host
-    if nodelist.nil?
-      return jobs_running.size < maxjobs
-    end
+    return jobs_running.size < maxjobs if runopts(:type) != 'ssh'
     allk = (0 .. nodelist.size-1).to_a
     busyk = jobs_running.map { |k| k[:hostk] }
-    availk = allk - busyk
-    availk.empty? ? nil : availk.first
+    (allk - busyk).first
   end
 
   ##
@@ -248,7 +241,7 @@ class MiGA::Daemon < MiGA::MiGA
     project.load
     if loop_i == -1
       say '-----------------------------------'
-      say 'MiGA:%s launched.' % project.name
+      say 'MiGA:%s launched' % project.name
       say '-----------------------------------'
       load_status
       @loop_i = 0
@@ -286,54 +279,52 @@ class MiGA::Daemon < MiGA::MiGA
     File.unlink(f) if File.exist? f
   end
 
-  private
-
-    def launch_job(job, hostk = nil)
-      # Execute job
-      case runopts(:type)
-      when 'ssh'
-        # Remote job
-        job[:hostk] = hostk
-        job[:cmd] = job[:cmd].miga_variables(host: nodelist[hostk])
-        job[:pid] = spawn job[:cmd]
-        Process.detach job[:pid] unless [nil, '', 0].include?(job[:pid])
-      when 'bash'
-        # Local job
-        job[:pid] = spawn job[:cmd]
-        Process.detach job[:pid] unless [nil, '', 0].include?(job[:pid])
-      else
-        # Schedule cluster job (qsub, msub, slurm)
-        job[:pid] = `#{job[:cmd]}`.chomp
-      end
+  ##
+  # Launch the job described by Hash +job+ to +hostk+-th host
+  def launch_job(job, hostk = nil)
+    # Execute job
+    case runopts(:type)
+    when 'ssh'
+      # Remote job
+      job[:hostk] = hostk
+      job[:cmd] = job[:cmd].miga_variables(host: nodelist[hostk])
+      job[:pid] = spawn job[:cmd]
+      Process.detach job[:pid] unless [nil, '', 0].include?(job[:pid])
+    when 'bash'
+      # Local job
+      job[:pid] = spawn job[:cmd]
+      Process.detach job[:pid] unless [nil, '', 0].include?(job[:pid])
+    else
+      # Schedule cluster job (qsub, msub, slurm)
+      job[:pid] = `#{job[:cmd]}`.chomp
+    end
 
-      # Check if registered
-      if [nil, '', 0].include? job[:pid]
-        job[:pid] = nil
-        @jobs_to_run << job
-        say "Unsuccessful #{job[:task_name]}, rescheduling"
-      else
-        @jobs_running << job
-        say "Spawned pid:#{job[:pid]}#{
-              " to #{job[:hostk]}:#{nodelist[job[:hostk]]}" if job[:hostk]
-            } for #{job[:task_name]}"
-      end
+    # Check if registered
+    if [nil, '', 0].include? job[:pid]
+      job[:pid] = nil
+      @jobs_to_run << job
+      say "Unsuccessful #{job[:task_name]}, rescheduling"
+    else
+      @jobs_running << job
+      say "Spawned pid:#{job[:pid]}#{
+            " to #{job[:hostk]}:#{nodelist[job[:hostk]]}" if job[:hostk]
+          } for #{job[:task_name]}"
     end
+  end
 
-    def update_format_0
-      say 'Outdated daemon.json format, updating from version 0'
-      {
-        cmd: %w[script vars cpus log task_name],
-        var: %w[key value],
-        alive: %w[pid],
-        kill: %w[pid]
-      }.each do |k,v|
-        runopts(
-          k, sprintf(
-            runopts(k).gsub(/%(\d+)\$d/, '%\\1$s'),
-            *v.map{ |i| "{{#{i}}}" }
-          )
-        ) unless runopts(k).nil?
-      end
-      runopts(:format_version, 1)
+  ##
+  # Update from daemon JSON format 0 to the latest version
+  def update_format_0
+    {
+      cmd: %w[script vars cpus log task_name],
+      var: %w[key value],
+      alive: %w[pid],
+      kill: %w[pid]
+    }.each do |k,v|
+      runopts(
+        k, runopts(k).gsub(/%(\d+\$)?d/, '%\\1s') % v.map{ |i| "{{#{i}}}" }
+      ) if !runopts(k).nil? && runopts(k) =~ /%(\d+\$)?[ds]/
     end
+    runopts(:format_version, 1)
+  end
 end

data/lib/miga/dataset/result.rb

@@ -4,13 +4,12 @@ require 'miga/result'
 require 'miga/dataset/base'
 
 ##
-# Helper module including specific functions to add dataset results.
+# Helper module including specific functions to add dataset results
 module MiGA::Dataset::Result
-
   include MiGA::Dataset::Base
 
   ##
-  # Get the result MiGA::Result in this dataset identified by the symbol +k+.
+  # Get the result MiGA::Result in this dataset identified by the symbol +k+
   def result(k)
     return nil if @@RESULT_DIRS[k.to_sym].nil?
     MiGA::Result.load(
@@ -19,11 +18,13 @@ module MiGA::Dataset::Result
   end
 
   ##
-  # Get all the results (Array of MiGA::Result) in this dataset.
-  def results ; @@RESULT_DIRS.keys.map{ |k| result k }.compact ; end
+  # Get all the results (Array of MiGA::Result) in this dataset
+  def results
+    @@RESULT_DIRS.keys.map { |k| result k }.compact
+  end
 
   ##
-  # For each result executes the 2-ary +blk+ block: key symbol and MiGA::Result.
+  # For each result executes the 2-ary +blk+ block: key symbol and MiGA::Result
   def each_result(&blk)
     @@RESULT_DIRS.keys.each do |k|
       blk.call(k, result(k)) unless result(k).nil?
@@ -49,8 +50,9 @@ module MiGA::Dataset::Result
       r_pre = MiGA::Result.load("#{base}.json")
       return r_pre if (r_pre.nil? && !save) || !r_pre.nil?
     end
-    r = File.exist?("#{base}.done") ?
-        self.send("add_result_#{result_type}", base, opts) : nil
+    r = if File.exist?("#{base}.done")
+      self.send("add_result_#{result_type}", base, opts)
+    end
     unless r.nil?
       r.save
       pull_hook(:on_result_ready, result_type)
@@ -69,7 +71,7 @@ module MiGA::Dataset::Result
   # initial input. Passes +save+ to #add_result.
   def first_preprocessing(save = false)
     @first_processing ||= @@PREPROCESSING_TASKS.find do |t|
-      not ignore_task?(t) and not add_result(t, save).nil?
+      !ignore_task?(t) && !add_result(t, save).nil?
     end
   end
 
@@ -82,22 +84,22 @@ module MiGA::Dataset::Result
     return nil if first.nil?
     @@PREPROCESSING_TASKS.each do |t|
       next if ignore_task? t
-      if after_first and add_result(t, save).nil?
+      if after_first && add_result(t, save).nil?
         if (metadata["_try_#{t}"] || 0) > (project.metadata[:max_try] || 10)
           inactivate!
           return nil
         end
         return t
       end
-      after_first = (after_first or (t==first))
+      after_first = (after_first || (t == first))
     end
     nil
   end
 
   ##
-  # Are all the dataset-specific tasks done? Passes +save+ to #add_result.
+  # Are all the dataset-specific tasks done? Passes +save+ to #add_result
   def done_preprocessing?(save = false)
-    !first_preprocessing(save).nil? and next_preprocessing(save).nil?
+    !first_preprocessing(save).nil? && next_preprocessing(save).nil?
   end
 
   ##
@@ -114,8 +116,8 @@ module MiGA::Dataset::Result
     state = 0
     next_task = next_preprocessing(save)
     @@PREPROCESSING_TASKS.each do |task|
-      state = 1 if first_task==task
-      state = 2 if !next_task.nil? and next_task==task
+      state = 1 if first_task == task
+      state = 2 if !next_task.nil? && next_task == task
       adv << state
     end
     adv
@@ -144,23 +146,23 @@ module MiGA::Dataset::Result
   def result_status(task)
     if first_preprocessing.nil?
       :ignore_empty
-    elsif not get_result(task).nil?
+    elsif !get_result(task).nil?
       :complete
     elsif @@PREPROCESSING_TASKS.index(task) <
-            @@PREPROCESSING_TASKS.index(first_preprocessing)
+          @@PREPROCESSING_TASKS.index(first_preprocessing)
       :-
     elsif ignore_task?(task)
-      if not is_active?
+      if !is_active?
         :ignore_inactive
       elsif metadata["run_#{task}"]
         :ignore_force
-      elsif task == :taxonomy and project.metadata[:ref_project].nil?
+      elsif task == :taxonomy && project.metadata[:ref_project].nil?
         :ignore_project
-      elsif @@_EXCLUDE_NOREF_TASKS_H[task] && ! is_ref?
+      elsif @@_EXCLUDE_NOREF_TASKS_H[task] && !is_ref?
         :ignore_noref
-      elsif @@_ONLY_MULTI_TASKS_H[task] && ! is_multi?
+      elsif @@_ONLY_MULTI_TASKS_H[task] && !is_multi?
         :ignore_multi
-      elsif @@_ONLY_NONMULTI_TASKS_H[task] && ! is_nonmulti?
+      elsif @@_ONLY_NONMULTI_TASKS_H[task] && !is_nonmulti?
         :ignore_nonmulti
       else
         :ignore
@@ -169,7 +171,7 @@ module MiGA::Dataset::Result
       :pending
     end
   end
-  
+
   ##
   # Clean-up all the stored distances, removing values for datasets no longer in
   # the project as reference datasets.
@@ -179,7 +181,7 @@ module MiGA::Dataset::Result
     return if r.nil?
     [:haai_db, :aai_db, :ani_db].each do |db_type|
       db = r.file_path(db_type)
-      next if db.nil? or not File.size? db
+      next if db.nil? || !File.size?(db)
       sqlite_db = SQLite3::Database.new db
       table = db_type[-6..-4]
       val = sqlite_db.execute "select seq2 from #{table}"
@@ -192,220 +194,259 @@ module MiGA::Dataset::Result
 
   private
 
-    ##
-    # Add result type +:raw_reads+ at +base+ (no +_opts+ supported).
-    def add_result_raw_reads(base, _opts)
-      return nil unless result_files_exist?(base, '.1.fastq')
-      r = MiGA::Result.new("#{base}.json")
-      add_files_to_ds_result(r, name,
-        ( result_files_exist?(base, '.2.fastq') ?
-          {pair1: '.1.fastq', pair2: '.2.fastq'} :
-          {single: '.1.fastq'} ))
-    end
-
-    ##
-    # Add result type +:trimmed_reads+ at +base+ (no +_opts+ supported).
-    def add_result_trimmed_reads(base, _opts)
-      return nil unless result_files_exist?(base, ".1.clipped.fastq")
-      r = MiGA::Result.new("#{base}.json")
-      if result_files_exist?(base, ".2.clipped.fastq")
-        r = add_files_to_ds_result(r, name,
-          pair1: ".1.clipped.fastq", pair2: ".2.clipped.fastq",
-          single: ".1.clipped.single.fastq")
+  ##
+  # Add result type +:raw_reads+ at +base+ (no +_opts+ supported)
+  def add_result_raw_reads(base, _opts)
+    return nil unless result_files_exist?(base, '.1.fastq')
+    r = MiGA::Result.new("#{base}.json")
+    add_files_to_ds_result(
+      r, name,
+      if result_files_exist?(base, '.2.fastq')
+        { pair1: '.1.fastq', pair2: '.2.fastq' }
       else
-        r = add_files_to_ds_result(r, name, single: ".1.clipped.fastq")
+        { single: '.1.fastq' }
       end
-      r.add_file(:trimming_sumary, "#{name}.1.fastq.trimmed.summary.txt")
-      r
-    end
+    )
+  end
 
-    ##
-    # Add result type +:read_quality+ at +base+ (no +_opts+ supported).
-    def add_result_read_quality(base, _opts)
-      return nil unless result_files_exist?(base, %w[.solexaqa .fastqc])
-      r = MiGA::Result.new("#{base}.json")
-      add_files_to_ds_result(r, name,
-        solexaqa: ".solexaqa", fastqc: ".fastqc")
+  ##
+  # Add result type +:trimmed_reads+ at +base+ (no +_opts+ supported)
+  def add_result_trimmed_reads(base, _opts)
+    return nil unless result_files_exist?(base, '.1.clipped.fastq')
+    r = MiGA::Result.new("#{base}.json")
+    if result_files_exist?(base, '.2.clipped.fastq')
+      r = add_files_to_ds_result(r, name,
+        pair1: '.1.clipped.fastq',
+        pair2: '.2.clipped.fastq',
+        single: '.1.clipped.single.fastq')
+    else
+      r = add_files_to_ds_result(r, name, single: '.1.clipped.fastq')
     end
+    r.add_file(:trimming_sumary, "#{name}.1.fastq.trimmed.summary.txt")
+    r
+  end
 
-    ##
-    # Add result type +:trimmed_fasta+ at +base+ (no +_opts+ supported).
-    def add_result_trimmed_fasta(base, _opts)
-      return nil unless
-        result_files_exist?(base, ".CoupledReads.fa") or
-        result_files_exist?(base, ".SingleReads.fa") or
-        result_files_exist?(base, %w[.1.fasta .2.fasta])
-      r = MiGA::Result.new("#{base}.json")
-      add_files_to_ds_result(r, name, coupled: ".CoupledReads.fa",
-        single: ".SingleReads.fa", pair1: ".1.fasta", pair2: ".2.fasta")
-    end
+  ##
+  # Add result type +:read_quality+ at +base+ (no +_opts+ supported)
+  def add_result_read_quality(base, _opts)
+    return nil unless result_files_exist?(base, %w[.solexaqa .fastqc])
+    r = MiGA::Result.new("#{base}.json")
+    add_files_to_ds_result(r, name, solexaqa: '.solexaqa', fastqc: '.fastqc')
+  end
 
-    ##
-    # Add result type +:assembly+ at +base+. Hash +opts+ supports
-    # +is_clean: Boolean+.
-    def add_result_assembly(base, opts)
-      return nil unless result_files_exist?(base, ".LargeContigs.fna")
-      r = MiGA::Result.new("#{base}.json")
-      r = add_files_to_ds_result(r, name, largecontigs: ".LargeContigs.fna",
-        allcontigs: ".AllContigs.fna", assembly_data: '')
-      opts[:is_clean] ||= false
-      r.clean! if opts[:is_clean]
-      unless r.clean?
-        MiGA::MiGA.clean_fasta_file(r.file_path :largecontigs)
-        r.clean!
-      end
-      r
-    end
+  ##
+  # Add result type +:trimmed_fasta+ at +base+ (no +_opts+ supported)
+  def add_result_trimmed_fasta(base, _opts)
+    return nil unless
+      result_files_exist?(base, '.CoupledReads.fa') ||
+      result_files_exist?(base, '.SingleReads.fa')  ||
+      result_files_exist?(base, %w[.1.fasta .2.fasta])
+    r = MiGA::Result.new("#{base}.json")
+    add_files_to_ds_result(
+      r, name,
+      coupled: '.CoupledReads.fa',
+      single: '.SingleReads.fa',
+      pair1: '.1.fasta',
+      pair2: '.2.fasta')
+  end
 
-    ##
-    # Add result type +:cds+ at +base+. Hash +opts+ supports +is_clean: Boolean+
-    def add_result_cds(base, opts)
-      return nil unless result_files_exist?(base, %w[.faa])
-      r = MiGA::Result.new("#{base}.json")
-      r = add_files_to_ds_result(r, name, proteins: ".faa", genes: ".fna",
-        gff2: ".gff2", gff3: ".gff3", tab: ".tab")
-      opts[:is_clean] ||= false
-      r.clean! if opts[:is_clean]
-      unless r.clean?
-        MiGA::MiGA.clean_fasta_file(r.file_path :proteins)
-        MiGA::MiGA.clean_fasta_file(r.file_path :genes) if r.file_path :genes
-        r.clean!
-      end
-      r
+  ##
+  # Add result type +:assembly+ at +base+. Hash +opts+ supports
+  # +is_clean: Boolean+.
+  def add_result_assembly(base, opts)
+    return nil unless result_files_exist?(base, '.LargeContigs.fna')
+    r = MiGA::Result.new("#{base}.json")
+    r = add_files_to_ds_result(
+      r, name,
+      largecontigs: '.LargeContigs.fna',
+      allcontigs: '.AllContigs.fna',
+      assembly_data: '')
+    opts[:is_clean] ||= false
+    r.clean! if opts[:is_clean]
+    unless r.clean?
+      MiGA::MiGA.clean_fasta_file(r.file_path(:largecontigs))
+      r.clean!
     end
+    r
+  end
 
-    ##
-    # Add result type +:essential_genes+ at +base+ (no +_opts+ supported).
-    def add_result_essential_genes(base, _opts)
-      return nil unless result_files_exist?(base, %w[.ess.faa .ess .ess/log])
-      r = MiGA::Result.new("#{base}.json")
-      add_files_to_ds_result(r, name, ess_genes: '.ess.faa',
-        collection: '.ess', report: '.ess/log', alignments: '.ess/proteins.aln')
+  ##
+  # Add result type +:cds+ at +base+. Hash +opts+ supports +is_clean: Boolean+
+  def add_result_cds(base, opts)
+    return nil unless result_files_exist?(base, %w[.faa])
+    r = MiGA::Result.new("#{base}.json")
+    r = add_files_to_ds_result(
+      r, name,
+      proteins: '.faa',
+      genes: '.fna',
+      gff2: '.gff2',
+      gff3: '.gff3',
+      tab: '.tab')
+    opts[:is_clean] ||= false
+    r.clean! if opts[:is_clean]
+    unless r.clean?
+      MiGA::MiGA.clean_fasta_file(r.file_path(:proteins))
+      MiGA::MiGA.clean_fasta_file(r.file_path(:genes)) if r.file_path(:genes)
+      r.clean!
     end
+    r
+  end
 
-    ##
-    # Add result type +:ssu+ at +base+. Hash +opts+ supports +is_clean: Boolean+
-    def add_result_ssu(base, opts)
-      return MiGA::Result.new("#{base}.json") if result(:assembly).nil?
-      return nil unless result_files_exist?(base, ".ssu.fa")
-      r = MiGA::Result.new("#{base}.json")
-      r = add_files_to_ds_result(r, name, longest_ssu_gene: ".ssu.fa",
-        gff: ".ssu.gff", all_ssu_genes: ".ssu.all.fa")
-      opts[:is_clean] ||= false
-      r.clean! if opts[:is_clean]
-      unless r.clean?
-        MiGA::MiGA.clean_fasta_file(r.file_path :longest_ssu_gene)
-        r.clean!
-      end
-      r
+  ##
+  # Add result type +:essential_genes+ at +base+ (no +_opts+ supported).
+  def add_result_essential_genes(base, _opts)
+    return nil unless result_files_exist?(base, %w[.ess.faa .ess .ess/log])
+    r = MiGA::Result.new("#{base}.json")
+    add_files_to_ds_result(
+      r, name,
+      ess_genes: '.ess.faa',
+      collection: '.ess',
+      report: '.ess/log',
+      alignments: '.ess/proteins.aln')
+  end
+
+  ##
+  # Add result type +:ssu+ at +base+. Hash +opts+ supports +is_clean: Boolean+
+  def add_result_ssu(base, opts)
+    return MiGA::Result.new("#{base}.json") if result(:assembly).nil?
+    return nil unless result_files_exist?(base, '.ssu.fa')
+    r = MiGA::Result.new("#{base}.json")
+    r = add_files_to_ds_result(
+      r, name,
+      longest_ssu_gene: '.ssu.fa',
+      gff: '.ssu.gff',
+      all_ssu_genes: '.ssu.all.fa')
+    opts[:is_clean] ||= false
+    r.clean! if opts[:is_clean]
+    unless r.clean?
+      MiGA::MiGA.clean_fasta_file(r.file_path(:longest_ssu_gene))
+      r.clean!
     end
+    r
+  end
 
-    ##
-    # Add result type +:mytaxa+ at +base+ (no +_opts+ supported).
-    def add_result_mytaxa(base, _opts)
-      if is_multi?
-        return nil unless result_files_exist?(base, '.mytaxa') or
-          result_files_exist?(base, '.nomytaxa.txt')
-        r = MiGA::Result.new("#{base}.json")
-        add_files_to_ds_result(
-          r, name,
-          mytaxa: '.mytaxa', blast: '.blast',
-          mytaxain: '.mytaxain', nomytaxa: '.nomytaxa.txt',
-          species: '.mytaxa.Species.txt', genus: '.mytaxa.Genus.txt',
-          phylum: '.mytaxa.Phylum.txt', innominate: '.mytaxa.innominate',
-          kronain: '.mytaxa.krona', krona: '.html'
-        )
-      else
-        MiGA::Result.new("#{base}.json")
-      end
+  ##
+  # Add result type +:mytaxa+ at +base+ (no +_opts+ supported)
+  def add_result_mytaxa(base, _opts)
+    if is_multi?
+      return nil unless
+        result_files_exist?(base, '.mytaxa') ||
+        result_files_exist?(base, '.nomytaxa.txt')
+      r = MiGA::Result.new("#{base}.json")
+      add_files_to_ds_result(
+        r, name,
+        mytaxa: '.mytaxa',
+        blast: '.blast',
+        mytaxain: '.mytaxain',
+        nomytaxa: '.nomytaxa.txt',
+        species: '.mytaxa.Species.txt',
+        genus: '.mytaxa.Genus.txt',
+        phylum: '.mytaxa.Phylum.txt',
+        innominate: '.mytaxa.innominate',
+        kronain: '.mytaxa.krona',
+        krona: '.html')
+    else
+      MiGA::Result.new("#{base}.json")
     end
+  end
 
-    ##
-    # Add result type +:mytaxa_scan+ at +base+ (no +_opts+ supported).
-    def add_result_mytaxa_scan(base, _opts)
-      if is_nonmulti?
-        return nil unless
-          result_files_exist?(base, %w[.pdf .mytaxa]) or
-          result_files_exist?(base, '.nomytaxa.txt')
-        r = MiGA::Result.new("#{base}.json")
-        add_files_to_ds_result(r, name, nomytaxa: '.nomytaxa.txt',
-          mytaxa: '.mytaxa', report: '.pdf', regions_archive: '.reg.tar',
-          # Intermediate / Deprecated
-          blast: '.blast', mytaxain: '.mytaxain', wintax: '.wintax',
-          gene_ids: '.wintax.genes', region_ids: '.wintax.regions',
-          regions: '.reg')
-      else
-        MiGA::Result.new("#{base}.json")
-      end
+  ##
+  # Add result type +:mytaxa_scan+ at +base+ (no +_opts+ supported)
+  def add_result_mytaxa_scan(base, _opts)
+    if is_nonmulti?
+      return nil unless
+        result_files_exist?(base, %w[.pdf .mytaxa]) ||
+        result_files_exist?(base, '.nomytaxa.txt')
+      r = MiGA::Result.new("#{base}.json")
+      add_files_to_ds_result(
+        r, name,
+        nomytaxa: '.nomytaxa.txt',
+        mytaxa: '.mytaxa',
+        report: '.pdf',
+        regions_archive: '.reg.tar',
+        # Intermediate / Deprecated:
+        blast: '.blast',
+        mytaxain: '.mytaxain',
+        wintax: '.wintax',
+        gene_ids: '.wintax.genes',
+        region_ids: '.wintax.regions',
+        regions: '.reg')
+    else
+      MiGA::Result.new("#{base}.json")
     end
+  end
 
-    ##
-    # Add result type +:distances+ at +base+ (no +_opts+ supported).
-    def add_result_distances(base, _opts)
-      if is_nonmulti?
-        if is_ref?
-          add_result_distances_ref(base)
-        else
-          add_result_distances_nonref(base)
-        end
+  ##
+  # Add result type +:distances+ at +base+ (no +_opts+ supported)
+  def add_result_distances(base, _opts)
+    if is_nonmulti?
+      if is_ref?
+        add_result_distances_ref(base)
       else
-        add_result_distances_multi(base)
+        add_result_distances_nonref(base)
       end
+    else
+      add_result_distances_multi(base)
     end
+  end
 
-    ##
-    # Add result type +:taxonomy+ at +base+ (no +_opts+ supported).
-    def add_result_taxonomy(base, _opts)
-      add_result_distances_nonref(base)
-    end
-
-    ##
-    # Add result type +:stats+ at +base+ (no +_opts+ supported).
-    def add_result_stats(base, _opts)
-      MiGA::Result.new("#{base}.json")
-    end
+  ##
+  # Add result type +:taxonomy+ at +base+ (no +_opts+ supported)
+  def add_result_taxonomy(base, _opts)
+    add_result_distances_nonref(base)
+  end
 
-    ##
-    # Add result type +:distances+ for _multi_ datasets at +base+.
-    def add_result_distances_multi(base)
-      MiGA::Result.new("#{base}.json")
-    end
+  ##
+  # Add result type +:stats+ at +base+ (no +_opts+ supported)
+  def add_result_stats(base, _opts)
+    MiGA::Result.new("#{base}.json")
+  end
 
-    ##
-    # Add result type +:distances+ for _nonmulti_ reference datasets at +base+.
-    def add_result_distances_ref(base)
-      pref = File.dirname(base)
-      return nil unless
-        File.exist?("#{pref}/01.haai/#{name}.db")
-      r = MiGA::Result.new("#{base}.json")
-      r.add_files(haai_db: "01.haai/#{name}.db", aai_db: "02.aai/#{name}.db",
-        ani_db: "03.ani/#{name}.db")
-      r
-    end
+  ##
+  # Add result type +:distances+ for _multi_ datasets at +base+
+  def add_result_distances_multi(base)
+    MiGA::Result.new("#{base}.json")
+  end
 
-    ##
-    # Add result type +:distances+ for _nonmulti_ query datasets at +base+.
-    def add_result_distances_nonref(base)
-      return nil unless
-        result_files_exist?(base, %w[.aai-medoids.tsv .aai.db]) or
-        result_files_exist?(base, %w[.ani-medoids.tsv .ani.db])
-      r = MiGA::Result.new("#{base}.json")
-      add_files_to_ds_result(
-        r, name,
-        aai_medoids: '.aai-medoids.tsv',
-        haai_db: '.haai.db', aai_db: '.aai.db', ani_medoids: '.ani-medoids.tsv',
-        ani_db: '.ani.db', ref_tree: '.nwk', ref_tree_pdf: '.nwk.pdf',
-        intax_test: '.intax.txt'
+  ##
+  # Add result type +:distances+ for _nonmulti_ reference datasets at +base+
+  def add_result_distances_ref(base)
+    pref = File.dirname(base)
+    return nil unless File.exist?("#{pref}/01.haai/#{name}.db")
+    MiGA::Result.new("#{base}.json").tap do |r|
+      r.add_files(
+        haai_db: "01.haai/#{name}.db",
+        aai_db: "02.aai/#{name}.db",
+        ani_db: "03.ani/#{name}.db"
       )
     end
+  end
 
-    ##
-    # Add files in +rel_files+ Hash to the result +r+ with dataset name +name+.
-    def add_files_to_ds_result(r, name, rel_files)
-      files = {}
-      rel_files.each{ |k,v| files[k] = name + v }
-      r.add_files(files)
-      r
-    end
+  ##
+  # Add result type +:distances+ for _nonmulti_ query datasets at +base+
+  def add_result_distances_nonref(base)
+    return nil unless
+      result_files_exist?(base, %w[.aai-medoids.tsv .aai.db]) ||
+      result_files_exist?(base, %w[.ani-medoids.tsv .ani.db])
+    r = MiGA::Result.new("#{base}.json")
+    add_files_to_ds_result(
+      r, name,
+      aai_medoids: '.aai-medoids.tsv',
+      haai_db: '.haai.db',
+      aai_db: '.aai.db',
+      ani_medoids: '.ani-medoids.tsv',
+      ani_db: '.ani.db',
+      ref_tree: '.nwk',
+      ref_tree_pdf: '.nwk.pdf',
+      intax_test: '.intax.txt')
+  end
 
+  ##
+  # Add files in +rel_files+ Hash to the result +r+ with dataset name +name+
+  def add_files_to_ds_result(r, name, rel_files)
+    files = {}
+    rel_files.each { |k, v| files[k] = name + v }
+    r.add_files(files)
+    r
+  end
 end

data/lib/miga/project/dataset.rb

@@ -25,7 +25,7 @@ module MiGA::Project::Dataset
   end
 
   ##
-  # Returns MiGA::Dataset.
+  # Returns MiGA::Dataset
   def dataset(name)
     name = name.miga_name
     return nil unless MiGA::Dataset.exist?(self, name)

data/lib/miga/version.rb

@@ -10,7 +10,7 @@ module MiGA
   # - Float representing the major.minor version.
   # - Integer representing gem releases of the current version.
   # - Integer representing minor changes that require new version number.
-  VERSION = [0.6, 1, 0]
+  VERSION = [0.6, 2, 0]
 
   ##
   # Nickname for the current major.minor version.
@@ -18,7 +18,7 @@ module MiGA
 
   ##
   # Date of the current gem release.
-  VERSION_DATE = Date.new(2020, 3, 10)
+  VERSION_DATE = Date.new(2020, 3, 11)
 
   ##
   # Reference of MiGA.

data/test/common_test.rb

@@ -71,14 +71,6 @@ class CommonTest < Test::Unit::TestCase
     FileUtils.rm_rf $tmp
   end
 
-  def test_tabulate
-    tab = MiGA::MiGA.tabulate(%w[a b], [%w[123 45], %w[678 90]])
-    assert_equal('  a  b ', tab[0])
-    assert_equal('  -  - ', tab[1])
-    assert_equal('123  45', tab[2])
-    assert_equal('678  90', tab[3])
-  end
-
   def test_miga_name
     assert_equal('Xa sp. C', 'Xa_sp__C'.unmiga_name)
     assert_equal('X_______', 'X^*.!{}!'.miga_name)

data/test/daemon_test.rb

@@ -11,7 +11,7 @@ class DaemonTest < Test::Unit::TestCase
     daemon_json = File.expand_path('.miga_daemon.json', ENV['MIGA_HOME'])
     File.open(daemon_json, 'w') do |fh|
       fh.puts '{"maxjobs":1,"ppn":1,"latency":2,"varsep":" ",
-        "var":"{{key}}={{value}}","cmd":"{{task_name}}",
+        "var":"{{key}}={{value}}","cmd":"echo {{task_name}} >/dev/null",
         "alive":"echo 1 # {{pid}}","type":"bash","format_version":1}'
     end
     $p1 = MiGA::Project.new(File.expand_path('project1', $tmp))
@@ -23,7 +23,30 @@ class DaemonTest < Test::Unit::TestCase
     ENV['MIGA_HOME'] = nil
   end
 
+  def helper_datasets_with_results(n = 1)
+    p1 = $p1
+    Array.new(n) do |i|
+      d = "d#{i}"
+      FileUtils.touch(File.expand_path(
+        "data/02.trimmed_reads/#{d}.1.clipped.fastq", p1.path
+      ))
+      FileUtils.touch(File.expand_path(
+        "data/02.trimmed_reads/#{d}.done", p1.path
+      ))
+      p1.add_dataset(MiGA::Dataset.new(p1, d, true).name).tap do |ds|
+        ds.first_preprocessing(true)
+      end
+    end
+  end
+
   def test_check_project
+    d1 = $d1
+    helper_datasets_with_results.first.inactivate!
+    out = capture_stdout { d1.check_project }
+    assert(out.string =~ /Queueing miga-project:p/)
+    assert_equal(1, d1.jobs_to_run.size)
+    assert_equal(:p, d1.jobs_to_run.first[:job])
+    assert_equal('project1:p:miga-project', d1.get_job(:p)[:task_name])
   end
 
   def test_check_datasets
@@ -48,7 +71,7 @@ class DaemonTest < Test::Unit::TestCase
     end
     assert(out.string =~ /Queueing #{ds.name}:d/)
     assert_equal(1, d.jobs_to_run.size)
-    assert_equal('project1:d:ds1', d.jobs_to_run.first[:cmd])
+    assert_equal('echo project1:d:ds1 >/dev/null', d.jobs_to_run.first[:cmd])
     assert_equal(d.jobs_to_run.first, d.get_job(:d, ds))
   end
 
@@ -74,11 +97,16 @@ class DaemonTest < Test::Unit::TestCase
     d.runopts(:latency, 0, true)
     assert_equal(0, d.latency)
     omit_if($jruby_tests, 'JRuby doesn\'t implement fork.')
-    $child = fork { d.start(['--shush']) }
+    child = $child = d.daemon(:start, ['--shush'])
+    assert(child.is_a? Integer)
+    assert(child != 0, 'The daemond process should have non-zero PID')
+    assert_equal(0, `ps -p "#{child}" -o ppid=`.strip.to_i,
+      'The daemon process should be detached')
     sleep(3)
-    dpath = File.expand_path("daemon/MiGA:#{p.name}",p.path)
+    dpath = File.join(p.path, 'daemon', "MiGA:#{p.name}")
     assert(File.exist?("#{dpath}.pid"))
     out = capture_stdout { d.stop }
+    assert_raise(Errno::ESRCH) { Process.kill(0, child) }
     assert_equal('', out.string)
     assert(!File.exist?("#{dpath}.pid"))
     assert(File.exist?("#{dpath}.output"))
@@ -90,7 +118,11 @@ class DaemonTest < Test::Unit::TestCase
       assert(l[3] =~ /Probing running jobs\n/)
     end
   ensure
-    Process.kill('KILL', $child) unless $child.nil?
+    begin
+      Process.kill('KILL', $child) if !$child.nil?
+    rescue Errno::ESRCH
+      false
+    end
   end
 
   def test_last_alive
@@ -102,18 +134,19 @@ class DaemonTest < Test::Unit::TestCase
   end
 
   def test_options
-    assert_respond_to($d1, :default_options)
-    assert_equal(:normal, $d1.default_options[:dir_mode])
-    assert_equal(2, $d1.runopts(:latency))
-    assert_equal(1, $d1.maxjobs)
-    assert_equal(2, $d1.latency)
-    assert_equal(1, $d1.ppn)
-    $d1.runopts(:alo, :ha)
-    assert_equal(:ha, $d1.runopts(:alo))
-    $d1.runopts(:maxjobs, '1')
-    assert_equal(1, $d1.maxjobs)
-    assert_raise { $d1.runopts(:latency, '!') }
-    assert_equal('bash', $d1.runopts(:type))
+    d1 = $d1
+    assert_respond_to(d1, :default_options)
+    assert_equal(:normal, d1.default_options[:dir_mode])
+    assert_equal(2, d1.runopts(:latency))
+    assert_equal(1, d1.maxjobs)
+    assert_equal(2, d1.latency)
+    assert_equal(1, d1.ppn)
+    d1.runopts(:alo, :ha)
+    assert_equal(:ha, d1.runopts(:alo))
+    d1.runopts(:maxjobs, '1')
+    assert_equal(1, d1.maxjobs)
+    assert_raise { d1.runopts(:latency, '!') }
+    assert_equal('bash', d1.runopts(:type))
   end
 
   def test_say
@@ -130,4 +163,153 @@ class DaemonTest < Test::Unit::TestCase
     assert_nil(d.last_alive)
   end
 
+  def test_maxjobs_json
+    d1 = $d1
+    helper_datasets_with_results(3)
+    assert_equal(0, d1.jobs_running.size)
+    assert_equal(0, d1.jobs_to_run.size)
+    capture_stdout { d1.in_loop }
+    assert_equal(1, d1.jobs_running.size)
+    assert_equal(2, d1.jobs_to_run.size)
+  end
+
+  def test_maxjobs_runopts
+    d1 = $d1
+    helper_datasets_with_results(3)
+    d1.runopts(:maxjobs, 2)
+    assert_equal(0, d1.jobs_running.size)
+    assert_equal(0, d1.jobs_to_run.size)
+    capture_stdout { d1.in_loop }
+    assert_equal(2, d1.jobs_running.size)
+    assert_equal(1, d1.jobs_to_run.size)
+  end
+
+  def test_load_status
+    d1 = $d1
+    p1 = $p1
+    assert_equal(0, d1.jobs_running.size)
+    assert_nil(d1.load_status)
+    assert_equal(0, d1.jobs_running.size)
+    p1.add_dataset(MiGA::Dataset.new(p1, 'd1').name)
+    f = File.join(p1.path, 'daemon', 'status.json')
+    File.open(f, 'w') do |h|
+      h.puts '{"jobs_running":[{"ds":1,"ds_name":"d1"},{}],"jobs_to_run":[]}'
+    end
+    out = capture_stdout { d1.load_status }
+    assert_equal(2, d1.jobs_running.size)
+    assert(out.string =~ /Loading previous status/)
+    assert_equal(MiGA::Dataset, d1.jobs_running[0][:ds].class)
+    assert_nil(d1.jobs_running[1][:ds])
+  end
+
+  def test_flush
+    d1 = $d1
+    p1 = $p1
+    helper_datasets_with_results
+    p1.add_dataset(MiGA::Dataset.new(p1, 'd1').name)
+    MiGA::Project.RESULT_DIRS.keys.each { |i| p1.metadata["run_#{i}"] = false }
+    f = File.join(p1.path, 'daemon', 'status.json')
+    File.open(f, 'w') do |h|
+      h.puts '{"jobs_running":' \
+        '[{"job":"p"},{"job":"d","ds":1,"ds_name":"d1"},' \
+        '{"job":"trimmed_reads","ds":1,"ds_name":"d0"}]' \
+        ',"jobs_to_run":[]}'
+    end
+    capture_stdout { d1.load_status }
+    assert_equal(3, d1.jobs_running.size)
+    out = capture_stdout { d1.flush! }
+    assert(out.string =~ /Completed pid:/)
+    assert_equal([], d1.jobs_running)
+  end
+
+  def test_next_host
+    d1 = $d1
+    f = File.join($tmp, 'nodes.txt')
+    File.open(f, 'w') { |h| h.puts 'localhost' }
+    assert_equal(true, d1.next_host)
+    out = capture_stdout { d1.runopts(:nodelist, f) }
+    assert(out.string =~ /Reading node list:/)
+    assert_equal(true, d1.next_host)
+    d1.runopts(:type, 'ssh')
+    assert_equal(0, d1.next_host)
+    f = File.join($p1.path, 'daemon', 'status.json')
+    File.open(f, 'w') do |h|
+      h.puts '{"jobs_running":[{"job":"p","hostk":0}], "jobs_to_run":[]}'
+    end
+    capture_stdout { d1.load_status }
+    assert_nil(d1.next_host)
+  end
+
+  def test_shutdown_when_done
+    $d1.runopts(:shutdown_when_done, true)
+    out = capture_stdout { assert(!$d1.in_loop) }
+    assert(out.string =~ /Nothing else to do/)
+  end
+
+  def test_update_format_0
+    f = File.join($tmp, 'daemon.json')
+    File.open(f, 'w') do |fh|
+      fh.puts '{"maxjobs":1,"ppn":1,"latency":2,"varsep":" ",
+        "var":"%1$s=%1$s","cmd":"echo %1$s","alive":"echo %1$d","type":"bash"}'
+    end
+    d2 = MiGA::Daemon.new($p1, f)
+    assert_equal('echo {{script}}', d2.runopts(:cmd))
+    assert_equal('echo {{pid}}', d2.runopts(:alive))
+  end
+
+  def test_launch_job_bash
+    t = File.join($tmp, 'launch_job_bash')
+    $d1.runopts(:type, 'bash')
+    $d1.runopts(:cmd, "echo {{task_name}} > '#{t}'")
+    helper_daemon_launch_job
+    assert_equal("project1:p:miga-project\n", File.read(t))
+  end
+
+  def test_launch_job_ssh
+    d1 = $d1
+    t = File.join($tmp, 'launch_job_ssh')
+    d1.runopts(:type, 'ssh')
+    d1.runopts(:cmd, "echo {{task_name}} > '#{t}'")
+    f = File.join($tmp, 'nodes.txt')
+    File.open(f, 'w') { |h| h.puts 'localhost' }
+    assert_raise('Unset environment variable: $MIGA_TEST_NODELIST') do
+      d1.runopts(:nodelist, '$MIGA_TEST_NODELIST')
+    end
+    ENV['MIGA_TEST_NODELIST'] = f
+    capture_stdout { d1.runopts(:nodelist, '$MIGA_TEST_NODELIST') }
+    helper_daemon_launch_job
+    assert_equal("project1:p:miga-project\n", File.read(t))
+  end
+
+  def test_launch_job_qsub
+    $d1.runopts(:type, 'qsub')
+    $d1.runopts(:cmd, 'echo {{task_name}}')
+    helper_daemon_launch_job
+    assert_equal('project1:p:miga-project', $d1.jobs_running.first[:pid])
+  end
+
+  def test_launch_job_failure
+    d1 = $d1
+    d1.runopts(:type, 'qsub')
+    d1.runopts(:cmd, 'echo ""')
+    helper_datasets_with_results.first.inactivate!
+    capture_stdout { d1.check_project }
+    out = capture_stdout { d1.launch_job(d1.jobs_to_run.shift) }
+    assert(out.string =~ /Unsuccessful project1:p:miga-project, rescheduling/)
+    assert_equal(0, d1.jobs_running.size)
+    assert_equal(1, d1.jobs_to_run.size)
+  end
+
+  def helper_daemon_launch_job
+    d1 = $d1
+    helper_datasets_with_results.first.inactivate!
+    assert_equal(0, d1.jobs_to_run.size, 'The queue should be empty')
+    capture_stdout { d1.check_project }
+    assert_equal(1, d1.jobs_to_run.size, 'The queue should have one job')
+    capture_stdout { d1.flush! }
+    sleep(1)
+    assert_equal(0, d1.jobs_to_run.size, 'There should be nothing running')
+    assert_equal(1, d1.jobs_running.size, 'There should be one job running')
+  end
+
 end

data/test/format_test.rb

@@ -0,0 +1,88 @@
+require 'test_helper'
+
+class FormatTest < Test::Unit::TestCase
+
+  def setup
+    $tmp = Dir.mktmpdir
+  end
+
+  def teardown
+    FileUtils.rm_rf $tmp
+  end
+
+  def helper_write_file(content)
+    f = File.join($tmp, 'f.fa')
+    File.open(f, 'w') { |h| h.print content }
+    f
+  end
+
+  def test_clean_fasta
+    c = ">MyFa|not-good\nACTG123ACTG-XXNN*\n>GoodOne + spaces!\n\nA C T G .\n"
+    cc = ">MyFa|not_good\nACTGACTG-XXNN\n>GoodOne + spaces!\nACTG.\n"
+    f = helper_write_file(c)
+    assert_equal(c, File.read(f))
+    MiGA::MiGA.clean_fasta_file(f)
+    assert_equal(cc, File.read(f))
+  end
+
+  def test_wrap_fasta
+    c = ">MyFa\n" + ('X' * 150)
+    cc = ">MyFa\n" + ('X' * 80) + "\n" + ('X' * 70) + "\n"
+    f = helper_write_file(c)
+    assert_equal(c, File.read(f))
+    MiGA::MiGA.clean_fasta_file(f)
+    assert_equal(cc, File.read(f))
+  end
+
+  def test_gz_fasta
+    c = ">a-\na"
+    cc = ">a_\na\n"
+    f = helper_write_file(c)
+    assert_equal(c, File.read(f))
+    `gzip "#{f}"`
+    MiGA::MiGA.clean_fasta_file("#{f}.gz")
+    `gzip -d "#{f}.gz"`
+    assert_equal(cc, File.read(f))
+  end
+
+  def test_seqs_length_fasta
+    c = ">a\nACA\n>b\nACG\n>c\nACTGA\n>d\nGTGAG\n"
+    f = helper_write_file(c)
+    o = MiGA::MiGA.seqs_length(f, :fasta)
+    assert_equal(4.0, o[:avg])
+    assert_equal(1.0, o[:var])
+    assert_equal(1.0, o[:sd])
+    assert_nil(o[:gc])
+    assert_nil(o[:n50])
+    assert_nil(o[:med])
+    o = MiGA::MiGA.seqs_length(f, :fasta, gc: true)
+    assert_equal(50.0, o[:gc])
+    assert_nil(o[:n50])
+    o = MiGA::MiGA.seqs_length(f, :fasta, n50: true)
+    assert_nil(o[:gc])
+    assert_equal(5, o[:n50])
+    o = MiGA::MiGA.seqs_length(f, :fasta, gc: true, n50: true)
+    assert_equal(50.0, o[:gc])
+    assert_equal(5, o[:n50])
+    assert_equal(4.0, o[:med])
+  end
+
+  def test_seqs_length_fastq
+    c = "@a\nac\n+\n!!\n@b\ntggg\n+\n####\n@c\nngt\n+\n!!!\n"
+    f = helper_write_file(c)
+    o = MiGA::MiGA.seqs_length(f, :fastq)
+    assert_equal(3.0, o[:avg])
+    assert_nil(o[:med])
+    o = MiGA::MiGA.seqs_length(f, :fastq, n50: true)
+    assert_equal(3, o[:med])
+  end
+  
+  def test_tabulate
+    tab = MiGA::MiGA.tabulate(%w[a b], [%w[123 45], %w[678 90]])
+    assert_equal('  a  b ', tab[0])
+    assert_equal('  -  - ', tab[1])
+    assert_equal('123  45', tab[2])
+    assert_equal('678  90', tab[3])
+  end
+
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: miga-base
 version: !ruby/object:Gem::Version
-  version: 0.6.1.0
+  version: 0.6.2.0
 platform: ruby
 authors:
 - Luis M. Rodriguez-R
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2020-03-10 00:00:00.000000000 Z
+date: 2020-03-11 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: daemons
@@ -193,6 +193,7 @@ files:
 - test/common_test.rb
 - test/daemon_test.rb
 - test/dataset_test.rb
+- test/format_test.rb
 - test/hook_test.rb
 - test/json_test.rb
 - test/metadata_test.rb