bioroebe 0.10.80

data/lib/bioroebe/shell/misc.rb

@@ -0,0 +1,4341 @@
+#!/usr/bin/ruby -w
+# 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
+
+  # ========================================================================= #
+  # === 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
+
+  # ========================================================================= #
+  # === 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
+
+  # ========================================================================= #
+  # === codon_to_aminoacid
+  #
+  # Translate a codon into an aminoacid through this method.
+  # ========================================================================= #
+  def codon_to_aminoacid(i)
+    Bioroebe.codon_to_aminoacid(i)
+  end
+
+  require 'bioroebe/enzymes/return_sequence_that_is_cut_via_restriction_enzyme.rb'
+  # ========================================================================= #
+  # === append                                                   (append tag)
+  #
+  # You can use this to simply append to the main string.
+  # ========================================================================= #
+  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
+    # ======================================================================= #
+    if only_nucleotides?(i)
+      erev "Now appending #{simp(i)}#{rev}."
+      sequence_object? << i # Next, append to the sequence object here.
+    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
+
+  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?
+      # ===================================================================== #
+      # First, we check here for german names. These names are kept in
+      # the file called
+      # 'amino_acids_long_name_to_one_letter.yml'
+      # ===================================================================== #
+      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
+      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.'
+      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.
+      # ===================================================================== #
+      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
+    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