bioroebe 0.10.80

data/lib/bioroebe/fasta_and_fastq/parse_fasta/misc.rb

@@ -0,0 +1,981 @@
+#!/usr/bin/ruby -w
+# Encoding: UTF-8
+# frozen_string_literal: true
+# =========================================================================== #
+# === Bioroebe::ParseFasta
+#
+# This class will parse through a local FASTA file and find the
+# proper entries.
+#
+# A FASTA file may have nucleotides or an aminoacid-sequence, so
+# we have to keep this in mind when parsing it.
+#
+# Usage examples:
+#
+#   Bioroebe::ParseFasta.new(ARGV)
+#   Bioroebe.parse_fasta(ARGV)
+#
+# =========================================================================== #
+# require 'bioroebe/fasta_and_fastq/parse_fasta/misc.rb'
+# Bioroebe.parse_fasta
+# Bioroebe.sizeseq
+# =========================================================================== #
+require 'bioroebe/base/commandline_application/commandline_application.rb'
+require 'bioroebe/fasta_and_fastq/parse_fasta/menu.rb'
+require 'bioroebe/fasta_and_fastq/parse_fasta/report.rb'
+
+module Bioroebe
+
+class ParseFasta < ::Bioroebe::CommandlineApplication # === Bioroebe::ParseFasta
+
+  require 'bioroebe/calculate/calculate_gc_content.rb'
+
+  # ========================================================================= #
+  # === show_help                                                  (help tag)
+  #
+  # This method will inform the user how this class may be used from the
+  # commandline.
+  #
+  # Invocation example:
+  #
+  #   pfasta --help
+  #
+  # ========================================================================= #
+  def show_help
+    e
+    eparse '  --size'
+    eparse '  --also-show-the-sequence'
+    eparse '  --header     # show the header as well (normally the '\
+           'header is not shown)'
+    eparse '  --limit=1000 # limit to show only the first 1000 '\
+           'nucleotides; use'
+    eparse '               # any number that you need here'
+    eparse '  --one-line   # show the sequence on one line only, '\
+           'e. g. all newlines'
+    eparse '               # were removed'
+    eparse '  --toprotein  # show the protein sequence as well '\
+           '(assumes DNA or RNA'
+    eparse '               # .fasta file)'
+    e
+  end
+
+  # ========================================================================= #
+  # === show_the_translated_protein_sequence?
+  # ========================================================================= #
+  def show_the_translated_protein_sequence?
+    @internal_hash[:show_the_translated_protein_sequence]
+  end
+
+  # ========================================================================= #
+  # === set_round_to
+  #
+  # This will set to how many decimal numbers we will round to. This is
+  # mostly done for display-purposes, hence why the default is a fairly
+  # low value.
+  # ========================================================================= #
+  def set_round_to(
+      i = :default
+    )
+    case i
+    # ======================================================================= #
+    # === :default
+    #
+    # Since as of April 2021, the new default is 2, for rounding.
+    # ======================================================================= #
+    when :default
+      i = DEFAULT_ROUND_TO
+    end
+    @round_to = i.to_i
+  end
+
+  # ========================================================================= #
+  # === do_process_the_commandline_arguments_that_are_files
+  # ========================================================================= #
+  def do_process_the_commandline_arguments_that_are_files(
+      these_files = commandline_arguments_that_are_files?
+    )
+    unless these_files.is_a? Array
+      these_files = [these_files].flatten.compact
+    end
+    these_files.each {|this_file|
+      set_input_file(this_file)
+      set_data # This will use the default file.
+      split_into_proper_sections
+      report_the_FASTA_header if @show_the_header
+      if @sort_by_size
+        run_sizeseq_comparison
+      else
+        # =================================================================== #
+        # === Handle cases where the input is a protein
+        # =================================================================== #
+        if is_the_sequence_a_polypeptide?
+          if be_verbose?
+            erev "This sequence is assumed to be a #{royalblue('protein')}#{rev}."
+            report_how_many_elements_we_have_found
+          end
+        else # Must be a protein.
+          # =================================================================== #
+          # === Else it must be RNA or DNA
+          # =================================================================== #
+          if be_verbose?
+            erev "This sequence is assumed to "\
+                 "be #{royalblue('DNA')}#{rev} or #{royalblue('RNA')}#{rev}."
+          end
+          calculate_gc_content # GC content makes only sense for nucleotides.
+          report_how_many_elements_we_have_found if be_verbose?
+        end
+        if be_verbose?
+          report_the_nucleotide_composition
+          report_on_how_many_entries_we_did_work
+          if report_the_sequence?
+            do_report_the_sequence
+          end
+        end
+      end
+    }
+  end
+
+  # ========================================================================= #
+  # === sanitize_the_description
+  #
+  # This method will iterate over the description entry and sanitize
+  # it. In this context sanitizing means to add the "length" entry,
+  # and the "type" entry, such as in:
+  #
+  #   " # length=231; type=dna"
+  #
+  # ========================================================================= #
+  def sanitize_the_description
+    @data.map! {|line|
+      if line.start_with?('>') and !line.include?('length=')
+        length = 0
+        if @hash.has_key? line.delete('>')
+          length = @hash[line.delete('>')].size
+        end
+        line << " # length=#{length}; type=dna" # Currently hardcoded to DNA.
+      end
+      line
+    }
+  end
+
+  # ========================================================================= #
+  # === entries?
+  # ========================================================================= #
+  def entries?
+    @data
+  end
+
+  # ========================================================================= #
+  # === we_may_exit
+  # ========================================================================= #
+  def we_may_exit
+    @may_we_exit = true
+  end
+
+  # ========================================================================= #
+  # === output_results
+  # ========================================================================= #
+  def output_results
+    pp @hash
+  end
+
+  # ========================================================================= #
+  # === sanitize_data
+  # ========================================================================= #
+  def sanitize_data(i)
+    if i.is_a? Array
+      i.flatten!
+      i.reject! {|entry| entry.start_with? '#' }
+      i.reject! {|entry| entry.strip.empty? }
+      if i.first and i.first.include? "\r"
+        # =================================================================== #
+        # Some FASTA files include "\r" line endings. We will check first
+        # for the first entry to contain a \r, and if so, we assume the
+        # whole FASTA file may have \r, which then will be removed.
+        # =================================================================== #
+        i.map! {|entry| entry.delete("\r") }
+      end
+    end
+    # ========================================================================= #
+    # === Run through SanitizeNucleotideSequence
+    # ========================================================================= #
+    if @internal_hash[:remove_numbers_from_input]
+      i = Bioroebe::SanitizeNucleotideSequence[i]
+    end
+    i
+  end
+
+  # ========================================================================= #
+  # === current_key?
+  # ========================================================================= #
+  def current_key?
+    @current_key
+  end; alias id?          current_key? # === id?
+       alias sequence_id? current_key? # === sequence_id?
+       alias title        current_key? # === title
+       alias title?       current_key? # === title?
+
+  # ========================================================================= #
+  # === opnn
+  # ========================================================================= #
+  def opnn
+    super(NAMESPACE) if use_opn?
+  end
+  
+  # ========================================================================= #
+  # === use_opn?
+  # ========================================================================= #
+  def use_opn?
+    @use_opn
+  end
+
+  # ========================================================================= #
+  # === calculate_gc_content
+  #
+  # Calculate the gc content through this method, which is called from
+  # within the method run().
+  # ========================================================================= #
+  def calculate_gc_content
+    _ = @hash.values.join.delete(N)
+    if is_polynucleotide? _
+      @hash.each_pair {|key, content|
+        # =================================================================== #
+        # Delegate towards the method Bioroebe.gc_content next, including
+        # to round towards 5 positions:
+        # =================================================================== #
+        gc_content = ::Bioroebe.gc_content(content.upcase, @round_to)
+        gc_content = gc_content.first if gc_content.is_a? Array
+        gc_content = gc_content.to_s
+        minimal_key = key.to_s
+        if minimal_key.include? '|'
+          minimal_key = minimal_key.split('|').last.strip
+        end
+        if be_verbose?
+          _ = minimal_key.strip
+          if _.size > 40 # Shorten the content a bit if it is too long.
+            _ = _[0 .. 40]+' [...]'
+          end
+          erev 'GC content of "'+simp(_)+rev+'" is: '+
+               "#{sfancy(gc_content)}#{rev} %"
+        end
+      }
+    else
+      erev '`'+simp(_)+rev+'` is not a polynucleotide.' if be_verbose?
+    end
+  end
+
+  # ========================================================================= #
+  # === first_value
+  #
+  # This will return the first entry of the Fasta files.
+  # ========================================================================= #
+  def first_value
+    sequences?.first
+  end
+
+  # ========================================================================= #
+  # === nucleotides_or_aminoacids?
+  # ========================================================================= #
+  def nucleotides_or_aminoacids?
+    if is_polynucleotide?
+      'nucleotides'
+    else
+      'aminoacids'
+    end
+  end
+
+  # ========================================================================= #
+  # === is_polynucleotide?
+  # ========================================================================= #
+  def is_polynucleotide?(i = main_sequence?)
+    !is_protein?(i)
+  end; alias is_a_nucleotide? is_polynucleotide? # === is_a_nucleotide?
+
+  # ========================================================================= #
+  # === is_this_sequence_a_polynucleotide_sequence?
+  # ========================================================================= #
+  def is_this_sequence_a_polynucleotide_sequence?
+    !is_protein?
+  end
+
+  # ========================================================================= #
+  # === data?
+  #
+  # This will contain the full content of the (whole) .fasta file, including
+  # the header.
+  # ========================================================================= #
+  def data?
+    @data
+  end; alias input?   data? # === input?
+       alias dataset? data? # === dataset?
+
+  # ========================================================================= #
+  # === hash?
+  # ========================================================================= #
+  def hash?
+    @hash
+  end
+
+  # ========================================================================= #
+  # === sequences?
+  #
+  # This method will obtain all found sequences.
+  # ========================================================================= #
+  def sequences?
+    @hash.values
+  end; alias sequences sequences? # === sequences
+       alias values    sequences? # === values
+
+  # ========================================================================= #
+  # === short_headers?
+  #
+  # The short-headers are like the headers, but if a ' ' token is found
+  # then the line will be truncated towards that first ' '.
+  #
+  # An example is:
+  #
+  #   sp|Q91FT8|234R_IIV6 Uncharacterized protein 234R OS=Invertebrate iridescent virus 6 OX=176652 GN=IIV6-234R PE=4 SV=1
+  #
+  # This will be truncated towards
+  #
+  #   sp|Q91FT8|234R_IIV6
+  #
+  # This could then be used to automatically rename FASTA files, for
+  # instance.
+  # ========================================================================= #
+  def short_headers?
+    headers?.map {|entry|
+      if entry.include? ' '
+        entry = entry.split(' ').first
+      end
+      entry
+    }
+  end
+
+  # ========================================================================= #
+  # === set_data
+  #
+  # This is the setter-method towards @data. It is no longer allowed to
+  # invoke set_input_file() since as of 12.06.2020. This means that
+  # you have to invoke that method prior to calling this method.
+  # ========================================================================= #
+  def set_data(i = @input_file)
+    # ======================================================================= #
+    # The next line attempts to ensure that even an Array can be used
+    # as input to that method.
+    # ======================================================================= #
+    i = [i].flatten.compact.first.to_s.dup
+    if File.exist? i.to_s # First try to read in from a file.
+      if be_verbose?
+        opnn; erev "Will read from the file `#{sfile(i)}#{rev}`."
+      end
+      i = File.readlines(i)
+      if @is_a_genbank_file
+        selected = i.select {|line|
+          line.start_with?('       ') and # such as: "       61 atggggcctg caatggggcc tgcaatgggg cctgca\n"
+          (line.strip =~ /\d+/)
+        }.map {|inner_line|
+          inner_line.strip.delete(' 0123456789').strip.upcase
+        }
+        i = ["> genbank file"]+selected
+      end
+    end
+    if i.nil? or i.empty?
+      i = DEFAULT_FASTA
+      opnn; erev 'No input was provided. Thus a default FASTA '\
+                 'sequence will be used instead.'
+    end
+    i = sanitize_data(i)
+    i = i.split(N) if i.is_a? String
+    @data = i
+  end; alias set_sequence set_data # === set_Sequence
+
+  # ========================================================================= #
+  # === set_be_verbose_and_report_the_sequence
+  # ========================================================================= #
+  def set_be_verbose_and_report_the_sequence
+    set_be_verbose
+    @internal_hash[:report_the_sequence] = true
+  end
+
+  # ========================================================================= #
+  # === condense_the_sequence_onto_a_single_line?
+  # ========================================================================= #
+  def condense_the_sequence_onto_a_single_line?
+    @internal_hash[:condense_the_sequence_onto_a_single_line]
+  end
+ 
+  # ========================================================================= #
+  # === return_size_sorted_hash
+  # ========================================================================= #
+  def return_size_sorted_hash(i = @hash)
+    _ = i.sort_by {|key, value| value.size }
+    i = Hash[_]
+    return i
+  end
+
+  # ========================================================================= #
+  # === do_sort_by_size
+  #
+  # This method will sort the hash by size of the sequence. It has been
+  # inspired by the EMBOSS sizeq functionality.
+  #
+  # The output that should be generated might look like this:
+  #
+  #   https://www.bioinformatics.nl/cgi-bin/emboss/help/sizeseq#input.1
+  #
+  # Invocation example:
+  #
+  #   x = Bioroebe::ParseFasta.new('/Depot/j/globins.fasta'); x.do_sort_by_size
+  #
+  # ========================================================================= #
+  def do_sort_by_size
+    # ======================================================================= #
+    # Sort it here first, by the size of the "value", aka the sequence body.
+    # ======================================================================= #
+    @hash = return_size_sorted_hash(@hash)
+    _ = ''.dup
+    @hash.each_pair {|key, sequence|
+      _ << '> ID '+sequence.size.to_s+' AA.; DE: '+key.to_s+
+           ' SQ '+sequence.size.to_s+' AA'+N # ; unknown MW as of yet; '\
+           #'unknown CRC64 as of yet'+N
+      _ << sequence+N+N
+    }
+    e _
+  end; alias run_sizeseq_comparison do_sort_by_size # === run_sizeseq_comparison
+
+  # ========================================================================= #
+  # === n_nucleotides?
+  # ========================================================================= #
+  def n_nucleotides?
+    @hash.values.first.delete("\n").size
+  end; alias return_n_aminoacids n_nucleotides? # === return_n_aminoacids
+       alias size?               n_nucleotides? # === size?
+       alias sequence_size?      n_nucleotides? # === sequence_size?
+
+  # ========================================================================= #
+  # === headers?
+  # ========================================================================= #
+  def headers?
+    @hash.keys
+  end
+
+  # ========================================================================= #
+  # === first_key?
+  #
+  # Obtain the very first entry.
+  # ========================================================================= #
+  def first_key?
+    headers?.first
+  end
+
+  # ========================================================================= #
+  # === header?
+  #
+  # This variant will always return the first entry.
+  # ========================================================================= #
+  def header?
+    headers?.first.to_s
+  end
+
+  # ========================================================================= #
+  # === raw_body?
+  # ========================================================================= #
+  def raw_body?
+    @hash.values.first
+  end
+
+  # ========================================================================= #
+  # === do_show_the_header
+  # ========================================================================= #
+  def do_show_the_header
+    @show_the_header = true
+  end
+
+  # ========================================================================= #
+  # === set_input_file
+  #
+  # This method will be used to keep track of the input-file, from
+  # which we will read the dataset.
+  # ========================================================================= #
+  def set_input_file(i = nil)
+    if i.nil?
+      # ===================================================================== #
+      # First, we try to find a .fasta or .fa file in the current
+      # directory. If we can find it, we will use that instead.
+      # ===================================================================== #
+      unless Dir['*.{fa,fasta}'].empty?
+        file = Dir['*.{fa,fasta}'].first
+        if be_verbose?
+          result = 'A '
+          if file.end_with? '.fasta'
+            result < 'FASTA '
+          end
+          result << 'file was found in this directory ('+sfile(file)+').'
+          opnn; erev result
+          opnn; erev 'We will use it.'
+        end
+        i = file
+      end
+      unless Dir['*.{fa,fasta}'].empty?
+        file = Dir['*.{fa,fasta}'].first
+        if be_verbose?
+          opnn; erev "We have found a file in this "\
+                     "directory (#{sfile(file)}#{rev})."
+          opnn; erev 'We will use it.'
+        end
+        i = file
+      end
+    end
+    if i and File.exist?(i)
+      dataset = File.read(i)
+      if dataset[0 .. ('LOCUS'.size - 1)] == 'LOCUS'
+        @is_a_genbank_file = true
+      end
+    end
+    @input_file = i
+  end; alias set_input_files set_input_file # === set_input_files
+
+  # ========================================================================= #
+  # === save_the_file?
+  # ========================================================================= #
+  def save_the_file?
+    @internal_hash[:save_the_file]
+  end
+
+  # ========================================================================= #
+  # === overwrite_the_original_file?
+  # ========================================================================= #
+  def overwrite_the_original_file?
+    @internal_hash[:overwrite_the_original_file]
+  end
+
+  # ========================================================================= #
+  # === split_into_proper_sections
+  #
+  # Split up into the fasta identifier, and the content.
+  # ========================================================================= #
+  def split_into_proper_sections
+    unless @data.to_s.include? '>'
+      erev 'No ">" character was found in this dataset.'
+      erev 'It is recommended to always have a > identifier '\
+           'for the'
+      erev 'FASTA format (such as in a .fasta or a .fa file).'
+    end if be_verbose? # Ok, the input data includes >. We can proceed.
+    @data.each { |line|
+      # ===================================================================== #
+      # === Handle the leading > FASTA identifier first
+      # ===================================================================== #
+      if line.start_with? '>' # leading identifier.
+        @current_key = line[1..-1].chomp # Select all but the first character.
+        @hash[@current_key] = ''.dup
+      else
+        line.delete!('_')
+        unless @current_key
+          @current_key = 'standard'
+          @hash[@current_key] = ''.dup
+        end
+        # =================================================================== #
+        # === Retain the newlines
+        #
+        # Here we may decide to get rid of newlines, but it is better to
+        # NOT remove the newlines - that way we can simply save the
+        # dataset again.
+        # @hash[@current_key] << no_newlines(line)
+        # =================================================================== #
+        @hash[@current_key] << line
+      end
+    }
+  end
+
+  # ========================================================================= #
+  # ===   save_into_a_fasta_file
+  # ========================================================================= #
+  def save_into_a_fasta_file(
+      be_verbose = be_verbose?
+    )
+    case be_verbose
+    when :be_verbose
+      be_verbose = true
+    end
+    if @data
+      what = @data.join("\n")
+      into = 'standard.fasta'
+      erev 'Saving into '+sfile(into)+rev+'.' if be_verbose
+      write_what_into(what, into)
+      return File.absolute_path(into) # And return the file we saved into.
+    else
+      opnn; erev 'No @data variable exists.'
+    end
+  end; alias do_save_the_file save_into_a_fasta_file # === do_save_the_file
+
+  # ========================================================================= #
+  # === add_length_information_to_the_header
+  # ========================================================================= #
+  def add_length_information_to_the_header
+    _ = header?.strip
+    _ << ' length='+sequence_size?.to_s+';'
+    # ======================================================================= #
+    # Next, designate where to store this file.
+    # ======================================================================= #
+    into = 'new_fasta_file.fasta'
+    if overwrite_the_original_file?
+      into = @input_file
+    end
+    what = ''.dup
+    what << "> "+_+"\n"
+    what << raw_body?
+    if what and into
+      erev 'Storing into `'+sfile(into)+rev+'`.'
+      write_what_into(what, into)
+    end
+  end
+
+  # ========================================================================= #
+  # === simplify_header
+  #
+  # This method can be called to simplify the header. It will save into
+  # a .fasta file at once.
+  # ========================================================================= #
+  def simplify_header
+    _ = header?
+    # ======================================================================= #
+    # Next, simplify the header. We must start with checking for [] first,
+    # because if there are any [] in the FASTA header then we can simplify
+    # stuff at once.
+    # ======================================================================= #
+    if _.include?('[') and _.include?(']')
+      _ = '> '+_.strip.scan(/\[.+\]/).flatten.first.delete('[]')+"\n"
+    elsif _.include? ','
+      _ = _[0 .. (_.index(',') - 1) ].strip
+    end
+    what = nil
+    # ======================================================================= #
+    # Next, designate where to store this file.
+    # ======================================================================= #
+    into = 'new_fasta_file.fasta'
+    if overwrite_the_original_file?
+      into = @input_file
+    end
+    if _.start_with? '>'
+      what = _
+    elsif _.include?('[') and _.include?(']') # For example: [Pan troglodytes]
+      # ===================================================================== #
+      # See rubular at:
+      #
+      #   https://rubular.com/r/aDjI0JwMOUlZzP
+      #
+      # ===================================================================== #
+      what = "> "+_.scan(/\[(.+)\]/).flatten.first.to_s+"\n".dup 
+    elsif _.include? 'Human'
+      _scanned_result = _.scan(/(Human)/)
+      what = "> "+$1.to_s.dup+"\n".dup
+    else
+      erev "Unsure what to do: #{steelblue(_)}"
+    end
+    if what and into
+      what << raw_body?
+      erev 'Storing into `'+sfile(into)+rev+'`.'
+      write_what_into(what, into)
+    end
+  end
+
+  # ========================================================================= #
+  # === sequence
+  #
+  # This method will return the sequence, without any newlines. It is also
+  # called the "body" of a FASTA file.
+  # ========================================================================= #
+  def sequence
+    _ = @hash.values.first
+    _.chomp! if _ and _.end_with?(N)
+    return no_newlines(_)
+  end; alias fasta_sequence      sequence # === fasta_sequence
+       alias sequence?           sequence # === sequence?
+       alias body?               sequence # === body?
+       alias body                sequence # === body?
+       alias naseq               sequence # === naseq
+       alias nucleotide_sequence sequence # === nucleotide_sequence
+       alias return_sequence     sequence # === return_sequence
+       alias content?            sequence # === content?
+
+  # ========================================================================= #
+  # === save
+  #
+  # This method will save our FASTA file.
+  # ========================================================================= #
+  def save
+    if @input_file.nil?
+      erev "The generic file #{sfile('foobar.fasta')}#{rev} "\
+           "will be used."
+      set_input_file('foobar.fasta')
+    end
+    into = @input_file
+    what = @data.join("\n")
+    erev 'Storing into '+sfile(into)+rev+'.'
+    write_what_into(what, into)
+    return into
+  end
+
+  # ========================================================================= #
+  # === []
+  #
+  # This is a simpler query-interface for obtaining the DNA/RNA sequence
+  # of the FASTA file (or aminoacid sequence, if we have a protein at
+  # hand here).
+  #
+  # Using the method sequences? here, which in turn works on @hash, is
+  # ok because Hashes are kept in a sorted manner in ruby since some
+  # time.
+  # ========================================================================= #
+  def [](i)
+    sequences?[i]
+  end
+
+  # ========================================================================= #
+  # === Bioroebe::ParseFasta[]
+  # ========================================================================= #
+  def self.[](i)
+    _ = new(i)
+    _.sequences?
+  end
+
+  # ========================================================================= #
+  # === type?
+  # ========================================================================= #
+  def type?
+    if is_the_sequence_a_polypeptide?
+      :protein
+    elsif is_this_sequence_a_polynucleotide_sequence?
+      :dna_or_rna
+    else
+      :unknown
+    end
+  end
+
+  # ========================================================================= #
+  # === is_the_sequence_a_polypeptide?
+  #
+  # This method can be used to determine whether a given input sequence
+  # is a polypeptide (aka a protein) or whether it is not.
+  #
+  # If this sequence is a polypeptide then this method will return true.
+  # Otherwise false will be returned.
+  # ========================================================================= #
+  def is_the_sequence_a_polypeptide?(
+      i = main_sequence?
+    )
+    return_value = false # Set the default return value here.
+    # ======================================================================= #
+    # Look at the first 120 positions to determine whether this is a protein
+    # or a nucleotide sequence.
+    # ======================================================================= #
+    subsequence = i[0 .. 119] # Must deduct 1 at the end since Arrays in ruby start at 0.
+    # ======================================================================= #
+    # Build a frequency of the characters there.
+    # ======================================================================= #
+    hash = {}
+    hash.default = 0
+    subsequence.chars.each {|character|
+      hash[character] += 1
+    }
+    keys_to_check_for = %w(
+      B D E F H I J K L M O P Q R S V W X Y Z
+    )
+
+    values = hash.select {|key, value|
+      if keys_to_check_for.include? key
+        true
+      else
+        false
+      end
+    }.values.sum
+    if values > 0
+      return_value = true
+    end
+    return return_value
+  end; alias is_protein?   is_the_sequence_a_polypeptide? # === is_protein?
+       alias is_a_protein? is_the_sequence_a_polypeptide? # === is_a_protein?
+
+  # ========================================================================= #
+  # === main_sequence?
+  #
+  # This will always return the first entry.
+  # ========================================================================= #
+  def main_sequence?
+    @hash.values.first
+  end
+
+  # ========================================================================= #
+  # === gc_content?
+  # ========================================================================= #
+  def gc_content?
+    return ::Bioroebe.gc_content(main_sequence?).to_f # Must be a float.
+  end; alias gc_content gc_content? # === gc_content
+
+  # ========================================================================= #
+  # === sequence_object
+  #
+  # This method will return a Sequence object.
+  #
+  # Usage example:
+  #
+  #   x = Bioroebe.parse_fasta 'ls_orchid.fasta'
+  #   y = x.sequence_object # y is now an instance of Bioroebe::Sequence
+  #
+  # ========================================================================= #
+  def sequence_object
+    ::Bioroebe::Sequence.new(main_sequence?)
+  end
+
+end
+
+Fasta = ParseFasta # Add an "alias" constant to class ParseFasta.
+
+# =========================================================================== #
+# === Bioroebe.parse_fasta_quietly
+#
+# As the variant above, but will work quietly.
+# =========================================================================== #
+def self.parse_fasta_quietly(
+    i, use_colours = true
+  )
+  ::Bioroebe.parse_fasta(i, use_colours) { :be_quiet }
+end
+
+# =========================================================================== #
+# === Bioroebe.return_fasta_entry_with_the_highest_gc_content
+#
+# The first argument should be a locally existing FASTA file that
+# contains different sequences.
+#
+# Usage example:
+#
+#   x = Bioroebe.return_fasta_entry_with_the_highest_gc_content('/rosalind_gc.txt')
+#
+# =========================================================================== #
+def self.return_fasta_entry_with_the_highest_gc_content(this_fasta_file)
+  if File.exist? this_fasta_file
+    dataset = File.read(this_fasta_file)
+    dataset = parse_fasta(dataset) { :be_quiet }
+    hash = dataset.hash?
+    hash.transform_values! {|this_value|
+      ::Bioroebe.gc_content(this_value).to_f
+    }
+    return hash.max_by {|key, value| value }
+  else
+    erev "No file exists at #{sfile(this_fasta_file)}#{rev}."
+  end
+end
+
+# =========================================================================== #
+# === Bioroebe.sizeseq
+#
+# This method will "size-sequence compare", typically on a .fasta file.
+# =========================================================================== #
+def self.sizeseq(i)
+  if i.is_a? Array
+    i = i.first
+  end
+  _ = Bioroebe.parse_fasta(i) { :be_quiet }
+  _.do_sort_by_size
+end
+
+# =========================================================================== #
+# === Bioroebe.return_sizeseq
+#
+# This is as Bioroebe.sizeseq(), but it will just return the result,
+# rather than output it.
+# =========================================================================== #
+def self.return_sizeseq(i)
+  if i.is_a? Array
+    i = i.first
+  end
+  _ = Bioroebe.parse_fasta(i) { :be_quiet }
+  hash = _.return_size_sorted_hash
+  result = ''.dup
+  hash.each_pair {|key, sequence|
+    result << '> ID '+sequence.size.to_s+' AA.; DE: '+key.to_s+
+         ' SQ '+sequence.size.to_s+' AA'+N
+    result << sequence+N+N
+  }
+  return result
+end
+
+# =========================================================================== #
+# === Bioroebe.genbank_to_fasta
+#
+# This method will convert from a genbank file, to a .fasta file.
+#
+# Invocation example:
+#
+#   Bioroebe.genbank_to_fasta('/home/x/DATA/PROGRAMMING_LANGUAGES/RUBY/src/bioroebe/lib/bioroebe/data/genbank/sample_file.genbank')
+#
+# =========================================================================== #
+def self.genbank_to_fasta(
+    this_file,
+    be_verbose = :be_verbose
+  )
+  case be_verbose
+  when :be_quiet
+    be_verbose = false
+  end
+  if this_file.is_a? Array
+    this_file = this_file.first
+  end
+  if File.exist? this_file
+    _ = Bioroebe::ParseFasta.new(this_file) { :be_quiet }
+  else
+    _ = Bioroebe::ParseFasta.new(:do_not_run_yet) { :be_quiet }
+    _.set_data # This will use the default file.
+    _.split_into_proper_sections
+  end
+  file_path = _.save_into_a_fasta_file(be_verbose)
+  return file_path
+end
+
+# =========================================================================== #
+# === Bioroebe.parse_fasta_file
+# =========================================================================== #
+def self.parse_fasta_file(
+    i, use_colours = true
+  )
+  use_this_hash = {
+    use_colours: use_colours,
+    be_verbose:  false
+  }
+  ParseFasta.new(i) { use_this_hash }
+end; self.instance_eval { alias fasta_file parse_fasta_file } # === Bioroebe.fasta_file
+
+# =========================================================================== #
+# === Bioroebe.parse_fasta
+#
+# Easier reader-method for .fasta files.
+#
+# The second argument determines whether we will use colours or whether
+# we will not. For now, the default is to not use colours when we use
+# this particular class method.
+#
+# Invocation examples:
+#
+#   x = Bioroebe.parse_fasta('/rosalind_gc.txt')
+#   hash = Bioroebe.parse_fasta('/rosalind_gc.txt').hash?
+#
+# =========================================================================== #
+def self.parse_fasta(
+    i,
+    use_colours = true
+  )
+  use_this_hash = {
+    use_colours: use_colours
+  }
+  if block_given?
+    use_this_hash = {
+      use_colours: use_colours,
+      be_verbose:  yield
+    }
+  end
+  ::Bioroebe::ParseFasta.new(i) { use_this_hash }
+end; self.instance_eval { alias fasta parse_fasta } # === Bioroebe.fasta
+
+end