bioroebe 0.12.24 → 0.13.31

data/lib/bioroebe/toplevel_methods/atomic_composition.rb

@@ -1,198 +0,0 @@
-#!/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

@@ -1,121 +0,0 @@
-#!/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

@@ -1,153 +0,0 @@
-#!/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

@@ -1,57 +0,0 @@
-#!/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

@@ -1,71 +0,0 @@
-#!/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

@@ -1,92 +0,0 @@
-#!/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