bioroebe 0.10.80

data/lib/bioroebe/raw_sequence/raw_sequence.rb

@@ -0,0 +1,557 @@
+#!/usr/bin/ruby -w
+# Encoding: UTF-8
+# frozen_string_literal: true
+# =========================================================================== #
+# === Bioroebe::RawSequence
+#
+# Usage example:
+#
+#   Bioroebe::RawSequence.new(ARGV)
+#
+# =========================================================================== #
+# require 'bioroebe/raw_sequence/raw_sequence.rb'
+# =========================================================================== #
+module Bioroebe
+
+class RawSequence # === Bioroebe::RawSequence
+
+  # ========================================================================= #
+  # === initialize
+  # ========================================================================= #
+  def initialize(
+      commandline_arguments = ARGV
+    )
+    reset
+    if commandline_arguments and
+       commandline_arguments.is_a?(Array) and
+       !commandline_arguments.empty?
+      set_raw_sequence(commandline_arguments)
+    elsif commandline_arguments and
+          commandline_arguments.is_a?(String)
+      set_raw_sequence(commandline_arguments)
+    end
+  end
+
+  # ========================================================================= #
+  # === reset                                                     (reset tag)
+  # ========================================================================= #
+  def reset
+    # ======================================================================= #
+    # === @sequence
+    #
+    # This instance variable keeps our whole sequence. It is the most
+    # important variable for objects instantiated from this class.
+    # ======================================================================= #
+    @sequence = ''.dup
+  end
+
+  # ========================================================================= #
+  # === to_str
+  #
+  # We need this method to allow to chain Sequence-objects together,
+  # in a String-like behaviour.
+  #
+  # Specifically this allows us to make use of the '+' method call.
+  #
+  # Objects in ruby implement the to_str method so that they can be
+  # treated like a String, for all practical purposes.
+  #
+  # This can be tested like in this way:
+  #
+  #   x = Bioroebe::RawSequence.new('ATGGATCGATGC'); y = Bioroebe::RawSequence.new('TTTGATCGATGC'); z = x + y
+  #
+  # ========================================================================= #
+  def to_str
+    # self # ← Old code since up to May 2020.
+    @sequence.to_s # ← This became the new default as of May 2020 again.
+  end
+
+  # ========================================================================= #
+  # === set_raw_sequence
+  # ========================================================================= #
+  def set_raw_sequence(i)
+    i = i.flatten.compact.first if i.is_a? Array
+    @sequence = i
+  end; alias assign set_raw_sequence # === assign
+
+  # ========================================================================= #
+  # === chars?
+  #
+  # This method will return the characters of the main sequence, as
+  # an Array.
+  # ========================================================================= #
+  def chars?
+    @sequence.chars
+  end; alias chars chars? # === chars
+
+  # ========================================================================= #
+  # === reverse
+  # ========================================================================= #
+  def reverse
+    @sequence.reverse
+  end
+
+  # ========================================================================= #
+  # === each_char
+  # ========================================================================= #
+  def each_char(&block)
+    @sequence.each_char(&block)
+  end
+
+  # ========================================================================= #
+  # === delete
+  # ========================================================================= #
+  def delete(i)
+    @sequence.delete(i)
+  end
+
+  # ========================================================================= #
+  # === +
+  #
+  # This method can "combine" - aka add - two sequences to one another.
+  # ========================================================================= #
+  def +(i)
+    if i.is_a?(Bioroebe::RawSequence) or
+       i.respond_to?(:sequence?) # This line will match for Bioroebe::Sequence
+      return @sequence+
+             i.sequence?
+    end
+  end
+
+  # ========================================================================= #
+  # === include?
+  #
+  # Check whether our sequence includes some other sequence.
+  # ========================================================================= #
+  def include?(i)
+    @sequence.to_s.include? i.to_s
+  end
+
+  # ========================================================================= #
+  # === start_with?
+  # ========================================================================= #
+  def start_with?(i)
+    to_s.start_with?(i)
+  end
+
+  # ========================================================================= #
+  # === composition
+  #
+  # This method will return a hash displaying the nucleotide or
+  # aminoacid composition of the sequence at hand.
+  #
+  # Usage example:
+  #
+  #   seq = Bioroebe::Sequence.new("ATGC"); seq.composition # => {"A"=>1, "T"=>1, "C"=>1, "G"=>1}
+  #   seq = Bioroebe::Sequence.new("EFGGHHGG"); seq.is_a_protein_now; seq.composition # => {"A"=>1, "T"=>1, "C"=>1, "G"=>1}
+  #
+  # ========================================================================= #
+  def composition?
+    hash = {} # This Hash will be returned for all the three cases defined below.
+    available_keys = @sequence.chars.uniq
+    available_keys.each {|this_key|
+      hash[this_key] = @sequence.count(this_key)
+    }
+    return hash
+  end; alias composition composition? # === composition
+
+  # ========================================================================= #
+  # === reverse!
+  # ========================================================================= #
+  def reverse!
+    @sequence.reverse!
+  end
+
+  # ========================================================================= #
+  # === count
+  # ========================================================================= #
+  def count(this_character)
+    @sequence.count(this_character)
+  end
+
+  # ========================================================================= #
+  # === split
+  # ========================================================================= #
+  def split(i)
+    @sequence.split(i)
+  end
+
+  # ========================================================================= #
+  # === scan
+  # ========================================================================= #
+  def scan(i)
+    @sequence.scan(i)
+  end
+
+  # ========================================================================= #
+  # === empty?
+  #
+  # Determine whether our sequence is empty or not. It is empty if it is
+  # a String of zero length, an "empty" String such as ''.
+  # ========================================================================= #
+  def empty?
+    @sequence.empty?
+  end
+
+  # ========================================================================= #
+  # === complement
+  # ========================================================================= #
+  def complement(
+      i = @sequence
+    )
+    _ = ''.dup
+    i.chars.each {|this_char|
+      case this_char
+      when 'G'
+        _ << 'C'
+      when 'C'
+        _ << 'G'
+      when 'A'
+        _ << 'T'
+      when 'T'
+        _ << 'A'
+      end
+    }
+    _
+  end
+
+  # ========================================================================= #
+  # === first_position=
+  #
+  # Use this method to assign a new sequence at the start. If this is DNA,
+  # then it is a new first nucleotide.
+  # ========================================================================= #
+  def first_position=(i)
+    @sequence = @sequence.dup if @sequence.frozen? # Prevent frozen String error here.
+    @sequence[0,1] = i
+  end; alias first_nucleotide= first_position= # === first_nucleotide=
+
+  # ========================================================================= #
+  # === shuffle
+  # ========================================================================= #
+  def shuffle
+    @sequence = @sequence.chars.shuffle.join
+  end; alias randomize shuffle # === randomize
+
+  # ========================================================================= #
+  # === downcase
+  #
+  # This method will always downcase our given sequence object at hand.
+  #
+  # .lower() has been added in September 2021 for (slight) compatibility
+  # towards biopython.
+  # ========================================================================= #
+  def downcase
+    @sequence.downcase! # Will always modify.
+  end; alias lowercase downcase # === lowercase
+       alias lower     downcase # === lower
+
+  # ========================================================================= #
+  # === to_s
+  #
+  # Query method over the given Sequence that this class stores, as a String.
+  #
+  # This method has several aliases, but it can not be guaranteed that
+  # all aliases will continue to work for the remainder of this project's
+  # lifecycle. For example, the method s? as alias for sequence? may
+  # be removed one day - but until then, it will be remain available.
+  #
+  # Still, it is recommended to use the slightly longer method name
+  # .sequence? or .to_s; the alias s? exists mostly so that we can
+  # be lazy in IRB and elsewhere. So perhaps it will be retained, but
+  # there is no guarantee - for your own scripts you should use either
+  # .to_s or .sequence? really.
+  #
+  # If you wish to test the output of this method, try:
+  #
+  #   require 'bioroebe'; x = Bioroebe::Seq.new('AGTACACTGGT'); puts x
+  #
+  # ========================================================================= #
+  def to_s
+    @sequence.to_s
+  end; alias sequence?                to_s # === sequence
+       alias sequence                 to_s # === sequence
+       alias string?                  to_s # === string?
+       alias seq                      to_s # === seq
+       alias seq?                     to_s # === seq?
+       alias s?                       to_s # === s?
+       alias main_string?             to_s # === main_string?
+       alias main_sequence_as_string? to_s # === main_sequence_as_string?
+
+  # ========================================================================= #
+  # === freeze
+  #
+  # If you wish to free the sequence object and thus disallow further
+  # modifications to it, use this method.
+  # ========================================================================= #
+  def freeze
+    @sequence.freeze
+  end
+
+  # ========================================================================= #
+  # === gsub
+  # ========================================================================= #
+  def gsub(replace_this, with_that)
+    @sequence.gsub(replace_this, with_that)
+  end
+
+  # ========================================================================= #
+  # === strip
+  #
+  # Similar to the method .strip() on class String.
+  # ========================================================================= #
+  def strip
+    @sequence.strip
+  end
+
+  # ========================================================================= #
+  # === size?
+  #
+  # Return the size of the string/sequence in question.
+  # ========================================================================= #
+  def size?
+    @sequence.size
+  end; alias size    size? # === size
+       alias length  size? # === length
+       alias length? size? # === length?
+
+  # ========================================================================= #
+  # === delete!
+  # ========================================================================= #
+  def delete!(i)
+    @sequence.delete!(i)
+  end
+
+  # ========================================================================= #
+  # === prepend
+  #
+  # If you wish to prepend something to your target sequence then this
+  # is the right method to use.
+  # ========================================================================= #
+  def prepend(i)
+    @sequence.prepend(i)
+  end
+
+  # ========================================================================= #
+  # === gsub!
+  # ========================================================================= #
+  def gsub!(replace_this, with_that)
+    @sequence.gsub!(replace_this, with_that)
+  end
+
+  # ========================================================================= #
+  # === upcase!
+  #
+  # This method will upcase the given sequence, so "atg" becomes "ATG".
+  #
+  # Note that .upcase() is an alias to .upcase!() - use whichever variant
+  # you want to, but keep in mind that the receiver will be modified
+  # in both variants.
+  #
+  # .upper() has been added in September 2021 for (slight) compatibility
+  # towards biopython.
+  # ========================================================================= #
+  def upcase!
+    @sequence.upcase!
+    return @sequence
+  end; alias upcase upcase! # === upcase
+       alias up     upcase! # === up
+       alias upper  upcase! # === upper
+
+  # ========================================================================= #
+  # === subseq
+  #
+  # This method will obtain a subsequence of the given sequence object at
+  # hand.
+  #
+  # We start to count at the first nucleotide. The second argument given
+  # to this method will denote the nucleotide position at where we will
+  # STOP. So (3,8) will translate to "take nucleotide 3, up to and
+  # including nucleotide 8, and then return this result".
+  #
+  # See the following examples to understand this more easily.
+  #
+  # Usage examples:
+  #
+  #   seq = Bioroebe::RawSequence.new("ATGCATGCAAAA"); seq.subseq(1, 3) # => "ATG"
+  #   seq = Bioroebe::RawSequence.new("ATGCATGCAAAA"); seq.subseq(3, 8) # => "GCATGC"
+  #   seq = Bioroebe::RawSequence.new("atgcatgcaaaa"); seq.subseq(3, 8) # => "GCATGC"
+  #   seq = Bioroebe::RawSequence.new("ATGCATGCAAAA"); seq.subseq(3, 833333333333) # => "GCATGCAAAA"
+  #   seq = Bioroebe::RawSequence.new("ATGCATGCAAATCCACAA"); seq.start_end(1, 10)  # => "ATGCATGCAA"
+  #
+  # ========================================================================= #
+  def subseq(
+      start_position,
+      end_position = :ask_the_user_for_an_end_position_number
+    )
+    if end_position == :ask_the_user_for_an_end_position_number
+      puts 'Please provide a valid end position (an Integer value).'
+    else
+      start_position -= 1
+      end_position -= start_position
+      sequence?[start_position, end_position]
+    end
+  end; alias []          subseq # === []
+       alias subsequence subseq # === subsequence
+       alias start_end   subseq # === start_end
+
+  # ========================================================================= #
+  # === remove_n_characters_from_the_left_side
+  #
+  # This method will remove n characters from the left side (aka 5').
+  #
+  # It can be applied to DNA, RNA and an aminoacid sequence, so it can
+  # be retained on the main Sequence class definition as-is.
+  # ========================================================================= #
+  def remove_n_characters_from_the_left_side(n_characters)
+    @sequence[0, n_characters] = ''
+  end
+
+  # ========================================================================= #
+  # === tr!
+  # ========================================================================= #
+  def tr!(a, b)
+    @sequence.tr!(a, b)
+  end
+
+  # ========================================================================= #
+  # === insert_at_this_position
+  #
+  # This method can be specifically used to insert content into a
+  # sequence object. For example, a His6-tag sequence into a DNA
+  # sequence object.
+  #
+  # The second argument is the new (DNA, RNA or Aminoacid) sequence
+  # that you wish to add. You can also use '|' tokens there if you
+  # like to - they will be removed.
+  # ========================================================================= #
+  def insert_at_this_position(
+      position, insert_this_new_content
+    )
+    if insert_this_new_content.include? '|'
+      insert_this_new_content.delete!('|')
+    end
+    @sequence[position, 0] = insert_this_new_content
+  end
+
+  # ========================================================================= #
+  # === <<
+  #
+  # The method called << is an "input method", that is, it will simply
+  # append onto the main sequence (stored as @sequence).
+  #
+  # In simpler words: the @sequence stores the DNA or RNA or aminoacid
+  # sequence.
+  #
+  # If a Sequence object is passed (Bioroebe::Sequence) then this method
+  # will tap into the main sequence (the main String) that it stores,
+  # through the .sequence? method, before continuing.
+  # ========================================================================= #
+  def <<(i)
+    if i.is_a?(::Bioroebe::Sequence) or i.is_a?(::Bioroebe::Sequence)
+      i = i.sequence?
+    elsif i.is_a? Symbol
+      case i
+      # ===================================================================== #
+      # === :stop
+      # ===================================================================== #
+      when :stop
+        if Bioroebe.stop_codons.empty?
+          Bioroebe.initialize_default_stop_codons
+        end
+        i = ::Bioroebe.stop_codons?.sample
+      end
+    end
+    @sequence << i
+    self # Returning self here since that will allow method-chaining.
+  end; alias add    << # === add
+       alias append << # === append
+       alias concat << # === concat
+       # alias +    << # === + # ← This one conflicts with another method defined below.
+
+  # ========================================================================= #
+  # === []=
+  #
+  # Note that we will start to count at 1 here, since we also start
+  # at the first nucleotide position in a given DNA/RNA strand.
+  #
+  # We will, however had, NOT do so when a negative number is
+  # passed to this method.
+  # ========================================================================= #
+  def []=(
+      start_position,
+      end_position,
+      new_content = ''
+    )
+    start_position = start_position.to_i
+    end_position   = end_position.to_i
+    unless start_position < 0
+      start_position -= 1 unless start_position < 1
+      end_position   -= 1 unless end_position   < 1
+    end
+    @sequence[start_position, end_position] = new_content
+  end
+
+  # ========================================================================= #
+  # === calculate_levensthein_distance
+  # ========================================================================= #
+  def calculate_levensthein_distance(a, b = sequence?)
+    require 'bioroebe/calculate/calculate_levensthein_distance.rb'
+    ::Bioroebe.calculate_levensthein_distance(a,b)
+  end
+
+  # ========================================================================= #
+  # === reverse_complement
+  #
+  # Complement to the other strand via this method here, which is actually
+  # called "reverse complement".
+  #
+  # The complement thus refers to the "complementary DNA strand", towards
+  # a 5'-NUCLEOTIDE-3' sequence.
+  #
+  # Usage example:
+  #
+  #   x = Bioroebe::Sequence.new('ATTGCCACAACTGAGACA'); x.complement # => "TGTCTCAGTTGTGGCAAT"
+  #
+  # ========================================================================= #
+  def reverse_complement(i = sequence?)
+    require 'bioroebe/toplevel_methods/nucleotides.rb'
+    return ::Bioroebe.complementary_dna_strand(i).reverse
+  end
+
+  # ========================================================================= #
+  # === find_substring_indices
+  #
+  # This method taps into the method called Bioroebe.find_substring().
+  #
+  # It will return an Array of all substring indices (if we have found
+  # any, that is) - otherwise it will return nil.
+  # ========================================================================= #
+  def find_substring_indices(this_substring)
+    require 'bioroebe/toplevel_methods/searching_and_finding.rb'
+    return ::Bioroebe.find_substring_indices(string?, this_substring)
+  end; alias find_this_subsequence find_substring_indices # === find_this_subsequence
+
+end; end
+
+if __FILE__ == $PROGRAM_NAME
+  # ========================================================================= #
+  # Next comes some testing code.
+  # ========================================================================= #
+  require 'cliner/autoinclude'
+  alias e puts
+  cliner
+  x = Bioroebe::RawSequence.new('ATGGATCGATGC')
+  y = Bioroebe::RawSequence.new('TTTGATCGATGC')
+  z = x + y
+  puts z+' ('+z.size.to_s+' nucleotides)'
+  cliner
+  raw_sequence = Bioroebe::RawSequence.new(ARGV)
+  e raw_sequence.to_s
+  e raw_sequence.to_str
+  e raw_sequence
+  pp raw_sequence.composition?
+  raw_sequence.first_position = 'T'
+  pp raw_sequence.composition?
+  puts raw_sequence.start_end(1, 3)
+end # rawsequence ATGC

