bioroebe 0.12.24 → 0.13.31

data/lib/bioroebe/toplevel_methods/phred_error_probability.rb

@@ -1,68 +0,0 @@
-#!/usr/bin/ruby -w
-# Encoding: UTF-8
-# frozen_string_literal: true
-# =========================================================================== #
-# require 'bioroebe/toplevel_methods/phred_error_probability.rb'
-# Bioroebe.phred_error_probability(ARGV)
-# =========================================================================== #
-module Bioroebe
-
-  # ========================================================================= #
-  # === Bioroebe.phred_error_probability
-  #
-  # Datasets obtained from next-generation reads specify a Phred score
-  # for each base. This is also known as the "Q score" (Quality score).
-  #
-  # The Q score is an integer value, and is typically within the range 2
-  # to 40. Q indicates the probability that the base call is incorrect (P_e).
-  #
-  # For example, Q=2 means that the error probability is 63%, so the machine
-  # is reporting that the base is more likely to be wrong than right, while
-  # Q=20 corresponds to an error probability of only 1%.
-  #
-  # The second argument to this method can be used to format to a specific
-  # number. So if we pass in 6 as the second argument then the result will
-  # be rounded to 6 slots after the first '.'. See the usage examples
-  # below.
-  #
-  # Usage examples:
-  #
-  #   Bioroebe.phred_error_probability '48'
-  #   Bioroebe.phred_error_probability '48',6 # => "0.000016"
-  #
-  # ========================================================================= #
-  def self.phred_error_probability(
-      quality_score                = 50,
-      optional_use_this_formatting = nil
-    )
-    if quality_score.is_a? Array
-      quality_score = quality_score.first
-    end
-    quality_score = quality_score.to_f # Need a Float past this point.
-    result = 10 ** (- quality_score / 10.0)
-    # ======================================================================= #
-    # Next, do some rounding if the user requested this through the
-    # second argument to this method.
-    # ======================================================================= #
-    if optional_use_this_formatting
-      if optional_use_this_formatting.is_a? Numeric
-        use_this_formatting_rule = "%.#{optional_use_this_formatting}f"
-        result = use_this_formatting_rule % result
-      else
-        result = optional_use_this_formatting.to_s % result
-      end
-    end
-    return result
-  end
-
-end
-
-if __FILE__ == $PROGRAM_NAME
-  if ARGV.empty?
-  (1 .. 40).each {|entry|
-    puts "#{entry.to_s.ljust(3)} #{Bioroebe.phred_error_probability(entry)}"
-  }
-  else
-    puts Bioroebe.phred_error_probability(ARGV)
-  end
-end # phrederrorprobability 48

data/lib/bioroebe/toplevel_methods/rds.rb

@@ -1,24 +0,0 @@
-#!/usr/bin/ruby -w
-# Encoding: UTF-8
-# frozen_string_literal: true
-# =========================================================================== #
-# require 'bioroebe/toplevel_methods/rds.rb'
-# =========================================================================== #
-module Bioroebe
-
-  # ========================================================================= #
-  # === Bioroebe.rds
-  #
-  # rds is an abbreviation and is short for "remove double slashes".
-  #
-  # We will thus get rid of too many '/' tokens in a given string,
-  # via this method.
-  #
-  # This is mostly used in order to sanitize local file paths, as
-  # "foo//bar" entries look quite ugly.
-  # ========================================================================= #
-  def self.rds(i)
-    i.squeeze('/')
-  end
-
-end

data/lib/bioroebe/toplevel_methods/remove.rb

