bioroebe 0.10.80 → 0.12.12

data/lib/bioroebe/shell/misc.rb

@@ -2,3697 +2,24 @@
 # Encoding: UTF-8
 # frozen_string_literal: true
 # =========================================================================== #
-# === Bioroebe::Shell
-#
-# This shell wraps together all related Bio tasks. It contains the
-# the core-functionality for the Bioroebe::Shell interface.
-#
-# To use it in one of your projects, do:
-#
-#   require 'bioroebe'; Bioroebe::Shell.new
-#
-# =========================================================================== #
-# require 'bioroebe/shell/misc.rb'
-# =========================================================================== #
-module Bioroebe
-
-class Shell < ::Bioroebe::CommandlineApplication
-
-  alias ee print
-
-  require 'bioroebe/toplevel_methods/misc.rb'
-  require 'bioroebe/string_matching/find_longest_substring.rb'
-
-  begin
-    require 'advanced_clipboard'
-  rescue LoadError; end
-
-  require 'bioroebe/configuration/configuration.rb'
-
-  if Bioroebe.is_on_roebe?
-    # ======================================================================= #
-    # Load up support for FtpParadise, but only on roebe-systems.
-    # ======================================================================= #
-    begin
-      require 'ftp_paradise'
-    rescue LoadError; end
-  end
-
-  # ========================================================================= #
-  # === Bioroebe::Shell.upload_this_pdf_file
-  #
-  # Use this method to upload the .pdf tutorial or any other .pdf
-  # file. This is primarily useful on my home system and may have
-  # very little value to other people.
-  # ========================================================================= #
-  def self.upload_this_pdf_file(path)
-    # ======================================================================= #
-    # ^^^ This will have generated the .pdf.
-    # ======================================================================= #
-    # Hardcoded for now where the .pdf will reside.
-    # ======================================================================= #
-    if Object.const_defined? :FtpParadise
-      ftp = FtpParadise.new(:shevy, :dont_run_yet)
-      ftp.do_login
-      ftp.upload_this_binary_file(path)
-      e 'Finished uploading!'
-    end
-  end
-
-  # ========================================================================= #
-  # === Bioroebe::Shell.generate_pdf_tutorial
-  #
-  # You can use this method to simply generate a new .pdf file, then
-  # upload it anyway.
-  # ========================================================================= #
-  def self.generate_pdf_tutorial(
-      also_upload_the_tutorial = true
-    )
-    url = ::Bioroebe.try_to_pass_through_beautiful_url('bioroebe_tutorial?pdf')
-    url = url.first if url.is_a? Array
-    url.gsub!(/^\/home\/x\/DATA\//, LOCALHOST) if url.include? HOME_DIRECTORY_OF_USER_X+'DATA/'
-    OpenURI.send(:open, url)
-    # ======================================================================= #
-    # === Designate where the tutorial can be found locally
-    # ======================================================================= #
-    path = FILE_BIOROEBE_TUTORIAL
-    if also_upload_the_tutorial
-      if File.exist? path
-        ::Bioroebe.upload_this_pdf_file(path)
-      else
-        e "Can not upload from #{sfile(path.to_s)} as this "\
-          "path does not exist."
-      end
-    end
-  end
-
-  require 'bioroebe/calculate/calculate_gc_content.rb'
-  # ========================================================================= #
-  # === calculcate_gc_content
-  #
-  # Use this method to calculate the GC content of a DNA sequence.
-  #
-  # If you need the number, you can use this piece of code:
-  #
-  #   CalculateGCContent.gc_percentage(i) # Will return the percentage number.
-  #
-  # ========================================================================= #
-  def calculcate_gc_content(
-      i = dna_sequence_as_string?
-    )
-    if i.nil? or i.empty? # The second check also checks for empty Arrays.
-      i = dna_sequence_as_string? # bl $BIOROEBE/calculate/calculate_gc_content.rb
-    end
-    CalculateGCContent.new(i)
-  end
-
-  require 'bioroebe/nucleotides/most_likely_nucleotide_sequence_for_this_aminoacid_sequence.rb'
-  # ========================================================================= #
-  # === aa_to_dna
-  # ========================================================================= #
-  def aa_to_dna(i)
-    if i.is_a? Array
-      i = i.join.strip
-    end
-    i = ::Bioroebe.aa_to_dna(i)
-    if i.is_a? Array
-      i = i.join.strip
-    end
-    e i
-  end
-
-  # ========================================================================= #
-  # === load_dna
-  #
-  # This method will assign from the default file.
-  # ========================================================================= #
-  def load_dna
-    _ = file_dna_string_saved?
-    if File.exist? _
-      erev "Now loading from the file #{sfile(_)}#{rev}."
-      assign(_)
-    end
-  end
-
-  # ========================================================================= #
-  # === file_dna_string_saved?
-  # ========================================================================= #
-  def file_dna_string_saved?
-    @internal_hash[:file_dna_string_saved]
-  end
-
-  # ========================================================================= #
-  # === to_talen
-  # ========================================================================= #
-  def to_talen(
-      i = dna_sequence?
-    )
-    i = dna_sequence? if i.nil? # Obtain the DNA sequence.
-    talen_sequence = '' # This will contain our final talen-sequence.
-    talens = YAML.load_file(::Bioroebe.file_talens)
-    i.scan(/./).each {|char|
-      talen_sequence << "{ #{talens[char]} }"
-    }
-    pp talen_sequence
-  end
-
-  # ========================================================================= #
-  # === bioshell_log_dir?
-  #
-  # This method will return where the bioshell/ log dir is kept.
-  # ========================================================================= #
-  def bioshell_log_dir?
-    "#{log_dir?}bioshell/"
-  end
-
-  # ========================================================================= #
-  # === dna_translate
-  # ========================================================================= #
-  def dna_translate(i)
-    i = i.join(' ').strip if i.is_a? Array
-    if i.nil? or i.empty?
-      if dna_sequence_as_string?
-        i = dna_sequence_as_string?
-        erev 'Using the current DNA sequence (size: '+
-             i.size.to_s+' nucleotides)'
-        # =================================================================== #
-        # assign_dna_sequence(i, :be_verbose) # First assign
-        # ^^^ Why would we want to re-assign here? Makes no sense, thus it
-        #     was disabled as of December 2021. 
-        # =================================================================== #
-      end
-    end
-    # ======================================================================= #
-    # Find and display the complement to this DNA sequence:
-    # ======================================================================= #
-    erev "The #{orange('complementary DNA Strand')}#{rev} is:"
-    e
-    show_nucleotide_sequence?.display(i) { :complementary_strand }
-    e
-  end
-
-  # ========================================================================= #
-  # === open_in_browser_tab
-  # ========================================================================= #
-  def open_in_browser_tab(i)
-    open_in_browser(i) # Defined in base.rb
-  end
-
-  # ========================================================================= #
-  # === set_mode
-  # ========================================================================= #
-  def set_mode(i = :dna)
-    case i
-    when :protein, :proteins # Aliases.
-      i = :aminoacids
-    end
-    @internal_hash[:mode] = i
-  end
-
-  # ========================================================================= #
-  # === mode?
-  # ========================================================================= #
-  def mode?
-    @internal_hash[:mode]
-  end
-
-  # ========================================================================= #
-  # === only_valid_nucleotides?
-  #
-  # This method will determine whether our input string (the argument in
-  # question) contains only valid nucleotides or whether it does not.
-  # ========================================================================= #
-  def only_valid_nucleotides?(i)
-    i = i.first if i.is_a? Array
-    if i.is_a? String
-      i = i.delete("\n ").chars
-    end
-    uniq = i.uniq
-    if uniq.all? {|entry| POSSIBLE_DNA_NUCLEOTIDES.include? entry }
-      return true
-    else
-      return false
-    end
-  end; alias only_valid_dna_nucleotides? only_valid_nucleotides? # === only_valid_dna_nucleotides?
-
-  require 'bioroebe/shell/fasta.rb'
-  # ========================================================================= #
-  # === to_genbank
-  #
-  # This method will generate, or rather output, the GenBank file format.
-  # ========================================================================= #
-  def to_genbank(
-      this_sequence = dna_sequence_as_string?
-    )
-    if fasta?
-      id = fasta?.sequence_id?
-      # ======================================================================= #
-      # bl $BIOROEBE/genbank/genbank_flat_file_format_generator.rb
-      # ======================================================================= #
-      _ = GenbankFlatFileFormatGenerator.new(this_sequence, :do_not_run_yet)
-      _.use_this_as_id = id
-      _.run
-    elsif !this_sequence.empty?
-      GenbankFlatFileFormatGenerator.new(this_sequence)
-    else
-      erev 'There does not seem to be any FASTA sequence assigned.'
-    end
-  end
-
-  # ========================================================================= #
-  # === config?
-  # ========================================================================= #
-  def config?
-    @config
-  end
-
-  # ========================================================================= #
-  # === find_shine_dalgarno_sequence
-  #
-  # Use this method to attempt to try and find a SD-sequence.
-  # ========================================================================= #
-  def find_shine_dalgarno_sequence(
-      i = dna_sequence_as_string?
-    )
-    i.upcase! # Need to ensure upcased input.
-    pure_sd_sequence = 'AGGAGGU'.dup
-    if is_dna?
-      pure_sd_sequence.tr!('U','T')
-    end
-    if i.nil?
-      report_that_a_string_must_be_assigned_first
-    else
-      sd_sequence = steelblue(
-        dna_padding(pure_sd_sequence, :no_spaces).lstrip
-      )
-      if i.include? 'T' # Assume that we have a DNA string rather than RNA.
-        pure_sd_sequence = 'AGGAGGT'
-        sd_sequence = steelblue(
-          dna_padding(pure_sd_sequence, :no_spaces).lstrip
-        )
-      end
-      if i.include? pure_sd_sequence
-        erev "Yes, our string contains at least one Shine Dalgarno "\
-             "(#{sd_sequence}#{rev}) sequence."
-        n_sd_sequences = i.scan(/#{pure_sd_sequence}/).size.to_s
-        erev 'We have found '+sfancy(n_sd_sequences)+rev+' instance(s) of '\
-             'Shine Dalgarno ('+sd_sequence+rev+') Sites.'
-        erev 'We will next show the particular sequence in '\
-             'question ('+simp(pure_sd_sequence)+rev+').'
-        # =================================================================== #
-        # Next, try to find restriction enzymes that cut at the
-        # Shine-Dalgarno site.
-        # =================================================================== #
-        try_to_find_restriction_enzymes_for(:shine_dalgarno)
-      else
-        erev "We did not find a Shine Dalgarno ("\
-             "#{simp(sd_sequence)}#{rev}) sequence."
-      end
-    end
-  end
-
-  # ========================================================================= #
-  # === raw_aminoacid_sequence?
-  #
-  # Reader method over the aminoacid sequence.
-  # ========================================================================= #
-  def raw_aminoacid_sequence?
-    @internal_hash[:array_aminoacid_sequence].last
-  end; alias aminoacids?          raw_aminoacid_sequence? # === aminoacids? # def aminoacids?
-       alias amino_acid_sequence? raw_aminoacid_sequence? # === amino_acid_sequence?
-       alias aminoacid_sequence?  raw_aminoacid_sequence? # === aminoacid_sequence?
-       alias aa_sequence?         raw_aminoacid_sequence? # === aa_sequence?
-       alias aa?                  raw_aminoacid_sequence? # === aa?
-
-  # ========================================================================= #
-  # === codon
-  #
-  # This method will identify codons.
-  #
-  # Usage example from within the Shell:
-  #
-  #   codon AAAGUCCAU
-  #
-  # ========================================================================= #
-  def codon(
-      i = sequence?
-    )
-    if i.is_a? Array # We don't want Arrays here.
-      i = i.join.strip
-    end
-    if i.nil?
-      i = sequence?
-    else
-      if i.is_a? String
-        i = sequence? if i.empty?
-      end
-    end
-    _ = nucleotides_to_aminoacid(i)
-    erev _
-  end; alias codons  codon # === codons
-       alias codon?  codon # === codon?
-       alias codons? codon # === codons?
-
-  # ========================================================================= #
-  # === calculate_atp_cost_for
-  #
-  # This method can be used to calculate the ATP cost in order to synthesize
-  # a protein.
-  # ========================================================================= #
-  def calculate_atp_cost_for(i = aminoacid_sequence?)
-    i = i.join.strip if i.is_a? Array
-    if i.nil?
-      i = aminoacid_sequence?
-    end
-  end
-
-  # ========================================================================= #
-  # === use_xsel?
-  # ========================================================================= #
-  def use_xsel?
-    @internal_hash[:use_xsel]
-  end
-
-  # ========================================================================= #
-  # === all_arguments?
-  # ========================================================================= #
-  def all_arguments?
-    @internal_hash[:all_arguments]
-  end; alias a? all_arguments? # === a?
-       # alias a  all_arguments? # === a
-
-  require 'bioroebe/utility_scripts/check_for_mismatches/check_for_mismatches.rb'
-  # ========================================================================= #
-  # === check_for_mismatches
-  # ========================================================================= #
-  def check_for_mismatches
-    CheckForMismatches.new
-  end
-
-  require 'bioroebe/toplevel_methods/nucleotides.rb'
-  # ========================================================================= #
-  # === only_nucleotides?
-  #
-  # Just a wrapper over the corresponding module-method.
-  # ========================================================================= #
-  def only_nucleotides?(i)
-    ::Bioroebe.only_nucleotides?(i)
-  end
-
-  # ========================================================================= #
-  # === exit_the_shell_how?
-  # ========================================================================= #
-  def exit_the_shell_how?
-    @internal_hash[:exit_the_shell_how]
-  end
-
-  # ========================================================================= #
-  # === do_quit                                          (exit tag, quit tag)
-  #
-  # Consistently use this method when quitting from the shell. No
-  # exception!
-  #
-  # On quitting, we may copy the bioroebe-files.
-  #
-  # We may either return a symbol, or we may simply call exit.
-  # ========================================================================= #
-  def do_quit(
-      # ===================================================================== #
-      # The variable that comes next is usually a Symbol.
-      # ===================================================================== #
-      determine_what_to_do = exit_the_shell_how?
-    )
-    # ======================================================================= #
-    # We can also copy the content of the Bioroebe-Project - but I am
-    # not sure if this is worth the trade-off, so it was disabled again.
-    # ======================================================================= #
-    # copy_bioroebe_shell_before_quitting
-    # ======================================================================= #
-    considering_changing_the_title_of_the_kde_konsole_tab('')
-    case determine_what_to_do
-    when :instantly
-      :break
-    else # This is valid for :exit_gracefully.
-      return determine_what_to_do # Allo a graceful exit.
-    end
-  end
-
-  # ========================================================================= #
-  # === handle_this_file
-  #
-  # This method can be used to handle a file in general.
-  # ========================================================================= #
-  def handle_this_file(this_file)
-    if File.exist?
-      e File.read(this_file)
-    end
-  end
-
-  # ========================================================================= #
-  # === remove_question_mark?
-  # ========================================================================= #
-  def remove_question_mark?
-    @internal_hash[:remove_last_character_if_it_is_a_question_mark]
-  end
-
-  # ========================================================================= #
-  # === default_length?
-  # ========================================================================= #
-  def default_length?
-    @internal_hash[:default_length]
-  end
-
-  # ========================================================================= #
-  # === set_default_length
-  # ========================================================================= #
-  def set_default_length(
-      i = DEFAULT_LENGTH_FOR_DNA, be_verbose = false
-    )
-    case be_verbose
-    when :be_verbose
-      be_verbose = true
-    end
-    if i.is_a? Array
-      i = i.join(' ').strip
-    end
-    i = i.to_i
-    if be_verbose
-      erev 'Setting to a default length of `'+simp(i.to_s)+rev+'` next.'
-    end
-    @internal_hash[:default_length] = i
-  end; alias set_maxlength set_default_length # === set_maxlength
-
-  # ========================================================================= #
-  # === second_argument?
-  # ========================================================================= #
-  def second_argument?
-    @internal_hash[:all_arguments][1]
-  end; alias second_argument second_argument? # === second_argument
-
-  # ========================================================================= #
-  # === initialize_clipboard
-  # ========================================================================= #
-  def initialize_clipboard
-    begin
-      require 'roebe/classes/clipboard.rb'
-    rescue LoadError; end
-    if Object.const_defined?(:Roebe) and
-       Roebe.const_defined?(:Clipboard)
-      @clipboard = Roebe::Clipboard.new
-    else
-      @clipboard = nil
-    end
-  end
-
-  require 'bioroebe/version/version.rb'
-  # ========================================================================= #
-  # === version?
-  # ========================================================================= #
-  def version?
-    ::Bioroebe.version
-  end
-
-  # ========================================================================= #
-  # === silent_startup?
-  # ========================================================================= #
-  def silent_startup?
-    @internal_hash and @internal_hash[:silent_startup]
-  end
-
-  # ========================================================================= #
-  # === say_goodbye
-  # ========================================================================= #
-  def say_goodbye
-    _ = ' '+version?.to_s
-    _ = '' if _.size == 1
-    erev "Bye from the BioShell#{_}!"
-  end
-
-  # ========================================================================= #
-  # === set_raw_sequence
-  # ========================================================================= #
-  def set_raw_sequence(i)
-    @internal_hash[:raw_sequence].assign(i)
-  end
-
-  # ========================================================================= #
-  # === raw_sequence?
-  # ========================================================================= #
-  def raw_sequence?
-    @internal_hash[:raw_sequence]
-  end
-
-  # ========================================================================= #
-  # === adenin?
-  #
-  # This will return e. g. "C5H5N5".
-  # ========================================================================= #
-  def adenin?
-    YAML.load_file(FILE_NUCLEOTIDES)['Adenin']
-  end
-
-  # ========================================================================= #
-  # === thymin?
-  # ========================================================================= #
-  def thymin?
-    YAML.load_file(FILE_NUCLEOTIDES)['Thymin']
-  end
-
-  # ========================================================================= #
-  # === cytosin?
-  # ========================================================================= #
-  def cytosin?
-    YAML.load_file(FILE_NUCLEOTIDES)['Cytosin']
-  end
-
-  # ========================================================================= #
-  # === guanin?
-  # ========================================================================= #
-  def guanin?
-    YAML.load_file(FILE_NUCLEOTIDES)['Guanin']
-  end
-
-  # ========================================================================= #
-  # === weight_of_adenin?
-  # ========================================================================= #
-  def weight_of_adenin?
-    ChemistryParadise::CalculateAtomicMass[adenin?].to_s.ljust(7,'0')
-  end
-
-  # ========================================================================= #
-  # === weight_of_thymin?
-  # ========================================================================= #
-  def weight_of_thymin?
-    ChemistryParadise::CalculateAtomicMass[thymin?].to_s.ljust(7,'0')
-  end
-
-  # ========================================================================= #
-  # === weight_of_cytosin?
-  # ========================================================================= #
-  def weight_of_cytosin?
-    ChemistryParadise::CalculateAtomicMass[cytosin?].to_s.ljust(7,'0')
-  end
-
-  # ========================================================================= #
-  # === weight_of_guanin?
-  # ========================================================================= #
-  def weight_of_guanin?
-    ChemistryParadise::CalculateAtomicMass[guanin?].to_s.ljust(7,'0')
-  end
-
-  # ========================================================================= #
-  # === colourize_nucleotide
-  #
-  # Assemble 5'-sequence-3', with colours.
-  # ========================================================================= #
-  def colourize_nucleotide(
-      i,
-      add_leading_five_and_trailing_three_primes = true
-    )
-    case add_leading_five_and_trailing_three_primes
-    # ======================================================================= #
-    # === :do_not_add_anything_else
-    # ======================================================================= #
-    when :do_not_add_anything_else,
-         :make_no_modifications
-      add_leading_five_and_trailing_three_primes = false
-    end
-    if add_leading_five_and_trailing_three_primes
-      leading_5_prime+
-      sfancy(i)+
-      rev+
-      trailing_3_prime
-    else
-      sfancy(i)+
-      rev
-    end
-  end; alias colourize_nucleotide_sequence colourize_nucleotide # === colourize_nucleotide_sequence
-
-  # ========================================================================= #
-  # === do_start_the_sinatra_interface
-  # ========================================================================= #
-  def do_start_the_sinatra_interface
-    require 'bioroebe/requires/require_the_bioroebe_sinatra_components.rb'
-    ::Bioroebe.start_sinatra_interface
-  end
-
-  require 'bioroebe/utility_scripts/punnet/punnet.rb'
-  # ========================================================================= #
-  # === punnet
-  #
-  # This method will show a Punnet square.
-  # ========================================================================= #
-  def punnet(i)
-    ::Bioroebe::Punnet.new(i)
-  end
-
-  # ========================================================================= #
-  # === mass_weight                                         (mass_weight tag)
-  #
-  # This will calculate the weight of some Aminoacids.
-  # ========================================================================= #
-  def mass_weight(
-      i          = aminoacids?,
-      be_verbose = true
-    )
-    if i.nil? and aminoacids?
-      i = aminoacids?
-    end
-    if i.nil?
-      erev 'Please first assign some aminoacids, like GGG.'
-    else
-      erev 'Now calculating the weight of `'+sfancy(i)+rev+'`.'
-      e
-      sum = 0
-      i.split(//).each {|aminoacid|
-        if aminoacid
-          weight = ::Bioroebe::AMINO_ACIDS_MASS_TABLE[aminoacid]
-          if be_verbose
-            erev '  The weight for '+royalblue(aminoacid)+
-                 rev+
-                 ' is: '+
-                  sfancy(
-                    weight.to_s.ljust(6,'0').rjust(10)
-                  )+rev
-          end
-          sum += weight
-        end
-      }
-      rounded_sum  = sum.round
-      n_aminoacids = i.to_s.chars.size 
-      erev '  The total sum of these '+simp(n_aminoacids)+rev+
-           ' aminoacids (the raw weight) is: '+sfancy(rounded_sum.to_s)
-      adjusted_value = sum - ((n_aminoacids - 1) * 18) # 18 for the H2O molecule.
-      erev '  The adjusted value (including loss of water '\
-           'molecules in the peptide bonds) is: '+
-           sfancy(adjusted_value.round(1).to_s)
-      e
-    end
-  end
-
-  # ========================================================================= #
-  # === bisulfite
-  # ========================================================================= #
-  def bisulfite(i)
-    return ::Bioroebe.bisulfite_treatment(i)
-  end
-
-  require 'bioroebe/utility_scripts/compseq/compseq.rb'
-  # ========================================================================= #
-  # === compseq
-  #
-  # Analyze a given sequence via compseq.
-  # ========================================================================= #
-  def compseq(i = dna_sequence?)
-    i = dna_sequence? if i.nil?
-    ::Bioroebe::Compseq.new(i) # bl $BIOROEBE/compseq.rb
-  end
-
-  require 'bioroebe/utility_scripts/move_file_to_its_correct_location.rb'
-  # ========================================================================= #
-  # === move_file_to_its_correct_location
-  # ========================================================================= #
-  def move_file_to_its_correct_location(i)
-    ::Bioroebe::MoveFileToItsCorrectLocation.new(i)
-  end
-
-  require 'bioroebe/pdb/fetch_fasta_sequence_from_pdb.rb'
-  # ========================================================================= #
-  # === fetch_from_pdb
-  #
-  # This method can obtain a .pdb file from the pdb website.
-  #
-  # It can also return the aminoacid sequence.
-  #
-  # A URL for the .pdb may be available like this:
-  #
-  #   https://files.rcsb.org/view/2BTS.pdb
-  #   https://files.rcsb.org/view/355D.pdb
-  #
-  # For the FASTA sequence, try:
-  #
-  #   https://www.rcsb.org/fasta/entry/2BTS/display
-  #
-  # ========================================================================= #
-  def fetch_from_pdb(i)
-    if i.is_a? Array
-      i = i.join(' ').strip
-    end
-    i.upcase!
-    remote_url = 'https://www.rcsb.org/structure/'+i
-    erev 'Looking for the protein called '+steelblue(i)+rev+
-         'at pdb next. (URL: '+royalblue(remote_url)+rev+')'
-    e
-    open_in_browser(remote_url)
-    e
-    remote_url_to_the_pdb_file = "https://files.rcsb.org/view/#{i}.pdb"
-    esystem "wget #{remote_url_to_the_pdb_file}"
-    e
-    begin
-      erev 'The fasta sequence, obtained from '+remote_url+', is:'
-      e
-      result = ::Bioroebe.return_fasta_sequence_from_this_pdb_file(remote_url)
-      e result
-      e
-      set_aminoacid_sequence(result) # And assign it as well.
-    rescue Exception => error
-      pp error
-    end
-    # ======================================================================= #
-    # The file may be without a .pdb entry, so rename it in that case.
-    # ======================================================================= #
-    target = File.basename(remote_url_to_the_pdb_file)
-    if File.exist? target
-      unless target.end_with? '.pdb'
-        unless File.exist? target+'.pdb'
-          new_location = target
-          rename_file(i, new_location) unless File.exist?(new_location)
-          target = new_location
-        end
-      end
-      move_file_to_its_correct_location(target)
-    end
-  end
-
-  # ========================================================================= #
-  # === prepend
-  #
-  # You can use this to simply prepend to the main string.
-  # ========================================================================= #
-  def prepend(i)
-    @sequence.prepend(i)
-  end
-
-  # ========================================================================= #
-  # === ereturn
-  # ========================================================================= #
-  def ereturn(i = '')
-    e i
-    return
-  end
-
-  # ========================================================================= #
-  # === open_expasy
-  # ========================================================================= #
-  def open_expasy(i = all_arguments?)
-    _ = 'https://www.expasy.org/'
-    open_in_browser(_)
-  end
-
-  require 'bioroebe/codons/codons.rb'
-  # ========================================================================= #
-  # === is_this_a_valid_codon?
-  #
-  # This method can determine whether the given input is a valid codon
-  # or whether it is not.
-  # ========================================================================= #
-  def is_this_a_valid_codon?(i)
-    ::Bioroebe.is_this_a_valid_codon?(i)
-  end
-
-  require 'bioroebe/toplevel_methods/file_and_directory_related_actions.rb'
-  # ========================================================================= #
-  # === chdir                                                        (cd tag)
-  # ========================================================================= #
-  def chdir(
-      i = :default
-    )
-    if i and i.start_with?('cd ')
-      i[0,3] = ''
-    end
-    case i
-    # ======================================================================= #
-    # === :home
-    # ======================================================================= #
-    when :home,
-         ':home'
-      i = log_dir?
-    # ======================================================================= #
-    # === :default
-    # ======================================================================= #
-    when :default,
-         nil
-      i = File.expand_path('~').to_s
-    end
-    if File.directory? i
-      ::Bioroebe.change_directory(i)
-    else
-      e "No directory at #{sdir(File.absolute_path(i))}#{rev} "\
-        "appears to exist."
-    end
-  end; alias cd chdir # === cd
-
-  # ========================================================================= #
-  # === shuffle_main_string
-  #
-  # This method will re-arrange the main DNA sequence.
-  # ========================================================================= #
-  def shuffle_main_string
-    erev 'Shuffling the main DNA string next.'
-    _ = dna_sequence?.split(//).shuffle.join
-    set_dna_string(_, :be_quiet)
-    show_dna_sequence
-  end
-
-  # ========================================================================= #
-  # === load                                                       (load tag)
-  #
-  # This method will try to load from the given input, if this is an
-  # existing file.
-  # ========================================================================= #
-  def load(
-      i = file_dna_string_saved?
-    )
-    if i.nil?
-      load(file_dna_string_saved?)
-    # ======================================================================= #
-    # === Handle Arrays
-    # ======================================================================= #
-    elsif i.is_a? Array
-      if i.nil? or i.empty?
-        load(file_dna_string_saved?) # Handle default input given.
-      else # else batch-process the Array next:
-        i.each {|entry| load(entry) }
-      end
-    else
-      i = i.to_s
-      # ===================================================================== #
-      # Check for i being a number:
-      # ===================================================================== #
-      if i =~ /^\d+$/i
-        entries = Dir['*']
-        sorted_entries = entries.sort_by {|entry|
-          File.basename(entry).downcase
-        }
-        i = sorted_entries[i.to_i - 1]
-        erev "Using the file #{sfile(i)}.#{rev}"
-      end
-      if i
-        if File.exist? i
-          data = File.read(i).chomp
-          assign_sequence data
-        else
-          erev 'Can not read from file '+sfile(i)+rev+
-               ' as it does not exist.'
-        end
-      else
-        load_my_file
-      end
-    end
-  end; alias load_dataset_from load # === load_dataset_from
-
-  # ========================================================================= #
-  # === load_my_file                                               (load tag)
-  #
-  # We will use this method to load the shell-file.
-  # ========================================================================= #
-  def load_my_file
-    assign(save_file?, :do_not_upcase)
-  end
-
-  # ========================================================================= #
-  # === is_a_stop_codon?
-  # ========================================================================= #
-  def is_a_stop_codon?(i)
-    ::Bioroebe.is_a_stop_codon?(i)
-  end
-
-  require 'bioroebe/codons/show_codon_tables.rb'
-  # ========================================================================= #
-  # === print_aminoacid_information_table
-  #
-  # This method will give us as much information as possible about the
-  # various different aminoacids in the assumed protein sequence at
-  # hand.
-  # ========================================================================= #
-  def print_aminoacid_information_table
-    show_mnemo
-    e
-    show_aminoacids_mass_table # This will also report the average weight of an aminoacid.
-    e
-    show_aminoacids_residues # Show all aminoacid residues (the "Reste").
-    e
-    display_all_aminoacids
-    e
-  end
-
-  # ========================================================================= #
-  # === permanently_disable_startup_intro
-  #
-  # This method can be used to permanently disable the startup intro.
-  #
-  # Invocation example:
-  #
-  #   bioshell --permanently-disable-startup-intro
-  #
-  # ========================================================================= #
-  def permanently_disable_startup_intro
-    target_file = Bioroebe.project_base_dir?+
-                  'shell/configuration/may_we_show_the_startup_information.yml'
-    what = 'false'
-    write_what_into(what, target_file)
-    erev 'Storing into the file '+sfile(target_file)+rev+'.'
-    if is_on_roebe?
-      target_file = RUBY_SRC+
-                    'bioroebe/lib/bioroebe/shell/configuration/may_we_show_the_startup_information.yml'
-      write_what_into(what, target_file)
-      erev 'Storing into the file '+sfile(target_file)+rev+'.'
-    end
-  end
-
-  # ========================================================================= #
-  # === may_we_show_the_startup_information?
-  # ========================================================================= #
-  def may_we_show_the_startup_information?
-    @internal_hash[:may_we_show_the_startup_information]
-  end
-
-
-  # ========================================================================= #
-  # === downcase_main_string                        (downcase tag, dcase tag)
-  #
-  # Use this method to downcase the main sequence.
-  # ========================================================================= #
-  def downcase_main_string
-    downcased_sequence = seq?.downcase
-    set_sequence(
-      downcased_sequence
-    )
-  end
-
-  # ========================================================================= #
-  # === set_exit_gracefully
-  # ========================================================================= #
-  def set_exit_gracefully
-    @internal_hash[:exit_the_shell_how] = :exit_gracefully
-  end
-
-  # ========================================================================= #
-  # === try_to_compare_these_two_sequences_for_equality
-  #
-  # This method will compare two sequences for equality, e. g. will
-  # return true or false, depending on whether they are equal or
-  # not.
-  #
-  # nil will be returned if the method could not find the necessary
-  # '==' characters.
-  #
-  # Invocation example from within a running bio-shell:
-  #
-  #   ATCGATCGATCG == ATCGATCG
-  #
-  # ========================================================================= #
-  def try_to_compare_these_two_sequences_for_equality(i)
-    i.strip!
-    if i.include? '=='
-      splitted = i.split('==').map(&:strip)
-      # ===================================================================== #
-      # Do the comparison next.
-      # ===================================================================== #
-      splitted.first == splitted.last
-    else
-      nil
-    end
-  end
-
-
-  # ========================================================================= #
-  # === set_padding
-  #
-  # This method allows us to set the default (left) padding that we may
-  # display for DNA strings.
-  # ========================================================================= #
-  def set_padding(
-      i          = DEFAULT_PADDING,
-      be_verbose = :be_quiet
-    )
-    case be_verbose
-    when :be_quiet
-      be_verbose = false
-    when :be_verbose
-      be_verbose = true
-    end
-    case i.to_s
-    when /(\d{1,3})/
-      i = ' ' * $1.to_s.dup.to_i
-    when 'default'
-      i = DEFAULT_PADDING
-    end
-    if be_verbose
-      erev 'The new padding will have '+sfancy(i.count(' ').to_s)+rev+
-           ' space characters.'
-    end
-    @internal_hash[:padding] = i
-  end
-
-  # ========================================================================= #
-  # === padding?                                                (padding tag)
-  # ========================================================================= #
-  def padding?
-    @internal_hash[:padding]
-  end; alias pad             padding? # === pad
-       alias pad?            padding? # === pad?
-       alias lpad?           padding? # === lpad?
-       alias left_pad?       padding? # === left_pad?
-       alias left_padding?   padding? # === left_padding?
-       alias default_padding padding? # === default_padding
-
-
-  # ========================================================================= #
-  # === efancy
-  # ========================================================================= #
-  def efancy(i)
-    e sfancy(i)
-  end
-
-  # ========================================================================= #
-  # === list
-  # ========================================================================= #
-  def list(i = nil)
-    case i
-    # ======================================================================= #
-    # === list ages
-    # ======================================================================= #
-    when /^age/
-      erev 'We will next list the maximum age of different organisms.'
-      if File.exist? BIO_LANG
-        hash_results = {}
-        dataset = File.read(BIO_LANG)
-        n_entries = dataset.scan(/  max_age: /).count
-        name_of_organism = ''
-        dataset.split(N).each {|line|
-          next if line.start_with? '#'
-          next if line.empty?
-          unless line.start_with?(' ')
-            name_of_organism = line.delete(':').strip
-          end
-          if line.include? '  max_age: '
-            its_max_age = line.gsub(/max_age:/,'').strip
-            if its_max_age.include? '#'
-              its_max_age = its_max_age[0, its_max_age.index('#')]
-            end
-            its_max_age.strip!
-            its_max_age << ' years' unless its_max_age.end_with? 'years'
-            hash_results[name_of_organism] = its_max_age
-          end
-        }
-        erev 'We did find '+sfancy(n_entries.to_s)+' results.'
-        e
-        hash_results.sort_by {|value, key| key }.reverse.each { |name, age|
-          erev '  '+(name+':').ljust(30)+' '+sfancy(age.rjust(12))
-        }; e # Trailing newline looks nice.
-      end
-    end
-  end
-
-  # ========================================================================= #
-  # === toggle_mode
-  # ========================================================================= #
-  def toggle_mode
-    if @internal_hash[:mode] == :dna
-      set_mode(:aminoacid)
-    else
-      set_mode(:dna)
-    end
-  end
-
-  # ========================================================================= #
-  # === report_syntax_help_for_frameshift_action
-  # ========================================================================= #
-  def report_syntax_help_for_frameshift_action
-    erev 'You can provide these options for the frameshifting menu:'
-    erev '  +1'
-    erev '  +2'
-    erev '  +3'
-    erev '  all'
-  end
-
-  # ========================================================================= #
-  # === include?
-  #
-  # This can be used to check if we include a string or not.
-  # ========================================================================= #
-  def include?(i)
-    _ = dna_string?
-    if _
-      if _.include? i
-        erev 'Yes, we found it. It is at:'
-        pp _.scan(/#{i}/)
-      else
-        erev 'No, we did not find it.'
-      end
-    else
-      erev 'It seems as if you yet have not defined a main string.'
-      erev 'Please do so first, via assign() or random().'
-    end
-  end
-
-  # ========================================================================= #
-  # === efetch
-  #
-  # Invocation example:
-  #
-  #   efetch https://eutils.ncbi.nlm.nih.gov/entrez/eutils/efetch.fcgi?db=nuccore&id=189458859&rettype=fasta&retmode=text
-  #
-  # ========================================================================= #
-  def efetch(i)
-    if i.is_a? Array
-      i.each {|entry| efetch(entry) }
-    else
-      ::Bioroebe::Ncbi.efetch_by_url(i)
-    end
-  end
-
-  # ========================================================================= #
-  # === generate_palindrome
-  #
-  # This method will generate a Palindrome sequence.
-  # ========================================================================= #
-  def generate_palindrome(i)
-    i = i.join.strip if i.is_a? Array
-    ::Bioroebe::PalindromeGenerator.new(i).report
-  end
-
-  # ========================================================================= #
-  # === is_palindrome?
-  # ========================================================================= #
-  def is_palindrome?(i)
-    erev ::Bioroebe.is_palindrome?(i) # is_palindrome? GATC
-  end
-
-  # ========================================================================= #
-  # === discover_all_palindromes
-  #
-  # We need to discover all palindromes. For this, we need a
-  # min and a max value.
-  # ========================================================================= #
-  def discover_all_palindromes(
-      i   = dna_sequence?,
-      min =  4,
-      max = 10
-    )
-    i = dna_sequence? unless i
-    case i # case tag
-    when 'default',
-         ':default'
-      i = dna_sequence?
-    end
-    @array_palindromes = [] # We store the Palindromes in this Array.
-    n_times = i.size
-
-    min.upto(max) {|length|
-      # ===================================================================== #
-      # First, iterate by starting over the min value.
-      # ===================================================================== #
-      n_times.times {|counter|
-        possible_palindrome_sequence = i[counter, length]
-        counter += 1 # Adding +1 because nucleotides start at 1, not 0.
-        if ::Bioroebe.is_palindrome?(possible_palindrome_sequence) and
-           (possible_palindrome_sequence.size >= length)
-          @array_palindromes << [possible_palindrome_sequence, counter]
-        end
-      }
-    }
-    e; e 'Starting nucleotide | Palindrome sequence'; e
-    @array_palindromes.each {|array|
-      index_position = array.last
-      nucleotides    = array.first
-      erev '                 '+index_position.to_s.rjust(3)+' '+
-           nucleotides+' ('+swarn(nucleotides.size.to_s)+rev+')'
-    }; e
-  end
-
-  # ========================================================================= #
-  # === mutate_position
-  #
-  # This method can be used to mutate DNA at a specific position.
-  #
-  # Usage example:
-  #
-  #   random 50; mutate_position 5 C
-  #   random 15; mutate_position 1
-  #
-  # ========================================================================= #
-  def mutate_position(
-      nucleotide_position,
-      mutate_to_this_nucleotide = return_random_nucleotide # Return randomly A, T, C or G here.
-    )
-    if nucleotide_position.is_a?(String) and nucleotide_position.strip.include?(' ')
-      nucleotide_position = nucleotide_position.split(' ')
-    end
-    # ======================================================================= #
-    # === Handle Arrays as input next
-    # ======================================================================= #
-    if nucleotide_position.is_a? Array # Assume that the user wanted to use things differently then.
-      mutate_to_this_nucleotide = nucleotide_position[1]
-      nucleotide_position       = nucleotide_position[0]
-    end
-    old_sequence = dna_sequence?
-    do_mutate_dna_sequence_at_this_nucleotide_position(
-      nucleotide_position,
-      old_sequence,
-      mutate_to_this_nucleotide
-    )
-    show_dna_sequence
-  end
-
-  # ========================================================================= #
-  # === mutate_aminoacid_position
-  #
-  # This method will allow us to mutate the aminoacid sequence.
-  #
-  # Full usage example:
-  #   random 24; show_aminoacid_sequence; mutate_aminoacid_position 1
-  # ========================================================================= #
-  def mutate_aminoacid_position(this_position = 1)
-    if this_position.is_a? Array
-      this_position = this_position.join.strip
-    end
-    this_position = this_position.to_i
-    sequence = aa_sequence?
-    new_aminoacid = return_random_aminoacid
-    old_aminoacid = sequence[this_position-1, 1]
-    erev 'We will mutate the aminoacid sequence at position '+
-          simp(this_position.to_s)+rev+'. The old aminoacid '
-    erev 'was '+simp(old_aminoacid)+rev+', the new aminoacid will '\
-         'be '+simp(new_aminoacid)+rev+'.'
-    sequence[this_position-1, 1] = new_aminoacid
-    show_aminoacid_sequence
-  end
-
-  # ========================================================================= #
-  # === n_uracil?
-  # ========================================================================= #
-  def n_uracil?
-    erev sequence_object?.n_uracil?
-  end
-
-  # ========================================================================= #
-  # === set_start_codon
-  #
-  # If you wish to use another start codon, this is the right method.
-  # ========================================================================= #
-  def set_start_codon(i = nil)
-    i = i.to_s
-    i.tr!('U','T')
-    if i.empty?
-      erev 'Please assign a non-empty start codon.'
-    else
-      erev 'Setting to use this as start codon next: '+
-            simp(i)
-      ::Bioroebe.set_start_codon(i)
-    end
-  end
-
-  # ========================================================================= #
-  # === first
-  # ========================================================================= #
-  def first(i)
-    if i.to_s =~ /^\d+$/ # If the input is only numbers
-      erev 'Obtaining the first '+simp(i).to_s+rev+' nucleotides next:'
-      erev simp(seq?[0,i.to_i])
-    else # Else change the first nucleotide.
-      change_first_nucleotide_to(f)
-    end
-  end
-
-  # ========================================================================= #
-  # === attempt_to_discover_dna_A_boxes
-  # ========================================================================= #
-  def attempt_to_discover_dna_A_boxes
-    dna_A_box_sequence = 'TTATCCACA'
-    erev 'The dnaA box in E. coli has this consensus sequence:'
-    e
-    efancy "  #{dna_A_box_sequence}#{rev}"
-    e
-    unless string?.empty?
-      results = string?.scan(/#{dna_A_box_sequence}/)
-      if results.empty?
-        erev 'The given DNA sequence does not contain any dnaA sequence elements.'
-      else
-        erev 'This sequence can be found '+simp(results.size.to_s)+rev+' times.'
-        pp results
-      end
-    end if dna_sequence?
-  end
-
-  # ========================================================================= #
-  # === run_sql_query
-  # ========================================================================= #
-  def run_sql_query(
-      i,
-      be_verbose           = true,
-      optional_append_this = ''
-    )
-    ::Bioroebe.run_sql_query(i, be_verbose, optional_append_this)
-  end; alias sql_query run_sql_query # === sql_query
-       alias run_query run_sql_query # === run_query
-       alias run_sql   run_sql_query # === run_sql
-       alias sqlq      sql_query     # === sqlq
-
-  # ========================================================================= #
-  # === return_available_vectors
-  # ========================================================================= #
-  def return_available_vectors
-    Dir[::Bioroebe.log_dir?+'vector_*']
-  end
-
-  # ========================================================================= #
-  # === check_for_local_vectors
-  # ========================================================================= #
-  def check_for_local_vectors
-    _ = return_available_vectors
-    unless _.empty? # Silent assignment comes next.
-      set_sequence_2(::Bioroebe::Sequence.sequence_from_file(_.first))
-    end
-  end
-
-  # ========================================================================= #
-  # === find_restriction_sites
-  #
-  # Call the parent method in the Bioroebe class.
-  # ========================================================================= #
-  def find_restriction_sites(i = string?)
-    i = string? if i.nil?
-    Bioroebe.restriction_sites?(i) # bl mybioruby
-  end
-
-  # ========================================================================= #
-  # === do_mutate_dna_sequence_at_this_nucleotide_position
-  #
-  # You can use this method to mutate a DNA sequence at a given position.
-  #
-  # The first argument should be the specific nucleotide position that
-  # you wish to modify. Keep in mind that in BioRoebe we will start to
-  # count at nucleotide position 1; in ruby Arrays, we would start to
-  # count at position 0 but DNA sequences don't have a nucleotide called
-  # 0 by definition, hence why we use a more (bio)logical way that
-  # makes more sense.
-  #
-  # Usage example:
-  #
-  #   random 15; mutate 1
-  #
-  # ========================================================================= #
-  def do_mutate_dna_sequence_at_this_nucleotide_position(
-      this_nucleotide_position = 1,
-      new_nucleotide           = nil,
-      old_sequence             = dna_sequence?
-    )
-    if this_nucleotide_position.is_a? Array
-      new_nucleotide = this_nucleotide_position[1] if this_nucleotide_position.size > 1
-      this_nucleotide_position = this_nucleotide_position.first
-    end
-    # ======================================================================= #
-    # === this_nucleotide_position must be a Fixnum past that point
-    # ======================================================================= #
-    this_nucleotide_position = this_nucleotide_position.to_i
-    if this_nucleotide_position < 1
-      this_nucleotide_position = 1 # 1 is minimum.
-    end
-    old_nucleotide = old_sequence[this_nucleotide_position-1, 1]
-    unless new_nucleotide # Enter this clause if new_nucleotide is nil.
-      new_nucleotide = (DNA_NUCLEOTIDES - [old_nucleotide]).sample # Obtain a random but different nucleotide.
-    end
-    erev 'At nucleotide position '+sfancy(this_nucleotide_position.to_s)+
-         rev+' we will replace '+simp(old_nucleotide)+rev+' with '+
-         simp(new_nucleotide)+rev+'.'
-    old_sequence[this_nucleotide_position-1, 1] = new_nucleotide
-    set_dna_sequence(old_sequence) # We'll also assign this.
-  end
-
-  # ========================================================================= #
-  # === mutate_dna_sequence
-  #
-  # Use this method to mutate a DNA nucleotide.
-  # ========================================================================= #
-  def mutate_dna_sequence(
-      n_times      = 1,
-      old_sequence = dna_sequence?
-    )
-    if n_times.is_a? Array
-      n_times = n_times.join(' ').strip.to_i
-    end
-    n_times = n_times.to_i
-    n_times.times {
-      this_nucleotide_position = rand(old_sequence.size)+1
-      do_mutate_dna_sequence_at_this_nucleotide_position(
-        this_nucleotide_position, old_sequence
-      )
-      show_dna_sequence
-    }
-  end
-
-  # ========================================================================= #
-  # === align_ORFS
-  #
-  # This method is used to align all intrinsic ORFs of agiven sequence.
-  #
-  # We delegate into class AlignOpenReadingFrames for the output.
-  # ========================================================================= #
-  def align_ORFS(i = dna_string?)
-    i = dna_string? if i.nil?
-    ::Bioroebe::AlignOpenReadingFrames.new(i) # bl $BIOROEBE/align_open_reading_frames.rb
-  end
-
-  # ========================================================================= #
-  # === calculate_hamming_distance_of
-  #
-  # We will delegate into class HammingDistance here.
-  #
-  # The argument to this method should ideally be an Array.
-  #
-  # To test this method, do:
-  #   hamming AGUUCGAUGG AGUCCGGUCG
-  #   hamming AGUUCGAUGGGGGGGTTT AGUCCGGUCGGGG
-  #   random 100; setseq2 hamming 1 2
-  # ========================================================================= #
-  def calculate_hamming_distance_of(i)
-    if i.is_a? String
-      if i.include? ' ' and i =~ /^\d+/ # The String could be "1 3" here, for instance.
-        splitted = i.split(' ').map(&:strip)
-        case splitted.size
-        when 2 # If we have at least 2 entries.
-          splitted[-1] = return_sequence_from_this_number(splitted[-1])
-          splitted[0]  = return_sequence_from_this_number(splitted[0])
-          i = splitted.join(' ')
-        end
-      end
-    end
-    ::Bioroebe::HammingDistance[i] # bl $BIOROEBE/hamming*rb
-  end
-
-  # ========================================================================= #
-  # === get_long_name_of_amino_acid
-  # ========================================================================= #
-  def get_long_name_of_amino_acid(i)
-    amino_acids_table = AMINO_ACIDS
-    if amino_acids_table.has_key? i
-      _ = amino_acids_table[i]
-      key = _.keys.select {|inner_key| inner_key.size == 3 }[0]
-      i = _[key].to_s
-    end
-    return i
-  end
-
-  # ========================================================================= #
-  # === verbose_report_numbered_amino_acid_sequence
-  #
-  # This method can be used to show a verbose and properly-aligned
-  # frame shift table for the given aminoacid sequence.
-  # ========================================================================= #
-  def verbose_report_numbered_amino_acid_sequence(
-      i,
-      which_frame = '1'
-    )
-    n_chunks = ::Bioroebe::Configuration.n_chunks?
-    erev 'The amino acid sequence, with numbers and split into chunks '\
-         'of '+plum(n_chunks.to_s)+rev+', for '+
-         sfancy('Frame '+which_frame.to_s)+rev+' is: '
-    e # Newline is good.
-    chars = i.chars
-    # ======================================================================= #
-    # Split into lines of 40, or rather what value was given to n_chunks.
-    # ======================================================================= #
-    slice = chars.each_slice(n_chunks).to_a
-    position = 1
-    slice.each {|array|
-      print '  '
-      array.each {|char|
-        char = char.rjust(3)
-        char = ::Bioroebe.colourize_aa(char)
-        print rev+char+rev+swarn('|')+rev
-      }; e # Do a newline for good measure.
-      print '  ' # Always have two ' ' before a new line.
-      # ===================================================================== #
-      # === Show the position of the aminoacid next
-      # ===================================================================== #
-      array.size.times {
-        print forestgreen(position.to_s.rjust(3))+rev+swarn('|')+rev
-        position += 1
-      }
-      e; e
-    }
-    e
-  end
-
-  # ========================================================================= #
-  # === uncolourize_this_aminoacid
-  # ========================================================================= #
-  def uncolourize_this_aminoacid(i)
-    if i.nil?
-      erev 'Please supply an argument, an aminoacid. Either one '\
-           'letter or the full name.'
-      return
-    end
-    unless ::Bioroebe.array_colourize_this_aminoacid.include? i
-      erev 'We will no longer colourize the '\
-           'aminoacid `'+swarn(i)+'`.'
-      ::Bioroebe.array_colourize_this_aminoacid.delete i # Using .delete() works here.
-    end
-  end
-
-  # ========================================================================= #
-  # === colourize_this_aminoacid
-  #
-  # Use this method to colourize any particular aminoacid.
-  #
-  # This should make it easier to detect special aminoacids.
-  # ========================================================================= #
-  def colourize_this_aminoacid(i)
-    if i.nil?
-      erev 'Please supply an argument, an aminoacid. Either one letter, '\
-           'such as A for Alanine, or the full name.'
-      return
-    end
-    unless ::Bioroebe.array_colourize_this_aminoacid.include? i
-      erev 'We will now colourize the aminoacid `'+swarn(i)+'`.'
-      ::Bioroebe.array_colourize_this_aminoacid << i
-    end
-  end
-
-  # ========================================================================= #
-  # === add_vertical_barrier_to_sequence
-  #
-  # This will turn a sequence such as "ATGCCC" into "ATG|CCC".
-  #
-  # Invocation example:
-  #
-  #   barrier ATGCCC
-  #
-  # ========================================================================= #
-  def add_vertical_barrier_to_sequence(
-      i = dna_sequence?
-    )
-    i = i.join if i.is_a? Array
-    i = dna_sequence? if i.nil?
-    splitted = i.scan(/.../)
-    joined = splitted.join('|')
-    e joined
-  end
-
-  # ========================================================================= #
-  # === obtain_url_for
-  # ========================================================================= #
-  def obtain_url_for(i)
-    ::Bioroebe.try_to_pass_through_beautiful_url(i)
-  end
-
-  # ========================================================================= #
-  # === set_locus
-  # ========================================================================= #
-  def set_locus(i)
-    i = i.join(' ').strip if i.is_a? Array
-    @locus = i
-  end
-
-  # ========================================================================= #
-  # === identify_aminoacid
-  #
-  # This method will also display the long name of the aminoacid at hand.
-  #
-  # Note that you can also identify a batch of aminoacids, by using the
-  # '-' character.
-  #
-  # Example for this:
-  #
-  #   identify_aminoacid A-Z
-  #
-  # We will ignore invalid aminoacids though.
-  # ========================================================================= #
-  def identify_aminoacid(i)
-    if i.is_a? Array
-      i.flatten!
-      if i.any? {|inner_entry| inner_entry.include? '-'}
-        # =================================================================== #
-        # In this case, at the least one entry has a '-' Range component.
-        # So we must substitute there.
-        # =================================================================== #
-        i.map! {|most_inner_entry|
-          if most_inner_entry.include?('-')
-            # =============================================================== #
-            # Assume a Range in this case and prepare it accordingly.
-            # =============================================================== #
-            chars = most_inner_entry.chars
-            start_position = chars.first
-            end_position   = chars.last
-            most_inner_entry = (start_position .. end_position).to_a
-            most_inner_entry = strict_filter_away_invalid_aminoacids(most_inner_entry)
-            most_inner_entry
-          end
-          most_inner_entry
-        }
-      end
-      # ===================================================================== #
-      # Recursively call the method if the input is an Array.
-      # ===================================================================== #
-      i.flatten!
-      e; i.each {|entry|
-        identify_aminoacid(entry)
-      }; e
-    else # else assume a String.
-      _ = ::Bioroebe::AMINO_ACIDS_MASS_TABLE
-      if i.empty?
-        erev 'Please supply at the least one character '\
-             '(aminoacid one letter code).'
-      elsif _.has_key? i
-        long_name_of_the_aminoacid = FILE_AMINO_ACIDS_ENGLISH[i]
-        erev i.ljust(3)+' ('+sfancy(long_name_of_the_aminoacid)+
-             rev+') corresponds to a molecular weight of '+
-             simp(_[i])+rev+' Dalton.'
-      else
-        erev "Did not find `#{simp(i)}`."
-      end
-    end
-  end
-  
-  # ========================================================================= #
-  # === compare_two_strings_as_alignment
-  #
-  # This allows us to interactively compare two strings.
-  # ========================================================================= #
-  def compare_two_strings_as_alignment(
-      string1 = nil,
-      string2 = nil
-    )
-    if string1 and string2
-      # Simply pass through in this case.
-    else
-      erev 'You desire to compare two strings.'
-      e
-      erev 'Please input the '+palegreen('first')+rev+' string/sequence now:'
-      print '  '
-      if has_readline?
-        string1 = Readline.readline
-      else
-        string1 = $stdin.gets.chomp
-      end
-      erev 'Please input the '+palegreen('second')+rev+' string now:'
-      print '  '
-      if has_readline?
-        string2 = Readline.readline
-      else
-        string2 = $stdin.gets.chomp
-      end
-    end
-    # ======================================================================= #
-    # Delegate into class SimpleStringComparer next.
-    # ======================================================================= #
-    _ = ::Bioroebe::SimpleStringComparer.new(:dont_run_yet) { :use_vertical_bar } # bl $BIOROEBE/string_matching/simple_string_comparer.rb
-    _.string1 = string1
-    _.string2 = string2
-    _.compare
-  end
-
-  # ========================================================================= #
-  # === clear
-  #
-  # Functionality that is associated with clearing something, can be
-  # stored here.
-  #
-  # Usage example:
-  #
-  #   clear highlighting
-  #
-  # ========================================================================= #
-  def clear(i)
-    if i.is_a? Array
-      i = i.join(' ').strip
-    end
-    case i
-    when /^highlight/
-      e 'Clearing all highlighting next.'
-      set_highlight_colour nil
-    end
-  end
-
-  # ========================================================================= #
-  # === add_timer_snapshot
-  # ========================================================================= #
-  def add_timer_snapshot
-    array_timer_snapshots? << Time.now
-  end
-
-  # ========================================================================= #
-  # === array_timer_snapshots?
-  # ========================================================================= #
-  def array_timer_snapshots?
-    @internal_hash[:array_timer_snapshots]
-  end
-
-  # ========================================================================= #
-  # === calculate_time_difference
-  # ========================================================================= #
-  def calculate_time_difference
-    (@internal_hash[:array_timer_snapshots][-2] - @internal_hash[:array_timer_snapshots][-1]) 
-  end
-
-  # ========================================================================= #
-  # === extract_sequence_from_this_file
-  #
-  # Use this method to extract a DNA sequence from the given file.
-  #
-  # The given input should thus, logically, be an existing (local)
-  # file.
-  #
-  # Currently this works via genbank .gb files but in the future,
-  # other formats may well be supported too.
-  # ========================================================================= #
-  def extract_sequence_from_this_file(i)
-    if i.is_a? Array
-      i.each {|entry| extract_sequence_from_this_file(entry) }
-    else
-      if File.exist? i
-        extname = File.extname(i).delete('.')
-        case extname
-        when 'gb'
-          # =================================================================== #
-          # Handle genbank .gb files here.
-          # =================================================================== #
-          _ = ::Bioroebe::GenbankParser.new(i) { :do_not_report_anything }
-          assign_sequence(_.sequence?)
-        end
-      else
-        no_file_exists_at(i)
-      end
-    end
-  end; alias extract_sequence extract_sequence_from_this_file # === extract_sequence
- 
-  # ========================================================================= #
-  # === coding_area?
-  #
-  # Query method over the "coding area" that we will focus on. So for
-  # example, if we have 100 nucleotides, but the coding area says 3-34,
-  # then we will only care for the nucleotides starting at position 3
-  # and ending at position 34.
-  # ========================================================================= #
-  def coding_area?
-    @internal_hash[:coding_area]
-  end
-
-  # ========================================================================= #
-  # === add_his_tag
-  #
-  # This method can be used to add a his tag. By default we will add 6
-  # Histidin tags in succession. This pattern is commonly found in expression
-  # vectors.
-  #
-  # These histidin tags will be randomly placed within the DNA sequence,
-  # by default. Note that CAT and CAC code for Histidin. In most vectors,
-  # there is an alternation between these codons.
-  # ========================================================================= #
-  def add_his_tag(i = 'add 6 random his tags')
-    n_his_tags_to_add = i.scan(/\d+/).first
-    position = rand(main_sequence?.size)+1
-    e 'Next adding '+sfancy(n_his_tags_to_add)+rev+
-      ' Histidin tags to our main sequence at nucleotide '\
-      'position '+sfancy(position.to_s)+rev+'.'
-    _ = main_sequence?
-    _.insert_at_this_position(
-      position+1, 'CAC|CAT|CAC|CAT|CAC|CAT' # Insert the His tag here.
-    )
-    assign_this_dna_sequence(_.to_str)
-  end
-
-  # ========================================================================= #
-  # === shorten_aminoacid
-  #
-  # This method will translate an Aminoacid from Lys to K.
-  #
-  # Usage example:
-  #
-  #   shorten Lys Val His His Leu Met Ala Ala Lys
-  #
-  # ========================================================================= #
-  def shorten_aminoacid(
-      these_aminoacids = aminoacid_sequence?
-    )
-    unless these_aminoacids
-      erev 'Please either assign an aminoacid sequence prior to invoking'
-      erev 'this method or simply pass in the aminoacids that you wish'
-      erev 'to short. Example:'
-      erev '  shorten Lys Val His'
-      return
-    end
-    erev N+'Now translating three letter Aminoacid to their one '\
-         'letter representation: '+N+'  '+sfancy(these_aminoacids)+rev+N
-    if these_aminoacids.include? ' '
-      these_aminoacids.delete!(' ') # get rid of ' '
-    end
-    if these_aminoacids.include? '-'
-      these_aminoacids = sanitize_input(these_aminoacids)
-    end
-    # ========================================================================= #
-    # Instantiate a new Bioroebe object next.
-    # ========================================================================= #
-    @bioroebe = ::Bioroebe.new(these_aminoacids)
-    erev '  '+@bioroebe.three_to_one+N
-    _ = @bioroebe.three_to_one
-    e
-    erev 'Next we will show the available codons for these aminoacids:'
-    e
-    _.scan(/./).each { |f|
-      erev '  '+f+' -> '+
-           '['+@bioroebe.aminoacid_to_codon(f).join(', ')+']'
-    }
-    e
-  end
-
-  # ========================================================================= #
-  # === translate_aminoacid
-  #
-  # Translate aminoacids from one letter to full name.
-  #
-  # Usage example:
-  #
-  #   translate kkrnn
-  #
-  # ========================================================================= #
-  def translate_aminoacid(
-      these_aminoacids = string?,
-      be_verbose       = true
-    )
-    these_aminoacids = string? if these_aminoacids.nil?
-    if these_aminoacids.include? ','
-      these_aminoacids.delete!(',')
-    end
-    if these_aminoacids == '?'
-      erev 'Help requested:' # The user requested help here.
-      erev '  '+sfancy('-> ')+rev+'Simply input some AminoAcids here.'
-      erev '  '+sfancy('-> ')+rev+'for instance, "translate kkrrr".'
-    else
-      if these_aminoacids
-        these_aminoacids = these_aminoacids.join(' ') if these_aminoacids.is_a? Array
-        these_aminoacids.gsub!(/#{N}/,'')
-        _ = these_aminoacids.gsub(/ /,'').upcase
-        if be_verbose
-          erev 'Now translating one letter Aminoacid to '\
-               'their full names: '
-          print '    '+these_aminoacids.upcase
-        end
-        _ = ::Bioroebe.translate(_)
-        if use_colours?
-          _ = sienna(_) if Object.const_defined? :Colours
-        end
-        erev ' -> '+_ # Invoke .translate if be_verbose
-        return _
-      end
-    end
-  end
-
-  # ========================================================================= #
-  # === to_dna
-  # ========================================================================= #
-  def to_dna(i = sequence?)
-    if i.nil?
-      if seq?
-        i = seq?
-      elsif aminoacids? # Handle Aminoacids here.
-        i = aminoacids?
-        return
-      end
-    end
-    erev padding?+dna_with_ends(Bioroebe.to_dna(i))
-  end
-
-  # ========================================================================= #
-  # === interactive_colour_menu
-  # ========================================================================= #
-  def interactive_colour_menu
-    erev 'You can decide here whether you want to use colours or not, and if'
-    erev 'you want to use colours, whether these will be simple ansi colours'
-    erev 'or the "more advanced" konsole submodule of the colours project.'
-    e
-    erev '  (1) no colours'
-    erev '  (2) ansi colours'
-    erev '  (3) konsole colours'
-    e
-    print 'Input your choice next: '
-    user_input = $stdin.gets.chomp
-    case user_input
-    when '1'
-      erev 'We will use no colours.'
-      disable_colours
-    when '2'
-      erev 'We will use ansi colours.'
-      enable_colours unless use_colours?
-      Shell.set_colour(:AnsiColours)
-    when '3'
-      erev 'We will use konsole colours.'
-      enable_colours unless use_colours?
-      Shell.set_colour(:Konsole)
-    end
-  end
-
-  # ========================================================================= #
-  # === return_all_genes
-  # ========================================================================= #
-  def return_all_genes
-    _ = dna_sequence?
-    result = _.to_enum(:scan, /(ATG|AUG)/i).map { |match|
-      $`.size + 1 # +1 because we refer to the nucleotide positions.
-    }
-    e
-    result.each_with_index {|nucleotide_position, index|
-      erev simp(index+1).to_s+rev+') DNA sequence:'
-      e
-      sequence = _[nucleotide_position-1 .. -1]
-      erev dna_with_ends(sequence, ::Bioroebe.start_codon?, 1)
-      e
-    }
-  end
-
-  # ========================================================================= #
-  # === generate_single_sequence_repeats
-  #
-  # This method can be used to generate SSR sequences.
-  # ========================================================================= #
-  def generate_single_sequence_repeats
-    _ = ''
-    length_of_the_SSR_sequence = 2+rand(4) # 2-5
-    length_of_the_SSR_sequence.times {
-      _ << return_random_nucleotide
-    }
-    n_repeats = 9+rand(22) # 9-30
-    result = _ * n_repeats
-    return result
-  end
-
-  # ========================================================================= #
-  # === on_roebe?
-  # ========================================================================= #
-  def on_roebe?
-    ::Bioroebe.is_on_roebe?
-  end
-
-  # ========================================================================= #
-  # === do_toggle_debug_value
-  # ========================================================================= #
-  def do_toggle_debug_value
-    if @debug
-      @debug = false
-    else
-      @debug = true
-    end
-  end
-
-  # ========================================================================= #
-  # === protein_stats
-  # ========================================================================= #
-  def protein_stats
-    e
-    e 'CURRENTLY NOT IMPLEMENTED'
-    e
-  end
-
-  # ========================================================================= #
-  # === generate_pdf_tutorial
-  #
-  # Easier wrapper to generate the .pdf Tutorial.
-  # ========================================================================= #
-  def generate_pdf_tutorial
-    ::Bioroebe.generate_pdf_tutorial
-  end
-
-  # ========================================================================= #
-  # === open_blast_webpage
-  # ========================================================================= #
-  def open_blast_webpage
-    open_in_browser_tab 'https://blast.ncbi.nlm.nih.gov/'\
-                        'Blast.cgi?PROGRAM=blastn&PAGE_TYPE=BlastSearch&LINK_LOC=blasthome'
-  end
-
-  # ========================================================================= #
-  # === nucleotides_or_aminoacids?
-  # ========================================================================= #
-  def nucleotides_or_aminoacids?
-    case mode?
-    # ======================================================================= #
-    # === :dna
-    # ======================================================================= #
-    when :dna,
-         :rna
-      'nucleotides'
-    # ======================================================================= #
-    # === :aminoacids
-    # ======================================================================= #
-    when :aminoacids
-      'aminoacids'
-    end
-  end
-
-  # ========================================================================= #
-  # === is_dna?
-  # ========================================================================= #
-  def is_dna?
-    mode? == :dna
-  end
-
-  # ========================================================================= #
-  # === do_open
-  #
-  # Open an URL - via browser.
-  # ========================================================================= #
-  def do_open(i)
-    case i
-    when 'all','ALL'
-      open_my_files
-    else # Default.
-      open_in_browser(i)
-    end
-  end; alias browse_to open # === browse_to
-
-  # ========================================================================= #
-  # === find_all_orfs
-  #
-  # This method will return all ORFs within the target sequence.
-  #
-  # It will return an Array, and then we will display these ORFs,
-  # starting with the LONGEST ORF first.
-  # ========================================================================= #
-  def find_all_orfs(
-      i = dna_sequence?
-    )
-    all_start_codons = i.to_enum(:scan, /#{::Bioroebe.start_codon?}/i).map { |match|
-      [$`.size] # [$`.size, match]
-    }
-    all_stop_codons = i.to_enum(:scan, /(TGA|TAG|TAA)/i).map { |match|
-      [$`.size]
-    }
-    array_with_the_proper_matches = []
-    current_match = nil
-    all_start_codons.each {|start_codon_position|
-      start_codon_position = start_codon_position.first
-      # ===================================================================== #
-      # Find the nearest stop codon position.
-      # ===================================================================== #
-      all_stop_codons.reverse.each {|stop_codon_position|
-        stop_codon_position = stop_codon_position.first
-        length = stop_codon_position - start_codon_position
-        next if length < 1
-        current_match = [start_codon_position, length]
-        if current_match
-          # Must be a smaller match.
-          if length < current_match[1] # [1] refers to the length.
-            unless length < 3
-              current_match = [start_codon_position, length]
-            end
-          end 
-        end
-      }
-      array_with_the_proper_matches << current_match
-    }
-    cliner token: '-'
-    pp array_with_the_proper_matches
-    cliner token: '-'
-    _ = dna_sequence?
-    array_with_the_proper_matches.each {|start, stop|
-      subsequence = _[start.to_i .. stop.to_i]
-      erev subsequence unless subsequence.empty?
-    }
-  end
-
-  # ========================================================================= #
-  # === to_rna
-  # ========================================================================= #
-  def to_rna(i = seq_object?)
-    i = seq_object? if i.nil? # Assign to default in this case.
-    if i.respond_to? :to_rna
-      i = i.to_rna
-    end
-    erev i
-  end
-
-  # ========================================================================= #
-  # === replay
-  # ========================================================================= #
-  def replay(i = nil)
-    if i
-      # ===================================================================== #
-      # The user did input something. Thus continue here.
-      # ===================================================================== #
-      case i
-      # ===================================================================== #
-      # === save
-      # ===================================================================== #
-      when 'save',
-           'store'
-        verbose_save_history_to_file
-      else
-        # =================================================================== #
-        # Else load the replay file. For instance, via "replay load".
-        # =================================================================== #
-        replay_file = log_dir?+'replay_file.yml'
-        if File.exist? replay_file
-          erev 'Now replaying the history from the file `'+sfile(replay_file)+rev+'`.'
-          array = YAML.load_file(replay_file)
-          array.each {|command|
-            run_this_user_input(command)
-          }
-        else
-          erev 'We are trying to replay the old history, but we could not find'
-          erev 'any file called '+sfile(replay_file)+'.'
-          e
-          erev 'You can generate a new replay file by inputting some commands'
-          erev 'and then invoking "replay".' 
-        end
-      end
-    else
-      verbose_save_history_to_file
-    end
-  end
-
-  # ========================================================================= #
-  # === change_first_nucleotide_to
-  #
-  # This will only work if we had already assigned a DNA sequence prior
-  # to running it.
-  # ========================================================================= #
-  def change_first_nucleotide_to(
-      i = dna_sequence?
-    )
-    i = i.join(' ').strip if i.is_a? Array
-    unless i.empty?
-      i = i.upcase
-      erev "Now changing the first nucleotide to `#{simp(i)}`."
-      @sequence.first_nucleotide = i
-      show_string
-    end
-  end
-
-  # ========================================================================= #
-  # === start_clipboard
-  #
-  # Make use of the clipboard here.
-  # ========================================================================= #
-  def start_clipboard(i = '"')
-    if @clipboard
-      erev 'Starting Clipboard now (exit it with '+i+')'
-      @clipboard.set_exit_token(i) # Set closing token. Default to }
-      @clipboard.fetch_input
-      return @clipboard.buffer?
-    end
-  end
-
-  # ========================================================================= #
-  # === assume_what_type_this_is
-  #
-  # Determine what type the given input is.
-  #
-  # Note that this currently has limitations in that it does not use a
-  # statistical way to determine whether we really have DNA/RNA/Aminoacids
-  # here.
-  #
-  # Eventually we will write a replacement for it but for now,
-  # it has to suffice.
-  #
-  # To test this method interactively, do this in the shell:
-  #
-  #   assume ATCG
-  #   assume AUCG
-  #   assume NNNLMMLLAAA
-  #
-  # ========================================================================= # 
-  def assume_what_type_this_is(i)
-    if i.is_a? Array
-      i = i.join
-    end
-    if i
-      chars = i.chars
-      if    chars.all? {|entry| POSSIBLE_DNA_NUCLEOTIDES.include? entry }
-        erev 'This must be a DNA sequence.'
-      elsif chars.all? {|entry| POSSIBLE_RNA_NUCLEOTIDES.include? entry }
-        erev 'This must be a RNA sequence.'
-      elsif chars.all? {|entry| POSSIBLE_AMINO_ACIDS.include? entry }
-        erev 'This must be an amino acid sequence.'
-      else
-        erev 'This can not be a valid sequence ('+
-              simp('DNA/RNA/Proteins')+rev+').'
-      end
-    else
-      erev 'Missing an input such as '+sfancy('ATCG')+rev+'.'
-    end
-  end
-
-  # ========================================================================= #
-  # === add_to_start
-  #
-  # Use this method to add to the start of a nucleotide sequence. In other
-  # words, to prepend to the main nucleotide sequence.
-  # ========================================================================= #
-  def add_to_start(i)
-    add_to_start_or_end(i, :to_start)
-  end; alias add_n_nucleotides add_to_start # === add_n_nucleotides
-
-  # ========================================================================= #
-  # === do_action
-  #
-  # Usage example:
-  #
-  #   do not truncate
-  #
-  # ========================================================================= #
-  def do_action(*i)
-    if i.is_a? Array
-      i.flatten!
-    end
-    first_argument  = i[0]
-    second_argument = i[1]
-    case second_argument
-    when 'truncate'
-      do_not_truncate if first_argument == 'not'
-    end
-  end
-
-  # ========================================================================= #
-  # === erev                                                       (erev tag)
-  #
-  # Easier wrapper over output that has rev().
-  # ========================================================================= #
-  def erev(i = '')
-    e "#{rev}#{i}"
-  end
-
-  # ========================================================================= #
-  # === dna_to_aminoacid_sequence
-  #
-  # Convert a DNA sequence into the corresponding aminoacid sequence.
-  # ========================================================================= #
-  def dna_to_aminoacid_sequence(i = dna_sequence?)
-    i = dna_sequence? if i.nil?
-    i = dna_sequence? if i.empty?
-    ::Bioroebe::DnaToAminoacidSequence.new(i)
-  end
-
-  # ========================================================================= #
-  # === set_jumper_directory
-  # ========================================================================= #
-  def set_jumper_directory(i)
-    if i
-      erev 'Adding '+sdir(i)+' to the jumper directories.'
-      @array_jumper_directories << i
-    end
-  end
-
-  # ========================================================================= #
-  # === dalton
-  #
-  # This method will calculate the weight of several aminoacids, in
-  # Dalton. We assume that each aminoacid will have a weight of 110
-  # Dalton.
-  # ========================================================================= #
-  def dalton(i)
-    n_dalton = i.to_f * 110
-    e sfancy(i.to_s)+rev+' aminoacids have a molecular weight of '+
-      simp(n_dalton.to_s)+rev+' Dalton ('+(n_dalton/1000.0).to_s+' kDa).'
-  end
-
-  # ========================================================================= #
-  # === analyze                                                 (analyze tag)
-  #
-  # The input to this method should be the DNA or aminoacid sequence.
-  # ========================================================================= #
-  def analyze(
-      i = sequence?
-    )
-    if i.is_a? Array
-      i << sequence? if i.empty?
-      i = i.join
-    end
-    # ======================================================================= #
-    # We require a String past this point.
-    # ======================================================================= #
-    i = i.to_s
-    if File.exist? i # Assume that we have a .pdb file here for now.
-      parse_this_pdb_file(i)
-    else
-      if block_given?
-        yielded = yield
-        case yielded
-        when :dna # Handle DNA "input" here.
-          analyze_dna_string(i)
-        else
-          do_analyze_sequence(i)
-        end
-      else # Default case without block.
-        do_analyze_sequence(i)
-      end
-    end
-  end
-
-  # ========================================================================= #
-  # === trailing_five_prime
-  # ========================================================================= #
-  def trailing_five_prime
-    " - 5'"
-  end; alias trailing_5_prime   trailing_five_prime # === trailing_5_prime
-       alias five_prime_trailer trailing_five_prime # === five_prime_trailer
-
-  # ========================================================================= #
-  # === mirror_repeat
-  # ========================================================================= #
-  def mirror_repeat(
-      i = dna_sequence?
-    )
-    i = dna_sequence? if i.nil? # Use a proper default in this case.
-    i = i.join(' ').strip if i.is_a? Array
-    erev default_padding+
-         five_prime+
-         colourize_dna_sequence(
-           ::Bioroebe.mirror_repeat_of(i, :use_separator_token)
-         )+
-         rev+
-         three_trailer
-  end
-
-  # ========================================================================= #
-  # === all_upcase?
-  #
-  # Return true if the input is all upcased.
-  # ========================================================================= #
-  def all_upcase?(i)
-    return true if i.upcase == i
-    false
-  end; alias is_all_upcase? all_upcase? # === is_all_upcase?
-
-  # ========================================================================= #
-  # === set_codon_table
-  #
-  # Set which codon table to use.
-  # ========================================================================= #
-  def set_codon_table(i)
-    ::Bioroebe.set_codon_table(i, :be_verbose) # defined in codon_table.rb
-  end
-
-  # ========================================================================= #
-  # === return_sequence_from_this_number
-  # ========================================================================= #
-  def return_sequence_from_this_number(i = 1)
-    case i.to_i
-    when 1
-      seq1?
-    when 2
-      seq2?
-    when 3
-      seq3?
-    when 4
-      seq4?
-    when 5
-      seq5?
-    when 6
-      seq6?
-    end
-  end
-
-  # ========================================================================= #
-  # === enter_base_directory
-  #
-  # Use this method to enter the base directory.
-  # ========================================================================= #
-  def enter_base_directory
-    cd ::Bioroebe.log_dir?
-  end
-
-  # ========================================================================= #
-  # === translate
-  #
-  # General translate method.
-  # ========================================================================= #
-  def translate(i, be_verbose = true)  # Translate tag.
-    translate_aminoacid(i, be_verbose) # for now, we default to this.
-  end
-
-  # ========================================================================= #
-  # === ee                                                           (ee tag)
-  #
-  # As e, but without newline. So basically it behaves like print.
-  # ========================================================================= #
-  def ee(i)
-    e(i, false)
-  end
-
-  # ========================================================================= #
-  # === convert_five_prime_dna_into_five_prime_mrna             (DNA to mRNA)
-  #
-  # This method will translate the 5'-DNA into 5'-mRNA.
-  # ========================================================================= #
-  def convert_five_prime_dna_into_five_prime_mrna(
-      this_string = sequence?
-    )
-    erev padding?+leading_5_prime+sfancy(this_string.upcase.tr('T','U'))+
-         rev+trailing_3_prime
-  end
-
-  # ========================================================================= #
-  # === trailing_3_prime
-  #
-  # This will essentually return a " -3'" string.
-  # ========================================================================= #
-  def trailing_3_prime(
-      get_rid_of_spaces = false
-    )
-    if show_the_trailer?
-      get_rid_of_spaces = true if get_rid_of_spaces == :no_spaces
-      _ = " - 3'".dup
-      _.delete!(' ') if get_rid_of_spaces
-      return _
-    end
-    return '' # Else return an empty String.
-  end; alias three_trailer        trailing_3_prime # === three_trailer
-       alias trailer              trailing_3_prime # === trailer
-       alias three_prime          trailing_3_prime # === three_prime
-       alias trailing_three_prime trailing_3_prime # === trailing_three_prime
-       alias trail_three_prime    trailing_3_prime # === trail_three_prime
-       alias trail_three          trailing_3_prime # === trail_three
-       alias trailing_three       trailing_3_prime # === trailing_three
-
-  # ========================================================================= #
-  # === format_this_nucleotide_sequence
-  #
-  # This method will properly format the passed-in nucleotide sequence,
-  # by making use of class ShowNucleotideSequence.
-  #
-  # It will return the formatted String.
-  # ========================================================================= #
-  def format_this_nucleotide_sequence(i, &block)
-    ::Bioroebe.format_this_nucleotide_sequence(i) { block }
-  end
-
-
-  # ========================================================================= #
-  # === find_longest_substring
-  # ========================================================================= #
-  def find_longest_substring(i = dna_string?)
-    if i.is_a? String and i.include? ' '
-      i = i.split(' ')
-    end
-    ::Bioroebe::FindLongestSubstring.new(i.first, i.last)
-  end
-
-  # ========================================================================= #
-  # === dna_padding                                         (dna_padding tag)
-  #
-  # This method will properly pad a DNA string (with leading 5' and
-  # trailing 3'). That string will be returned.
-  #
-  # First argument should be the string (sequence) that you wish to
-  # modify. 
-  # ========================================================================= #
-  def dna_padding(
-      this_sequence,
-      get_rid_of_spaces = false
-    )
-    return left_pad?+
-           five_prime(get_rid_of_spaces)+rev+
-           sfancy(this_sequence)+rev+
-           trailer(get_rid_of_spaces)
-  end; alias properly_spaced_dna        dna_padding # === properly_spaced_dna
-       alias properly_padded_dna_string dna_padding # === properly_padded_dna_string
-
-  # ========================================================================= #
-  # === no_newlines
-  #
-  # This will get rid of the newlines in a fasta file, at the least for
-  # displaying purposes.
-  # ========================================================================= #
-  def no_newlines(this_file)
-    if this_file.is_a? Array
-      this_file.each {|entry| no_newlines(entry) }
-    else
-      dataset = File.readlines(this_file)
-      dataset.map! {|line|
-        line.chomp! unless line.start_with? '>'
-        line
-      }
-      e dataset.join
-    end
-  end
-
-  # ========================================================================= #
-  # === annotate_this_file
-  # ========================================================================= #
-  def annotate_this_file(i)
-    ::Bioroebe::CreateAnnotationFormat.new(i)
-  end
-
-  # ========================================================================= #
-  # === display_all_aminoacids
-  #
-  # This method will display all Aminoacids.
-  #
-  # Invocation example:
-  #
-  #   daminoacids
-  #
-  # ========================================================================= #
-  def display_all_aminoacids
-    e
-    erev 'Aminoacids Shortnames:'
-    erev # Newline here is ok.
-    aa = ::Bioroebe::AMINO_ACIDS # Is a hash.
-    aa.keys.sort.each {|key|
-      result = aa[key].select {|inner_key, value| inner_key.size == 3 }.values.first
-      erev '  '+key+': '+sfancy(result)
-    }; e # Trailing newline.
-  end
-
-  # ========================================================================= #
-  # === toggle_truncate
-  # ========================================================================= #
-  def toggle_truncate
-    if do_truncate?
-      do_not_truncate
-    else
-      ::Bioroebe.do_truncate
-      erev 'We will truncate too-long output.'
-    end
-  end
-
-  # ========================================================================= #
-  # === do_truncate?
-  # ========================================================================= #
-  def do_truncate?
-    ::Bioroebe.do_truncate?
-  end
-
-  # ========================================================================= #
-  # === will_we_truncate?
-  # ========================================================================= #
-  def will_we_truncate?
-    if do_truncate?
-      erev 'We will truncate.'
-    else
-      erev 'We will not truncate.'
-    end
-  end
-
-  # ========================================================================= #
-  # === do_not_truncate
-  # ========================================================================= #
-  def do_not_truncate
-    ::Bioroebe.do_not_truncate
-    erev 'We will no longer truncate too-long output.'
-  end
-
-  # ========================================================================= #
-  # === designate_this_input_as_coding_entry
-  #
-  # Invocation example:
-  #
-  #   coding_entry 51..3251
-  #
-  # ========================================================================= #
-  def designate_this_input_as_coding_entry(i)
-    if i.is_a? Array
-      i = i.first
-    end
-    if i.include? '..'
-      # ===================================================================== #
-      # Assume Range-behaviour here.
-      # ===================================================================== #
-      @internal_hash[:coding_area] = i
-    end
-    erev "Using the coding-area #{sfancy(i)}#{rev}."
-    erev 'You can test this by e. g. invoking '+sfancy('ORF?')+rev+'.'
-  end
-
-  # ========================================================================= #
-  # === report_where_we_store
-  # ========================================================================= #
-  def report_where_we_store
-    erev "We will store output from the Bioroebe-Project "\
-         "into #{sfile(save_file?)}."
-  end
-
-  # ========================================================================= #
-  # === calculate_melting_temperature
-  #
-  # This method just delegates towards class CalculateMeltungTemperature.
-  # ========================================================================= #    
-  def calculate_melting_temperature(i)
-    i = string? if i.nil?
-    if i == :show_formulas
-      CalculateMeltingTemperature.show_formulas # bl $BIOROEBE/calculate_melting_temperature.rb
-    else
-      @_.calculate_melting_temperature(i)
-    end
-  end
-
-  # ========================================================================= #
-  # === salt_adjusted_tm
-  # ========================================================================= #
-  def salt_adjusted_tm(i)
-    if i.is_a? Array
-      i = i.join.strip
-    end
-    return ::Bioroebe.salt_adjusted_tm(i)
-  end
-
-  # ========================================================================= #
-  # === leading_5_prime
-  #
-  # This method will output the leading 5' part, like a header.
-  # ========================================================================= #
-  def leading_5_prime(
-      get_rid_of_spaces = false
-    )
-    if show_the_leader?
-      get_rid_of_spaces = true if get_rid_of_spaces == :no_spaces
-      _ = "5' - ".dup # <- This here is the header-tag.
-      _.delete!(' ') if get_rid_of_spaces
-      return _
-    end
-    return ''
-  end; alias five_prime               leading_5_prime # === five_prime
-       alias leading_five_prime       leading_5_prime # === leading_five_prime
-       alias leader                   leading_5_prime # === leader
-       alias lead_five_prime          leading_5_prime # === lead_five_prime
-       alias return_five_prime_header leading_5_prime # === return_five_prime
-       alias leading_five             leading_5_prime # === return_five
-
-  # ========================================================================= #
-  # === is_a_registered_compound?
-  # ========================================================================= #
-  def is_a_registered_compound?(i)
-    %w( glycine ).include? i.to_s.downcase
-  end
-
-  # ========================================================================= #
-  # === compare_two_files
-  #
-  # We will here compare whether two files are identical.
-  #
-  # First argument is the first file, second argument is the second file.
-  # ========================================================================= #
-  def compare_two_files(file_a, file_b)
-    if File.exist? file_a
-      file_a = File.read(file_a)
-    else
-      erev file_a+' does not exist.'
-    end
-    if File.exist? file_b
-      file_b = File.read(file_b)
-    else
-      erev file_b+' does not exist.'
-    end
-    erev (file_a == file_b)
-  end
-
-  # ========================================================================= #
-  # === molecular_mass_of_amino_acids_in_the_sequence
-  #
-  # This method will calculate the mass of all amino acids in the given
-  # sequence.
-  #
-  # The default input sequence will be the aminoacid sequence.
-  # ========================================================================= #
-  def molecular_mass_of_amino_acids_in_the_sequence(
-      i = aminoacid_sequence?
-    )
-    total_mass = 0
-    if i.is_a? Array # We require a String here really.
-      if i.empty? # In this case, assign a default.
-        i = aminoacid_sequence?
-      else
-        i = i.join
-      end
-    elsif i.nil?
-      i = aminoacid_sequence?
-    end
-    # ======================================================================= #
-    # The user may have inputted something such as 'lysine'. In this
-    # case, we will convert this to the one-letter code.
-    # ======================================================================= #
-    if (i != ::Bioroebe.return_short_aminoacid_letter_from_long_aminoacid_name(i))
-      i = ::Bioroebe.return_short_aminoacid_letter_from_long_aminoacid_name(i)
-    end
-    _ = i # Use a copy.
-    unless _
-      erev 'Please assign an aminoacid sequence.'
-      return
-    end
-    dataset_molecular_formula = YAML.load_file(FILE_AMINOACIDS_MOLECULAR_FORMULA)
-    chars =_.chars
-    chars.each {|this_aminoacid|
-      # ===================================================================== #
-      # The following constant has the mass of the aminoacid at hand. It
-      # is stored in the one-letter abbreviation.
-      # ===================================================================== #
-      value = AMINO_ACIDS_MASS_TABLE[this_aminoacid]
-      total_mass += value.to_f
-      molecular_formula = dataset_molecular_formula[one_letter_to_long_name(this_aminoacid).capitalize]
-      erev 'The molecular formula for '+sfancy(this_aminoacid)+rev+
-           ' is: '+lightgreen(molecular_formula)+rev
-    }
-    erev "The total mass (#{seagreen('molecular weight')}#{rev}) of "\
-         "this sequence (#{_.size.to_s} entries), using "\
-         "#{teal('mono-isotopic mass')}#{rev}, is: "
-    if has_konsole?
-      erev '  '+cadetblue(total_mass.to_s)
-    else
-      e "  #{simp(total_mass.to_s)}"
-    end
-    # ======================================================================= #
-    # Next calculate the average mass.
-    # ======================================================================= #
-    total_mass = 0
-    i.chars.each {|this_aminoacid|
-      value = AMINO_ACIDS_AVERAGE_MASS_TABLE[this_aminoacid]
-      total_mass += value.to_f
-    }
-    erev "The total mass (#{seagreen('molecular weight')}#{rev}) of "\
-         "this sequence (#{_.size.to_s} entries), using "\
-         "#{teal('average molecular mass')}#{rev}, is: "
-    erev '  '+cadetblue(total_mass.to_s)
-  end; alias molecular_mass_of_amino_acids_in_this_sequence molecular_mass_of_amino_acids_in_the_sequence # === molecular_mass_of_aminco_acids_in_this_sequence
-
-  # ========================================================================= #
-  # === dump
-  #
-  # This method can be used to save the main DNA string into a file.
-  #
-  # You can also store RNA of course; simply pass the argument
-  # "rna" or "to_rna" to this method.
-  # ========================================================================= #
-  def dump(optional_arguments = nil)
-    what = dna_string?
-    if optional_arguments.is_a? Array
-      optional_arguments = optional_arguments.join(' ').strip
-    end
-    case optional_arguments
-    when 'rna',/to_?rna/
-      what = ::Bioroebe.to_rna(what)
-    end
-    into = file_dna_string_saved?
-    erev 'Storing into `'+sfile(into)+'`.'
-    write_what_into(what, into)
-  end
-
-  # ========================================================================= #
-  # === name_of_gene?
-  # ========================================================================= #
-  def name_of_gene?
-    sequence_object?.name_of_gene?
-  end
-
-  # ========================================================================= #
-  # === set_name_of_gene
-  #
-  # Use this method to set the name of a gene in question.
-  # ========================================================================= #
-  def set_name_of_gene(
-      i          = '',
-      be_verbose = :be_verbose
-    )
-    case be_verbose
-    when :be_verbose
-      be_verbose = true
-    end
-    if i.is_a? Array # We don't want Arrays here.
-      i = i.join(' ').strip
-    end
-    if i.nil? or i.to_s.empty?
-      erev 'Please assign a non-empty name for the gene.'
-      return
-    end
-    if be_verbose
-      erev 'Now assigning the gene name to "'+simp(i)+rev+'", without '\
-           'the quotes.'
-    end
-    sequence_object?.name_of_gene = i
-  end
-
-  # ========================================================================= #
-  # === do_not_show_the_trailer
-  # ========================================================================= #
-  def do_not_show_the_trailer(be_verbose = true)
-    if be_verbose
-      e "The 3'-trailer of nucleotide sequences will not be shown."
-    end
-    @internal_hash[:show_the_trailer] = false
-  end
-
-  # ========================================================================= #
-  # === do_not_show_the_leader
-  # ========================================================================= #
-  def do_not_show_the_leader(
-      be_verbose = true
-    )
-    if be_verbose
-      e "The 3'-trailer of nucleotide sequences will not be shown."
-    end
-    @internal_hash[:show_the_leader] = false
-  end
-
-  # ========================================================================= #
-  # === show_the_leader?
-  # ========================================================================= #
-  def show_the_leader?
-    @internal_hash[:show_the_leader]
-  end
-
-  # ========================================================================= #
-  # === show_the_trailer?
-  # ========================================================================= #
-  def show_the_trailer?
-    @internal_hash[:show_the_trailer]
-  end
-
-  require 'bioroebe/toplevel_methods/download_and_fetch_data.rb'
-  # ========================================================================= #
-  # === uniprot_fetch
-  #
-  # This method can be sued to obtain the .fasta sequence of a protein
-  # listed at uniprot.
-  # ========================================================================= #
-  def uniprot_fetch(
-      i = 'P12345'
-    )
-    i = 'P12345' if i.nil?
-    ::Bioroebe.fetch_data_from_uniprot(i)
-  end
-
-  # ========================================================================= #
-  # === calculate_exponential_growth
-  # ========================================================================= #
-  def calculate_exponential_growth(a, b)
-    erev ::Bioroebe.calculate_exponential_growth(a,b)
-  end
-
-  # ========================================================================= #
-  # === molecular_mass_of
-  #
-  # Give out the molecular mass of an amino-acid.
-  #
-  # We will use only the first input character, and upcase it.
-  #
-  # You can also input an Array here, though.
-  #
-  # Usage examples:
-  #
-  #   mmasse tyrosin
-  #   mmasse KKKRAAA
-  #   mmasse Glycine
-  #
-  # ========================================================================= #
-  def molecular_mass_of(
-      i                   = aminoacids?,
-      optional_round_here = nil
-    )
-    case i
-    # ======================================================================= #
-    # === HELP
-    # ======================================================================= #
-    when /^-?-?help$/i
-      erev 'Input an amino acid, such as H.'
-      return
-    end if i.is_a? String
-    i = aminoacids? if i.nil? # Safeguard.
-    # ======================================================================= #
-    # === Handle Arrays first
-    # ======================================================================= #
-    if i.is_a? Array
-      i.uniq.each {|entry|
-        molecular_mass_of(entry, optional_round_here)
-      }
-    elsif is_a_registered_compound?(i)
-      original_name = i.dup
-      # ===================================================================== #
-      # This menu is a bit ad-hoc. In the long run we will probably have
-      # to make this more generic.
-      # ===================================================================== #
-      case i
-      # ===================================================================== #
-      # === Glycine
-      # ===================================================================== #
-      when /^Glycine?$/i
-        i = 'C8H9NO3'
-      end
-      i = ChemistryParadise.molmass_of?(i)
-      erev 'The molecular mass of '+sfancy(original_name)+rev+
-           ' is: '+simp(i.to_s.rjust(5))
-    else # Else we assume a String here.
-      # ===================================================================== #
-      # Some input may be like "tyrosin". In this case, we will assume
-      # that the user may have input 
-      # ===================================================================== #
-      if i.size > 1
-        if i.size > 3
-          _ = i.to_s.downcase
-          if _.size > 3
-            reversed = AMINO_ACIDS_ABBREVIATIONS.invert
-            if reversed.has_key? _
-              _ = reversed[_]
-              if AMINO_ACIDS_THREE_TO_ONE.has_key? _
-                _ = AMINO_ACIDS_THREE_TO_ONE[_]
-              end
-              molecular_mass_of(_, optional_round_here)
-              return
-            end
-          end
-        end
-        # =================================================================== #
-        # Here, either we grab the mass of each character, or we
-        # try to find a single AA replacement.
-        # =================================================================== #
-        molecular_mass_of(i.chars, optional_round_here)
-      else
-        if AMINO_ACIDS_MASS_TABLE.has_key? i
-          left = rev+'The molecular mass of '+sfancy(i)+rev+' ('+
-                 get_long_name_of_amino_acid(i)+rev+')'+rev+' is: '
-          ljust_value = 72
-          ljust_value = 92 if use_colours?
-          left = left.ljust(ljust_value)
-          result = AMINO_ACIDS_MASS_TABLE[i]
-          if optional_round_here
-            result = result.to_f.round(optional_round_here)
-          end
-          erev left+simp(result.to_s.rjust(5))
-        else
-          # e 'Please input a specific amino acid, such as "H".'
-        end
-      end
-    end
-  end
-
-  # ========================================================================= #
-  # === colour_scheme_for_nucleotides
-  #
-  # This method can eventually be used to display the colour codes for
-  # the nucleotides.
-  # ========================================================================= # 
-  def colour_scheme_for_nucleotides(i = dna_sequence?)
-    begin
-      require 'roebe/classes/hex_to_rgb.rb'
-    rescue LoadError; end
-    if Object.const_defined?(:Roebe) and
-       Roebe.const_defined?(:HexToRGB)
-      i = dna_sequence? if i.nil?
-      i = i.first if i.is_a? Array
-      hash = ::Bioroebe::ColourScheme::Nucleotide.colours?
-      tokens = i.chars
-      # ======================================================================= #
-      # Get it in chunks of 80.
-      # ======================================================================= #
-      chunks = tokens.each_slice(80).to_a
-      e; chunks.each {|array|
-        array.each {|char|
-          if hash.has_key? char
-            value = hash[char]
-            array = Roebe::HexToRGB[value] # Obtain the R,G,B Array from here.
-            ::Colours.rgb_print(array, char)
-          end
-        }
-        e
-      }; e
-    else
-      erev 'Please install the gem hex_to_rgb, in order '\
-           'to use this method.'
-    end
-  end
-
-  # ========================================================================= #
-  # === www_finder_run
-  # ========================================================================= #
-  def www_finder_run
-    Bioroebe::GUI::Gtk::WwwFinder.run
-  end
-
-  # ========================================================================= #
-  # === primer?
-  # ========================================================================= #
-  def primer(i)
-    i = i.to_s
-    if i.empty?
-      erev 'Please provide a number, which is the length of the Primer.'
-    else
-      erev 'We will design two primers, with a '\
-           'length of '+i+rev+' each.'
-      report_sequence
-      _ = sequence?[0, i.to_i]
-      reverse_sequence = sequence?.reverse[0, i.to_i]
-      forward_primer = leading_three_prime+
-                       rev+
-                       sfancy(
-                         complement(reverse_sequence.reverse)
-                       )+rev+trailing_five_prime+
-                       rev
-      reverse_primer = leading_five_prime+
-                       sfancy(
-                         complement(_.reverse)
-                       )+rev+trailing_three_prime+
-                       rev
-      erev 'Forward primer: '+forward_primer
-      erev 'Reverse primer: '+reverse_primer
-      e
-      padding = ' ' * (sequence?.size.to_i - _.size)
-      erev '  '+padding+forward_primer
-      show_sequence # This is the main sequence.
-      spacer = '|' * sequence?.size.to_i
-      erev "       #{swarn(spacer)} #{rev}" 
-      erev '  '+leading_three_prime+rev+
-           sfancy(complement(sequence?))+rev+trailing_five_prime+rev
-      erev '  '+leading_five_prime+rev+
-           sfancy(_.to_s)+rev+
-           trailing_three_prime+rev
-      e
-    end
-  end
-
-  # ========================================================================= #
-  # === open_this_file_in_editor                                 (editor tag)
-  # ========================================================================= #
-  def open_this_file_in_editor(file)
-    case file
-    when :bioshell, :shell
-      file = HOME_DIR+'shell.rb'
-    end
-    _ = MAIN_EDITOR+' '+file
-    if File.exist? file
-      splitted = _.split(' ')
-      splitted[1][0,0] = sfile
-      erev splitted.join(' ')+main_colour
-      system _
-    else
-      erev 'The file `'+sfile(file)+rev+'` does not exist.'
-    end
-  end
-
-  # ========================================================================= #
-  # === open_this_ncbi_page
-  #
-  # This method will help us open the proper NCBI pages.
-  # ========================================================================= #
-  def open_this_ncbi_page(i)
-    search_term = i
-    search_term = '' if search_term.nil?
-    search_term = search_term.join(' ').strip.to_s if search_term.is_a? Array
-    if search_term =~ /^\d+$/ # If only numbers.
-      _ = '"https://www.ncbi.nlm.nih.gov/gene/'+search_term.to_s+'"'
-    else
-      _ = '"https://www.ncbi.nlm.nih.gov/gquery/?term='+search_term+'"'
-    end
-    erev _
-    open_in_browser_tab(_)
-  end
-
-  # ========================================================================= #
-  # === feedback_whether_we_are_in_debug_mode
-  # ========================================================================= #
-  def feedback_whether_we_are_in_debug_mode
-    erev 'Are we in debug mode? '+simp(@debug.to_s)+rev
-  end
-
-  # ========================================================================= #
-  # === upcase_main_string
-  #
-  # Use this method to upcase the main sequence.
-  # ========================================================================= #
-  def upcase_main_string
-    set_sequence(sequence?.upcase)
-  end
-
-  # ========================================================================= #
-  # === notify_the_user_as_to_how_findgene_works
-  # ========================================================================= #
-  def notify_the_user_as_to_how_findgene_works
-    begin
-      _ = project_base_dir?+'find_gene.rb'
-      ClassDocuShower[_]
-    rescue LoadError
-      erev 'Please install class_docu_shower for this functionality to work.'
-    end
-  end
-
-  require 'bioroebe/utility_scripts/find_gene.rb'
-  # ========================================================================= #
-  # === find_gene
-  #
-  # Wrapper towards class Bioroebe::FindGene.
-  # ========================================================================= #
-  def find_gene(i = :default)
-    case i
-    when :default, nil
-      i = dna_sequence?
-    end 
-    if i.empty?
-      report_that_a_string_must_be_assigned_first
-    else
-      ::Bioroebe::FindGene.new(i.upcase) # bl $BIOROEBE/find_gene.rb
-    end
-  end
-
-  require 'bioroebe/nucleotides/sanitize_nucleotide_sequence.rb'
-  # ========================================================================= #
-  # === sanitize_nucleotide_sequence
-  #
-  # Invocation example:
-  #   sanitize_nucleotide_sequence "  10 AGTA \n  20 TTGC"
-  # ========================================================================= #
-  def sanitize_nucleotide_sequence(i)
-    if i.is_a? Array
-      i = i.join
-    end
-    @result = ::Bioroebe::SanitizeNucleotideSequence.new(i).result?.delete('"')
-    set_dna_sequence(@result)
-  end
-
-  require 'bioroebe/colours/colour_schemes/colour_scheme_demo.rb'
-  # ========================================================================= #
-  # === colour_scheme_demo
-  # ========================================================================= #
-  def colour_scheme_demo(
-      use_this_sequence = 'ATGCATGCATGCATGCATGCATGCATGCATGCATGCATGCATGC'
-    )
-    ColourSchemeDemo.new(use_this_sequence)
-    file = ::Bioroebe::ColourSchemeDemo.create_demo_file.to_s
-    erev file
-    open_in_browser(file) if File.exist? file
-  end
-
-  # ========================================================================= #
-  # === design_polylinker
-  #
-  # This method will design a polylinker from 3-8 random restriction
-  # enzymes sites.
-  #
-  # You can pass a first argument to this method.
-  #
-  # Example:
-  #
-  #   design_polylinker 100
-  #
-  # ========================================================================= #
-  def design_polylinker(
-      optional_length_of_polylinker = nil,
-      be_verbose                    = true
-    )
-    if optional_length_of_polylinker.is_a? Array
-      optional_length_of_polylinker = optional_length_of_polylinker[0]
-    end
-    if optional_length_of_polylinker.nil?
-      optional_length_of_polylinker = 20
-    end
-    optional_length_of_polylinker = optional_length_of_polylinker.to_i
-    full_sequence = ''
-    n_restriction_sites = rand(6)+3
-    n_restriction_sites.times {
-      full_sequence << return_random_restriction_enzyme(be_verbose)
-    }
-    if full_sequence.size < optional_length_of_polylinker
-      loop {
-        full_sequence << return_random_restriction_enzyme(be_verbose)
-        break if full_sequence.size > optional_length_of_polylinker
-      }
-    end
-    erev 'Our generated polylinker has '+sfancy(n_restriction_sites.to_s)+
-         ' sites for restriction enzymes available (DNA Sequence '+
-         'length is: '+full_sequence.size.to_s+').'
-    erev 'We will also assign this sequence as the new DNA sequence.'
-    assign_dna_sequence(full_sequence, :be_quiet)
-    return full_sequence
-  end
-
-  # ========================================================================= #
-  # === perform_frameshift_action
-  #
-  # This method attempts to perform a frameshift on our target sequence.
-  # We can give, as argument, +1,+2,+3 etc. Note that the + character
-  # is optional - if omitted, we assume that it was passed.
-  # ========================================================================= #
-  def perform_frameshift_action(i)
-    i = i.to_s
-    if sequence?.empty?
-      erev 'Please first "assign" a sequence before trying to'
-      erev 'perform a frameshift on it.'
-    else
-      if i == 'all'
-        erev 'We will perform all frameshift actions next.'
-        perform_frameshift_action '+1'
-        perform_frameshift_action '+2'
-        perform_frameshift_action '+3'
-      elsif i.to_i == 0
-        report_syntax_help_for_frameshift_action
-      else
-        erev 'Performing a frameshift on our target sequence next.'
-        erev 'The frameshift to perform will be '+simp(('+'+i).squeeze('+'))+'.'
-        erev 'We will modify the main sequence directly.'
-        @sequence[0, i.to_i] = ''
-        show_main_string
-      end
-    end
-  end
-
-  # ========================================================================= #
-  # === verbose_handle_this_sys_command
-  # ========================================================================= #
-  def verbose_handle_this_sys_command(
-      i, arguments = a?
-    )
-    if a and a.is_a?(Array)
-      arguments = a.join(' ').strip
-    end
-    esystem i+' '+arguments.to_s+' &'
-  end
-
-  # ========================================================================= #
-  # === leading_3_prime
-  #
-  # This is when 3' is at the start of an output.
-  # ========================================================================= #
-  def leading_3_prime
-    "3' - "
-  end; alias leading_three_prime leading_3_prime # === leading_three_prime
-       alias leading_3           leading_3_prime # === leading_3
-
-  require 'bioroebe/toplevel_methods/verbose.rb'
-  # ========================================================================= #
-  # === verbose_truth
-  #
-  # Delegate towards the module Bioroebe::VerboseTruth here.
-  # ========================================================================= #
-  def verbose_truth(i)
-    ::Bioroebe::VerboseTruth[i]
-  end
-
-  # ========================================================================= #
-  # === will_we_use_colours?
-  # ========================================================================= #
-  def will_we_use_colours?
-    erev "Will we use colours? #{verbose_truth(@use_colours)}#{rev}"
-  end
-
-  # ========================================================================= #
-  # === create_balanced_composition
-  #
-  # This method will create a balanced nucleotide-composition.
-  #
-  # In other words, we can do a DNA string with 25% A, G, C, T each.
-  # ========================================================================= #
-  def create_balanced_composition(i = nil)
-    string = ''.dup # The return string.
-    if i.nil?
-      n_nucleotides_to_be_generated = 1000 # Default.
-      # In this case, go interactive.
-      erev 'Please enter the percentage of each nucleotide next.'
-      ee 'A: '
-      a = $stdin.gets.chomp.to_i
-      ee 'T: '
-      t = $stdin.gets.chomp.to_i
-      ee 'C: '
-      c = $stdin.gets.chomp.to_i
-      erev 'G is automatically calculated.'
-      g = 100 - (a + t + c)
-      ee 'G: '
-      # The following is not yet finished.
-      string << ('A' * a)+('T' * t)+('C' * c)+('G' * g)
-    else
-      i = 1000 if i.nil? or (i.is_a?(Array) and i.empty?) # The default.
-      n_nucleotides_to_be_generated = i
-      # ===================================================================== #
-      # Otherwise, we assume it to be 25% for each nucleotide. The following
-      # code will ensure that.
-      # ===================================================================== #
-      n_times = n_nucleotides_to_be_generated.to_i / 4
-      n_times.times {
-        _ = return_dna_nucleotides # Get all four entries first.
-        _.shuffle.each {|nucleotide|
-          string << nucleotide
-        }
-      }
-    end
-    erev "Note: we will assume the target size will "\
-         "be #{n_nucleotides_to_be_generated.to_s} nucleotides."
-    return string # The nucleotide-string to be returned.
-  end
-
-  # ========================================================================= #
-  # === interactive_use_of_levensthein
-  # ========================================================================= #
-  def interactive_use_of_levensthein(
-      i = all_arguments?
-    )
-    require 'bioroebe/string_matching/levensthein.rb'
-    erev 'You want to use class '+steelblue('Bioroebe::Levensthein')+
-          rev+'. This class needs two'
-    erev 'input sequences (defaulting to nucleotides).'
-    e
-    if i.nil? or i.empty?
-      erev 'Input the nucleotide sequence to the '+
-           slateblue('first')+rev+' sequence:'
-      print '  '; sequence1 = $stdin.gets.chomp
-      e
-      erev 'Input the nucleotide sequence to the '+
-           slateblue('second')+rev+' sequence:'
-      print '  '; 
-      sequence2 = $stdin.gets.chomp
-      ::Bioroebe::Levensthein.new(sequence1, sequence2)
-    else
-      ::Bioroebe::Levensthein.new(i)
-    end
-  end
-
-  # ========================================================================= #
-  # === considering_changing_the_title_of_the_kde_konsole_tab
-  # ========================================================================= #
-  def considering_changing_the_title_of_the_kde_konsole_tab(
-      to_this_title = 'BioRoebe'
-    )
-    if ::Bioroebe.try_to_rename_kde_konsole? and
-       Object.const_defined? :Roebe # For project roebe.
-      require 'roebe/classes/kde/kde_konsole/kde_konsole.rb'
-      Roebe.change_konsole_tab_title(to_this_title, :be_silent)
-    end
-  end
-
-  # ========================================================================= #
-  # === show_xorg_buffer
-  # ========================================================================= #
-  def show_xorg_buffer
-    if @internal_hash[:use_xsel]
-      esystem 'xsel -o'
-    end
-  end
-
-  # ========================================================================= #
-  # === open_1igt_in_the_browser
-  # ========================================================================= #
-  def open_1igt_in_the_browser
-    _ = 'https://www.rcsb.org/structure/1igt'
-    e; e _; e
-    open_in_browser _
-  end
-
-
-  # ========================================================================= #
-  # === show_the_aminoacids_frequencies
-  # ========================================================================= #
-  def show_the_aminoacids_frequencies
-    pp YAML.load_file(FILE_AMINO_ACIDS_FREQUENCY)
-  end
-
-  # ========================================================================= #
-  # === is_this_a_cd_alias?
-  #
-  # The reason why this does a check for :Rcfiles is because not every
-  # user may have the rcfiles-project available.
-  # ========================================================================= #
-  def is_this_a_cd_alias?(i)
-    Object.const_defined?(:Rcfiles) and
-    ::Rcfiles::DirectoryAliases.is_this_input_a_cd_alias?(i)
-  end
-
-  # ========================================================================= #
-  # === print_rev
-  # ========================================================================= #
-  def print_rev
-    print rev
-  end
-
-  # ========================================================================= #
-  # === try_to_run_rnalfold_on_this_file
-  # ========================================================================= #
-  def try_to_run_rnalfold_on_this_file(i)
-    if File.exist? i
-      esystem("RNALfold --infile=#{i}")
-    else
-      erev 'No file called `'+sfile(i)+rev+'` exists.'
-    end
-  end
-
-  require 'bioroebe/utility_scripts/compacter.rb'
-  # ========================================================================= #
-  # === compact_file
-  #
-  # Delegate into class Bioroebe::Compacter.
-  # ========================================================================= #
-  def compact_file(this_file = nil)
-    ::Bioroebe::Compacter.new(this_file)
-  end
-
-  # ========================================================================= #
-  # === return_dna_nucleotides
-  #
-  # This method will return the Array holding A, T, C and G (the four
-  # DNA nucleotides).
-  # ========================================================================= #
-  def return_dna_nucleotides
-    %w( A T C G )
-  end
-
-  # ========================================================================= #
-  # === feedback_version
-  # ========================================================================= #
-  def feedback_version
-    erev version?
-  end
-
-
-  require 'bioroebe/string_matching/find_longest_substring_via_LCS_algorithm.rb'
-  # ========================================================================= #
-  # === find_longest_substring_via_LCS
-  #
-  # To invoke this, try:
-  #
-  #   longest_substring? ATTATTGTT | ATTATTCTT
-  #
-  # ========================================================================= #
-  def find_longest_substring_via_LCS(i)
-    i = i.join(' | ') if i.is_a? Array
-    ::Bioroebe::FindLongestSubstringViaLCSalgorithm.new(i) { :do_also_show_the_two_sequences }
-  end
-
-  require 'bioroebe/aminoacids/deduce_aminoacid_sequence.rb'
-  # ========================================================================= #
-  # === deduce_this_aminoacid_sequence
-  #
-  # Thi method will show the possible codons for an aminoacid sequence.
-  #
-  # It will display the result in an ASCII table, on the commandline.
-  #
-  # Trigger this like so:
-  #
-  #   sof
-  #   sof Lys-Ser-Pro-Ser-Leu-Asn-Ala-Ala-Lys
-  #   sof Thr Thr Glu Ala Val Glu Ser Thr Val Ala Thr Leu Glu Asp Ser
-  #   sof T-T-G-A-V-G-S-T-V
-  #
-  # ========================================================================= #
-  def deduce_this_aminoacid_sequence(
-      i                     = 'Lys-Ser-Pro-Ser-Leu-Asn-Ala-Ala-Lys',
-      show_the_rna_sequence = true
-    )
-    if i.nil? # This is the default.
-      if aminoacid_sequence?
-        i = aminoacid_sequence?
-      else
-        i = 'Lys-Ser-Pro-Ser-Leu-Asn-Ala-Ala-Lys'
-      end
-    end
-    DeduceAminoacidSequence.new(i, show_rna: show_the_rna_sequence) # bl DeduceAminoacidSequence
-  end
-
-  # ========================================================================= #
-  # === open_in_uniprot
-  #
-  # This method will open the remote, associated URL with the protein
-  # at hand.
-  # ========================================================================= #
-  def open_in_uniprot(
-      i = 'A1XPA3'
-    )
-    i = 'A1XPA3' if i.nil? # <- Ensure a default.
-    _ = 'https://www.uniprot.org/uniprot/?query='+i+'&sort=score'
-    erev _
-    set_xclip(_) if configuration?.additionally_set_xorg_buffer
-    open_in_browser(_)
-  end
-
-  # ========================================================================= #
-  # === lpad?
-  # ========================================================================= #
-  def lpad?
-    '  '
-  end
-
-  # ========================================================================= #
-  # === purge
-  #
-  # This method can be used to purge nucleotides. E. g. if you want to
-  # get rid of all Thymines.
-  #
-  # To invoke this method, do:
-  #
-  #   purge thymines
-  #
-  # ========================================================================= #
-  def purge(i)
-    if i.nil?
-      erev 'Please provide some input such as "thymine" or "t".'
-      return
-    end
-    if i.is_a? Array
-    else
-      erev "Now purging all #{simp(i)}#{rev}:"
-      case i
-      when 'thymine','thymines'
-        i = 'T'
-      when 'cytosine','cytosines'
-        i = 'C'
-      when 'guanine','guanines'
-        i = 'G'
-      end
-      new_string = sequence?.tr(i.upcase, '')
-      set_sequence(new_string)
-      show_string
-    end
-  end
-
-  # ========================================================================= #
-  # === interactively_pick_colour
-  #
-  # This method can be used to interactively assign a new colour for
-  # the rev() part.
-  # ========================================================================= #
-  def interactively_pick_colour
-    erev 'You can pick a Konsole colour here, for rev(), which is '\
-         'the default colour.'
-    erev 'In order to make it a bit easier for you, we will show 5 '\
-         'random examples for this:'
-    string = ''
-    5.times {
-      string << ::Colours.colours.sample << ', '
-    }
-    erev '  '+string
-    erev 'Input your Colours colour next:'
-    user_input = $stdin.gets.chomp
-    colour_to_use = ::Colours.send(user_input.to_sym)
-    erev colour_to_use+'Testing: '+rev
-    # ======================================================================= #
-    # Next, set a new default colour to use.
-    # ======================================================================= #
-    ::Bioroebe.set_default_colour(colour_to_use)
-  end
-
-  # ========================================================================= #
-  # === sanitize_input
-  #
-  # Right now this method only gets rid of '-' but check if the string
-  # contains '-' first before calling this method.
-  # ========================================================================= #
-  def sanitize_input(i)
-    i.tr('-','')
-  end
-
-  # ========================================================================= #
-  # === main_colour
-  # ========================================================================= #
-  def main_colour
-    ::Bioroebe.main_colour
-  end; alias main_col main_colour # === main_col
-
-  begin
-    require 'easycompile'
-  rescue LoadError; end
-
-  # ========================================================================= #
-  # === copy_bioroebe_shell_before_quitting
-  #
-  # Use this method to copy the Bioroebe shell before quitting.
-  #
-  # We will make use of class InstallRubyProject for this.
-  #
-  # This was disabled as of Jan 2016. The reason is that it confuses me
-  # too much, seriously. Perhaps I will re-enable it again at a later time.
-  # ========================================================================= #
-  def copy_bioroebe_shell_before_quitting
-    _ = RUBY_SRC+'bioroebe/'
-    begin
-      require 'roebe/classes/install_ruby_project.rb'
-    rescue LoadError; end
-    if Object.const_defined? :Roebe
-      irp = Roebe::InstallRubyProject.new(_, false)
-      irp.run
-    elsif on_roebe?
-      erev 'The project custom_methods/install_ruby_project is not available.'
-      erev 'We will install it now.'
-      cd '$RSRC/roebe/'
-      Easycompile.rinstall2 if Object.const_defined? :Easycompile
-    end if false # Disabled it here. Not sure if I will re-enable it.
-  end
-
-  # ========================================================================= #
-  # === install                                                 (install tag)
-  # ========================================================================= #
-  def install(i)
-    case i.to_s
-    when 'bioruby','bioroebe','bio','1', # install bioroebe.
-         :default
-      erev 'We now install Bioruby.'
-      file_location = '/home/x/src/bioruby/bioruby-2.0.0.tar.xz'
-      begin
-        Easycompile::Easycompile.new(file_location) # Make use of Easycompile to install it.
-      rescue Exception => error
-        pp error
-      end
-    else
-      ewarn 'Do not know how to install `'+simp(i)+'`.'
-    end
-  end
+# require 'bioroebe/shell/misc.rb'
+# =========================================================================== #
+require 'bioroebe/base/commandline_application/commandline_application.rb'
 
-  # ========================================================================= #
-  # === translate_dna_into_aminoacid
-  #
-  # The first argument should be the DNA sequence.
-  # ========================================================================= #
-  def translate_dna_into_aminoacid(
-      i     = dna_sequence?,
-      frame = 1
-    )
-    i = dna_sequence? if i.nil?
-    if i.is_a? Array
-      i.each {|entry| translate_dna_into_aminoacid(entry) }
-    else
-      i.upcase!
-      case frame
-      when 1 # normal frame, default.
-      when 2 # one shifted
-        i[0,1] = ''
-      when 3 # two shifted
-        i[0,1] = ''
-        i[0,1] = ''
-      end
-      # ===================================================================== #
-      # Next, return the result.
-      # ===================================================================== #
-      return ::Bioroebe.translate_dna_into_aminoacid(i)
-    end
-  end; alias translate_dna_into_aminoacid_frame1 translate_dna_into_aminoacid # === translate_dna_into_aminoacid_frame1
+module Bioroebe
 
-  # ========================================================================= #
-  # === print_aa_table
-  #
-  # Use this method to print an overview over the aminoacid sequence that
-  # was assigned.
-  # ========================================================================= #
-  def print_aa_table(optional_arguments = all_arguments?)
-    require 'bioroebe/aminoacids/display_aminoacid_table.rb'
-    if optional_arguments.is_a?(Array) and !optional_arguments.empty?
-      _ = optional_arguments
-    else
-      _ = aminoacids?
-    end
-    _ = _.first if _.is_a? Array
-    Bioroebe::DisplayAminoacidTable.new(_)
-  end
+class Shell < ::Bioroebe::CommandlineApplication # === Bioroebe::Shell
 
   # ========================================================================= #
-  # === codon_to_aminoacid
-  #
-  # Translate a codon into an aminoacid through this method.
+  # === create_file
   # ========================================================================= #
-  def codon_to_aminoacid(i)
-    Bioroebe.codon_to_aminoacid(i)
+  def create_file(i = a?)
+    [i].flatten.each {|this_file|
+      unless File.exist?(this_file)
+        erev 'Creating the file '+sfile(this_file)+rev+' next.'
+        FileUtils.touch(this_file)
+      end
+    }
   end
 
   require 'bioroebe/enzymes/return_sequence_that_is_cut_via_restriction_enzyme.rb'
@@ -3704,638 +31,63 @@ class Shell < ::Bioroebe::CommandlineApplication
   def append(i)
     i = i.join.strip if i.is_a? Array
     i = i.to_s
-    case i # case tag
-    # ======================================================================= #
-    # === start
-    # ======================================================================= #
-    when 'start'
-      i = ::Bioroebe.start_codon?
-      erev 'We will append the START codon '+sfancy(i)+rev+' next.'
-    # ======================================================================= #
-    # === stop
-    # ======================================================================= #
-    when 'stop'
-      i = ::Bioroebe.stop_codons?.sample
-      erev 'We will append the STOP codon '+sfancy(i)+rev+' next.'
-    when 'shine'
-      i = 'AGGAGGT' # Can only add nucleotides to the main sequence.
-      erev 'We will append the '+mediumslateblue('Shine Dalgarno')+
-           rev+' (SD) sequence '+sfancy("#{i}-3")+rev+' next.'
-    end
-    if i =~ /^\d+$/ # If input is only numbers.
-        erev "Only numbers were given: Adding #{sfancy(i.to_s)}#{rev}"\
-             " random nucleotides to the main string next."
-      new_string = ''.dup
-      i.to_i.times { new_string << return_random_nucleotide }
-      i = new_string
-    end
     # ======================================================================= #
-    # === Check that we add only DNA or RNA nucleotides past this point
+    # First check whether the main sequence is frozen:
     # ======================================================================= #
-    if only_nucleotides?(i)
-      erev "Now appending #{simp(i)}#{rev}."
-      sequence_object? << i # Next, append to the sequence object here.
+    if is_the_main_sequence_frozen?
+      report_that_the_main_sequence_is_frozen
     else
+      case i # case tag
       # ===================================================================== #
-      # The user may also wish to append a restriction site, such
-      # as via add EcoRI. We need to enable this here.
+      # === start
       # ===================================================================== #
-      _ = ::Bioroebe.return_sequence_that_is_cut_via_restriction_enzyme(i, :no_colours)
-      if _
-        _.tr!('|','')
-        erev 'Now appending '+simp(_)+rev+'.'
-        sequence_object? << _ # Next, append to the sequence object here.
-        show_dna_sequence
-      else
-        erev 'Can not add the sequence '+simp(i)+rev+' because there are '\
-             'non-nucleotides in it.'
-      end
-    end
-  end
-
-  require 'bioroebe/count/count_amount_of_nucleotides.rb'
-  # ========================================================================= #
-  # === analyze_dna_string
-  #
-  # This method presently only counts the amount of nucleotides found
-  # in the given DNA string at hand.
-  #
-  # We use the class Bioroebe::CountAmountOfNucleotides, in
-  # bl count_amount_of_nucleotides.rb
-  # ========================================================================= #
-  def analyze_dna_string(
-      i = dna_string?
-    )
-    # ======================================================================= #
-    # Set some default values:
-    # ======================================================================= #
-    i = dna_string? if i.nil?
-    if i.is_a? Array and i.empty?
-      i = dna_string?
-    end
-    ::Bioroebe::CountAmountOfNucleotides.new(
-      i, :use_cliner
-    ) {{ use_colours: use_colours? }} # bl $BIOROEBE/count_amount_of_nucleotides.rb
-  end
-
-  # ========================================================================= #
-  # === could_this_be_an_amino_acid?
-  #
-  # If the input is an amino acid, we return true for this method here.
-  #
-  # Characters such as '?' will be removed.
-  #
-  # Invocation examples:
-  #
-  #   phenylalanine
-  #   glycin
-  #   glycine
-  #
-  # ========================================================================= #
-  def could_this_be_an_amino_acid?(i)
-    i = i.to_s.downcase
-    i.delete!('?') if i.include? '?' # Get rid of '?' tokens.
-    return_value = false
-    unless i.empty?
+      when 'start'
+        i = ::Bioroebe.start_codon?
+        erev 'We will append the START codon '+sfancy(i)+rev+' next.'
       # ===================================================================== #
-      # First, we check here for german names. These names are kept in
-      # the file called
-      # 'amino_acids_long_name_to_one_letter.yml'
+      # === stop
+      #
+      # Add a random stop-codon in this case.
       # ===================================================================== #
-      unless AMINO_ACIDS_RESTE.has_key?(i)
-        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
+      when 'stop'
+        i = ::Bioroebe.stop_codons?.sample
+        erev 'We will append the STOP codon '+sfancy(i)+rev+' next.'
+      when 'shine'
+        i = 'AGGAGGT' # Can only add nucleotides to the main sequence.
+        erev 'We will append the '+mediumslateblue('Shine Dalgarno')+
+             rev+' (SD) sequence '+sfancy("#{i}-3")+rev+' next.'
       end
-      if AMINO_ACIDS_RESTE.has_key?(i)
-        return_value = true
-      end
-    end
-    return return_value
-  end
-
-  require 'bioroebe/genbank/genbank_flat_file_format_generator.rb'
-  # ========================================================================= #
-  # === chunked_display
-  #
-  # This method will show a "chunked" display of the nucleotides that
-  # is similar to the FASTA display at NCBI.
-  #
-  # Invoke via:
-  #
-  #   cdisplay
-  #
-  # ========================================================================= #
-  def chunked_display(
-      i = dna_sequence?
-    )
-    i = i.join if i.is_a? Array
-    i = dna_sequence? if i.nil?
-    i = dna_sequence? if i.empty?
-    ::Bioroebe::GenbankFlatFileFormatGenerator.new(i) # bl $BIOROEBE/genbank/genbank_flat_file_format_generator.rb
-  end
-
-  require 'bioroebe/toplevel_methods/fasta_and_fastq.rb'
-  # ========================================================================= #
-  # === automatically_rename_this_fasta_file
-  # ========================================================================= #
-  def automatically_rename_this_fasta_file(i)
-    [i].flatten.compact.each {|this_fasta_file|
-      Bioroebe.automatically_rename_this_fasta_file(this_fasta_file)
-    }
-  end
-
-  # ========================================================================= #
-  # === reverse_complement                           (reverse complement tag)
-  #
-  # Reverse-Complement a given sequence at hand. In other words, if given
-  # a sequence of DNA or RNA, we will first build the complement to
-  # that DNA sequence, and then reverse that complement.
-  #
-  # In the shell interface, you can test this like so:
-  #
-  #   assign AAATTT; reverse_complement
-  #
-  # ========================================================================= #
-  def reverse_complement(i = sequence?)
-    i = sequence? if i.nil?
-    if i.nil?
-      report_that_a_string_must_be_assigned_first
-      erev 'Example:'
-      e
-      e simp('  assign TTATTA')
-      e
-    else
-      result = padding?+leading_five_prime+
-               sfancy(
-                 return_complement(i.reverse)
-               )+rev+
-               trailing_three_prime
-      result << ' ('+orange(i.size)+rev+' nucleotides)'
-      erev result
-    end
-  end
-
-  # ========================================================================= #
-  # === translate_dna_into_aminoacid_frame2
-  # ========================================================================= #
-  def translate_dna_into_aminoacid_frame2(i = nil)
-    translate_dna_into_aminoacid(i, 2) # Frame 2.
-  end
-  
-  # ========================================================================= #
-  # === translate_dna_into_aminoacid_frame3
-  # ========================================================================= #
-  def translate_dna_into_aminoacid_frame3(i = nil)
-    translate_dna_into_aminoacid(i, 3) # Frame 3.
-  end
-
-  # ========================================================================= #
-  # === set_log_dir
-  # ========================================================================= #
-  def set_log_dir(
-      i = first_argument?
-    )
-    i = i.dup if i.frozen?
-    i << '/' unless i.end_with? '/'
-    # ======================================================================= #
-    # === Handle blocks next
-    # ======================================================================= #
-    if block_given?
-      yielded = yield
-      case yielded
-      when :be_verbose
-        erev 'Will be using '+sdir(i)+rev+' as the new log-directory.'
+      if i =~ /^\d+$/ # If input is only numbers.
+          erev "Only numbers were given: Adding #{sfancy(i.to_s)}#{rev}"\
+               " random nucleotides to the main string next."
+        new_string = ''.dup
+        i.to_i.times { new_string << return_random_nucleotide }
+        i = new_string
       end
-    end
-    unless File.directory? i
-      mkdir(i)
-    end
-    ::Bioroebe.set_log_dir(i)
-  end
-
-
-  require 'bioroebe/conversions/convert_aminoacid_to_dna.rb'
-  # ========================================================================= #
-  # === backtranseq
-  #
-  # Translate an Aminoacid Sequence back into the most likely DNA sequence
-  # that would code for this sequence/protein. Thus, this method translates
-  # from Aminoacids to DNA sequence - in other words it does a
-  # "reverse-lookup".
-  #
-  # Currently, we hardcode to the homo sapiens frequency codon table, but 
-  # at a later time, we will probably change to a more flexible layout,
-  # to allow a backtranseq for more organisms.
-  # ========================================================================= #
-  def backtranseq(
-      i                    = aminoacid_sequence?,
-      output_as_dna_or_rna = :dna
-    )
-    sequence = ConvertAminoacidToDNA[i].to_str.delete('-')
-    erev lpad?+
-         leading_five_prime+
-         sfancy(sequence)+
-         rev+
-         trailing_three_prime
-    erev 'Note that we have also assigned the above to be the new DNA sequence.'
-    assign_sequence(sequence, :be_silent)
-  end; alias translate_aminoacids_into_dna backtranseq # === translate_aminoacids_into_dna
-
-  # ========================================================================= #
-  # === do_analyze_sequence
-  #
-  # Use this method to find unique sequences.
-  # ========================================================================= #
-  def do_analyze_sequence(
-      i = sequence?
-    )
-    if i.is_a?(Array) and i.empty?
-      i = sequence?
-    end
-    if i.empty? and (!aminoacid_sequence?)
-      erev 'Please first assign a sequence.'
-    elsif aminoacid_sequence?
-      aminoacid_sequence = aminoacid_sequence?
-      show_protein_composition(aminoacid_sequence)
       # ===================================================================== #
-      # Also show the molecular mass.
+      # === Check that we add only DNA or RNA nucleotides past this point
       # ===================================================================== #
-      molecular_mass_of_amino_acids_in_this_sequence(aminoacid_sequence)
-    else
-      erev 'Searching for '+steelblue('NLS sequences')+rev+' first:'
-      run_nls_search
-    end
-  end
-
-  # ========================================================================= #
-  # === find_kdel_sequence
-  # ========================================================================= #
-  def find_kdel_sequence
-    # ======================================================================= #
-    # We must operate on the aminoacid-sequence next.
-    # ======================================================================= #
-    aminoacid_sequence = aminoacid_sequence?.to_s
-    scan_result = aminoacid_sequence.scan(/KDEL/)
-    has_kdel = scan_result.empty?
-    if has_kdel
-      erev 'This sequence has at the least '+
-           steelblue('one')+' KDEL sequence. '\
-           '(Has '+scan_result.size.to_s+')'
-    else
-      erev 'This sequence does not have any KDEL sequence.'
-    end
-  end
-
-  # ========================================================================= #
-  # === calculcate_at_content
-  #
-  # Calculate the AT content of a DNA or RNA sequence.
-  #
-  # Usage example:
-  #
-  #   set_dna ATGCGCGCGCGAACGATGCATGACTGCTAGTCGACA; calc_at_content
-  #
-  # ========================================================================= #
-  def calculcate_at_content(
-      i = dna_sequence?
-    )
-    if i.is_a? Array
-      i = i.first
-    end
-    i = dna_sequence? if i.nil?
-    i.upcase!
-    total = i.size
-    n_A = i.count('A')
-    n_T = i.count('T')
-    result = ( (n_A + n_T) * 100 ) / total
-    erev 'The AT content of this sequence is '+
-          simp(result.to_s)+rev+' %.'
-  end
-
-  # ========================================================================= #
-  # === run_sizeseq
-  #
-  # This method essentially does what the Emboss sizeseq is doing.
-  # ========================================================================= #
-  def run_sizeseq
-    last_fasta_entry?.do_sort_by_size
-  end
-
-  # ========================================================================= #
-  # === open_my_files                                   (open tag, files tag)
-  #
-  # This opens some bioroebe-related files.
-  # ========================================================================= #
-  def open_my_files
-    array_my_files = []
-    array_my_files << BIOROEBE_AT_HOME+'shell/bioshell.rb'
-    array_my_files << BIOROEBE_AT_HOME+'shell/help.rb'
-    array_my_files << BIOROEBE_AT_HOME+'shell/menu.rb'
-    array_my_files << BIOROEBE_AT_HOME+'bioroebe.rb'
-    array_my_files << BIOROEBE_AT_HOME+'constants/constants.rb'
-    array_my_files << RUBY_SRC+'/bioroebe/doc/todo/todo.md'
-    # array_my_files << BIOROEBE+'/count_amount_of_nucleotides.rb'
-    array_my_files.each {|file| open_this_file_in_editor(file) }
-  end
-
-  # ========================================================================= #
-  # === pubmed
-  #
-  # Open a pubmed citation stuff.
-  # ========================================================================= #
-  def pubmed(number = 125512)
-    if number.is_a? Array
-      number = number.join(' ').strip
-    end
-    use_this_url = 'https://pubmed.ncbi.nlm.nih.gov/'.dup
-    if number and !number.nil?
-      use_this_url << '?term='+number.to_s
-    end
-    ::Bioroebe.open_in_browser(use_this_url)
-  end
-
-  # ========================================================================= #
-  # === perform_a_pubmed_search
-  # ========================================================================= #
-  def perform_a_pubmed_search(i)
-    if i.is_a? Array
-      i = i.first
-    end
-    search_term = i.dup.delete('=')
-    url = 'https://eutils.ncbi.nlm.nih.gov/entrez/eutils/esearch.fcgi?db=pubmed&term='+
-          search_term
-    dataset = open(url).read
-    # =================================================================== #
-    # Grab the IDs next - this functionality is very unfinished as of
-    # right now (December 2018):
-    # =================================================================== #
-    id_matches = dataset.scan(/<Id>\d+<\/Id>/)
-    unless id_matches.empty?
-      e
-      erev 'The following '+sfancy(id_matches.size.to_s)+
-           rev+' IDs were found:'
-      e
-      id_matches.each {|entry|
-        erev '  '+sfancy(entry.delete('Id</>'))+rev
-      }
-      e
-    end
-  end
-
-  # ========================================================================= #
-  # === what_sequence_is_this?
-  #
-  # This method attempts to find common sequences.
-  # ========================================================================= #
-  def what_sequence_is_this?(
-      i = dna_sequence?
-    )
-    erev 'The sequence length is '+i.size.to_s+'.'
-    # ======================================================================= #
-    # Obtain the corresponding aminoacid sequence next.
-    # ======================================================================= #
-    aa_sequence = ::Bioroebe.dna_to_aa(i)
-    if aa_sequence.include? ::Bioroebe.ubiquitin
-      erev 'The aminoacid sequence has at least one Ubiquitin-related sequence.'
-    end
-  end
-
-  # ========================================================================= #
-  # === feedback_where_files_are_kept_locally
-  #
-  # We feedback where some files are kept, like the restriction enzymes.
-  # ========================================================================= #
-  def feedback_where_files_are_kept_locally
-    erev 'The restriction enzymes are kept here:'
-    e
-    e "  #{sfile(::Bioroebe.restriction_enzymes_file)}"
-    e
-    erev 'The files with the mass table of the amino acids is kept here:'
-    e
-    e "  #{sfile(::Bioroebe::FILE_AMINO_ACIDS_MASS_TABLE)}"
-    e
-    report_where_we_store
-  end
-
-  # ========================================================================= #
-  # === count_amount_of_aminoacids
-  # ========================================================================= #
-  def count_amount_of_aminoacids(i)
-    ::Bioroebe::CountAmountOfAminoacids.new(i)
-  end
-
-  # ========================================================================= #
-  # === freeze_the_main_sequence
-  # ========================================================================= #
-  def freeze_the_main_sequence
-    @internal_hash[:the_main_sequence_is_frozen] = true
-  end
-
-  # ========================================================================= #
-  # === unfreeze_the_main_sequence
-  # ========================================================================= #
-  def unfreeze_the_main_sequence
-    @internal_hash[:the_main_sequence_is_frozen] = false
-  end
-
-  # ========================================================================= #
-  # === is_the_main_sequence_frozen?
-  # ========================================================================= #
-  def is_the_main_sequence_frozen?
-    @internal_hash[:the_main_sequence_is_frozen]
-  end
-
-  # ========================================================================= #
-  # === report_that_the_main_sequence_is_frozen
-  # ========================================================================= #
-  def report_that_the_main_sequence_is_frozen
-    e 'The main sequence is frozen and can not be modified anymore.'
-  end
-
-  # ========================================================================= #
-  # === f?
-  # ========================================================================= #
-  def f?
-    @internal_hash[:first_argument]
-  end; alias f               f? # === f
-       alias first_argument? f? # === first_argument?
-
-  # ========================================================================= #
-  # === remaining_arguments?
-  # ========================================================================= #
-  def remaining_arguments?
-    @internal_hash[:remaining_arguments]
-  end
-
-  # ========================================================================= #
-  # === add_poly_a_sequence
-  #
-  # Use this method to tag a PolyA sequence to the 3' end of a mRNA.
-  #
-  # First, the mRNA will be cleaved by the enzyme CPSF, usually at
-  # the sequence AAUAAA (most common one, but variants exist).
-  # AAUAAA is found in 90% of all sequenced polyadenylation elements. 
-  # ========================================================================= #
-  def add_poly_a_sequence
-    this_sequence = 'A' * 250
-    @internal_hash[:rna].append(this_sequence)
-  end
-
-  # ========================================================================= #
-  # === use_expand_cd_aliases?
-  # ========================================================================= #
-  def use_expand_cd_aliases?
-    ::Bioroebe::Configuration.use_expand_cd_aliases?
-  end
-
-  # ========================================================================= #
-  # === set_save_file
-  # ========================================================================= #
-  def set_save_file(
-      i = :default
-    )
-    case i
-    # ======================================================================= #
-    # === :default_fasta
-    # ======================================================================= #
-    when :default_fasta
-      i = return_pwd+'standard_fasta.fa'
-    # ======================================================================= #
-    # === :pwd
-    # ======================================================================= #
-    when :pwd
-      return_pwd+File.basename(save_file?)
-    # ======================================================================= #
-    # === :default
-    # ======================================================================= #
-    when :default
-      i = Bioroebe.log_dir?+
-          File.basename(save_file?)
-    end
-    @internal_hash[:save_file] = i
-  end
-
-  # ========================================================================= #
-  # === save_file?
-  # ========================================================================= #
-  def save_file?
-    @internal_hash[:save_file]
-  end
-
-  # ========================================================================= #
-  # === save_my_file                                               (save tag)
-  #
-  # We .strip on the @sequence because I think it is better to not have
-  # any padding on it.
-  # ========================================================================= #
-  def save_my_file(&block)
-    _ = dna_sequence_as_string?
-    if _.empty?
-      erev 'Can not save anything as the main string is empty.'
-    else
-      erev 'Saving the main string now into the file `'+
-            sfile(save_file?)+
-            rev+'`.'
-      save_file(_.strip, save_file?)
-    end # string must be empty.
-  end
-
-  # ========================================================================= #
-  # === remove_sequence
-  #
-  # Use this method to chop away from the beginning part of a nucleotide
-  # sequence.
-  # ========================================================================= #
-  def remove_sequence(i)
-    i = i.first if i.is_a? Array
-    i = i.to_i
-    if dna_sequence_as_string?.size == 0
-      erev 'Can not remove any more characters as we do not have a '\
-           'sequence anymore.'
-    else
-      erev "Removing #{sfancy(i)}#{rev} characters from the "\
-           "start (left side; 5' end)."
-      _ = dna_sequence?
-      _.remove_n_characters_from_the_left_side(i)
-      this_sequence = _
-      set_dna_sequence(this_sequence)
-    end
-  end; alias remove remove_sequence # === remove (remove tag)
-
-  # ========================================================================= #
-  # === return_complement
-  #
-  # This method is aliased to complement() as well (def complement).
-  #
-  # It will return the complement sequence to a given DNA/RNA sequence.
-  # ========================================================================= #
-  def return_complement(
-      i = dna_sequence?
-    )
-    return ::Bioroebe::NucleotideModule.complementary_strand(i)
-  end; alias complement           return_complement # === complement (complement tag)
-       alias complement_sequence? return_complement # === complement_sequence?
-       alias reverse              return_complement # === reverse (reverse tag)
-
-  # ========================================================================= #
-  # === find_complementary_strand
-  #
-  # Invoke this via:
-  #
-  #    3'-ATGCCTGCC
-  #
-  # ========================================================================= #
-  def find_complementary_strand(i = dna_sequence?)
-    _ = i.strip # The original input.
-    if _.include? "3'-" and _.start_with?('3')
-      _ = _.gsub(/3'-/,'').
-            gsub(/-5'/,'').
-            gsub(/3'-/,'')
-      erev lpad?+leading_three_prime+
-           colourize_nucleotide(_, :do_not_add_anything_else)+
-           trailing_five_prime
+      if only_nucleotides?(i)
+        erev "Now appending #{simp(i)}#{rev}."
+        sequence_object? << i # Next, append to the sequence object here.
+        show_DNA_sequence
+      else
+        # ===================================================================== #
+        # The user may also wish to append a restriction site, such
+        # as via add EcoRI. We need to enable this here.
+        # ===================================================================== #
+        _ = ::Bioroebe.return_sequence_that_is_cut_via_restriction_enzyme(i, :no_colours)
+        if _
+          _.tr!('|','')
+          erev "Now appending #{simp(_)}#{rev}."
+          sequence_object? << _ # Next, append to the sequence object here.
+          show_dna_sequence
+        else
+          erev 'Can not add the sequence '+simp(i)+rev+' because there '\
+               'are non-nucleotides in it.'
+        end
+      end
     end
-    result = lpad?+
-             colourize_nucleotide(
-               return_complement(i.reverse)
-             )
-    erev result
-    return result
-  end; alias show_complementary_strand find_complementary_strand # === show_complementary_strand
-
-  # ========================================================================= #
-  # === Bioroebe::Shell[]
-  # ========================================================================= #
-  def self.[](i = '')
-    new(i)
   end
 
-end
-
-# =========================================================================== #
-# === Bioroebe.generate_pdf_tutorial
-# =========================================================================== #
-def self.generate_pdf_tutorial
-  ::Bioroebe::Shell.generate_pdf_tutorial
-end
-
-# =========================================================================== #
-# === Bioroebe.upload_this_pdf_file
-# =========================================================================== #
-def self.upload_this_pdf_file(i)
-  ::Bioroebe::Shell.upload_this_pdf_file(i)
-end
-
-# =========================================================================== #
-# === Bioroebe.shell
-#
-# This is the main method to instantiate the Shell component of the
-# Bioroebe component.
-# =========================================================================== #
-def self.shell(i = ARGV)
-  ::Bioroebe::Shell.new(i)
-end; self.instance_eval { alias start_shell shell } # === Bioroebe.start_shell
-
-end
+end; end