data/lib/bioroebe/readline/README.md

@@ -0,0 +1,2 @@
+This directory contains code for GNU readline support, which
+is in particular useful for the bioroebe-shell interface.

data/lib/bioroebe/readline/readline.rb

@@ -0,0 +1,31 @@
+#!/usr/bin/ruby -w
+# Encoding: UTF-8
+# frozen_string_literal: true
+# =========================================================================== #
+# require 'bioroebe/readline/readline.rb'
+# =========================================================================== #
+module Bioroebe
+
+  # ========================================================================= #
+  # === Try to enable readline support
+  #
+  # We will try to load up readline support, if possible.
+  # ========================================================================= #
+  begin
+    require 'readline'
+    @readline_is_available = true # This is the default, if the user has Readline available.
+  rescue LoadError
+    @readline_is_available = false
+  end
+
+  # ========================================================================= #
+  # === Bioroebe.readline_is_available?
+  #
+  # Check whether readline is available.
+  # ========================================================================= #
+  def self.readline_is_available?
+    @readline_is_available
+  end; self.instance_eval { alias use_readline? readline_is_available? } # === Bioroebe.use_readline?
+       self.instance_eval { alias has_readline? readline_is_available? } # === Bioroebe.has_readline?
+
+end

data/lib/bioroebe/regexes/README.md