@@ -1,86 +0,0 @@
-#!/usr/bin/ruby -w
-# Encoding: UTF-8
-# frozen_string_literal: true
-# =========================================================================== #
-# require 'bioroebe/toplevel_methods/remove.rb'
-# Bioroebe.remove_numbers(ARGV)
-# =========================================================================== #
-module Bioroebe
-
-  # ========================================================================= #
-  # === Bioroebe.remove_numbers
-  #
-  # This method will simply remove numbers from the given input at hand.
-  #
-  # Usage example:
-  #
-  #   Bioroebe.remove_numbers("abc123def")
-  #
-  # ========================================================================= #
-  def self.remove_numbers(i = ARGV)
-    if i.is_a? Array
-      i = i.join
-    end
-    i.gsub(/[0-9]/,'')
-  end; self.instance_eval { alias remove_numbers_from remove_numbers } # === Bioroebe.remove_numbers_from
-
-  # ========================================================================= #
-  # === Bioroebe.remove_subsequence
-  #
-  # This method will remove one or more subsequences from a given
-  # String at hand. The String that you wish to modify, should be
-  # given as the second argument to this method, called `from`.
-  #
-  # The first argument to this method can be an Array or a String - in
-  # either case, if the variable `from` contains this sequence, it
-  # will be removed.
-  #
-  # Note that only the FIRST occurence found will be removed - the others
-  # will be ignored, if they exist.
-  #
-  # The second argument to this method must be a String.
-  #
-  # Usage example:
-  #
-  #   Bioroebe.remove_subsequence(["ATCGGTCGAA", "ATCGGTCGAGCGTGT"], 'ATGGTCTACATAGCTGACAAACAGCACGTAGCAATCGGTCGAATCTCGAGAGGCATATGGTCACATGATCGGTCGAGCGTGTTTCAAAGTTTGCGCCTAG')
-  #   Bioroebe.remove_subsequence(array, main_sequence)
-  #
-  # ========================================================================= #
-  def self.remove_subsequence(
-      subsequence,
-      from # ← Must be a String.
-    )
-    unless from.is_a? String
-      raise 'Please input a String as second argument to this method.'
-    end
-    unless subsequence.is_a? Array
-      subsequence = [subsequence].flatten
-    end
-    from = from.dup if from.frozen?
-    subsequence.each {|this_subsequence|
-      from.sub!(/#{this_subsequence}/,'')
-    }
-    from # Return the, possibly modified, String here.
-  end; self.instance_eval { alias remove_subsequences remove_subsequence } # === Bioroebe.remove_subsequences
-
-end
-
-if __FILE__ == $PROGRAM_NAME
-  require 'colours/autoinclude'
-  alias e puts
-  main_sequence = 'ATGGTCTACATAGCTGACAAACAGCACGTAGCAATCGGTCGAATCTCGAGAGGCATATGGTCACATGATCGGTCGAGCGTGTTTCAAAGTTTGCGCCTAG'
-  subsequence1 = 'ATCGGTCGAA'
-  subsequence2 = 'ATCGGTCGAGCGTGT'
-  e "#{Colours.rev}The main sequence is:"
-  e
-  e "  #{Colours.lightgreen(main_sequence)} (size: #{main_sequence.size})"
-  e
-  e 'The two subsequences '+Colours.slateblue(subsequence1)+
-    ' and '+Colours.slateblue(subsequence2)+' will be removed next.'
-  e
-  e 'And now the resulting new String is:'
-  e
-  new_string = Bioroebe.remove_subsequence([subsequence1, subsequence2], main_sequence)
-  e "  #{Colours.lightgreen(new_string)} (size: #{new_string.size})"
-  e
-end # removesubsequence

data/lib/bioroebe/toplevel_methods/return_source_code_of_this_method.rb

@@ -1,35 +0,0 @@
-#!/usr/bin/ruby -w
-# Encoding: UTF-8
-# frozen_string_literal: true
-# =========================================================================== #
-# require 'bioroebe/toplevel_methods/return_source_code_of_this_method.rb'
-# Bioroebe.return_source_code_of_this_method
-# =========================================================================== #
-module Bioroebe
-
-  # ========================================================================= #
-  # === Bioroebe.return_source_code_of_this_method
-  #
-  # This method will return the source code of a particular method.
-  #
-  # Note that the method will stop at the first 'end' encountered.
-  # ========================================================================= #
-  def self.return_source_code_of_this_method(i)
-    if i.is_a? Array
-      i = i.first
-    end
-    content = i.source_location
-    full_content = File.readlines(
-      content[0].to_s
-    )[ (content[1]-1) .. -1 ].join.to_s
-    if full_content.include? 'end'
-      full_content = full_content[0 .. full_content.index('end')+2]
-    end
-    return full_content  
-  end
-
-end
-
-if __FILE__ == $PROGRAM_NAME
-  Bioroebe.return_source_code_of_this_method
-end

data/lib/bioroebe/toplevel_methods/return_subsequence_based_on_indices.rb

@@ -1,68 +0,0 @@
-#!/usr/bin/ruby -w
-# Encoding: UTF-8
-# frozen_string_literal: true
-# =========================================================================== #
-# require 'bioroebe/toplevel_methods/return_subsequence_based_on_indices.rb'
-# Bioroebe.return_subsequence_based_on_indices
-# =========================================================================== #
-module Bioroebe
-
-  # ========================================================================= #
-  # === Bioroebe.return_subsequence_based_on_indices
-  #
-  # This method will return a subsequence that was sliced out from the
-  # given input array of indices (the second argument to this method).
-  #
-  # This method here also allows us to read from an existing File. The
-  # format of that file has to be simple, though - the first line must
-  # be the sequence; and the second line will constitute the array
-  # of indices.
-  #
-  # For a usage example, see the end of this file here please. It has
-  # been written primarily to solve a specific task at Rosalind.
-  # ========================================================================= #
-  def self.return_subsequence_based_on_indices(
-      i, *array_of_indices
-    )
-    if array_of_indices.is_a? Array
-      array_of_indices.map! {|entry| entry.to_i }
-    end
-    result = ''.dup
-    if i and i.is_a?(String) and File.exist?(i)
-      dataset = File.readlines(i).reject {|line| line.strip.empty? }
-      i = dataset.first
-      array_of_indices = dataset.last.split(' ').map(&:to_i)
-    end
-    array_of_indices.each_slice(2).each {|a, b|
-      result << i[a .. b]+' '
-    }
-    result.strip
-  end
-
-end
-
-if __FILE__ == $PROGRAM_NAME
-  a =  22 # These four variables determine the sub-indices.
-  b =  27
-  c =  97
-  d = 102
-  if ARGV.empty?
-    test_this_string = 'HumptyDumptysatonawallHumptyDumpty'\
-                       'hadagreatfallAlltheKingshorsesandalltheKingsmen'\
-                       'CouldntputHumptyDumptyinhisplaceagain.'
-  else
-    test_this_string = ARGV.first
-    if test_this_string and File.file?(test_this_string)
-      dataset = File.readlines(test_this_string)
-      test_this_string = dataset.first
-      splitted = dataset.last.split(' ')
-      a = splitted[0]
-      b = splitted[1]
-      c = splitted[2]
-      d = splitted[3]
-    end
-  end
-  puts Bioroebe.return_subsequence_based_on_indices(
-    test_this_string, a, b, c, d
-  )
-end # returnsubsequencebasedonindices /HUM.txt

data/lib/bioroebe/toplevel_methods/rna_splicing.rb

@@ -1,73 +0,0 @@
-#!/usr/bin/ruby -w
-# Encoding: UTF-8
-# frozen_string_literal: true
-# =========================================================================== #
-# require 'bioreobe/module_methods/rna_splicing.rb'
-# =========================================================================== #
-module Bioroebe
-
-  require 'bioroebe/toplevel_methods/remove.rb'
-
-  # ========================================================================= #
-  # === Bioroebe.rna_splicing
-  #
-  # This is a VERY primitive method that has been written primarily to
-  # solve a specific question on Rosalind.
-  #
-  # This is NOT how splicing normally works - but it works to solve
-  # the given question at Rosalind.
-  #
-  # Invocation example:
-  #
-  #    Bioroebe.rna_splicing('/SPLICING.md')
-  #
-  # ========================================================================= #
-  def self.rna_splicing(i)
-    require 'bioroebe/fasta_and_fastq/parse_fasta/parse_fasta.rb'
-    if i and File.exist?(i)
-      # ===================================================================== #
-      # Read in the file should it exist.
-      # ===================================================================== #
-      i = File.read(i).strip
-    end
-    if i.is_a?(String) and i.include?('>')
-      _ = ::Bioroebe::ParseFasta.new(i) { :be_quiet }
-      sequences = _.sequences?
-      main_sequence = sequences.first
-      array_subsequences = sequences[1 .. -1]
-      result = ::Bioroebe.remove_subsequence(array_subsequences, main_sequence)
-      return result
-    end
-  end
-
-end
-
-if __FILE__ == $PROGRAM_NAME
-  alias e puts
-  if ARGV.empty?
-    use_this_dataset = '>Rosalind_10
-ATGGTCTACATAGCTGACAAACAGCACGTAGCAATCGGTCGAATCTCGAGAGGCATATGGTCACATGATCGGTCGAGCGTGTTTCAAAGTTTGCGCCTAG
->Rosalind_12
-ATCGGTCGAA
->Rosalind_15
-ATCGGTCGAGCGTGT'
-  else
-    use_this_dataset = ARGV.first
-  end
-  e 'Original input is:'
-  e
-  e 'ATGGTCTACATAGCTGACAAACAGCACGTAGCAATCGGTCGAATCTCGAGAGGCATATGGTCACATGATCGGTCGAGCGTGTTTCAAAGTTTGCGCCTAG'
-  e
-  result = Bioroebe.rna_splicing use_this_dataset
-  e result
-  # ========================================================================= #
-  # The next code is if you need an aminoacid sequence:
-  # ========================================================================= #
-  e
-  e 'This corresponds to these aminoacids:'
-  e
-  e Bioroebe.to_aa(result)
-  e
-end # rnasplicing
-    # rnasplicing /RNA_SPLICING.md
-    # rnasplicing /SPLICING.md

data/lib/bioroebe/toplevel_methods/rnalfold.rb

@@ -1,69 +0,0 @@
-#!/usr/bin/ruby -w
-# Encoding: UTF-8
-# frozen_string_literal: true
-# =========================================================================== #
-# require 'bioroebe/toplevel_methods/rnalfold.rb'
-# =========================================================================== #
-module Bioroebe
-
-  require 'bioroebe/toplevel_methods/e.rb'
-
-  # ========================================================================= #
-  # === Bioroebe.rnalfold
-  #
-  # This method allows us to make use of RNALfold. By default the method
-  # will attempt to obtain all .fa files in the current directory; this
-  # should simplify batch-processing.
-  #
-  # Otherwise, the first input argument to this method should be the
-  # file(s) that you wish to manipulate.
-  #
-  # A typical usage example may be:
-  #
-  #   Bioroebe.rnalfold { '--zscore=-3 -L 200' }
-  #
-  # ========================================================================= #
-  def self.rnalfold(
-      i = :use_all_fasta_files_in_the_current_directory
-    )
-    require 'bioroebe/colours/sfancy.rb'
-    require 'bioroebe/colours/sfile.rb'
-    # ======================================================================= #
-    # RNALfold will be used (as command).
-    # ======================================================================= #
-    use_this_command = 'RNALfold'.dup
-    case i
-    when :default,
-         :use_all_fasta_files_in_the_current_directory
-      i = Dir['**.fa']
-    end
-    if block_given?
-      yielded = yield
-      # ===================================================================== #
-      # Simply append these block-commands in that case:
-      # ===================================================================== #
-      use_this_command << " #{yielded}"
-    end
-    # ======================================================================= #
-    # We assume that our input is an Array past this point.
-    # ======================================================================= #
-    i.each {|this_file|
-      e "Working on `#{sfancy(this_file)}` next."
-      new_filename = this_file.dup
-      regex_to_use = /-L (\d+)/
-      use_this_command =~ regex_to_use
-      new_filename << '.'+$1.to_s.dup
-      new_filename << '.lfold'
-      _ = use_this_command+' < '+this_file+' > '+new_filename
-      esystem _
-      if File.exist? new_filename
-        e "A new file has been created at `#{sfile(new_filename)}`."
-      end
-    }
-  end
-
-end
-
-if __FILE__ == $PROGRAM_NAME
-  Bioroebe.rnalfold { '--zscore=-3 -L 200' }
-end # bioroebernalfold

data/lib/bioroebe/toplevel_methods/searching_and_finding.rb

@@ -1,116 +0,0 @@
-#!/usr/bin/ruby -w
-# Encoding: UTF-8
-# frozen_string_literal: true
-# =========================================================================== #
-# The file here will contain code that is related to "find"-ing something,
-# typically within another string or object or dataset.
-# =========================================================================== #
-# require 'bioroebe/toplevel_methods/searching_and_finding.rb'
-# Bioroebe.find_substring 'GATATATGCATATACTT', 'ATAT' # => [2, 4, 10]
-# =========================================================================== #
-module Bioroebe
-
-  # ========================================================================= #
-  # === Bioroebe.find_substring
-  #
-  # This method can be used to find a substring within a larger String.
-  #
-  # For example, in the below default values, the substring "ATAT"
-  # would exist at the positions 2, 4 and 10, if compared to the
-  # larger parent string "GATATATGCATATACTT".
-  #
-  # The following display may help you see this more easily, in
-  # regards to the substring matches:
-  #
-  #   GATATATGCATATACTT
-  #    ATATAT  ATAT
-  #
-  # If you look closely, you will be able to see that "ATAT" can
-  # be found three times in the string above.
-  #
-  # Indices in this context start at position 1, not 0. This is
-  # mostly done to refer to nucleotides or aminoacids, which
-  # also typically start at the first letter. Position 0 makes
-  # no sense for a nucleotide - what would "nucleotide 0" even
-  # refer to?
-  #
-  # The first argument to this method may also be the path to a
-  # locally existing file, such as "/rosalind_subs.txt". In
-  # fact this method has been largely motivated by Rosalind
-  # tasks.
-  #
-  # The method will return an Array with the positions of all
-  # substrings that are found in the full_string variable. See
-  # the usage example below for how this may be.
-  #
-  # Usage example:
-  #
-  #    Bioroebe.find_substring 'GATATATGCATATACTT', 'ATAT' # => [2, 4, 10]
-  #
-  # ========================================================================= #
-  def self.find_substring(
-      full_string    = 'GATATATGCATATACTT', # ← The full String comes here.
-      this_substring = :default             # ← The substring we are searching for comes here.
-    )
-    if full_string.is_a? Array
-      # ===================================================================== #
-      # Presently this method will only work on the first member of an Array.
-      # ===================================================================== #
-      full_string = full_string.first
-    end
-    if full_string and File.file?(full_string) and
-       this_substring == :default
-      # ===================================================================== #
-      # In this case it is ok to read from that file.
-      # ===================================================================== #
-      _ = File.read(full_string)
-      splitted = _.split("\n")
-      full_string    = splitted.first
-      this_substring = splitted.last
-    end
-    case this_substring
-    # ======================================================================= #
-    # Use a default value in this case. In reality users should supply
-    # their own substring when they use this method here.
-    # ======================================================================= #
-    when :default,
-         nil
-      this_substring = 'ATAT'
-    else
-      if this_substring.empty?
-        this_substring = 'ATAT'
-      end
-    end
-    if full_string.nil? or full_string.empty?
-      full_string = 'GATATATGCATATACTT' # ← Use the default in this case.
-    end
-    result = Array.new.tap { |indexes|
-      final_index_position = full_string.size - this_substring.size
-      i = 0
-      while (i < final_index_position)
-        index = full_string.to_s.index(this_substring.to_s, i)
-        break if index.nil?
-        i = index + 1
-        indexes << i
-      end
-    }
-    result = nil if result.empty? # ← We will try this here; could also return an empty Array, though.
-    result # Return our findings here.
-  end; self.instance_eval { alias find_substring_indices find_substring } # === Bioroebe.find_substring_indices
-
-end
-
-if __FILE__ == $PROGRAM_NAME
-  if File.exist?(ARGV.first)
-    # ======================================================================= #
-    # Handle locally existing files first.
-    # ======================================================================= #
-    puts Bioroebe.find_substring(ARGV.first).join(' ').strip
-  else
-    puts Bioroebe.find_substring(ARGV[0], ARGV[1]).join(' ').strip
-  end
-end # findsubstring TATATA AT
-    # findsubstring TATATATA AT
-    # findsubstring GATATATGCATATACTT ATAT
-    # findsubstring GATATATGCATATACTT ATAT
-    # findsubstring /rosalind_subs.txt

data/lib/bioroebe/toplevel_methods/shuffleseq.rb

@@ -1,37 +0,0 @@
-#!/usr/bin/ruby -w
-# Encoding: UTF-8
-# frozen_string_literal: true
-# =========================================================================== #
-# require 'bioroebe/toplevel_methods/shuffleseq.rb'
-# Bioroebe.shuffleseq
-# =========================================================================== #
-module Bioroebe
-
-  # ========================================================================= #
-  # === Bioroebe.shuffleseq
-  #
-  # This method simulates the Emboss shuffleseq-functionality. It will
-  # take the input string, such as an assumed DNA sequence, and simply
-  # re-arrange it as-is.
-  #
-  # You can read this here:
-  #
-  #   https://www.bioinformatics.nl/cgi-bin/emboss/shuffleseq
-  #
-  # Usage example:
-  #
-  #   Bioroebe.shuffleseq 'ATCGATCG' # => "AGTTACGC"
-  #
-  # ========================================================================= #
-  def self.shuffleseq(i = ARGV)
-    if i.is_a? Array
-      i = i.join(' ').strip
-    end
-    return i.chars.shuffle.join
-  end; self.instance_eval { alias randomize_the_sequence shuffleseq } # === Bioroebe.randomize_the_sequence
-
-end
-
-if __FILE__ == $PROGRAM_NAME
-  puts Bioroebe.shuffleseq(ARGV)
-end # shuffleseq ATCGATCG

data/lib/bioroebe/toplevel_methods/statistics.rb

@@ -1,53 +0,0 @@
-#!/usr/bin/ruby -w
-# Encoding: UTF-8
-# frozen_string_literal: true
-# =========================================================================== #
-# require 'bioroebe/toplevel_methods/statistics.rb'
-# Bioroebe.show_exon_statistics
-# =========================================================================== #
-module Bioroebe
-
-  require 'bioroebe/colours/colours.rb'
-  require 'bioroebe/toplevel_methods/e.rb'
-  require 'bioroebe/toplevel_methods/esystem.rb'
-  require 'bioroebe/toplevel_methods/file_and_directory_related_actions.rb'
-
-  # ========================================================================= #
-  # === Bioroebe.show_exon_statistics
-  #
-  # This is mostly "throw-away" code; it will quickly tell us how many
-  # exons may span over some junction.
-  #
-  # It was specifically created to analyze a .gtf file.
-  #
-  # Invocation example:
-  #
-  #   bioroebe --show-exon-statistics-for=/tmp/praktikum/Mouse/chromosome_8/parsed/cdna.8.L100.global.gtf
-  #
-  # ========================================================================= #
-  def self.show_exon_statistics(these_files)
-    [these_files].flatten.compact.each {|this_file|
-      if File.exist? this_file
-        result = `cat #{this_file} | awk '{print $12}' | sort | uniq -c | sort -k1n | awk '{print $1}' | sort | uniq -c | less`
-        e gold('        n exons')
-        splitted = result.split("\n")
-        # =================================================================== #
-        # splitted may look like this:
-        #
-        #   ["  89839 1", "  26031 2", "   1136 3", "     24 4"]
-        #
-        # =================================================================== #
-        splitted.each {|line|
-          e line.sub(/( \d+)$/, gold('\1'))
-        }
-      else
-        no_file_exists_at(this_file)
-      end
-    }
-  end
-
-end
-
-if __FILE__ == $PROGRAM_NAME
-  Bioroebe.show_exon_statistics(ARGV)
-end # showexonstatistics /tmp/praktikum/Mouse/chromosome_8/parsed/cdna.8.L100.global.gtf