bioroebe 0.10.80

data/lib/bioroebe/toplevel_methods/atomic_composition.rb

@@ -0,0 +1,198 @@
+#!/usr/bin/ruby -w
+# Encoding: UTF-8
+# frozen_string_literal: true
+# =========================================================================== #
+# require 'bioroebe/toplevel_methods/atomic_composition.rb'
+# Bioroebe.show_atomic_composition
+# =========================================================================== #
+module Bioroebe
+
+  require 'bioroebe/constants/files_and_directories.rb'
+  require 'bioroebe/colours/rev.rb'
+  require 'bioroebe/toplevel_methods/aminoacids_and_proteins.rb'
+  require 'bioroebe/toplevel_methods/e.rb'
+  require 'bioroebe/toplevel_methods/is_on_roebe.rb'
+
+  # ========================================================================= #
+  # === Bioroebe.atomic_composition
+  #
+  # This method will return the composition of atoms in a given protein,
+  # via Hash, such as:
+  #
+  #   {"C"=>11, "H"=>19, "N"=>5, "O"=>6, "S"=>0}
+  #
+  # The Hash keeps track of 11 C atoms, 19 H atoms, 5 N atoms,
+  # 6 O atoms and 0 S atoms.
+  #
+  # This hash can then be formatted via the method:
+  #
+  #   Bioroebe.show_atomic_composition()
+  #
+  # Which can be found below.
+  #
+  # Presently this method works on aminoacids only, but in theory the
+  # code could be extended to work with DNA nucleotides and RNA
+  # nucleotides as well.
+  #
+  # Either way, the one letter abbreviation should be used as input
+  # to this method.
+  #
+  # When we use aminoacids, we need to remember that a peptide bond
+  # deducts 1x H₂O (water). This will have to be deducted from the
+  # formula, but only if it is an internal aminoacid. In other words,
+  # the only two aminoacids that will behave differently, are the
+  # first one (since it will miss one -OH group) and the last
+  # aminoacid (as this one will lack a -H molecule.
+  #
+  # Remember that the input sequence to this method should be the
+  # one-letter code for the aminoacid sequence at hand.
+  # ========================================================================= #
+  def self.atomic_composition(
+      of = 'GGGGA' # ← This should be the aminoacid sequence.
+    )
+    begin
+      require 'chemistry_paradise/split_molecule_names.rb'
+      require 'chemistry_paradise/toplevel_methods/remove_this_molecule_from.rb'
+    rescue LoadError
+      if is_on_roebe?
+        puts 'Two files from the chemistry_paradise gem are not available.'
+      end
+    end
+    # ======================================================================= #
+    # Load up the molecular formula for each aminoacid next. This will
+    # be used as our reference-point for calculating things such as the
+    # composition, or weight.
+    # ======================================================================= #
+    dataset_molecular_formula_for_the_aminoacids = YAML.load_file(
+      FILE_AMINOACIDS_MOLECULAR_FORMULA
+    )
+    if of.is_a?(Array)
+      if of.empty?
+        of = 'GGGGA' # In this case reinstate the default.
+      else
+        if of.first.is_a?(String) and of.first.size > 1
+          of = of.first.split(//) # Split it on a per-character basis here.
+        end
+      end
+    end
+    if of.is_a? String
+      of = of.split(//)
+    end
+    unless of.is_a? Array
+      of = [of]
+    end
+    hash_keeping_track_of_the_atomic_composition = {}
+    # ======================================================================= #
+    # Build up the default values, for the atoms C, H, N, O and S.
+    # ======================================================================= #
+    hash_keeping_track_of_the_atomic_composition['C'] = 0
+    hash_keeping_track_of_the_atomic_composition['H'] = 0
+    hash_keeping_track_of_the_atomic_composition['N'] = 0
+    hash_keeping_track_of_the_atomic_composition['O'] = 0
+    hash_keeping_track_of_the_atomic_composition['S'] = 0
+    # ======================================================================= #
+    # Next obtain the formula from the ChemistryParadise project. We
+    # do so by iterating over the given input, and we assume that
+    # this input is always an Array.
+    # ======================================================================= #
+    of.map.with_index {|this_amino_acid, position_of_that_aminoacid|
+      # ===================================================================== #
+      # Next, we have to obtain the formula for this amino acid.
+      # ===================================================================== #
+      this_amino_acid = AMINO_ACIDS_ENGLISH[this_amino_acid]
+      formula_for_this_amino_acid = dataset_molecular_formula_for_the_aminoacids[this_amino_acid]
+      # ===================================================================== #
+      # The next case-menu will handle the position of the aminoacid at hand.
+      # We will skip doing so if there is only one aminoacid though.
+      # ===================================================================== #
+      if of.first.to_s.size > 1
+        case position_of_that_aminoacid # case tag
+        when 0 # This is the first aminoacid. It loses only one 'OH' group.
+          formula_for_this_amino_acid = 
+            ::ChemistryParadise.remove_this_molecule_from('OH', formula_for_this_amino_acid)
+        when (of.size - 1) # This is the last entry. It loses only one 'H' group.
+          formula_for_this_amino_acid = 
+            ::ChemistryParadise.remove_this_molecule_from('H', formula_for_this_amino_acid)
+        else
+          # ================================================================= #
+          # Else it will lose a full H₂O group.
+          # ================================================================= #
+          formula_for_this_amino_acid = 
+            ::ChemistryParadise.remove_this_molecule_from('H2O', formula_for_this_amino_acid)
+        end
+      end
+      array_chemical_formula = ::ChemistryParadise.split_this_molecular_formula_into_a_hash(
+        formula_for_this_amino_acid
+      )
+      array_chemical_formula.each {|molecule_and_number| # e. g. 'H13'
+        if molecule_and_number =~ /\d+/ # If it has at the least one number.
+          molecule_and_number =~ /([A-Z]+)(\d{1,2})/ # See: https://rubular.com/r/nCojEDcY6g
+          molecule = $1.to_s.dup
+          n_times  = $2.to_s.dup.to_i
+          hash_keeping_track_of_the_atomic_composition[molecule] += n_times
+        else # else it must be 1, since there is no other number, such as 'N'.
+          hash_keeping_track_of_the_atomic_composition[molecule_and_number] += 1
+        end
+      }
+    }
+    return hash_keeping_track_of_the_atomic_composition
+  end
+
+  # ========================================================================= #
+  # === Bioroebe.show_atomic_composition
+  #
+  # This method will output the above.
+  #
+  # Display style is similar to ExPASY output.
+  #
+  #   Atomic composition:
+  #
+  #   Carbon      C	        11
+  #   Hydrogen    H	        19
+  #   Nitrogen    N	         5
+  #   Oxygen      O	         6
+  #   Sulfur      S	         0
+  #
+  # ========================================================================= #
+  def self.show_atomic_composition(
+      of = 'GGGGA'
+    )
+    if of.is_a? Array
+      of = of.join(' ').strip
+    end
+    padding_to_use = '  '
+    hash = ::Bioroebe.atomic_composition(of)
+    _ = ''.dup
+    _ << "#{rev}Atomic composition of #{steelblue(of)}#{rev}:\n\n"
+    n_atoms_in_total = hash.values.sum
+    array = %w( C H N O S )
+    array.each {|this_atom|
+      case this_atom
+      when 'C'
+        _ << "#{padding_to_use}#{rev}Carbon    C  #{hash[this_atom].to_s.rjust(4)}\n"
+      when 'H'
+        _ << "#{padding_to_use}#{rev}Hydrogen  H  #{hash[this_atom].to_s.rjust(4)}\n"
+      when 'N'
+        _ << "#{padding_to_use}#{rev}Nitrogen  N  #{hash[this_atom].to_s.rjust(4)}\n"
+      when 'O'
+        _ << "#{padding_to_use}#{rev}Oxygen    O  #{hash[this_atom].to_s.rjust(4)}\n"
+      when 'S'
+        _ << "#{padding_to_use}#{rev}Sulfur    S  #{hash[this_atom].to_s.rjust(4)}\n"
+      end
+    }
+    _ << "  "+("-" * 18)
+    _ << "\n"
+    _ << "  Total:          #{n_atoms_in_total}\n\n"
+    puts _
+  end
+
+end
+
+if __FILE__ == $PROGRAM_NAME
+  if ARGV.empty?
+    pp Bioroebe.atomic_composition(ARGV)
+    Bioroebe.show_atomic_composition
+  else
+    Bioroebe.show_atomic_composition(ARGV)
+  end
+end # atomiccomposition GGGGA

data/lib/bioroebe/toplevel_methods/base_composition.rb

@@ -0,0 +1,121 @@
+#!/usr/bin/ruby -w
+# Encoding: UTF-8
+# frozen_string_literal: true
+# =========================================================================== #
+# require 'bioroebe/toplevel_methods/base_composition.rb'
+# Bioroebe.report_base_composition
+# =========================================================================== #
+module Bioroebe
+
+  require 'bioroebe/colours/colours.rb'
+  require 'bioroebe/colours/rev.rb'
+  require 'bioroebe/toplevel_methods/e.rb'
+
+  # ========================================================================= #
+  # === Bioroebe.base_composition
+  #
+  # This method can be used to query the composition of a given DNA
+  # sequence, that is, in percentage, the values for A, T, C and
+  # G.
+  #
+  # This method will then return a Hash, consisting of the percentage
+  # values of A, T, C and G in the given DNA sequence at hand.
+  #
+  # Note that the input to this method has to include a '%' character,
+  # at the least up until March 2020. Past March 2020 this requirement 
+  # was dropped, but I still think it is visually more elegant to
+  # include a '%' character.
+  # ========================================================================= #
+  def self.base_composition(
+      i = '52%GC'
+    )
+    if i.is_a? Array
+      if i.empty?
+        i = '52%GC' # Default value.
+      else
+        i = i.join(' ').strip
+      end
+    end
+    # ======================================================================= #
+    # Add support for Files here.
+    # ======================================================================= #
+    if i and File.exist?(i)
+      i = File.readlines(i).reject {|line| line.start_with? '>' }.join("\n").delete("\n")
+    end
+    # ======================================================================= #
+    # We must use a Hash for this.
+    # ======================================================================= #
+    hash = {
+      'A' => 0,
+      'T' => 0,
+      'C' => 0,
+      'G' => 0,
+    }
+    if i.include? '%'
+      splitted = i.split('%').map(&:strip)
+      frequency = splitted.first.to_i
+      opposite_frequency = 100 - frequency
+      characters = splitted.last.split(//)
+      characters.each {|this_nucleotide|
+        hash[this_nucleotide] = frequency / 2
+      }
+      # ===================================================================== #
+      # Next calculate the missing nucleotides:
+      # ===================================================================== #
+      missing_nucleotides = hash.select {|key, value|
+        value == 0
+      }
+      missing_nucleotides.each_pair {|this_nucleotide, value|
+        hash[this_nucleotide] = opposite_frequency / 2
+      }
+    else
+      frequency = Hash.new(0)
+      chars = i.chars
+      chars.each { |entry| frequency[entry] += 1 }
+      sum = frequency.values.sum
+      frequency.each_pair {|this_nucleotide, value|
+        hash[this_nucleotide] = ((value * 100.0) / sum).round(2)
+      }
+    end
+    return hash
+  end; self.instance_eval { alias frequency_of base_composition } # === Bioroebe.frequency_of
+
+  # ========================================================================= #
+  # === Bioroebe.report_base_composition
+  #
+  # This is the convenience-method for reporting the base composition
+  # at hand.
+  # ========================================================================= #
+  def self.report_base_composition(
+      i = '52%GC'
+    )
+    if i.is_a? Array
+      if i.empty?
+        i = '52%GC' # Default value.
+      else
+        i = i.join(' ').strip
+      end
+    end
+    hash = ::Bioroebe.base_composition(i)
+    a = hash['A']
+    t = hash['T']
+    c = hash['C']
+    g = hash['G']
+    erev 'The base composition frequencies of this sequence '\
+         '(length: '+i.size.to_s+') is as follows:'
+    e
+    e '  '\
+      ' A: '+steelblue(a.to_s+'%')+rev+
+      ' T: '+steelblue(t.to_s+'%')+rev+
+      ' C: '+steelblue(c.to_s+'%')+rev+
+      ' G: '+steelblue(g.to_s+'%')+rev
+    e
+  end; self.instance_eval { alias show_base_composition report_base_composition } # === show_base_composition
+
+end
+
+if __FILE__ == $PROGRAM_NAME
+  pp Bioroebe.base_composition(ARGV)
+  Bioroebe.report_base_composition(ARGV)
+end # basecomposition ATGC
+    # basecomposition ATTGCCCCCCCCAACCCCACA

data/lib/bioroebe/toplevel_methods/blast.rb

@@ -0,0 +1,153 @@
+#!/usr/bin/ruby -w
+# Encoding: UTF-8
+# frozen_string_literal: true
+# =========================================================================== #
+# require 'bioroebe/toplevel_methods/blast.rb'
+# =========================================================================== #
+module Bioroebe
+
+  # ========================================================================= #
+  # === Bioroebe.blast_neighborhood
+  #
+  # The second argument to this method is a score-filter, e. g. to
+  # select only entries that have a score higher than 1.
+  # ========================================================================= #
+  def self.blast_neighborhood(
+      this_mer                                    = 'CTC',
+      optional_apply_filter_for_score_higher_than = nil
+    )
+    require 'bioroebe/toplevel_methods/e.rb'
+    if this_mer.is_a? Array
+      this_mer = this_mer.first
+    end
+    if this_mer.nil?
+      this_mer = 'CTC' # Set the same default as above.
+    end
+    match_score     =  2
+    mis_match_score = -2
+    # ======================================================================= #
+    # Next use an Array of sequences that we will compare.
+    # ======================================================================= #
+    compare_these_sequences = %w(
+      AAA
+      AAT
+      AAC
+      AAG
+      ATA
+      ATT
+      ATC
+      ATG
+      ACA
+      ACT
+      ACC
+      ACG
+      AGA
+      AGT
+      AGC
+      AGG
+      TAA
+      TAT
+      TAC
+      TAG
+      TTA
+      TTT
+      TTC
+      TTG
+      TCA
+      TCT
+      TCC
+      TCG
+      TGA
+      TGT
+      TGC
+      TGG
+      CAA
+      CAT
+      CAC
+      CAG
+      CTA
+      CTT
+      CTC
+      CTG
+      CCA
+      CCT
+      CCC
+      CCG
+      CGA
+      CGT
+      CGC
+      CGG
+      GAA
+      GAT
+      GAC
+      GAG
+      GTA
+      GTT
+      GTC
+      GTG
+      GCA
+      GCT
+      GCC
+      GCG
+      GGA
+      GGT
+      GGC
+      GGG
+    )
+    compare_these_sequences.each {|this_sequence|
+      score = 0
+      chars = this_sequence.chars
+      first_char  = chars[0]
+      second_char = chars[1]
+      third_char  = chars[2]
+      if first_char == this_mer[0]
+        # =================================================================== #
+        # Found the first match.
+        # =================================================================== #
+        score += match_score
+      else
+        # =================================================================== #
+        # else it must be a mismatch
+        # =================================================================== #
+        score += mis_match_score
+      end
+      if second_char == this_mer[1]
+        # =================================================================== #
+        # Found the first match.
+        # =================================================================== #
+        score += match_score
+      else
+        # =================================================================== #
+        # else it must be a mismatch
+        # =================================================================== #
+        score += mis_match_score
+      end
+      if third_char == this_mer[2]
+        # =================================================================== #
+        # Found the first match.
+        # =================================================================== #
+        score += match_score
+      else
+        # =================================================================== #
+        # else it must be a mismatch
+        # =================================================================== #
+        score += mis_match_score
+      end
+      if optional_apply_filter_for_score_higher_than
+         if (score.to_i > optional_apply_filter_for_score_higher_than)
+          e "#{this_sequence}: score of "\
+            "#{score.to_s.rjust(3)}"
+         end
+      else
+        e this_sequence+': score of '+
+          score.to_s.rjust(3)
+      end
+    }
+  end
+
+end
+
+if __FILE__ == $PROGRAM_NAME
+  # Bioroebe.blast_neighborhood(ARGV)
+  Bioroebe.blast_neighborhood(ARGV, 1)
+end # rb blast_neighb*

data/lib/bioroebe/toplevel_methods/calculate_n50_value.rb

@@ -0,0 +1,57 @@
+#!/usr/bin/ruby -w
+# Encoding: UTF-8
+# frozen_string_literal: true
+# =========================================================================== #
+# require 'bioroebe/toplevel_methods/calculate_n50_value.rb'
+# Bioroebe.calculate_n50_value(ARGV)
+# =========================================================================== #
+module Bioroebe
+
+  # ========================================================================= #
+  # === Bioroebe.calculate_n50_value
+  #
+  # This method will calculate the N50 value of the given input. The input
+  # to this method should be a sorted Array.
+  # ========================================================================= #
+  def self.calculate_n50_value(
+      i = [
+        1989, 1934, 1841,
+        1785, 1737, 1649,
+        1361,  926,  848,
+         723
+      ]
+    )
+    # ======================================================================= #
+    # The following conversion is necessary because ARGV will contain only
+    # String objects, not integer-values.
+    # ======================================================================= #
+    i.map! {|entry| entry.to_i }
+    calculate_sum_for_the_loop = 0
+    sum = i.sum
+    half = sum / 2.0
+    find_the_proper_contig = nil
+    i.each {|this_number|
+      calculate_sum_for_the_loop += this_number
+      # ===================================================================== #
+      # Compare the temporary sum with the half-sum.
+      # ===================================================================== #
+      if calculate_sum_for_the_loop > half
+        find_the_proper_contig = this_number
+        break
+      end
+    }
+    return find_the_proper_contig
+  end
+
+end
+
+if __FILE__ == $PROGRAM_NAME
+  if ARGV.empty?
+    pp Bioroebe.calculate_n50_value
+    array_to_test = [1252, 919, 917, 765, 711, 690, 632, 516, 463, 218]
+    pp array_to_test
+    pp Bioroebe.calculate_n50_value(array_to_test)
+  else
+    pp Bioroebe.calculate_n50_value(ARGV)
+  end
+end # calculaten50value

data/lib/bioroebe/toplevel_methods/cat.rb

@@ -0,0 +1,71 @@
+#!/usr/bin/ruby -w
+# Encoding: UTF-8
+# frozen_string_literal: true
+# =========================================================================== #
+# require 'bioroebe/toplevel_methods/cat.rb'
+# =========================================================================== #
+module Bioroebe
+
+  require 'bioroebe/toplevel_methods/convert_global_env.rb'
+  require 'bioroebe/toplevel_methods/e.rb'
+  require 'bioroebe/colours/colours.rb'
+  require 'bioroebe/colours/rev.rb'
+  require 'bioroebe/colours/sfile.rb'
+  require 'bioroebe/colours/sdir.rb'
+
+  # ========================================================================= #
+  # === Bioroebe.cat                                                (cat tag)
+  #
+  # A variant of cat to use here.
+  # ========================================================================= #
+  def self.cat(i = nil)
+    if i
+      i = convert_global_env(i) if i.include? '$'
+      i = Dir['*'][i.to_i - 1] if i =~ /^\d+$/
+    end
+    if i.nil?
+      erev 'Please provide an argument to Bioroebe.cat() (the name of a file)'
+    # ======================================================================= #
+    # === Handle directories next
+    # ======================================================================= #
+    elsif File.directory? i
+      erev "We can not read from `#{sdir(i)}#{rev}` as it is a directory."
+    # ======================================================================= #
+    # Else the File will exist in this clause:
+    # ======================================================================= #
+    elsif File.exist?(i)
+      _ = File.extname(i).delete('.')
+      case _ # case tag
+      # ===================================================================== #
+      # === fasta
+      # ===================================================================== #
+      when 'fasta',
+           'fa'
+        e 'This is a fasta file, so rather than cat-ing the content,'
+        e 'we will send this dataset to the ParseFasta class.'
+        require 'bioroebe/fasta_and_fastq/parse_fasta/parse_fasta.rb'
+        Bioroebe::ParseFasta.new(i)
+      else # The default here.
+        e "Now displaying the file `#{sfile(i)}`."
+        # e File.read(i)
+        # ^^^ Or we could use the above. We have to reconsider this one day.
+        File.readlines(i).each {|line| e "  #{line.chomp}" } # With a bit of padding.
+      end
+    else # else the file does not exist.
+      e "#{swarn('Trying to display the file `')}#{sfile(i)}#{swarn('`')}"
+      e swarn('but it does not exist.')
+    end
+  end
+
+  # ========================================================================= #
+  # === cat
+  # ========================================================================= #
+  def cat(i)
+    ::Bioroebe.cat(i)
+  end
+
+end
+
+if __FILE__ == $PROGRAM_NAME
+  Bioroebe.cat '/etc/wgetrc' # This is just for testing purposes really.
+end # bioroebe_cat

data/lib/bioroebe/toplevel_methods/chunked_display.rb

@@ -0,0 +1,92 @@
+#!/usr/bin/ruby -w
+# Encoding: UTF-8
+# frozen_string_literal: true
+# =========================================================================== #
+# This code will return a properly-chunked nucleotide sequence, with
+# numbers.
+#
+# The genbank format uses such a chunked display.
+#
+# The display will look similar to this:
+#
+#
+#        1 ATGGGGCCTG CAATGGGGCC TGCAATGGGG CCTGCAATGG GGCCTGCAAT GGGGCCTGCA
+#       61 ATGGGGCCTG CAATGGGGCC TGCAATGGGG CCTGCA
+#
+#
+# The chunks width defaults to the genbank format.
+# =========================================================================== #
+# require 'bioroebe/toplevel_methods/chunked_display.rb'
+# puts Bioroebe.chunked_display(ARGV, 10)
+# =========================================================================== #
+module Bioroebe
+
+  require 'bioroebe/constants/newline.rb'
+
+  # ========================================================================= #
+  # === Bioroebe.return_nucleotide_sequence_as_ten_nucleotides_chunks
+  # ========================================================================= #
+  def self.return_nucleotide_sequence_as_ten_nucleotides_chunks(i)
+    i.split(/(.{10})/).reject(&:empty?)
+  end
+
+  # ========================================================================= #
+  # === Bioroebe.return_chunked_display
+  #
+  # The second argument to this method tells us how many nucleotides
+  # shall be grouped together (and then displayed as such).
+  # ========================================================================= #
+  def self.return_chunked_display(
+      i,
+      group_together_n_nucleotides = 10
+    )
+    i = i.first if i.is_a? Array
+    chunks = i.split(/(.{#{group_together_n_nucleotides}})/).reject(&:empty?)
+    sliced = chunks.each_slice(6).to_a
+    _ = ''.dup # We need a dynamic String.
+    sliced.each {|array|
+      # ===================================================================== #
+      # First, add the number to the beginning.
+      # ===================================================================== #
+      nucleotide_position = (
+        _.strip.tr(' ','').tr(N,'').gsub(/\d/,'').strip.size + 1
+      ).to_s
+      _ << nucleotide_position.rjust(9)+' '
+      _ << array.join(' ')
+      _ << N
+    }
+    return _
+  end; self.instance_eval { alias chunked_display return_chunked_display } # === Bioroebe.chunked_display
+
+  # ========================================================================= #
+  # === Bioroebe.downcase_chunked_display
+  #
+  # This is similar to the regular chunked display, but will return
+  # the nucleotides in a downcased manner, aka "A" will become "a"
+  # and so forth.
+  #
+  # In the past this functionality resided in its own .rb file, but
+  # since as of March 2020 a bin/ executable was added, so that
+  # the functionality can be more easily called when the bioroebe
+  # gem is installed.
+  #
+  # Usage example:
+  #
+  #   Bioroebe.downcase_chunked_display 'ATGGGGCCTGCAATGGGGCCTGCAATGGGGCCTGCAATGGGGCCTGCAATGGGGCCTGCAATGGGGCCTGCAATGGGGCCTGCAATGGGGCCTGCA'
+  #
+  # ========================================================================= #
+  def self.downcase_chunked_display(
+      i,
+      group_together_n_nucleotides = 10
+    )
+    sequence = ::Bioroebe.return_chunked_display(i, group_together_n_nucleotides).downcase
+    return sequence
+  end
+
+end
+
+if __FILE__ == $PROGRAM_NAME
+  puts Bioroebe.chunked_display(ARGV, 10)
+  puts Bioroebe.downcase_chunked_display(ARGV, 10)
+end # chunkeddisplay ATGGGGCCTGCAATGGGGCCTGCAATGGGGCCTGCAATGGGGCCTGCAATGGGGCCTGCAATGGGGCCTGCAATGGGGCCTGCAATGGGGCCTGCA
+    # downcasechunkeddisplay ATGGGGCCTGCAATGGGGCCTGCAATGGGGCCTGCAATGGGGCCTGCAATGGGGCCTGCAATGGGGCCTGCAATGGGGCCTGCAATGGGGCCTGCA