@@ -0,0 +1,2 @@
+This directory can store regexes that can be re-used for the
+Bioroebe project.

data/lib/bioroebe/regexes/regexes.rb

@@ -0,0 +1,34 @@
+#!/usr/bin/ruby -w
+# Encoding: UTF-8
+# frozen_string_literal: true
+# =========================================================================== #
+# require 'bioroebe/regexes/regexes.rb'
+# =========================================================================== #
+module Bioroebe
+
+  require 'bioroebe/codons/start_codons.rb'
+
+  # ========================================================================= #
+  # === Bioroebe.regex_with_startcodons
+  #
+  # This toplevel-method will return the regex for a start codon.
+  #
+  # Usually this means that we will return /ATG|AUG/ so we also
+  # match towards the mRNA variant. It was created precisely
+  # because the user may often wish to identify any start codon,
+  # no matter if it is kept in RNA or in DNA.
+  # ========================================================================= #
+  def self.regex_with_startcodons(
+      use_this_start_codon = ::Bioroebe.start_codon?
+    )
+    start_codon_as_mRNA = use_this_start_codon.
+                          tr('T','U') 
+    regex = /(#{use_this_start_codon}|#{start_codon_as_mRNA})/i
+    return regex # Return the regex here.
+  end
+
+end
+
+if __FILE__ == $PROGRAM_NAME
+  p Bioroebe.regex_with_startcodons
+end # regexwithstartcodons

data/lib/bioroebe/requires/commandline_application.rb

@@ -0,0 +1,5 @@
+#!/usr/bin/ruby -w
+# Encoding: UTF-8
+# frozen_string_literal: true
+# =========================================================================== #
+require 'bioroebe/base/commandline_application/commandline_application.rb'

data/lib/bioroebe/requires/require_all_aminoacids_files.rb

@@ -0,0 +1,28 @@
+#!/usr/bin/ruby -w
+# Encoding: UTF-8
+# frozen_string_literal: true
+# =========================================================================== #
+# require 'bioroebe/requires/require_all_aminoacids_files.rb'
+# =========================================================================== #
+module Bioroebe
+
+  require 'bioroebe/project/project.rb'
+
+  # ========================================================================= #
+  # === Bioroebe.require_all_aminoacids_files
+  #
+  # Use this to require all aminoacids.
+  # ========================================================================= #
+  def self.require_all_aminoacids_files(
+      from_this_dir = AMINOACIDS_DIRECTORY
+    )
+    _ = Dir["#{from_this_dir}*.rb"]
+    _.each {|file|
+      file = "bioroebe/aminoacids/#{File.basename(file)}"
+      require file
+    }
+  end
+
+  require_all_aminoacids_files # Call it at once.
+
+end

data/lib/bioroebe/requires/require_all_calculate_files.rb

@@ -0,0 +1,26 @@
+#!/usr/bin/ruby -w
+# Encoding: UTF-8
+# frozen_string_literal: true
+# =========================================================================== #
+# require 'bioroebe/requires/require_all_calculate_files.rb'
+# =========================================================================== #
+module Bioroebe
+
+  require 'bioroebe/project/project.rb'
+
+  # ========================================================================= #
+  # === Bioroebe.require_all_calculate_files
+  #
+  # Use this to require all files in the calculate/ directory.
+  # ========================================================================= #
+  def self.require_all_calculate_files
+    _ = Dir["#{CALCULATE_DIRECTORY}*.rb"]
+    _.each {|file|
+      file = "bioroebe/calculate/#{File.basename(file)}"
+      require file
+    }
+  end
+
+  require_all_calculate_files # Call it at once.
+
+end