bioroebe 0.10.80 → 0.12.12

data/lib/bioroebe/shell/show_report_and_display.rb

@@ -1,2901 +0,0 @@
-#!/usr/bin/ruby -w
-# Encoding: UTF-8
-# frozen_string_literal: true
-# =========================================================================== #
-# require 'bioroebe/shell/show_report_and_display.rb'
-# =========================================================================== #
-module Bioroebe
-
-class Shell < ::Bioroebe::CommandlineApplication
-
-  require 'bioroebe/shell/search.rb'
-  require 'bioroebe/codons/show_codon_usage.rb'
-  require 'bioroebe/codons/show_this_codon_table.rb'
-  require 'bioroebe/count/count_amount_of_aminoacids.rb'
-
-  # ========================================================================= #
-  # === report_main_sequence
-  #
-  # We will call dna_with_ends() here in this method. The argument colourize will
-  # determine whether we will colourize the DNA strand or not.
-  #
-  # Invocation examples:
-  #
-  #    report_main_sequence(::Bioroebe.start_codon?)
-  #    report_main_sequence(:start_codon) # ← is the same as the ^^^ above
-  #    report_main_sequence(:stop_codon)  # ← Colourize the stop-codons.
-  #
-  # ========================================================================= #
-  def report_main_sequence(
-      colourize = nil,
-      input     = dna_sequence_as_string?
-    )
-    case colourize
-    # ======================================================================= #
-    # === :stop_codon
-    #
-    # We attempt to colourize the stop-codons via this method.
-    # ======================================================================= #
-    when :stop_codon
-      colourize = stop_codons?
-    # ======================================================================= #
-    # === :stop_codon_in_frame1
-    # ======================================================================= #
-    when :stop_codon_in_frame1
-      new_string = remove_trailing_escape_code(
-        colour_for_nucleotides(
-          ''.dup
-        ).dup
-      ).dup
-      scanned = input.scan(/.../)
-      scanned.each {|codon|
-        if is_a_stop_codon? codon
-          new_string << colour_for_stop_codon(codon.dup).dup+
-                        remove_trailing_escape_code(
-                          colour_for_nucleotides
-                        )
-        else
-          new_string << codon.dup
-        end
-      }
-      e padding?+
-        rev+
-        leading_five_prime+
-        new_string+
-        rev+
-        trailing_three_prime
-      return
-    # ======================================================================= #
-    # === :start_codon
-    # ======================================================================= #
-    when :start_codon # Instruction to use a start codon here.
-      colourize = start_codon?
-    # ======================================================================= #
-    # === :start_and_stop_codon
-    # ======================================================================= #
-    when :start_and_stop_codon
-      colourize = [start_codon?, stop_codons?]
-    end
-    # ======================================================================= #
-    # The old code was:
-    #   erev padding?+
-    #        dna_with_ends(input, colourize) { :honour_coding_area_if_it_exists } # The dna_with_ends() method can deal with Arrays.
-    # This is now mostly ported (April 2020), but the :honour_coding_area_if_it_exists
-    # is not yet ported, so the above code will remain as-is, for the time
-    # being.
-    # ======================================================================= #
-    show_nucleotide_sequence?.report_this_sequence(input) {{
-      padding_to_use: padding?,
-      colourize_this_subsequence: colourize
-    }}
-  end; alias show_main_string         report_main_sequence # === show_main_string
-       alias show_main_sequence       report_main_sequence # === show_main_sequence
-       alias show_colourized_sequence report_main_sequence # === show_colourized_sequence
-       alias show_dna_sequence        report_main_sequence # === show_dna_sequence
-
-  # ========================================================================= #
-  # === show_composition
-  #
-  # This method will analyse the DNA string composition.
-  #
-  # Invocation example:
-  #
-  #   scompo
-  #
-  # ========================================================================= #
-  def show_composition(
-      i = dna_string?
-    )
-    length = i.size
-    report_size_of_main_string
-    hash = ::Bioroebe::CountAmountOfNucleotides.show_composition(i) # bl count_nucleotides
-    erev 'Showing how many of the '+steelblue('four nucleotides')+rev+
-         ' are in that sequence (absolute numbers):'
-    print '  '
-    string = ''.dup
-    hash.each_pair {|nucleotide, n_times|
-      string << "#{nucleotide}: #{lightslategray(n_times.to_s)}#{rev}, "
-    }
-    e string.rstrip.chop # .chop() to get rid of the last ',' token.
-    erev "The respective frequencies derived from these absolute "\
-         "numbers, #{steelblue('in percent')}#{rev}"\
-         ", are:"
-    print '  '
-    hash.each_pair {|nucleotide, n_times|
-      percentage = (n_times.to_f * 100 / length).round(2).to_s
-      print "#{rev}#{nucleotide}: #{orange(percentage)}#{rev}% "
-    }; erev
-  end
-
-  # ========================================================================= #
-  # === show_codon_usage
-  #
-  # This shows the codon usage of the string.
-  # ========================================================================= #
-  def show_codon_usage(
-      i = dna_sequence_as_string?
-    )
-    if i.is_a? Array
-      if i.empty?
-        i = dna_sequence_as_string?
-      else
-        i = i.flatten.compact.join
-      end
-    end
-    ::Bioroebe::ShowCodonUsage.new(i)
-  end
-
-  # ========================================================================= #
-  # === show_all_codon_tables
-  #
-  # We used to tap into the Bio::CodonTable here for this part.
-  #
-  # But since some time, we no longer depend on this part - we
-  # have made available all of this in yaml files.
-  #
-  # The argument to this method can either be:
-  #
-  #   :everything
-  #   :only_names
-  #
-  # The first one is the default. This means that we will show everything.
-  #
-  # The second version is useful if you only what to report the names
-  # of the codon table in question. Several aliases exist for the
-  # second invocation.
-  # ========================================================================= #
-  def show_all_codon_tables(
-      show_what = :everything
-    )
-    unless Bioroebe.const_defined? :ShowCodonTables
-      require 'bioroebe/codons/show_codon_tables.rb'
-    end
-    e
-    ::Bioroebe::ShowCodonTables.new(show_what)
-    e
-  end
-
-  # ========================================================================= #
-  # === report_n_start_codons
-  #
-  # Use this method to count how many ATG codons we have. We will honour
-  # the default start_codon in use.
-  #
-  # The third argument determines which reading frame is to be used. By
-  # default, the method will use the first reading frame.
-  # ========================================================================= #
-  def report_n_start_codons(
-      this_string             = string?,
-      use_this_as_start_codon = ::Bioroebe.start_codon?, # Use the proper start codon.
-      in_which_frame          = :frame1
-    )
-    # ======================================================================= #
-    # === Handle blocks next
-    # ======================================================================= #
-    if block_given?
-      yielded = yield
-      case yielded
-      when /^frame/
-        in_which_frame = yielded.to_sym
-      end
-    end
-    # ======================================================================= #
-    # The following can be invoked via:
-    #   n_ORF? frame1
-    # ======================================================================= #
-    case in_which_frame
-    when :frame1
-      in_which_frame = 'frame 1'
-    when :frame2
-      in_which_frame = 'frame 2'
-    when :frame3
-      in_which_frame = 'frame 3'
-    end
-    n_start_codons = this_string.upcase.scan(/#{use_this_as_start_codon}/).size.to_s
-    # ======================================================================= #
-    # The above is not yet in the proper frame, though.
-    # ======================================================================= #
-    trailing_message = " Initiation Codons "\
-                       "(in #{orangered(in_which_frame)}#{rev})."
-    erev "Our main string has #{sfancy(n_start_codons)}#{rev}"\
-         " #{simp(use_this_as_start_codon)}#{rev} ("\
-         "#{use_this_as_start_codon.tr('T','U')})"+
-         trailing_message
-    if coding_area? # This has been user-supplied in that case.
-      erev 'However had, only the nucleotides from position'
-      erev "#{sfancy(coding_area?.to_s.split('..').first.to_s)}#{rev}"\
-           " to position #{sfancy(coding_area?.to_s.split('..').last.to_s)}"\
-           "#{rev} will be colourized."
-    end
-  end
-
-  # ========================================================================= #
-  # === show_human_genome_version
-  #
-  # Use this method to show the most current human genome version.
-  # ========================================================================= #
-  def show_human_genome_version
-    human_genome_version = '' # Default.
-    remote_URL = 'https://www.ensembl.org/Homo_sapiens/Info/Index'
-    dataset = URI.open(remote_url).read
-    use_this_regex = /Genome assembly: (.{1,11}\.p\d+) <small>/ # See: https://rubular.com/r/DD5FhaPs3b
-    scanned = dataset.scan(use_this_regex).flatten
-    human_genome_version = scanned.first.to_s
-    erev "The most current human genome version is: "\
-         "#{sfancy(human_genome_version)}"
-    erev "The URL that was used to query this has been: "\
-         "#{steelblue(remote_URL)}"
-  end
-
-  # ========================================================================= #
-  # === show_oligo_length_three
-  #
-  # We align in chunks of three and tell the user how often we can find
-  # these individual codons.
-  #
-  # Invocation example:
-  #
-  #   random 99; oligo_3
-  #
-  # ========================================================================= #
-  def show_oligo_length_three(
-      sequence = dna_sequence_object?
-    )
-    sequence = sequence.upcase # This is the sequence that will be scanned.
-    dna = ::Bioroebe.dna? # This is equal to A, T, C and G.
-    erev 'We will align the nucleotides in chunks of 3 and show their '\
-         'frequency.'
-    dna.each {|first_entry| # First nucleotide.
-      dna.each {|second_entry| # Second nucleotide.
-        dna.each {|third_entry| # Third nucleotide.
-          _ = first_entry+second_entry+third_entry
-          erev _+' '+sequence.scan(_).size.to_s
-        }
-      }
-    }
-  end
-
-  # ========================================================================= #
-  # === show_oligo_length_two
-  #
-  # Show all oligo of length two.
-  # ========================================================================= #
-  def show_oligo_length_two(
-      string = string?
-    )
-    sequence = string.upcase # Shorter copy and always upcased.
-    dna = ::Bioroebe.dna?
-    dna.each {|first_entry|
-      dna.each {|second_entry|
-        _ = "#{first_entry}#{second_entry}"
-        erev _+' '+sequence.scan(_).size.to_s
-      }
-    }
-  end
-
-  # ========================================================================= #
-  # === show_position_for_the_main_sequence
-  # ========================================================================= #
-  def show_position_for_the_main_sequence
-    array = sequence?.scan(/.{,25}/)
-    index_position = 1
-    array.each {|entry|
-      unless entry.empty?
-        erev entry.split(//).join('   ')
-        second_line = ''
-        start = index_position
-        index_position += entry.size
-        start.upto(index_position-1) {|position|
-          second_line << position.to_s.ljust(4)
-        }
-        erev cadetblue(second_line)+rev
-        e
-      end
-    }
-  end
-
-  # ========================================================================= #
-  # === report_this_input_was_not_found
-  #
-  # This method is used to notify the user that a certain input was
-  # not found.
-  # ========================================================================= #
-  def report_this_input_was_not_found(
-      i = ''
-    )
-    unless i.empty?
-      erev "Input `#{sfancy(i.to_s)}#{rev}` was not "\
-           "found to be a valid input for the BioShell."
-    end
-  end
-
-  # ========================================================================= #
-  # === show_local_sequences
-  #
-  # This method will show the available local sequences.
-  # ========================================================================= #
-  def show_local_sequences
-    possible_matches = return_fasta_files_in_the_log_directory
-    if possible_matches.empty?
-      erev 'No local fasta sequences could be found.'
-    else
-      e
-      erev 'The following local sequences were found in '\
-           'the main log'
-      erev 'directory ('+sdir(log_dir?)+rev+').'
-      e
-      possible_matches.each_with_index {|entry, index|
-        index += 1
-        _ = possible_matches.size.to_s.size
-        erev padding?+'('+index.to_s.rjust(_)+') '+rev+
-             sfile(File.basename(entry))+rev
-      }; e
-    end
-  end
-
-  # ========================================================================= #
-  # === show_nucleotide_sequence?
-  # ========================================================================= #
-  def show_nucleotide_sequence?
-    @internal_hash[:show_nucleotide_sequence]
-  end; alias display_nucleotide_object? show_nucleotide_sequence? # === display_nucleotide_object?
-
-  # ========================================================================= #
-  # === show_sequence_with_a_ruler
-  #
-  # This will show the main sequence together with a "ruler" on top.
-  #
-  # The first argument specifies how many nucleotides are to be displayed
-  # per given line.
-  #
-  # This method can also be called in this way:
-  #
-  #   show_sequence_with_a_ruler { :without_colours }
-  #
-  # This will skip showing the ruler.
-  # ========================================================================= #
-  def show_sequence_with_a_ruler(
-      group_together_n_nucleotides = :default,
-      use_this_sequence            = main_sequence?
-    )
-    if group_together_n_nucleotides.is_a?(Array)
-      group_together_n_nucleotides = group_together_n_nucleotides.first
-      if group_together_n_nucleotides.nil? or group_together_n_nucleotides.empty?
-        group_together_n_nucleotides = :default
-      end
-    end
-    case group_together_n_nucleotides
-    # ======================================================================= #
-    # === :default
-    # ======================================================================= #
-    when :default,
-         nil
-      group_together_n_nucleotides = 70
-    end
-    if group_together_n_nucleotides.is_a? String
-      # ===================================================================== #
-      # We need an Integer here.
-      # ===================================================================== #
-      group_together_n_nucleotides = group_together_n_nucleotides.to_i
-    end
-    e
-    e "Displaying the main sequence (length: #{use_this_sequence.to_s.size}) "\
-      "in a chunk of #{slateblue(group_together_n_nucleotides.to_s)}#{rev}"\
-      " nucleotides/\naminoacids next."
-    e
-    use_this_sequence = use_this_sequence.to_s
-    chunks = use_this_sequence.split(/(.{#{group_together_n_nucleotides}})/).reject(&:empty?)
-    array = chunks.each_slice(group_together_n_nucleotides).to_a.flatten #.join.split("\n")
-    use_this_ruler_type = :show_ruler # Note that :show_ruler is the default.
-    # ======================================================================= #
-    # === Handle blocks given next
-    # ======================================================================= #
-    if block_given?
-      yielded = yield
-      case yielded
-      # ===================================================================== #
-      # === :without_colours
-      # ===================================================================== #
-      when :without_colours
-        use_this_ruler_type = :without_colours
-      end
-    end
-    array.each {|sequence|
-      show_nucleotide_sequence?.display_with_prior_formatting(sequence) {
-        use_this_ruler_type
-      }
-      e
-    }
-  end
-
-  # ========================================================================= #
-  # === dna_with_ends
-  #
-  # Display DNA with proper ends.
-  #
-  # The first argument should be the string that we will colourize.
-  #
-  # If the second argument is given (`optional_colourize`), then this
-  # method will colourize the sequence at certain positions. This
-  # can be useful to display, for instance, restriction-sites.
-  # ========================================================================= #
-  def dna_with_ends(
-      i                    = dna_sequence_as_string?,
-      optional_colourize   = nil,
-      colourize_everything = true
-    )
-    i.upcase! if config?.respond_to?(:upcase_nucleotides) and config?.upcase_nucleotides
-    if optional_colourize.is_a? String
-      optional_colourize = [optional_colourize]
-    end
-    if block_given?
-      yielded = yield
-      case yielded
-      # ===================================================================== #
-      # === :honour_coding_area_if_it_exists
-      # ===================================================================== #
-      when :honour_coding_area_if_it_exists
-        if optional_colourize and @internal_hash[:coding_area]
-          # ================================================================= #
-          # We will colourize based on the coding area that was designated.
-          # ================================================================= #
-          _ = @internal_hash[:coding_area]
-          # ================================================================= #
-          # We deduct 1 because ruby Arrays start at 0.
-          # ================================================================= #
-          start_position = _.split('..').first.to_i - 1
-          end_position   = _.split('..').last.to_i  - 1
-          internal_segment = i[start_position .. end_position]
-          use_this_as_return_string = ''
-          use_this_as_return_string << i[0..(start_position-1)]
-          optional_colourize.each {|inner_entry|
-            internal_segment.gsub!(inner_entry, yellow+inner_entry+rev)
-          }
-          use_this_as_return_string << internal_segment
-          use_this_as_return_string << i[(end_position+1) .. -1]
-          i = use_this_as_return_string
-        elsif optional_colourize
-          # ================================================================= #
-          # Apply all entries given in the Array.
-          # ================================================================= #
-          if optional_colourize.is_a? Array
-            optional_colourize.flatten.each {|inner_entry|
-              i.gsub!(
-                inner_entry, colour_for_stop_codon(inner_entry)+rev
-              ) # Colourize in yellow.
-            }
-          else
-            # =================================================================== #
-            # Make sure that we have a String past this point.
-            # =================================================================== #
-            optional_colourize = optional_colourize.to_s
-            if colourize_everything == true
-              i.gsub!(optional_colourize, colour_for_stop_codon(optional_colourize)+rev)
-            else
-              if colourize_everything == 1
-                i.sub!(optional_colourize, colour_for_stop_codon(optional_colourize)+rev)
-              end
-            end
-          end
-        end
-      end
-    else
-      i = "#{sfancy(i)}#{rev}"
-    end
-    # ======================================================================= #
-    # We will report the DNA sequence with leading 5' prime and
-    # trailing 3' prime.
-    # ======================================================================= #
-    return "#{leading_five_prime}#{i}#{trailing_three_prime}"
-  end
-
-  require 'bioroebe/toplevel_methods/matches.rb'
-  # ========================================================================= #
-  # === report_the_first_atg
-  #
-  # This method will simply report the first ATG codon.
-  # ========================================================================= #
-  def report_the_first_atg
-    dna_sequence = dna_sequence_object_as_string?
-    array_matches = ::Bioroebe.return_all_substring_matches(
-      dna_sequence, start_codon?
-    )
-    start_position = array_matches.first.first
-    erev 'The first ATG can be found at position '+
-          simp(start_position.to_s)+rev+'.'
-    erev 'We will next show the first 100 nucleotides, starting from this:'
-    report_five_prime_three_prime(
-      dna_sequence_object?[start_position-1,100]
-    )
-  end
-
-  # ========================================================================= #
-  # === show_aminoacid_sequence
-  #
-  # To show the aminoacid sequence, do:
-  #   show_aa
-  # ========================================================================= #
-  def show_aminoacid_sequence
-    erev padding?+
-         aminoacid_sequence? # aminoacids? # Will also use some padding.
-  end
-
-  # ========================================================================= #
-  # === show_dna_string                           (show string tag, show tag)
-  #
-  # Use this method to show the @sequence, or another string of your
-  # choosing, if you pass it to the method.
-  #
-  # You can also invoke this method with something like this:
-  #
-  #   show_string { :with_colourized_separator }
-  #
-  # This means that we will use '|' separators that are colourized.
-  # ========================================================================= #
-  def show_dna_string(
-      this_string              = dna_string?,
-      truncate_too_long_result = do_truncate?
-    )
-    result = rev.dup # This is the String that will be returned.
-    case truncate_too_long_result
-    when :do_not_truncate
-      truncate_too_long_result = false
-    end
-    truncate_at_n_elements = TRUNCATE_AT_N_ELEMENTS
-    if this_string.nil?
-      this_string = dna_string? if dna_string?
-    end
-    if this_string.to_s.empty?
-      report_that_a_string_must_be_assigned_first
-    else
-      # this_string.upcase! # Nope, do not upcase here. Use other methods to do so.
-      if mode? == :dna
-        if this_string.size > truncate_at_n_elements # Threshold for now.
-          if truncate_too_long_result or
-            (truncate_too_long_result == :do_not_truncate_and_do_not_show_leader_and_trailer)
-            this_string =
-              this_string[0, truncate_at_n_elements]+
-              swarn(' [TRUNCATED as the sequence '\
-              'is longer than '+truncate_at_n_elements.to_s+' nucleotides]')
-          end
-        end
-        # =================================================================== #
-        # Next, display the main string, without upcasing it.
-        # =================================================================== #
-        if block_given?
-          yielded = yield
-          case yielded
-          when :with_colourized_separator
-            _ = this_string.split(//)
-            str = ''.dup
-            _.each_with_index {|char, index|
-              str << char
-              str << paleturquoise('|')+sfancy if (index+1) % 3 == 0
-            }
-            this_string = str
-          end
-        end
-        if truncate_too_long_result == :do_not_truncate_and_do_not_show_leader_and_trailer
-        else
-          result << padding?+leading_5_prime
-        end
-        # =================================================================== #
-        # Next, add the DNA sequence to the result that will be displayed.
-        # =================================================================== #
-        result << colourize_dna_sequence(this_string)+rev
-        if truncate_too_long_result == :do_not_truncate_and_do_not_show_leader_and_trailer
-        else
-          result << trailing_3_prime
-        end
-        # =================================================================== #
-        # Delegate to class ShowNucleotideSequence next:
-        # =================================================================== #
-        display_nucleotide_sequence(this_string)
-      else # Else use the aminoacid mode.
-        show_aminoacid_sequence
-      end
-    end
-  end; alias show_main_string       show_dna_string # === show_main_string
-       alias report_sequence        show_dna_string # === report_sequence
-       alias show_sequence          show_dna_string # === show_sequence
-       alias show_main_dna_sequence show_dna_string # === show_main_dna_sequence
-       alias show_string            show_dna_string # === show_string
-
-  # ========================================================================= #
-  # === report_size_of_main_string
-  # ========================================================================= #
-  def report_size_of_main_string(
-      i              = dna_sequence_object?,
-      type_of_string = 'main ' # This is usually the main DNA string.
-    )
-    i = dna_sequence_object? if i.nil?
-    i = dna_sequence_object? if i.is_a?(Array) and i.empty?
-    erev 'The '+type_of_string+'string has '+sfancy(i.size.to_s)+
-         rev+' '+nucleotides_or_aminoacids?+'.'
-  end; alias report_length_of_the_dna_string report_size_of_main_string # === report_length_of_the_dna_string
-       alias report_size_of_this_sequence    report_size_of_main_string # === report_size_of_this_sequence
-
-  # ========================================================================= #
-  # === show_editor_in_use
-  # ========================================================================= #
-  def show_editor_in_use
-    e MAIN_EDITOR
-  end
-
-  # ========================================================================= #
-  # === show_welcome_message
-  #
-  # Show a little welcome message on startup. This can be disabled of
-  # course.
-  # ========================================================================= #
-  def show_welcome_message
-    unless silent_startup?
-      erev 'Welcome to the Bioroebe::Shell Version '+
-           sfancy(version?.to_s)+
-           rev+
-           ', last updated: '+
-           simp(::Bioroebe.last_updated?)+
-           rev+'.'
-      erev 'Type "'+sfancy('help')+rev+'" to get some help.'
-    end
-  end
-
-  # ========================================================================= #
-  # === show_the_weight_of_the_four_individual_nucleotides
-  # ========================================================================= #
-  def show_the_weight_of_the_four_individual_nucleotides
-    e
-    erev '  A: '+adenin?.rjust(10)+' '+
-          palevioletred(weight_of_adenin?)
-    erev '  T: '+thymin?.rjust(10)+' '+
-          palevioletred(weight_of_thymin?)
-    erev '  C: '+cytosin?.rjust(10)+' '+
-          palevioletred(weight_of_cytosin?)
-    erev '  G: '+guanin?.rjust(10)+' '+
-          palevioletred(weight_of_guanin?)
-    e
-  end
-
-  # ========================================================================= #
-  # === show_this_subsequence
-  #
-  # Sometimes we want to show a subsequence. This method helps us to do
-  # so, too.
-  #
-  # The input may be "tainted", e. g. be a String like "12,345" or
-  # "12.345", so this method will have to eliminate the ',' and '.'
-  # characters as well, before converting this String into an
-  # Integer. (It must be an Integer because nucleotide counting
-  # can logically not be a Float.)
-  #
-  # Usage example:
-  #
-  #   random 99; [22..33]
-  #
-  # ========================================================================= #
-  def show_this_subsequence(
-      start_position        =  1,
-      end_position          = 10,
-      work_on_this_sequence = dna_sequence_object?
-    )
-    start_position = start_position.to_s.delete(',.').to_i
-    end_position   = end_position.to_s.delete(',.').to_i
-    if start_position < 1
-      erev 'The minimum for the start-position must be 1, so this'
-      erev 'is now treated as one rather than '+start_position.to_s+'.'
-      start_position = 1
-    end
-    if end_position > work_on_this_sequence.size
-      erev 'The sequence is '+slateblue('too long')+rev+' ('+
-           crimson('end_position')+rev+' is '\
-           'at '+sfancy(end_position.to_s)+rev+', '+
-           nucleotides_or_aminoacids?.to_s+' sequence length '\
-           'was: '+sfancy(work_on_this_sequence.size.to_s)+
-           rev+').'
-      erev 'It will be limited next to '+
-           sfancy(work_on_this_sequence.size.to_s)+rev+' in length.'
-      end_position = work_on_this_sequence.size
-    end
-    sequence = work_on_this_sequence.start_end(
-      start_position,
-      end_position
-    )
-    if sequence
-      size = sequence.size.to_s
-      nucleotides_or_aminoacids_or_empty = ''
-      if work_on_this_sequence.respond_to? :nucleotides_or_aminoacids?
-        nucleotides_or_aminoacids_or_empty = work_on_this_sequence.nucleotides_or_aminoacids?.to_s
-      end
-      erev 'Next showing a subsequence, '+
-           nucleotides_or_aminoacids_or_empty+' '+
-           olive(start_position.to_s)+rev+' to '+
-           olive(end_position.to_s)+rev+
-           ' (including '+olive(start_position.to_s)+
-           rev+' and '+olive(end_position.to_s)+rev+').'
-      erev 'The length of the fragment will be '+
-           simp(size)+rev+
-           ' '+
-           nucleotides_or_aminoacids_or_empty+
-           '.'
-      report_this_dna_sequence_with_proper_trailer_and_leader(sequence) { :try_to_colourize_start_codon }
-    else
-      erev 'This subsequence appears to be invalid '\
-           '(start: '+start_position.to_s+', end: '+end_position.to_s+')'
-    end
-  end
-
-  # ========================================================================= #
-  # === report_where_the_home_directory_can_be_found
-  # ========================================================================= #
-  def report_where_the_home_directory_can_be_found(
-      i = log_dir?
-    )
-    erev 'The "home" directory (actually called the log directory) '\
-         'can be found here:'
-    e
-    e "  #{sdir(i)}"
-    e
-  end
-
-  # ========================================================================= #
-  # === show_double_strand
-  # ========================================================================= #
-  def show_both_dna_strands
-    show_main_sequence
-    show_complement(string?, :include_prime_ends)
-  end; alias show_double_strand show_both_dna_strands # === show_double_strand
-
-  # ========================================================================= #
-  # === show_codon_piped_sequence
-  # ========================================================================= #
-  def show_codon_piped_sequence
-    # _ = dna_sequence_object?.gsub(/(...)/, "\\1|") # Add | at every third position.
-    # erev rev+padding?+leading_5_prime+sfancy(_)+rev+trailing_3_prime
-    display_nucleotide_sequence(:default) { :piped }
-  end
-
-  # ========================================================================= #
-  # === show                                                       (show tag)
-  #
-  # Bundle together some show-related methods.
-  # ========================================================================= #
-  def show(i)
-    i = i.join(' ').strip if i.is_a? Array
-    case i
-    when 'codon_table','codon','codon table'
-      show_codon_table
-    when 'blosum','blosum matrix','blosum_matrix'
-      show_blosum_matrix
-    when '',nil # Empty or nil.
-      show_dna_string
-    end
-  end
-
-  # ========================================================================= #
-  # === display_nucleotide_sequence
-  #
-  # Consistently use this method whenever you wish to display a
-  # nucleotide sequence.
-  # ========================================================================= #
-  def display_nucleotide_sequence(
-      this_sequence = dna_sequence_object?,
-      &block
-    )
-    case this_sequence
-    when :default
-      this_sequence = dna_sequence_object?
-    end
-    do_show_piped_output = false
-    if block_given?
-      yielded = yield
-      case yielded
-      when :piped,
-           :show_piped
-        do_show_piped_output = true
-      end
-    end
-    hash = {
-      padding_to_use:    padding?,
-      show_piped_output: do_show_piped_output
-    }
-    show_nucleotide_sequence?.report_this_sequence(this_sequence) { hash }
-  end; alias display_this_nucleotide_sequence display_nucleotide_sequence # === display_this_nucleotide_sequence
-       alias display_this_sequence            display_nucleotide_sequence # === display_this_sequence
-       alias show_this_sequence               display_nucleotide_sequence # === show_this_sequence
-
-  # ========================================================================= #
-  # === report_how_many_aminoacids_we_have
-  #
-  # This method will report how many aminoacids we have assigned.
-  # ========================================================================= #
-  def report_how_many_aminoacids_we_have
-    if aminoacids?
-      n_aminoacids = aminoacids?.size
-    else
-      n_aminoacids = dna_sequence_object?.size / 3.0
-    end
-    n_aminoacids = n_aminoacids.to_i
-    erev "This sequence has #{simp(n_aminoacids.to_s)}#{rev} aminoacids."
-  end
-
-  # ========================================================================= #
-  # === show_chromosome_table
-  # ========================================================================= #
-  def show_chromosome_table
-    lpadding_to_use = 16
-    erev 'Chromosome Table from file '+sfile(FILE_CHROMOSOME_NUMBERS)+rev
-    if File.exist? FILE_CHROMOSOME_NUMBERS
-      dataset = YAML.load_file(FILE_CHROMOSOME_NUMBERS)
-      e
-      dataset.each_pair {|key, value|
-        erev "  "+key.ljust(lpadding_to_use)+
-             ' '+
-             steelblue(value.to_s.rjust(3))
-      }
-      e
-    else
-      no_file_exists_at(FILE_CHROMOSOME_NUMBERS)
-    end
-  end
-
-  # ========================================================================= #
-  # === report_everything_about_this_amino_acid
-  #
-  # Use this method to report everything about any particular amino acid.
-  # ========================================================================= #
-  def report_everything_about_this_amino_acid(i)
-    if i.is_a? Array
-      i.each {|entry| report_everything_about_this_amino_acid(entry) }
-    else
-      i.delete!('?') if i.include? '?'
-      erev 'It seems as is we did find an Amino Acid ('+simp(i)+rev+
-           '). Its characteristic residue (R) is:'+N+N
-      unless AMINO_ACIDS_RESTE.has_key?(i)
-        # =================================================================== #
-        # This here is to map german names, such as "glycin",
-        # onto "glycine", the corresponding english name.
-        # =================================================================== #
-        if AMINO_ACIDS_LONG_NAME_TO_ONE_LETTER.has_key?(i)
-          i = AMINO_ACIDS_LONG_NAME_TO_ONE_LETTER[i]
-          i = AMINO_ACIDS_ENGLISH[i].downcase
-        end
-      end
-      residue = AMINO_ACIDS_RESTE[i.downcase].to_s
-      efancy "  #{residue}#{N}"
-      erev 'The codons coding for the aminoacid '+simp(i)+rev+' are:'
-      e
-      e '  '+mediumturquoise(
-          ::Bioroebe::PossibleCodonsForThisAminoacid.new(i).pretty_result
-        )
-      e
-      molecular_mass_of(i, 2) # The 2 says to round to 2 digit.
-    end
-  end
-
-  # ========================================================================= #
-  # === report_five_prime_three_prime
-  # ========================================================================= #
-  def report_five_prime_three_prime(i)
-    erev dna_with_ends(i)
-  end
-
-  # ========================================================================= #
-  # === show_startup_information
-  #
-  # This method here will usually be shown only once, on an initial startup
-  # of the Bioroebe::Shell. Afterwards, it will no longer be shown at all.
-  #
-  # Note that showing this can be disabled.
-  # ========================================================================= #
-  def show_startup_information
-    e
-    erev "This seems to be the first time that you are using the "\
-         "#{olivedrab('Bioroebe::Shell')}#{rev}, at the least on"
-    erev 'this computer.'
-    e
-    erev 'It is recommended to have a look at the following components first:'
-    e
-    efancy '   help'
-    efancy '   random'
-    efancy '   assign'
-    efancy '   complement'
-    e
-    erev 'If you want to show this intro-menu again, do:'
-    e
-    efancy '  show-intro'
-    e
-    erev 'You can also see more documentation at:'
-    e
-    e "  #{slateblue(URL_TO_THE_DOCUMENTATION)}"
-    e
-    erev 'If you feel that something is missing or incorrect, feel '\
-         'free to send an email to:'
-    e
-    efancy "  #{EMAIL}"
-    e
-  end
-
-  require 'bioroebe/colours/colourize_sequence.rb'
-  # ========================================================================= #
-  # === report_colourized_sequence
-  #
-  # This method will use the new class ColourizeSequence, rather than
-  # the old internal way.
-  #
-  # In the long run, it may be best to transition all of the Bioroebe::Shell
-  # into the new class - but for now, we will use a hybrid system.
-  #
-  # To invoke this method, try:
-  #
-  #   start_and_stop?
-  #
-  # ========================================================================= #
-  def report_colourized_sequence(
-      colourize_what = :start_and_stop_codon
-    )
-    _ = ColourizeSequence.return_sequence(dna_sequence_object?) { colourize_what }
-    show_nucleotide_sequence?.display(_)
-    e
-  end
-
-  # ========================================================================= #
-  # === show_complement
-  #
-  # If the second argument is true, we pad via 5' and 3'.
-  #
-  # As of Feb 2015, we will try with leading padding as well.
-  # ========================================================================= #
-  def show_complement(
-      i                       = dna_string?,
-      also_include_prime_ends = false
-    )
-    case also_include_prime_ends
-    # ======================================================================= #
-    # === :show_leading_primes
-    # ======================================================================= #
-    when :show_leading_primes,
-         :include_prime_ends
-      also_include_prime_ends = true
-    end
-    i = dna_string? if i.nil?
-    i = i.join('') if i.is_a? Array
-    if also_include_prime_ends
-      erev padding?+rev+
-           leading_3_prime+
-           sfancy(complement(i))+
-           rev+trailing_5_prime
-    else
-      erev complement(i)
-    end
-  end
-
-  # ========================================================================= #
-  # === show_position_of_sequence
-  #
-  # This currently works only for Amino Acids - at the least I have tested
-  # it only on aminoacids so far, and not on DNA/RNA.
-  # ========================================================================= #
-  def show_position_of_sequence(
-      i          = aa_sequence?,
-      chunk_size = 10 # How many chunks to display per row.
-    )
-    array = i.chars
-    _ = '' # The Display-String.
-    index_string = ''
-    0.upto(array.size) {|index|
-      _ << array[index].to_s.rjust(2)+' '
-      unless array.size == index
-        index_string << palevioletred((index+1).to_s.rjust(2)+' ')
-      end
-      if index % chunk_size == (chunk_size - 1)
-        _ << N
-        _ << index_string << rev << N << N
-        index_string = ''
-      end
-    }
-    erev _ # Report it finally.
-    erev index_string
-  end
-
-  # ========================================================================= #
-  # === show_alu_sequence
-  #
-  # Invoke this method by doing something like:
-  #
-  #   alu_sequence?
-  #
-  # ========================================================================= #
-  def show_alu_sequence
-    fasta_dataset = ::Bioroebe.parse_fasta(FILE_ALU_ELEMENTS)
-    _ = fasta_dataset.fasta_sequence
-    erev 'The ALU sequence in humans may be this (length: '+
-          sfancy(_.size.to_s)+rev+'):'
-    erev'  '+simp(_)
-  end
-
-  # ========================================================================= #
-  # === show_possible_codons_for_this_aminoacid
-  # ========================================================================= #
-  def show_possible_codons_for_this_aminoacid(i)
-    possible_codons = PossibleCodonsForThisAminoacid[i,
-      :use_only_the_four_standard_nucleotide_letters]
-    @array_aminoacid_sequence << possible_codons
-    return possible_codons
-  end
-
-  # ========================================================================= #
-  # === show_date
-  # ========================================================================= #
-  def show_date
-    erev Time.now.strftime('%d.%m.%Y')
-  end
-
-  # ========================================================================= #
-  # === show_taxid
-  #
-  # This method will show the particular TaxID, using the NCBI taxonomy
-  # database.
-  #
-  # The tax-id 9606 is "Homo sapiens".
-  # ========================================================================= #
-  def show_taxid(id = 9606)
-    id = 9606 if id.nil?
-    id = id.to_s
-    url = 'http://www.ncbi.nlm.nih.gov/Taxonomy/Browser/wwwtax.cgi?id='+id+'&lvl=0'
-    erev 'The remote URL is: '+sfancy(url)
-    webpage = open(url).read
-    regex = /^<table width="100%"><tr><td valign="top"><h2>(Homo sapiens)<\/h2>/ # See: http://rubular.com/r/aQK5O8ZfGa
-    webpage =~ regex
-    name_of_the_organism = $1.to_s.dup
-    erev 'The TaxID of '+simp(id)+rev+' corresponds to `'+
-          sfancy(name_of_the_organism)+rev+'`.'
-  end
-
-  # ========================================================================= #
-  # === show_nucleotides_table
-  #
-  # Use this method to show the nucleotides table - their formula and
-  # the molecular mass.
-  # ========================================================================= #
-  def show_nucleotides_table
-    array_display_these = %w(
-      Adenin Cytosin Guanin Thymin
-    )
-    # ======================================================================= #
-    # Grab the nucleotides.yml dataset next
-    # ======================================================================= #
-    dataset = YAML.load_file(FILE_NUCLEOTIDES)
-    dataset.each_pair {|key, chemical_formula|
-      if array_display_these.include? key # Display it in this case.
-        molmasse = ChemistryParadise::CalculateAtomicMass.new(chemical_formula, :do_not_report).masse?
-        molmasse = molmasse.to_f.round(2)
-        e key.to_s.ljust(8)+' -> '+chemical_formula.to_s.rjust(8)+
-          rev+' (Molecular mass: '+simp(molmasse.to_s)+')'+rev
-      end
-    }
-  end
-
-  # ========================================================================= #
-  # === show_ori_sequences
-  #
-  # The DnaA box is: TTATC[CA]A[CA]A
-  # ========================================================================= #
-  def show_ori_sequences
-    erev 'The DnaA box has this consensus sequence: '+
-          sfancy("5'-TTATC[CA]A[CA]A-3'")
-    _ = 'TTATCCACA'
-    erev 'Searching for '+_
-    try_to_find_restriction_enzymes_for(_)
-    _ = 'TTATCAAAA'
-    erev 'Searching for '+_
-    try_to_find_restriction_enzymes_for(_)
-  end
-
-  # ========================================================================= #
-  # === show_segments
-  #
-  # This method will show the DNA segments via a R-compatible way.
-  #
-  # Usage example:
-  #
-  #   set AAAATGCAGTAACCCATGCCC; show_segments
-  #
-  # ========================================================================= #
-  def show_segments
-    array = ::Bioroebe.scan_this_input_for_startcodons(dna_sequence_object?)
-    erev '         start end width'
-    array.each_with_index {|inner_array, index|
-      index += 1
-      start_position = inner_array.first
-      codon          = inner_array.last.first
-      erev '  ['+index.to_s+']  '+start_position.to_s.rjust(5)+' '+
-            (start_position+2).to_s.rjust(5)+' '+'3'.rjust(4)+' ['+codon.downcase+']'
-    }
-  end
-
-  require 'bioroebe/toplevel_methods/aminoacids_and_proteins.rb'
-  # ========================================================================= #
-  # === show_possible_phosphorylation_sites
-  #
-  # This method will find all possible phosphorylation sites in any
-  # given target sequence. It will also identify the aminoacids that
-  # can be phosphorylated.
-  #
-  # To test this, try:
-  #
-  #   random 250; P?
-  #
-  # ========================================================================= #
-  def show_possible_phosphorylation_sites(i = aminoacid_sequence?)
-    _ = dna_sequence_object?
-    array_all_codons = []
-    array_all_codons << ::Bioroebe.codons_for?(:serine)
-    array_all_codons << ::Bioroebe.codons_for?(:tyrosine)
-    array_all_codons << ::Bioroebe.codons_for?(:threonine)
-    array_all_codons.flatten!
-    # ======================================================================= #
-    # === Convert Y into Purine/Pyrimidine next
-    # ======================================================================= #
-    if array_all_codons.any? {|entry| entry.end_with? 'Y' }
-      array_all_codons.map! {|inner_entry|
-        if inner_entry.end_with? 'Y'
-          inner_entry = [
-            inner_entry.sub(/Y$/,'T'),
-            inner_entry.sub(/Y$/,'C')
-          ]
-        end
-        inner_entry
-      }
-      array_all_codons.flatten!
-    end
-    all_codons_found_in_the_sequence = []
-    n_phosphorylation_sites = 0
-    n_phosphorylation_sites = 
-      array_all_codons.map {|entry|
-        if _.scan(/#{entry}/).size > 0
-          all_codons_found_in_the_sequence << entry
-        end
-        _.scan(/#{entry}/).size  }.inject(0){|sum, inner_element| sum + inner_element
-      }
-    all_codons_found_in_the_sequence.uniq!
-    singular_or_plural = 'site'
-    if n_phosphorylation_sites < 1
-      singular_or_plural << 's'
-    end
-    erev 'In this sequence, we have found '+simp(n_phosphorylation_sites.to_s)+rev+
-         ' possible phosphorylation '+singular_or_plural+', using all '\
-         '3 possible frames.'
-    e
-    erev 'In particular, these '+all_codons_found_in_the_sequence.size.to_s+
-         ' different codons were found: '
-    e
-    erev '  '+simp(all_codons_found_in_the_sequence.join('/'))+rev
-    e
-    erev 'For the first frame, the start positions are these:'
-    e
-    # ======================================================================= #
-    # === Find the start positions for frame 1 next
-    # ======================================================================= #
-    array_start_positions_for_frame_1 = []
-    scanned_result = _.scan(/.../)
-    scanned_result.each_with_index {|codon, index|
-      if all_codons_found_in_the_sequence.include? codon
-        array_start_positions_for_frame_1 << (index * 3)+1
-      end
-    }
-    erev '  DNA:     '+simp(array_start_positions_for_frame_1.join('/'))+rev
-    erev '  Protein: '+simp(array_start_positions_for_frame_1.map {|entry|
-      entry = entry.to_i * 3
-      entry.to_s
-    }.join('/'))+rev
-    # ======================================================================= #
-    # Now modify the DNA sequence there but only in the first frame.
-    # ======================================================================= #
-    new_colourized_dna_sequence = ''
-    all_triplets = _.scan(/.../)
-    all_triplets.each {|codon|
-      codon = swarn(codon) if all_codons_found_in_the_sequence.include? codon
-      new_colourized_dna_sequence << codon+rev
-    }
-    e
-    erev 'The DNA sequence with possible phosphorylation sites is:'
-    e
-    erev left_padding?+leading_five_prime+new_colourized_dna_sequence+trailing_three_prime
-    e
-    erev 'The Aminoacid sequence with possible phosphorylation sites is:'
-    e
-    erev '  '+
-         ::Bioroebe.colourize_aa(i, ARRAY_AMINOACIDS_THAT_CAN_BE_PHOSPHORYLATED).to_s
-    e
-  end
-
-  # ========================================================================= #
-  # === show_molweight
-  # ========================================================================= #
-  def show_molweight(use_cliner = true)
-    cliner if use_cliner
-    MolecularWeightOfNucleotides.weights.each_with_index {|entry, index|
-      case index
-      when 0
-        erev 'Adenine:  '+sfancy(entry.to_s)+rev
-      when 1
-        erev 'Thymine:  '+sfancy(entry.to_s)+rev
-      when 2
-        erev 'Guanine:  '+sfancy(entry.to_s)+rev
-      when 3
-        erev 'Cytosine: '+sfancy(entry.to_s)+rev
-      end
-    }; cliner if use_cliner
-  end
-
-  # ========================================================================= #
-  # === show_weight_of_this_nucleotide
-  #
-  # Use this method to show the total weight of a specific nucleotide.
-  #
-  # Usage examples:
-  #
-  #   weight? U
-  #   weight? T
-  #   weight? Adenine
-  #
-  # ========================================================================= #
-  def show_weight_of_this_nucleotide(i)
-    i = i.to_s
-    if i.empty?
-      erev 'Please supply a nucleotide, such as "Adenine" or "A".'
-      erev 'Note that the short variant is preferred.'
-      return
-    end
-    i = i[0,1] if i.size > 1
-    _ = FILE_NUCLEOTIDES_WEIGHT # bl /Users/x/DATA/SCIENCE/YAML/nucleotides_weight.yml
-    if File.exist?(_)
-      _ = YAML.load_file(_)
-      dataset = {}
-      _.each_pair {|key, value|
-        dataset[key[0,1]] = value
-      }
-      if dataset.has_key?(i)
-        erev 'The weight of '+sfancy(i)+rev+' is: '+
-          sfancy(
-            ChemistryParadise.atomic_mass_of(dataset[i])
-          )
-      else
-        erev 'The key `'+sfancy(i)+rev+'` was not found.'
-      end
-    else
-      ewarn 'We did not find a required file at '+sfile(_)+rev+'.'
-    end
-  end
-
-  # ========================================================================= #
-  # === show_todo_file
-  # ========================================================================= #
-  def show_todo_file
-    cat '$RUBY_SRC/bioroebe/doc/TODO_FOR_THE_BIOROEBE_PROJECT.md'
-  end
-
-  # ========================================================================= #
-  # === report_where_the_pdf_tutorial_can_be_found
-  #
-  # Do notify the user where to find the .pdf tutorial.
-  # ========================================================================= #
-  def report_where_the_pdf_tutorial_can_be_found
-    _ = File.basename(FILE_BIOROEBE_TUTORIAL)
-    erev 'You can find the tutorial here:'
-    e
-    erev '  '+simp('http://shevegen.square7.ch/'+_)+rev
-    e
-  end
-
-  # ========================================================================= #
-  # === show_directory_content
-  # ========================================================================= #
-  def show_directory_content(of_this_dir = '*')
-    of_this_dir.prepend '*' unless of_this_dir.include? '*'
-    cliner {
-      Dir[of_this_dir].sort.each_with_index {|entry, index|
-        index += 1
-        entry << '/' if File.directory?(entry)
-        erev index.to_s.rjust(2)+') '+entry
-      }
-    }
-  end
-
-  require 'bioroebe/protein_structure/alpha_helix.rb'
-  # ========================================================================= #
-  # === show_length_of_alpha_helix
-  # ========================================================================= #
-  def show_length_of_alpha_helix(i)
-    erev ::Bioroebe::AlphaHelix.length?(i)
-  end
-
-  # ========================================================================= #
-  # === show_and_calculate_weight_of_dna_string
-  # ========================================================================= #
-  def show_and_calculate_weight_of_dna_string(
-      i = dna_sequence_object?
-    )
-    i = dna_sequence_object? if i.nil?
-    i = dna_sequence_object? if is_a? Array and i.empty?
-    sum = 0
-    i.upcase.chars.each {|nucleotide|
-      _ = case nucleotide
-      when 'A'
-        weight_of_adenin?
-      when 'T'
-        weight_of_thymin?
-      when 'C'
-        weight_of_cytosin?
-      when 'G'
-        weight_of_guanin?
-      end
-      sum += _.to_f
-    }
-    # ======================================================================= #
-    # Round the sum properly here.
-    # ======================================================================= #
-    sum = sum.round(2)
-    erev 'The weight of this nucleotide sequence is: '+
-          simp(sum.to_s)+rev+' Dalton.'
-  end
-
-  # ========================================================================= #
-  # === show_name_of_the_gene
-  # ========================================================================= #
-  def show_name_of_the_gene
-    erev 'The name of the gene at hand is: '+
-          sfancy(sequence_object?.name_of_gene)
-  end
-
-  # ========================================================================= #
-  # === show_agarose_table
-  #
-  # This method will simply show common agarose concentrations.
-  # ========================================================================= #
-  def show_agarose_table
-    hash = load_bioroebe_yaml_file(:agarose)
-    e
-    e 'Agarose concentrations:'
-    e
-    hash.each_pair {|concentration_of_the_gel, kb_fragment|
-      erev '  A concentration of '+simp(concentration_of_the_gel.to_s+'%')+
-           rev+' will separate DNA fragments between '+sfancy(kb_fragment)+
-           rev+' kb.'
-    }; e
-  end
-
-  # ========================================================================= #
-  # === start_codon?
-  # ========================================================================= #
-  def start_codon?
-    ::Bioroebe.start_codon?
-  end
-
-  # ========================================================================= #
-  # === stop_codons?
-  # ========================================================================= #
-  def stop_codons?
-    ::Bioroebe.stop_codons?
-  end
-
-  # ========================================================================= #
-  # === show_all_dmp_files
-  #
-  # Show all .dmp files here.
-  # ========================================================================= #
-  def show_all_dmp_files
-    show_directory_content('.dmp')
-  end
-
-  # ========================================================================= #
-  # === show_and_calculate_weight_of_dna_string_or_aminoacid_sequence
-  # ========================================================================= #
-  def show_and_calculate_weight_of_dna_string_or_aminoacid_sequence(
-      i = dna_sequence_object?
-    )
-    if i.nil?
-      if dna_sequence_object?
-        i = dna_sequence_object?
-      end
-    end
-    # ======================================================================= #
-    # First, we check if the input is an aminoacid-sequence.
-    # ======================================================================= #
-    if ::Bioroebe.is_aminoacid?(i)
-      reverse = AMINO_ACIDS_ENGLISH.reverse
-      i = reverse[i] # Replace it with the one-letter code next.
-      # ===================================================================== #
-      # Obtain the mass of this aminoacid.
-      # ===================================================================== #
-      i = AMINO_ACIDS_AVERAGE_MASS_TABLE[i]
-      erev 'The weight of this aminoacid is: '+
-            simp(i.to_s)+rev+' Dalton.'
-    else
-      show_and_calculate_weight_of_dna_string(i)
-    end
-  end
-
-  # ========================================================================= #
-  # === show_t_phages
-  # ========================================================================= #
-  def show_t_phages
-    dataset = YAML.load_file(
-      ::Bioroebe.yaml_dir?+'viruses/ecoli_phages.yml'
-    )
-    # ======================================================================= #
-    # Next, display that as a table.
-    # ======================================================================= #
-    erev 'Name of Phage | Plaque Size | Head diameter | tail length | latent period | burst size'
-    cliner length: 88
-    dataset.each_pair {|name_of_phage, value|
-      print '|',name_of_phage.to_s.center(13),'|'
-      # ===================================================================== #
-      # Display the plague size next, aka small, medium or large.
-      # ===================================================================== #
-      plaque_size = value['plaque_size']
-      print plaque_size.to_s.center(13),'|'
-      head = value['head']
-      print head.to_s.center(15),'|'
-      tail = value['tail']
-      print tail.to_s.center(13),'|'
-      # ===================================================================== #
-      # Display the latent period.
-      # ===================================================================== #
-      latent_period = value['latent_period']
-      print latent_period.to_s.center(15),'|'
-      burst_size = value['burst_size']
-      print burst_size.to_s.center(12),'|'
-      e
-      cliner length: 88
-    }
-  end
-
-  # ========================================================================= #
-  # === show_html_colours
-  # ========================================================================= #
-  def show_html_colours
-    e 'The available HTML colours are:'; e
-    ::Colours.show_html_colours; e
-  end
-
-  # ========================================================================= #
-  # === show_restriction_table
-  #
-  # This method will show a restriction table, that is, a table with
-  # some different restriction enzymes.
-  #
-  # To invoke this method, do:
-  #
-  #   show_restriction_table
-  #
-  # ========================================================================= #
-  def show_restriction_table
-    most_ljust = 20
-    erev 'Showing a few different cutters (4,5,6,7,8) in table format next:'
-    erev '---------------------------------------------------------'
-    e peru('  4-cutter'.ljust(most_ljust))+' | '+orange('ChaI'.ljust(10))+' | '+
-      olivedrab('GATC'.ljust(10))
-    e peru('  5-cutter'.ljust(most_ljust))+' | '+orange('FmuI'.ljust(10))+' | '+
-      olivedrab('GGNCC'.ljust(10))
-    e peru('  6-cutter'.ljust(most_ljust))+' | '+orange('EcoRI'.ljust(10))+' | '+
-      olivedrab('GAATTC'.ljust(10))
-    e peru('  7-cutter'.ljust(most_ljust))+' | '+orange('PfoI'.ljust(10))+' | '+
-      olivedrab('TCCNGGA'.ljust(10))
-    e peru('  8-cutter'.ljust(most_ljust))+' | '+orange('PacI'.ljust(10))+' | '+
-      olivedrab('TTAATTAA'.ljust(10))
-    erev '---------------------------------------------------------'
-  end
-
-  # ========================================================================= #
-  # === show_numbered_nucleotide_positions
-  #
-  # This method will show "numbered" nucleotide positions such as:
-  #
-  #     1234567891234567891234567
-  #     ATGCAGGTCATCAGTCAGTCAGTCA
-  #
-  # ========================================================================= #  
-  def show_numbered_nucleotide_positions
-    _ = sequence?.string?
-    chars = _.chars
-    chunk = chars.each_slice(40) 
-    chunked = chunk.map {|line| line.join }
-    chunked.each {|line|
-      chars = line.chars
-      upper_strand = ''.dup
-      counter = 0
-      chars.each {|char| counter += 1
-        if counter > 9
-          counter = 0
-        end
-        upper_strand << counter.to_s
-      }
-      e lightsteelblue(upper_strand)
-      erev line
-    }
-  end
-
-  # ========================================================================= #
-  # === show_fastq_quality_score_table
-  # ========================================================================= #
-  def show_fastq_quality_score_table
-    _ = FILE_FASTQ_QUALITY_SCHEMES
-    if File.exist? _
-      dataset = YAML.load_file(_)
-      keys = dataset.keys
-      keys.each {|this_key|
-        e sfancy(this_key+':')
-        e
-        inner_dataset = dataset[this_key]
-        erev '  Ascii character range: '+
-             seagreen(inner_dataset['ascii_character_range'].to_s)
-        erev '  Offset:                '+
-             seagreen(inner_dataset['offset'].to_s)
-        erev '  Quality score type:    '+
-             seagreen(inner_dataset['quality_score_type'].to_s)
-        erev '  Quality score range:   '+
-             seagreen(inner_dataset['quality_score_range'].to_s)
-        e
-      }; e
-    end
-  end
-
-  # ========================================================================= #
-  # === report_the_protein_weight
-  # ========================================================================= #
-  def report_the_protein_weight
-    _ = aminoacid_sequence?
-    if _.include? '*'
-      erev 'Note that this aminoacid sequence has a stop codon, denoted by the *:'
-      e
-      erev '  '+sfancy(_)+rev
-      e
-      erev 'Since a stop codon is not translated into an aminoacid'
-      erev 'it makes little sense to include it into the weight-calculation.'
-      erev 'Thus, we will use only the part up to the first * token.'
-      _ = _[0 .. (_.index('*') - 1)]
-    end
-    sum = ::Bioroebe.amino_acid_average_mass(_)
-    e 'The total weight of these '+simp(_.size.to_s)+rev+
-      ' aminoacids is: '+sfancy(sum.to_f.round(2).to_s)+rev+
-      ' Dalton'
-  end
-
-  # ========================================================================= #
-  # === report_all_stop_codons
-  #
-  # This method will report all stop codons in the given sequence.
-  #
-  # We will not modify the input given to this method.
-  #
-  # The three stop codons, in RNA, are:
-  #
-  #     UGA
-  #     UAG
-  #     UAA
-  #
-  # ========================================================================= #
-  def report_all_stop_codons(
-      i = dna_sequence_object?
-    )
-    i.upcase!
-    erev 'Our input sequence has '+simp(i.size.to_s)+rev+' nucleotides.'
-    n_UGA = 'UGA'
-    n_UGA = 'TGA' if is_dna?
-    erev 'We did find '+
-          simp(
-            i.scan(/#{n_UGA}/
-          ).size.to_s.rjust(2))+rev+' '+n_UGA+' stop codons.'
-    n_UAG = 'UAG'
-    n_UAG = 'TAG' if is_dna?
-    erev 'We did find '+
-          simp(i.scan(/#{n_UAG}/).size.to_s.rjust(2))+rev+' '+n_UAG+' stop codons.'
-    n_UAA = 'UAA'
-    n_UAA = 'TAA' if is_dna?
-    erev 'We did find '+
-          simp(i.scan(/#{n_UAA}/).size.to_s.rjust(2))+rev+' '+n_UAA+' stop codons.'
-  end
-
-  # ========================================================================= #
-  # === determine_and_report_all_stop_codons
-  # ========================================================================= #
-  def determine_and_report_all_stop_codons
-    dna_sequence = dna_sequence_object?
-    erev 'Because 3 different stop codons exist, we have '\
-         'to do '+slateblue('3 runs')+rev+'.'
-    stop_codons?.each {|this_stop_codon|
-      array_matches = ::Bioroebe.return_all_substring_matches(
-        dna_sequence, this_stop_codon
-      )
-      if array_matches.empty?
-        erev 'No match has been found.'
-      else
-        start_position = array_matches.last.first
-        erev 'For the stop codon '+sfancy(this_stop_codon)+rev+' the last codon'
-        erev 'occurrs at position '+simp(start_position.to_s)+rev+'.'
-      end
-    }
-  end
-
-  # ========================================================================= #
-  # === show_seq_1
-  # ========================================================================= #
-  def show_seq_1(i = seq1?)
-    erev padding?+leading_five_prime+
-         sfancy(i)+rev+trailing_three_prime
-  end
-
-  # ========================================================================= #
-  # === show_seq_2
-  # ========================================================================= #
-  def show_seq_2(i = seq2?)
-    erev padding?+leading_five_prime+
-         sfancy(i)+rev+trailing_three_prime
-  end
-
-  # ========================================================================= #
-  # === show_seq_3
-  # ========================================================================= #
-  def show_seq_3(i = seq3?)
-    erev padding?+leading_five_prime+
-         sfancy(i)+rev+trailing_three_prime
-  end
-
-  # ========================================================================= #
-  # === show_seq_4
-  # ========================================================================= #
-  def show_seq_4
-    erev padding?+leading_five_prime+sfancy(seq4?)+rev+trailing_three_prime
-  end
-
-  # ========================================================================= #
-  # === show_seq_5
-  # ========================================================================= #
-  def show_seq_5
-    erev padding?+leading_five_prime+sfancy(seq5?)+rev+trailing_three_prime
-  end
-
-  # ========================================================================= #
-  # === show_seq_6
-  # ========================================================================= #  
-  def show_seq_6
-    erev padding?+leading_five_prime+sfancy(seq6?)+rev+trailing_three_prime
-  end
-
-  # ========================================================================= #
-  # === show_start_and_stop_codons
-  #
-  # This will show BOTH start and stop codons, in different colours.
-  #
-  # Since start codons may be more important, we will first locate
-  # and colourize them, and afterwards, will also colourize the
-  # stop codons.
-  # ========================================================================= #
-  def show_start_and_stop_codons
-    _ = string?
-    start_codon = ::Bioroebe.start_codon?
-    stop_codons = ::Bioroebe.stop_codons?
-    _.gsub!(/(#{start_codon})/, yellow+'\\1'+colour_for_nucleotide)
-    stop_codons.each {|stop_codon|
-      _.gsub!(/(#{stop_codon})/, salmon('\\1')+colour_for_nucleotide)
-    }
-    erev 'Start codon: '+yellow+start_codon+rev
-    stop_codons = stop_codons.join(', ').strip
-    stop_codons.chop! if stop_codons.end_with? ','
-    # ======================================================================= #
-    # Show the stop codons that we will use:
-    # ======================================================================= #
-    erev 'Stop codons: '+salmon(stop_codons)+rev
-    erev dna_padding(_)
-  end
-
-  # ========================================================================= #
-  # === report_when_the_bioroebe_project_was_last_updated
-  # ========================================================================= #
-  def report_when_the_bioroebe_project_was_last_updated
-    result = 'The Bioroebe-Project was last updated on: '+
-              slateblue(LAST_UPDATE)+rev
-    result = result.dup
-    n_days_difference = ((Time.now - Time.parse(LAST_UPDATE))/60/60/24).round(2).to_s
-    result << ' (~'+n_days_difference.to_s+' days ago)'
-    erev result
-  end
-
-  # ========================================================================= #
-  # === show_information_about_the_gff_format
-  # ========================================================================= #
-  def show_information_about_the_gff_format
-    erev 'Fields must be tab-separated in the .gff format.'
-    e
-    erev 'All but the final field in each feature line must'
-    erev 'contain a value; "empty" columns should be denoted with a "."'
-    e
-    egold 'seqname:'
-    erev 'This is the name of the chromosome or scaffold; chromosome names'
-    erev 'can be given with or without the "chr" prefix.'
-    erev 'Important note: the seqname must be one used within Ensembl, '
-    erev 'i.e. a standard chromosome name or an Ensembl identifier such as a'
-    erev 'scaffold ID, without any additional content such as species or'
-    erev 'assembly. See the example GFF output below.'
-    e
-    egold 'source:'
-    erev 'Name of the program that generated this feature, or '
-    erev 'the data source (database or project name)'
-    e
-    egold 'feature:'
-    erev 'feature type name, e.g. Gene, Variation, Similarity'
-    e
-    egold 'start:'
-    erev 'Start position of the feature, with sequence numbering starting at 1.'
-    e
-    egold 'end:'
-    erev 'End position of the feature, with sequence numbering '\
-         'starting at 1.'
-    e
-    egold 'score:'
-    erev 'A floating point value.'
-    e
-    egold 'strand:'
-    erev 'defined as + (forward) or - (reverse).'
-    e
-    egold "frame:"
-    erev " - One of '0', '1' or '2'. '0' indicates that the first base "
-    erev "of the feature is the first base of a codon, '1' that the second "
-    erev "base is the first base of a codon, and so on."
-    e
-    egold 'attribute:'
-    erev 'A semicolon-separated list of tag-value pairs, providing '
-    erev 'additional information about each feature.'
-    e
-  end
-
-  # ========================================================================= #
-  # === show_header_of_this_pdb_file
-  # ========================================================================= #
-  def show_header_of_this_pdb_file(i)
-    lines  = File.readlines(i)
-    first  = lines.first.split(' ')[1..-1].join(' ').strip
-    second = lines[1].split(' ')[1..-1].join(' ').strip
-    erev first
-    erev '  '+second
-  end
-
-  # ========================================================================= #
-  # === show_useful_URLs
-  #
-  # This method will simply show some important, bioinformatics related
-  # URLs. In particular URLs that may be important for bioinformatics
-  # related tasks, e. g. NCBI, GeneBank and so forth.
-  # ========================================================================= #
-  def show_useful_URLs
-    e
-    erev 'NCBI:    '+sfancy(obtain_url_for(:ncbi))
-    erev 'GenBank: '+sfancy(obtain_url_for(:genbank))
-    erev 'PDB:     '+sfancy(obtain_url_for(:pdb))
-    erev 'Prosite: '+sfancy(obtain_url_for(:prosite))
-    e
-  end
-
-  # ========================================================================= #
-  # === show_header_of
-  # ========================================================================= #
-  def show_header_of(i)
-    if i.is_a? Array
-      i.each {|entry| show_header_of(entry) }
-    else
-      unless File.exist? i
-        erev "No file exists at `#{sfile(i)}#{rev}`."
-        return
-      end
-      case i
-      # ===================================================================== #
-      # === .pdb
-      # ===================================================================== #
-      when /\.pdb$/
-        show_header_of_this_pdb_file(i)
-      end
-    end
-  end
-
-  # ========================================================================= #
-  # === show_GFP_sequence                                           (gfp tag)
-  #
-  # This method will show the GFP sequence, on the DNA level.
-  # ========================================================================= #
-  def show_GFP_sequence
-    erev return_five_prime_header+
-         return_default_GFP_sequence
-  end
-
-  # ========================================================================= #
-  # === return_default_GFP_sequence
-  # ========================================================================= #
-  def return_default_GFP_sequence(
-      path_to_the_file = FILE_GFP_SEQUENCE
-    )
-    Fasta.new(path_to_the_file) { :be_quiet }.return_sequence
-  end
-
-  # ========================================================================= #
-  # === try_to_show_the_configuration
-  # ========================================================================= #
-  def try_to_show_the_configuration
-    @config.show_config if @config.respond_to? :show_config
-    _ = verbose_truth(use_expand_cd_aliases?)
-    colourized_yes_or_no = simp(_.to_s)
-    erev 'Will we use class Rcfiles::DirectoryAliases: '+
-         colourized_yes_or_no
-  end
-
-  require 'bioroebe/aminoacids/aminoacids_mass_table.rb'
-  # ========================================================================= #
-  # === show_aminoacids_mass_table
-  #
-  # This shows the weight of the aminoacids, in a table-layout.
-  # ========================================================================= #
-  def show_aminoacids_mass_table
-    AminoacidsMassTable.report_which_file_is_used
-    AminoacidsMassTable.show(padding?) # bl aminoacids_mass_table.rb
-  end; alias aminoacid_table_overview show_aminoacids_mass_table # === show_aminoacids_mass_table
-
-  require 'bioroebe/utility_scripts/pathways.rb'
-  # ========================================================================= #
-  # === show_all_pathways
-  #
-  # Simply show all Pathways.
-  # ========================================================================= #
-  def show_all_pathways
-    ::Bioroebe::Pathways.show_all_pathways
-  end
-
-  # ========================================================================= #
-  # === show_sequence_in_splitted_form
-  #
-  # We will show the main DNA sequence in a three-letter splitted form.
-  #
-  # You can optionally use an argument, the first argument, a number. By
-  # default this is 3, so we will split into chunks of 3.
-  #
-  # The second argument says which token we will use for rejoining. It
-  # defaults to ' ' so the nucleotides will be rejoined via ' ', but
-  # you can also use another token such as '-', which may lead to a
-  # String such as 'ATG-CGA-ACC' and so forth.
-  # ========================================================================= #
-  def show_sequence_in_splitted_form(
-      how_many                     = 3,
-      use_this_token_for_rejoining = ' ' # <- Which token to use for the re-joining action.
-    )
-    case how_many
-    when nil, :default # Use a default value here.
-      how_many = 3
-    end
-    result = '.' * how_many.to_i
-    use_this_regex = /#{result}/
-    if string?.empty?
-      erev 'Please first "assign" a sequence.'
-    else
-      if block_given?
-        yielded = yield
-        if yielded.is_a? Hash
-          # ================================================================= #
-          # === :use_this_token
-          # ================================================================= #
-          if yielded.has_key? :use_this_token
-            use_this_token_for_rejoining = yielded.delete(:use_this_token)
-          end
-        end
-      end
-      string = string?.to_s
-      scanned = string.scan(use_this_regex)
-      scanned.map! {|entry|
-        # =================================================================== #
-        # Colourize start codons next.
-        # =================================================================== #
-        if is_this_a_start_codon? entry
-          entry = mediumseagreen(entry)+
-                  return_colour_for_nucleotides
-        elsif is_this_a_stop_codon? entry
-          entry = mediumorchid(entry)+
-                  return_colour_for_nucleotides
-        end
-        entry
-      }
-      _ = scanned.join(use_this_token_for_rejoining)
-      # ===================================================================== #
-      # Finally show the sequence.
-      # ===================================================================== #
-      erev left_padding?+
-           five_prime+
-           return_colour_for_nucleotides+
-           _+
-           rev+
-           three_prime
-    end
-  end
-
-  # ========================================================================= #
-  # === show_disulfides
-  #
-  # Show the (possible) disulfide positions in a protein.
-  # ========================================================================= #
-  def show_disulfides
-    _ = aminoacid_sequence?
-    if _.include? 'C'
-      n_cytosines = _.count('C')
-      erev "This aminoacid sequence has #{steelblue(n_cytosines.to_s)}#{rev} cysteines."
-      if n_cytosines > 1
-        erev 'Thus, there could be disulfide bonds. '+
-             gold(cheerful_person)+rev
-        show_sequence_with_a_ruler(:default, _)
-        erev 'The positions of cysteines are at:'
-        _.chars.each_with_index {|aminoacid, index|
-          if aminoacid == 'C'
-            erev 'Position: '+steelblue((index+1).to_s.rjust(3))
-          end
-        }
-      end
-    else
-      e 'This aminoacid sequence has no cystein. Thus, '\
-        'there can not be any disulfide bonds.'
-    end
-  end
-
-  # ========================================================================= #
-  # === show_aminoacids_residues
-  # ========================================================================= #
-  def show_aminoacids_residues
-    erev 'The aminoacid residues are:'; e
-    ENGLISH_LONG_NAMES_FOR_THE_AMINO_ACIDS.each {|this_aminoacid|
-      erev this_aminoacid.ljust(14)+': '+
-           simp(AMINO_ACIDS_RESTE[this_aminoacid.downcase]) # Must downcase.
-    }; e
-  end
-
-  # ========================================================================= #
-  # === show_hint_how_to_use_the_local_sequences
-  #
-  # Show a hint for the user.
-  # ========================================================================= #
-  def show_hint_how_to_use_the_local_sequences
-    unless return_fasta_files_in_the_log_directory.empty?
-      erev 'You can load up any of these sequences by issuing:'
-      e
-      erev '  use_this_fasta 1 # for file number 1'
-      e
-    end
-  end
-
-  # ========================================================================= #
-  # === colour_for_stop_codon
-  # ========================================================================= #
-  def colour_for_stop_codon(i)
-    orange(i)
-  end
-
-  # ========================================================================= #
-  # === colour_for_nucleotide
-  # ========================================================================= #
-  def colour_for_nucleotide(i = '')
-    royalblue(i)
-  end; alias colour_for_nucleotides colour_for_nucleotide # === colour_for_nucleotides
-
-  # ========================================================================= #
-  # === report_this_dna_sequence_with_proper_trailer_and_leader
-  # ========================================================================= #
-  def report_this_dna_sequence_with_proper_trailer_and_leader(i)
-    i = i.to_s
-    if block_given?
-      yielded = yield
-      case yielded
-      when :try_to_colourize_start_codon
-        # =================================================================== #
-        # We will try to colourize the start codon here.
-        # =================================================================== #
-        if i.start_with? start_codon?
-          i[0,3] = cyan(i[0,3])+return_colour_for_nucleotides
-        end
-      end
-    end
-    colourized_dna_sequence = colourize_this_dna_sequence(i)
-    colourized_dna_sequence = remove_trailing_escape_code(
-      colourized_dna_sequence
-    )
-    erev left_pad?+
-         leading_5_prime+
-         colourized_dna_sequence+
-         rev+
-         trailing_3_prime
-  end
-
-  # ========================================================================= #
-  # === show_hydropathy_table
-  #
-  # Show the hydropathy table.
-  # ========================================================================= #
-  def show_hydropathy_table
-    e
-    HYDROPATHY_TABLE.each_pair {|aminoacid_one_letter, hydropathy_value|
-      e '  '+sfancy(aminoacid_one_letter)+'  | '+
-        simp(hydropathy_value.to_s.rjust(4))
-    }; e
-  end
-
-  # ========================================================================= #
-  # === show_known_nls_sequences
-  #
-  # This Wikipedia page may be useful:
-  #   http://en.wikipedia.org/wiki/Nuclear_localization_sequence
-  # ========================================================================= #
-  def show_known_nls_sequences
-    erev 'These NLS sequences are known:'+N+N
-    padding = 36
-    NUCLEAR_LOCALIZATION_SEQUENCES.each_pair {|key, value|
-      e sfancy(key.ljust(padding))+' '+value
-    }
-  end
-
-  # ========================================================================= #
-  # === report_mode
-  # ========================================================================= #
-  def report_mode
-    erev mode?
-  end
-
-  # ========================================================================= #
-  # === show_reste
-  #
-  # This will show the residues of the various amino acids.
-  # ========================================================================= #
-  def show_reste
-    e; AMINO_ACIDS_RESTE.each_pair {|key, value|
-      erev '  '+key.ljust(14)+' -> '+sfancy(value)
-    }; e
-  end
-
-  require 'bioroebe/string_matching/simple_string_comparer.rb'
-  # ========================================================================= #
-  # === show_sixpack_alignment
-  #
-  # We will feed some input to class Bioroebe::SimpleStringComparer.
-  # ========================================================================= #
-  def show_sixpack_alignment(
-      i = dna_sequence_object?
-    )
-    erev 'Input sequence 1:'
-    string1 = $stdin.gets.chomp
-    erev 'Input sequence 2:'
-    string2 = $stdin.gets.chomp
-    # ======================================================================= #
-    # Delegate into class SimpleStringComparer next.
-    # ======================================================================= #
-    _ = ::Bioroebe::SimpleStringComparer.new(:dont_run_yet) # bl $BIOROEBE/string_matching/simple_string_comparer.rb
-    _.set_main_alignment_token_to '|'
-    _.string1 = string1
-    _.string2 = string2
-    _.compare
-  end
-
-  # ========================================================================= #
-  # === show_average_weight_of_a_nucleotide
-  #
-  # The formulat was obtained from the following website:
-  #
-  #   http://www.biophp.org/minitools/useful_formulas/demo.php
-  #
-  # ========================================================================= #
-  def show_average_weight_of_a_nucleotide
-    erev 'The average molecular weight (MW) of dsDNA is '+sfancy('660')+' Da.'
-    erev 'The average molecular weight (MW) of ssDNA is '+sfancy('330')+' Da.'
-  end
-
-  # ========================================================================= #
-  # === show_config_dir
-  #
-  # This method will show the configuration directory.
-  # ========================================================================= #
-  def show_config_dir
-    config_dir = File.dirname(__FILE__)+'/configuration/'
-    erev 'The configuration directory for the Bioroebe::Shell is at:'
-    erev '  `'+sfile(config_dir)+rev+'`'
-  end
-
-  # ========================================================================= #
-  # === show_last_downloaded_file
-  # ========================================================================= #
-  def show_last_downloaded_file
-    if @array_all_downloads.empty?
-      erev 'We have not yet downloaded any file.'
-    else
-      erev 'The last downloaded data was: '+
-            sfancy(@array_all_downloads.last)
-    end
-  end
-
-  # ========================================================================= #
-  # === show_jumper_directories
-  # ========================================================================= #
-  def show_jumper_directories
-    if @internal_hash[:array_jumper_directories].empty?
-      erev 'No jumper directory has been assigned yet.'
-    else
-      erev 'The available jumper directories are:'
-      pp @internal_hash[:array_jumper_directories]
-    end
-  end
-
-  # ========================================================================= #
-  # === show_save_file
-  # ========================================================================= #
-  def show_save_file
-    erev 'We will store into the file '+sfile(save_file?)+rev+'.'
-    erev 'If you wish to instead store into the current directory,'
-    erev 'input "save_here".'
-  end
-
-  # ========================================================================= #
-  # === show_sigma_tutorial
-  #
-  # This method tells the user a bit about the sigma factors.
-  # ========================================================================= #
-  def show_sigma_tutorial
-    erev 'This subsection contains some information about Sigmafactors.'
-    e
-    erev 'A sigma factor a protein needed for initiation of RNA synthesis.'
-    e
-    erev 'It is a bacterial transcription initiation factor.'
-    e
-    erev 'It will enable the specific binding of RNA polymerase to gene promoters.'
-    e
-    erev 'Sigma factors vary, which allows the bacterial cell to respond to'
-    erev 'different environmental signals.'
-    e
-    erev 'Every molecule of RNA polymerase holoenzyme will contain only one '\
-         'sigma factor.'
-    e
-    erev 'The number of sigma factors varies between bacterial species.'
-    e
-    erev 'E. coli has seven sigma factors.'
-    e
-    erev 'Sigma factors are distinguished by their characteristic molecular '\
-         'weights.'
-    e
-    erev 'For instance, sigma-70 refers to the sigma factor with a molecular '\
-         'weight of 70 kDa.'
-    e
-    erev 'Once initiation of RNA transcription is complete, the sigma'
-    erev 'factor can leave the complex.'
-    e
-    erev 'Sigmafactor rpoD 70 can be found here:'
-    e '  '+simp('http://www.ncbi.nlm.nih.gov/gene/947567')
-  end
-
-  # ========================================================================= #
-  # === show_last_input
-  #
-  # sli can be used as command to access this method.
-  # ========================================================================= #
-  def show_last_input
-    if readline_is_available?
-      e sfancy(Readline::HISTORY[-1])
-      Readline::HISTORY.pop
-    end
-    e "The last user input was: #{sfancy(@user_input)}"
-  end
-
-  # ========================================================================= #
-  # === show_mnemo
-  #
-  # A little helper-method to memorize things.
-  # ========================================================================= #
-  def show_mnemo
-    e
-    erev 'Amino Acids with negatively charged side groups: -'
-    e sfancy('  D E')
-    erev 'Amino Acids with positive charged side groups: +'
-    e sfancy('  K R H')
-    e
-    e sfancy('Oxidoreduktasen:')+rev+' Oxidations-Reduktions-Reaktionen'
-    e sfancy('Transferasen:')+rev+'    Übertragung funktioneller Gruppen'
-    e sfancy('Hydrolasen:')+rev+'      Hydrolasereaktionen'
-    e sfancy('Lyasen:')+rev+'          Eliminierung von Gruppen unter '\
-      'Ausbildung von Doppelbindungen'
-    e sfancy('Isomerasen:')+rev+'      Isomerisierungen'
-    e sfancy('Ligasen:')+rev+'         ATP-hydrolytic formation of bonds'
-    e
-  end
-
-  # ========================================================================= #
-  # === show_histone_table
-  # ========================================================================= #
-  def show_histone_table
-    erev 'The following table will show Calf Thymus Histones:'
-    e
-    erev 'Histone | number of residues | mass in kDa | n% Arginine | n% Lysine'
-    erev '  H1             215               23.0          1             29'
-    erev '  H2A            129               14.0          9             11'
-    erev '  H2B            125               13.8          6             16'
-    erev '  H3             135               15.3         13             10'
-    erev '  H4             102               11.3         14             11'
-    e
-  end
-
-  # ========================================================================= #
-  # === show_average_weight_of_an_aminoacid
-  #
-  # Show the average weight for an aminoacid that is part of a protein.
-  # ========================================================================= #
-  def show_average_weight_of_an_aminoacid
-    erev 'The average molecular weight (MW) of an amino '\
-         'acid is '+sfancy('110')+' Da.'
-  end
-
-  # ========================================================================= #
-  # === show_first_orf
-  #
-  # This will show the first ORF.
-  #
-  # Invocation example:
-  #
-  #   show_first_orf
-  #
-  # ========================================================================= #
-  def show_first_orf(
-      of_this_sequence = dna_sequence_object?
-    )
-    _ = of_this_sequence
-    return_all_possible_start_codons.each {|this_codon|
-      if _.include? this_codon
-        index = _.index(this_codon)
-        sequence = _[index..-1]
-        e rev+padding?+leading_5_prime+sfancy(sequence)+
-          rev+trailing_3_prime+' (Start position at nucleotide: '+
-          orange((index+1).to_s)+rev+')'
-      else
-        erev 'Not found the codon '+simp(this_codon)+rev+'.'
-      end
-    }
-  end
-
-  # ========================================================================= #
-  # === show_available_vectors
-  # ========================================================================= #
-  def show_available_vectors
-    erev 'We will next try to show the available vectors.'
-    erev 'For now, these are all file names that start with the '\
-         'the prefix '+orange('vector_')+rev+'.'
-    _ = return_available_vectors # Defined in bioroebe/shell.rb
-    if _.empty?
-      erev 'No vector-sequence was found.'
-    else
-      erev 'We found at the least one entry.'
-      print '  '
-      pp _
-      erev 'Assigning the first one to the second sequence.'
-      set_sequence_2(Bioroebe::Sequence.sequence_from_file(_.first))
-      erev 'You can feedback this sequence via:'
-      e
-      erev '  seq2?'
-      e
-    end
-  end
-
-  # ========================================================================= #
-  # === report_current_genbank_version
-  #
-  # You can use this method to report the current genbank version.
-  # ========================================================================= #
-  def report_current_genbank_version(
-      optional_arguments = nil
-    )
-    remote_url = 'https://www.ncbi.nlm.nih.gov/genbank/statistics/'
-    if optional_arguments
-      case optional_arguments
-      when :also_report_the_URL
-        erev 'We will obtain the latest Genbank version from the URL:'
-        e
-        erev "  #{simp(remote_url)}"
-        e
-      end
-    end
-    remote_dataset = URI.open(remote_url).read.split(N)
-    # ======================================================================= #
-    # For the following Regex, see this link:
-    #
-    #   https://rubular.com/r/XC97c7i6sR
-    #
-    # ======================================================================= #
-    regex_to_use =
-      /<td>(\d{1,3})<\/td><td>(.{1,3}\s{1,3}\d{4})<\/td><td>\d+<\/td><td>\d+<\/td><td>\d+<\/td><td>\d+<\/td><\/tr><\/tbody><\/table>$/
-    _ = ''.dup
-    is_open = false
-    remote_dataset.each {|line|
-      if line.include? '<table id="stats_table" summary="GENBANK AND WGS'
-        _ << line
-        is_open = true
-      else
-        _ << line if is_open
-        if line.include? '</table>'
-          is_open = false
-        end
-      end
-    }
-    _ =~ regex_to_use # Match the regex against the substring assigned to _.
-    version        = $1.to_s.dup
-    month_and_year = $2.to_s.dup
-    erev 'The current Genbank version is: '+simp(version)+
-         rev+' (released on '+simp(month_and_year)+rev+')'
-  end
-
-  # ========================================================================= #
-  # === show_copyright_clause
-  #
-  # This method will simply show the licence used for the project.
-  #
-  # This has to be updated manually, though; and since the licence
-  # may change one day, I will keep track when this method has been
-  # last modified, which is on the 28.04.2020 (28th April, 2020).
-  # ========================================================================= #
-  def show_copyright_clause
-    e
-    erev 'This project is free software, licensed under the LGPL-2.0 license.'
-    erev 'No "any later clause"; LGPL-2.0 applies to it.'
-    e
-    erev '  Copyright: Robert A. Heiler (2010-2020 and later)'
-    e
-    erev 'The biomart component is licensed under the MIT license and is'
-    erev 'written by Darren Oakley. The MIT license is retained for the'
-    erev 'Biomart component.'
-    e
-    erev '(Note that the bioroebe project used to be under the GPL licence'
-    erev 'before some time; see the homepage of this gem for the explanation'
-    erev 'as to why a switch occurred towards LGPL.)'
-  end
-
-  # ========================================================================= #
-  # === report_n_proteins_registered_in_swiss_prot
-  #
-  # This method will report how many proteins are registered in swiss-prot.
-  #
-  # Invoke this method like so:
-  #
-  #   swiss-prot?
-  #
-  # ========================================================================= #
-  def report_n_proteins_registered_in_swiss_prot
-    regex_to_use = /contains (\d+) sequence entries/ # See: http://rubular.com/r/Bl9tHfheEx
-    url = 'https://web.expasy.org/docs/relnotes/relstat.html'
-    dataset = open(url).read
-    dataset =~ regex_to_use
-    n_registered_proteins = $1.to_s.dup
-    erev 'There are '+simp(n_registered_proteins)+rev+' registered '\
-         'proteins in the Swiss-Prot database.'
-    erev "The URL used to determine this was: "\
-         "#{simp(url)}"
-  end
-
-
-  # ========================================================================= #
-  # === report_whether_readline_is_available
-  # ========================================================================= #
-  def report_whether_readline_is_available
-    erev 'Is readline available? '+
-      slateblue(
-        verbose_truth(
-          (Object.const_defined? :Readline)
-        )
-      )
-  end
-
-  require 'bioroebe/dotplots/advanced_dotplot.rb'
-  # ========================================================================= #
-  # === show_2D_dotplot
-  # ========================================================================= #
-  def show_2D_dotplot(
-      string1 = nil, string2 = nil
-    )
-    if string1.nil? and string2.nil?
-      erev 'You want to use a dotplot.'
-      erev 'Please provide the first string, which will be on the left side:'
-      string1 = $stdin.gets.chomp
-      erev 'Please provide the second string, which will be on the top side:'
-      string2 = $stdin.gets.chomp
-    end
-    ::Bioroebe::AdvancedDotplot.new(string1, string2)
-  end
-
-  # ========================================================================= #
-  # === show_reverse_dna_string
-  #
-  # This method will simply show the DNA sequence reversed.
-  # ========================================================================= #
-  def show_reverse_dna_string
-    erev padding?+
-         leading_five_prime+
-         sfancy(return_reverse_dna_string)+
-         rev+
-         trailing_three_prime
-  end
-
-  # ========================================================================= #
-  # === show_download_dir
-  # ========================================================================= #
-  def show_download_dir
-    erev ::Bioroebe.download_directory?
-  end
-
-  # ========================================================================= #
-  # === show_this_sequence_padded
-  #
-  # Usage example:
-  #
-  #   show_this_sequence_padded ATGACTTAGCCACAACTGCATGCATATGCATGACTGACT
-  #
-  # ========================================================================= #
-  def show_this_sequence_padded(
-      i = dna_sequence_object?
-    )
-    if i.is_a? Array and i.empty?
-      i << dna_sequence_object?
-    end
-    if i.is_a? Array
-      i = i.join
-    end
-    # ======================================================================= #
-    # First, split it into an array of 80 characters each.
-    # ======================================================================= #
-    array = i.scan(/.{,80}/).reject {|entry| entry.empty? }
-    array.each {|entry|
-      erev entry
-    }
-  end
-
-  require 'bioroebe/enzymes/restriction_enzymes_file.rb'
-  # ========================================================================= #
-  # === show_all_yaml_files
-  #
-  # We show which yaml files we will use here.
-  # ========================================================================= #
-  def show_all_yaml_files
-    erev 'The file that holds our restriction enzymes can be found here:'
-    e
-    erev "  #{sfile(::Bioroebe.restriction_enzymes_file)}"
-    e
-  end
-
-  # ========================================================================= #
-  # === show_resources_about_the_horseradish_peroxidase
-  # ========================================================================= #
-  def show_resources_about_the_horseradish_peroxidase
-    e 'https://www.ncbi.nlm.nih.gov/gene/?term=%22Horseradish+Peroxidase%22'
-    e 'https://www.ncbi.nlm.nih.gov/gene/836533'
-    e 'Fasta: https://www.ncbi.nlm.nih.gov/nuccore/NC_003076.8?report=fasta&from=25659257&to=25661007&strand=true'
-  end
-
-  # ========================================================================= #
-  # === report_whether_we_will_make_use_of_expand_cd_aliases
-  # ========================================================================= #
-  def report_whether_we_will_make_use_of_expand_cd_aliases
-    erev Bioroebe::VerboseTruth[use_expand_cd_aliases?]
-  end
-
-  # ========================================================================= #
-  # === report_useful_packages_installed
-  #
-  # This aggregate method can be used to report versions that may be
-  # installed on the given system, e. g. science-based projects and
-  # similar variants.
-  # ========================================================================= #
-  def report_useful_packages_installed
-    try_to_report_the_version_of_viennarna
-    try_to_report_the_version_of_bedtools
-  end
-
-  # ========================================================================= #
-  # === try_to_report_the_version_of_viennarna
-  #
-  # This method can be used to see the version of ViennaRNA, if it is
-  # installed at all.
-  # ========================================================================= #
-  def try_to_report_the_version_of_viennarna
-    result = `RNAplfold --version 2>&1`
-    if result.include? 'command not found'
-      e
-      erev 'ViennaRNA does not appear to be installed / available.'
-      e
-      if is_on_roebe?
-        erev 'You may be able to install it via:'
-        e
-        erev '  rbt viennarna'
-        e
-      end
-    else
-      version = result.sub(/RNAplfold/,'').strip.to_s
-      erev 'The version of ViennaRNA is: '+
-         orange(version)+rev
-    end
-  end
-
-  # ========================================================================= #
-  # === report_current_working_directory
-  # ========================================================================= #
-  def report_current_working_directory
-    erev 'We are in the directory:'
-    erev "  #{sdir(return_working_directory)}"
-  end
-
-  # ========================================================================= #
-  # === report_which_yaml_engine_is_in_use
-  # ========================================================================= #
-  def report_which_yaml_engine_is_in_use
-    erev 'The yaml engine in use is: '+
-         sfancy(::Bioroebe.use_which_yaml_engine?)+
-         rev
-  end
-
-  begin
-    require 'directory_paradise'
-  rescue LoadError; end
-  # ========================================================================= #
-  # === show_file_listing
-  #
-  # Make use of DirectoryContent to show the content of a file.
-  #
-  # To invoke this method from within the Bioroebe::Shell, do:
-  #
-  #   ll
-  #
-  # ========================================================================= #
-  def show_file_listing(
-      from_this_directory = Dir.pwd
-    )
-    _ = DirectoryParadise::Report.new(from_this_directory, :dont_run_yet)
-    _.dont_report_total_filesize
-    _.disable_colours unless use_colours?
-    _.run
-  end
-
-  # ========================================================================= #
-  # === try_to_report_the_version_of_bedtools
-  # ========================================================================= #
-  def try_to_report_the_version_of_bedtools
-    result = `bedtools --version 2>&1`
-    if result.include? 'command not found'
-      e
-      erev 'The bedtools do not appear to be installed / available.'
-      e
-      if is_on_roebe?
-        erev 'You may be able to install it via:'
-        e
-        erev '  rbt bedtools'
-        e
-      end
-    else
-      version = result.sub(/bedtools/,'').strip.to_s.delete('v')
-      erev "The version of bedtools is: "\
-           "#{orange(version)}#{rev}"
-    end
-  end
-
-  # ========================================================================= #
-  # === three_to_one
-  #
-  # This method will translate, and output, a three-letter aminoacid
-  # into the corresponding single-letter code.
-  #
-  # Invocation example:
-  #
-  #   three_to_one Thr Thr Glu Ala Val Glu Ser Thr Val Ala Thr Leu Glu Asp Ser # => T T E A V E S T V A T L E D S
-  #   3to1 ARG-ALA-SER-LEU-PHE-TRP-LYS-HIS-ASN-SER-VAL-LEU-ILE-VAL-PRO
-  #
-  # ========================================================================= #
-  def three_to_one(i)
-    if i.is_a? Array
-      i = i.join('-').strip
-    end
-    e ::Bioroebe.three_to_one(i).strip
-  end
-
-  require 'bioroebe/codons/codons.rb'
-  # ========================================================================= #
-  # === show_codons_of_this_aminoacid_or_show_kazusa_codon
-  #
-  # This method can be used to output which codon codes for a specific
-  # aminoacid.
-  #
-  # The input to this method should be a specific codon, such as ATG or
-  # GGC and so forth.
-  #
-  # If no input is provided, we will instead show the webpage of
-  # kazusa.
-  #
-  # Invocation examples:
-  #
-  #   codon? ATG # => M
-  #   codon? AUG # => M
-  #
-  # ========================================================================= #
-  def show_codons_of_this_aminoacid_or_show_kazusa_codon(i = nil)
-    if i.is_a? Array
-      i = i.first
-    end
-    if i # If the user provided input, we check it.
-      # ===================================================================== #
-      # Next, find all codons for the given aminoacid.
-      # ===================================================================== #
-      e ::Bioroebe.codon_to_aminoacid(i)
-    else
-      erev "The URL is at: "\
-           "#{simp('http://www.kazusa.or.jp/codon/')}"
-    end
-  end
-
-  # ========================================================================= #
-  # === return_reverse_dna_string
-  # ========================================================================= #
-  def return_reverse_dna_string
-    complement_sequence?.reverse
-  end
-
-  # ========================================================================= #
-  # === showorf                                                 (showorf tag)
-  #
-  # Use this method to show the open reading frame of a given sequence.
-  #
-  # We can also use it to selectively show a certain frame, such as
-  # frame2. See class Bioroebe::ShowOrf for this.
-  #
-  # Note that in May 2020 (10.05.2020) class Bioroebe::ShowOrf here
-  # was replaced with 
-  # ========================================================================= #
-  def showorf(
-      i                    = dna_sequence_object?,
-      show_how_many_frames = :show_three_frames
-    )
-    i = dna_sequence_object? if i.nil?
-    i = dna_sequence_object? if i.is_a?(Array) and i.empty?
-    display_open_reading_frames(i) { show_how_many_frames }
-  end
-
-  # ========================================================================= #
-  # === display_open_reading_frames
-  #
-  # Invocation example:
-  #
-  #   display_open_reading_frames ATGAGCAAGGCCGACTACGAGAAG
-  #
-  # ========================================================================= #
-  def display_open_reading_frames(
-      i = dna_sequence_object?, &block
-    )
-    i = i.first if i.is_a? Array
-    i = dna_sequence_object? if i.nil?
-    i = dna_sequence_object? if i.empty?
-    require 'bioroebe/utility_scripts/display_open_reading_frames/display_open_reading_frames.rb'
-    ::Bioroebe::DisplayOpenReadingFrames.new(i, &block)
-  end
-
-  require 'bioroebe/fasta_and_fastq/show_fasta_headers.rb'
-  # ========================================================================= #
-  # === show_fasta_headers
-  #
-  # Just show the fasta headers.
-  # ========================================================================= #
-  def show_fasta_headers(i)
-    ::Bioroebe::ShowFastaHeaders.new(i) # Delegate into class Bioroebe::ShowFastaHeaders.
-  end
-
-  # ========================================================================= #
-  # === show_commandline_options
-  #
-  # Show the available commandline options.
-  #
-  # To invoke this method from the commandline, do:
-  #
-  #   bioroebe --help
-  #
-  # ========================================================================= #
-  def show_commandline_options
-    e
-    ecomment('  --silent               # perform a silent startup')
-    ecomment('  --sequence             # use this nucleotide sequence on '\
-             'startup; can be a number too such as 150')
-    ecomment('  --n_fasta_entries      # report how many fasta '\
-             'entries are in this directory')
-    ecomment('  --disable-opn          # permanently disable opn')
-    ecomment('  --random-aminoacids=33 # "generate" 33 random amino acids and display them')
-    ecomment('  --n-aminoacids=33      # an alias to the ^^^ above')
-    ecomment('  --protein-to-dna       # convert protein-aminoacid '\
-             'sequence back to DNA')
-    e
-    exit
-  end
-
-  # ========================================================================= #
-  # === show_codon_table
-  # ========================================================================= #
-  def show_codon_table(i = nil)
-    if i and i.is_a?(Array) and i.empty?
-      i << 1 # Default to the vertebrate codon table in this case.
-    end
-    ShowThisCodonTable.new(i)
-  end
-
-  # ========================================================================= #
-  # === show_rna_sequence
-  #
-  # Use this method to convert a given sequence to RNA.
-  # ========================================================================= #
-  def show_rna_sequence(
-      i = sequence_object?.to_rna
-    )
-    i = sequence_object?.to_rna if i.nil?
-    i = i.to_str if i.respond_to? :to_str
-    if i.include? 'T'
-      i.tr!('T','U')
-    end
-    display_nucleotide_object?.display(i) {{ use_this_as_padding: lpad? }}
-  end
-
-  # ========================================================================= #
-  # === report_size_of
-  # ========================================================================= #
-  def report_size_of(
-      i = nil
-    )
-    if i.nil?
-      i = dna_sequence_object?
-    end
-    if i
-      erev "This sequence contains #{sfancy(i.size.to_s)}#{rev} nucleotides."
-    else
-      report_size_of_main_string
-    end
-  end
-
-  # ========================================================================= #
-  # === display_glycolysis_pathway
-  #
-  # This method will show the glycolysis Pathway.
-  # ========================================================================= #
-  def display_glycolysis_pathway
-    array = Pathways.glycolysis_pathway # Obtain the glyclosis pathway, as Array.
-    if Object.const_defined? :Display
-      Display.display(array, ')')
-    else
-      array.each {|entry| e ' - '+entry }
-    end
-  end
-
-  # ========================================================================= #
-  # === show_the_weight_of_some_common_proteins
-  # ========================================================================= #
-  def show_the_weight_of_some_common_proteins(
-      use_this_file = FILE_WEIGHT_OF_COMMON_PROTEINS
-    )
-    erev 'Showing the weight of some common proteins next (in kDa):'
-    e
-    dataset = File.readlines(use_this_file).select {|line|
-      line.include? ' # '
-    }
-    dataset.each {|line|
-      splitted = line.split(':')
-      key = splitted[0]
-      value = splitted[1 .. -1].join(' ').strip
-      erev "  #{(key+':').ljust(25)} "\
-           "#{lightblue((value.to_s+' kDa').rjust(12))}"
-    }
-    e
-  end
-
-  # ========================================================================= #
-  # === show_protein_composition
-  #
-  # Delegate towards class CountAmountOfAminoacids
-  # ========================================================================= #
-  def show_protein_composition(i)
-    ::Bioroebe::CountAmountOfAminoacids.new(i) # bl $BIOROEBE/count_amount_of_aminoacids.rb
-  end
-
-  # ========================================================================= #
-  # === show_all_deducible_aminoacid_sequences
-  #
-  # Note that if the string is too short, we won't display the other frames.
-  #
-  # If the third argument, `show_translations_aligned`, is set to
-  # true then we will additionally display all 3 frames aligned
-  # one to another.
-  #
-  # Usage example:
-  #
-  #   toproteins AUG
-  #   toproteins AUGAUGUUGAAU
-  #   toproteins AUG-AUG-UUG-AAA-GGU-CGC-AAU-STOP
-  #
-  # ========================================================================= #
-  def show_all_deducible_aminoacid_sequences(
-      i                         = dna_sequence_as_string?,
-      also_show_numbers         = true,
-      show_translations_aligned = true
-    )
-    if i and i.is_a?(Array) and i.empty?
-      i = dna_sequence_as_string?
-    end
-    i = dna_sequence_as_string? if i.nil?
-    i = i.join(' ').strip if i.is_a? Array
-    i = i.to_s.dup # To avoid nil-operations.
-    i.delete!('-') if i.include? '-'
-    if i.empty? # This means that the user has not yet assigned a DNA sequence.
-      erev 'Please assign some DNA sequence. You can also randomly generate'
-      erev 'a new sequence via "random".'
-      return
-    end
-    cliner
-    erev N+'The amino acid sequence for '+sfancy('Frame 1')+rev+' is: '
-    e
-    converted_sequence_for_frame_1 = translate_dna_into_aminoacid(i).to_s
-    erev '  '+converted_sequence_for_frame_1+N+N
-    # ======================================================================= #
-    # === Also show numbers
-    # ======================================================================= #
-    if also_show_numbers
-      verbose_report_numbered_amino_acid_sequence(converted_sequence_for_frame_1)
-    end
-    cliner
-    if i && i.size > 2
-      erev N+N+'The amino acid sequence for '+sfancy('Frame 2')+rev+' is: '
-      e
-      converted_sequence_for_frame_2 = translate_dna_into_aminoacid_frame2(i)
-      erev '  '+converted_sequence_for_frame_2+N+N
-      if also_show_numbers
-        verbose_report_numbered_amino_acid_sequence(converted_sequence_for_frame_2, '2')
-      end
-      cliner
-      e
-      erev N+N+'The amino acid sequence for '+sfancy('Frame 3')+rev+' is: '
-      e
-      converted_sequence_for_frame_3 = translate_dna_into_aminoacid_frame3(i)
-      erev '  '+converted_sequence_for_frame_3+N+N
-      if also_show_numbers
-        verbose_report_numbered_amino_acid_sequence(converted_sequence_for_frame_3, '3')
-      end
-      e
-      cliner
-      if show_translations_aligned
-        showorf(i) # Delegate into class Showorf here.
-      end
-    end
-  end
-
-  # ========================================================================= #
-  # === show_blosum_matrix
-  #
-  # Delegate towards bioroebe here, and invoke the .blosum() method.
-  # ========================================================================= #
-  def show_blosum_matrix
-    erev 'Showing the blosum matrix next:'
-    require 'bioroebe/blosum/blosum.rb'
-    Bioroebe::Blosum.show_matrix
-  end
-
-end; end