bioroebe 0.10.80 → 0.12.24

data/lib/bioroebe/toplevel_methods/misc.rb

@@ -16,19 +16,90 @@ module Bioroebe
   require 'bioroebe/toplevel_methods/extract.rb'
 
   # ========================================================================= #
-  # === Bioroebe.thousand_percentage
+  # === Bioroebe.percentage_count_non_DNA_bases_in_this_sequence
+  #
+  # Usage examples:
+  #
+  #   Bioroebe.percentage_count_non_DNA_bases_in_this_sequence('ATCGF')
+  #   Bioroebe.percentage_count_non_DNA_bases_in_this_sequence('ACTNGTGCTYGATRGTAGC', %w( A T G C Y R ))
   #
-  # This method is solely a helper-method for Bioroebe.frequency_per_thousand().
   # ========================================================================= #
-  def self.thousand_percentage(
-      this_codon_n_times =   1,
-      total_n_elements  = 1000
+  def self.percentage_count_non_DNA_bases_in_this_sequence(
+      i, array = Bioroebe.return_DNA_nucleotides
     )
-    result = (
-      (this_codon_n_times * 1000.0) / total_n_elements.to_f
-    ).round(1)
-    padded_result = result.to_s.rjust(5, ' ')
-    return padded_result
+    n = count_non_DNA_bases_in_this_sequence(i, array)
+    percentage = (n * 100.0 / i.size.to_f)
+    return percentage
+  end
+
+  # ========================================================================= #
+  # === Bioroebe.count_non_DNA_bases_in_this_sequence
+  #
+  # Usage example:
+  #
+  #   Bioroebe.count_non_DNA_bases_in_this_sequence('ATCGF')
+  #
+  # ========================================================================= #
+  def self.count_non_DNA_bases_in_this_sequence(
+      i, array = Bioroebe.return_DNA_nucleotides
+    )
+    i = i.dup
+    array.each {|this_nucleotide|
+      i.delete!(this_nucleotide)
+    }
+    return i.size
+  end
+
+  # ========================================================================= #
+  # === Bioroebe.sequence_based_on_these_restriction_enzymes
+  #
+  # Usage example:
+  #
+  #   x = Bioroebe.sequence_based_on_these_restriction_enzymes(%w( EcoRI SacI KpnI XmaI BamHI XbaI SalI )); 'GAATTCGAGCTCGGTACCCCCGGGGGATCCTCTAGAGTCGAC'
+  #
+  # ========================================================================= #
+  def self.sequence_based_on_these_restriction_enzymes(*i)
+    require 'bioroebe/enzymes/restriction_enzyme.rb'
+    _ = ''.dup
+    i.flatten.each {|this_restriction_enzyme|
+      _ << ::Bioroebe.restriction_sites?(this_restriction_enzyme)
+    }
+    return _
+  end
+
+  # ========================================================================= #
+  # === Bioroebe.create_jar_archive
+  #
+  # This method will create a .jar file.
+  #
+  # To invoke it from the commandline do:
+  #
+  #   bioroebe --jar
+  #
+  # To execute a .jar file do:
+  #
+  #   java -jar foobar.jar
+  #
+  # ========================================================================= #
+  def self.create_jar_archive
+    e 'Creating a .jar archive next:'
+    e
+    original_dir = return_pwd
+    cd '/home/x/programming/ruby/src/bioroebe/lib/bioroebe/java/bioroebe/src/main/java/'
+    esystem 'jar cf bioroebe.jar bioroebe/'
+    target_file = File.absolute_path('bioroebe.jar')
+    cd original_dir
+    if File.exist? target_file
+      e 'Moving the created .jar file into the current working '\
+        'directory next.'
+      move_file(target_file, original_dir)
+      e 'It should now be at:'
+      e
+      e sfile("  #{original_dir}#{File.basename(target_file)}")
+      e
+    end
+#   esystem 'jar cfe bioroebe.jar myClass myClass.class'
+    e
   end
 
   # ========================================================================= #
@@ -86,6 +157,7 @@ EOF
   # Usage example:
   #
   #   Bioroebe.codon_frequency_of_this_string
+  #   Bioroebe.codon_frequency_of_this_string 'ATTCGTACGATCGACTACTACT' # => {"UAC"=>2, "GAC"=>1, "AUC"=>1, "ACG"=>1, "CGU"=>1, "AUU"=>1}
   #
   # ========================================================================= #
   def self.codon_frequency_of_this_string(
@@ -107,6 +179,22 @@ EOF
     return sorted_hash
   end
 
+  # ========================================================================= #
+  # === Bioroebe.thousand_percentage
+  #
+  # This method is solely a helper-method for Bioroebe.frequency_per_thousand().
+  # ========================================================================= #
+  def self.thousand_percentage(
+      this_codon_n_times =   1,
+      total_n_elements  = 1000
+    )
+    result = (
+      (this_codon_n_times * 1000.0) / total_n_elements.to_f
+    ).round(1)
+    padded_result = result.to_s.rjust(5, ' ')
+    return padded_result
+  end
+
   # ========================================================================= #
   # === Bioroebe.align_this_string_via_multiple_sequence_alignment
   #
@@ -314,7 +402,13 @@ EOF
   # ========================================================================= #
   # === Bioroebe.bisulfite_treatment
   #
-  # Simply convert all C into U.
+  # Simply convert all C into U. The underlying idea here is that
+  # bilsufite will convert unmethylated Cytosines into Uracil.
+  #
+  # Usage example:
+  #
+  #   Bioroebe.bisulfite_treatment('CCCGCAATGCATACCTCGCCG') # => "UUUGUAATGUATAUUTUGUUG"
+  #
   # ========================================================================= #
   def self.bisulfite_treatment(i)
     if i.is_a? Array
@@ -420,6 +514,76 @@ EOF
   end; self.instance_eval { alias on_windows?    windows_platform? } # === Bioroebe.on_windows?
        self.instance_eval { alias is_on_windows? windows_platform? } # === Bioroebe.is_on_windows?
 
+  # ========================================================================= #
+  # === Bioroebe.two_dimensional_plot
+  #
+  # This method makes use of gnuplot to draw a 2D plot.
+  #
+  # The first argument should contain your dataset, as a String.
+  # ========================================================================= #
+  def self.two_dimensional_plot(
+      dataset =  '6 12
+8 14
+10 18
+12 23
+14 28
+16 29
+18 26
+20 23
+22 20',
+      optional_hash = {
+        width:    800,
+        height:   640
+      }
+    )
+    # ======================================================================= #
+    # Provide some generic fall-back values for width and height next:
+    # ======================================================================= #
+    width  = 1000
+    height =  800
+    _ = optional_hash
+    if _.is_a? Hash
+      # ===================================================================== #
+      # === :width
+      # ===================================================================== #
+      if _.has_key? :width
+        width = _.delete(:width)
+      end
+      # ===================================================================== #
+      # === :height
+      # ===================================================================== #
+      if _.has_key? :height
+        height = _.delete(:height)
+      end
+    end
+    # ======================================================================= #
+    # Go to a safe base directory.
+    # ======================================================================= #
+    cd :bioroebe_log_directory
+    mkdir 'gnuplot' unless File.directory?('gnuplot')
+    cd 'gnuplot'
+    # ======================================================================= #
+    # First save the dataset into dataset.md:
+    # ======================================================================= #
+    into = File.absolute_path('dataset.md')
+    e 'Storing the dataset into '+sfile(into)+' next.'
+    write_what_into(dataset, into)
+    what = <<-EOF
+
+set terminal png size #{width},#{height} enhanced font "Helvetica, 18"
+set output 'fancy_graph.png'
+plot '#{into}' with linespoints ls 1 notitle
+
+EOF
+    into = File.absolute_path('gnuplot.file')
+    e 'Storing into '+into+'.'
+    write_what_into(what, into)
+    esystem 'gnuplot '+into
+    if File.exist? 'fancy_graph.png' and is_on_roebe?
+      Open.in_browser('fancy_graph.png')
+    end
+  end
+
 end
 
 if __FILE__ == $PROGRAM_NAME

data/lib/bioroebe/toplevel_methods/nucleotides.rb

@@ -19,6 +19,102 @@ module Bioroebe
   require 'bioroebe/constants/nucleotides.rb'
   require 'bioroebe/toplevel_methods/e.rb'
 
+  # ========================================================================= #
+  # === Bioroebe.can_base_pair_with?
+  #
+  # Usage example:
+  #
+  #   Bioroebe.can_base_pair_with?('A','T') # => true
+  #   Bioroebe.can_base_pair_with?('A','G') # => false
+  #
+  # ========================================================================= #
+  def self.can_base_pair_with?(a, b)
+    ::Bioroebe.partner_nucleotide(a) == b
+  end
+
+  # ========================================================================= #
+  # === Bioroebe.partner_nucleotide
+  #
+  # This small "table" will simply return the corresponding Nucleotide
+  # matching the given input at hand - in other words, the corresponding
+  # DNA nucleotide that can base-pair with the input nucleotide.
+  #
+  # Since this is a method call this may be a bit slow if you have to
+  # invoke the method repeatedly. In this case, you should consider
+  # using the method befined below, through the method
+  # Bioroebe.partner_nucleotide_hash(), and then use that Hash instead.
+  #
+  # Usage example:
+  #
+  #   Bioroebe.partner_nucleotide('A') # => "T"
+  #   Bioroebe.should_match_to?('T') # => "A"
+  #
+  # ========================================================================= #
+  def self.partner_nucleotide(i)
+    i = i.first if i.is_a? Array # We only handle the first entry in an Array.
+    if i
+      i = i.dup if i.frozen?
+      i.upcase! # just in caase.
+      case i # case tag.
+      when 'A'
+        return 'T'
+      when 'T','U'
+        return 'A'
+      when 'G'
+        return 'C'
+      when 'C'
+        return 'G'
+      else
+        return nil # means illegal value.
+      end
+    end
+    return i # Return just in case.
+  end; self.instance_eval { alias complementary_nucleotide partner_nucleotide } # === Bioroebe.complementary_nucleotide
+       self.instance_eval { alias return_dna_match         partner_nucleotide } # === Bioroebe.return_dna_match
+       self.instance_eval { alias should_match_to?         partner_nucleotide } # === Bioroebe.should_match_to?
+
+  # ========================================================================= #
+  # === Bioroebe.contains_an_inverted_repeat?
+  #
+  # We assume an inverted repeat to exist if at the least 2 nucleotides
+  # match to one another in the reverse, so a total of 4 matching
+  # nucleotides. This assumption may not necessarily be correct and
+  # we may have to fine-tune this at a later time.
+  #
+  # For testing purpose, the sequence 'TTACGAAAAAACGTAA' can be used. 
+  # ========================================================================= #
+  def self.contains_an_inverted_repeat?(
+      #i = 'AGCCCCGCAAAAAAGGCGGGCU'
+      i = 'TTACGAAAAAACGTAA' # This is in the 5'→3' direction.
+    )
+    contains_an_inverted_repeat = false
+    longest_stretch = 0
+    current_stretch = 0
+    halfed_position = i.size / 2
+    both_sides = [
+      i[0 .. (halfed_position-1)],
+      i[halfed_position .. -1]
+    ]
+    # ======================================================================= #
+    # Now that we have both sides, we will try to match them. First reverse
+    # the second, though.
+    # ======================================================================= #
+    first  = both_sides[0]
+    second = both_sides[1].reverse # Work via the reverse sequence.
+    first.chars.each_with_index {|this_nucleotide, index|
+      if can_base_pair_with?(second[index], this_nucleotide)
+        current_stretch += 1
+        longest_stretch = current_stretch if current_stretch > longest_stretch 
+      else
+        current_stretch = 0
+      end
+    }
+    if longest_stretch >= 2
+      contains_an_inverted_repeat = true
+    end
+    return contains_an_inverted_repeat
+  end
+
   # ========================================================================= #
   # === Bioroebe.complementary_rna_strand
   #
@@ -147,47 +243,6 @@ module Bioroebe
     return _.flatten.uniq.sort
   end
 
-  # ========================================================================= #
-  # === Bioroebe.partner_nucleotide
-  #
-  # This small "table" will simply return the corresponding Nucleotide
-  # matching the given input at hand - in other words, the corresponding
-  # DNA nucleotide that can base-pair with the input nucleotide.
-  #
-  # Since this is a method call this may be a bit slow if you have to
-  # invoke the method repeatedly. In this case, you should consider
-  # using the method befined below, through the method
-  # Bioroebe.partner_nucleotide_hash(), and then use that Hash instead.
-  #
-  # Usage example:
-  #
-  #   Bioroebe.partner_nucleotide('A') # => "T"
-  #   Bioroebe.should_match_to?('T') # => "A"
-  #
-  # ========================================================================= #
-  def self.partner_nucleotide(i)
-    i = i.first if i.is_a? Array # We only handle the first entry in an Array.
-    if i
-      i = i.dup if i.frozen?
-      i.upcase! # just in caase.
-      case i # case tag.
-      when 'A'
-        return 'T'
-      when 'T','U'
-        return 'A'
-      when 'G'
-        return 'C'
-      when 'C'
-        return 'G'
-      else
-        return nil # means illegal value.
-      end
-    end
-    return i # Return just in case.
-  end; self.instance_eval { alias complementary_nucleotide partner_nucleotide } # === Bioroebe.complementary_nucleotide
-       self.instance_eval { alias return_dna_match         partner_nucleotide } # === Bioroebe.return_dna_match
-       self.instance_eval { alias should_match_to?         partner_nucleotide } # === Bioroebe.should_match_to?
-
   # ========================================================================= #
   # === Bioroebe.return_all_positions_of_this_nucleotide
   #
@@ -270,12 +325,19 @@ module Bioroebe
   #   Bioroebe.random_dna 15 # => "TTGGTAAGCTCTTTA"
   #   Bioroebe.random_dna 25 # => "TTAGCACAAGCATGGACGGACCAGA"
   #   Bioroebe.random_dna(50, { A: 10, T: 10, C: 10, G: 70}) # => "GGGGTGGGGAGGGTATGCGGAGGAAGGGCGGGAAGGGCGGGGGCTGGGCG"
+  #   Bioroebe.random_dna(20, 'ATGGGGGGGG') # => "TGAGGGGGGGGGTGGGAGGG"
+  #   Bioroebe.random_dna(20, 'ATGGGGGGGG') # => "GGTAGGGGGGGGTAGGGGGG"
   #
   # ========================================================================= #
   def self.generate_random_dna_sequence(
-      i = ARGV,
-      optional_hash_with_the_frequencies = {}
+      i                                  = ARGV,
+      optional_hash_with_the_frequencies = {} # ← This may be a String too, mind you.
     )
+    # ======================================================================= #
+    # First define our result-String. This one will be returned by this
+    # method.
+    # ======================================================================= #
+    result = ''.dup
     _ = Bioroebe::DNA_NUCLEOTIDES # Get a handle to the four DNA nucleotides.
     if i.is_a? Array
       i = i.join.strip
@@ -284,9 +346,19 @@ module Bioroebe
     when :default
       i = 250
     end
-    i = i.to_i
-    result = ''.dup
-    if optional_hash_with_the_frequencies.empty?
+    i = i.to_i # This is "n times".
+    # ======================================================================= #
+    # First handle the case where the user passed a String:
+    # ======================================================================= #
+    if optional_hash_with_the_frequencies.is_a? String
+      pool = optional_hash_with_the_frequencies.dup.chars.shuffle
+      i.times {
+        if pool.size == 0
+          pool = optional_hash_with_the_frequencies.dup.chars.shuffle
+        end
+        result << pool.pop
+      }
+    elsif optional_hash_with_the_frequencies.empty?
       # ===================================================================== #
       # This is the default clause.
       # ===================================================================== #

data/lib/bioroebe/toplevel_methods/open_in_browser.rb

@@ -18,6 +18,8 @@ module Bioroebe
   # This constant specifies the default browser to use for the
   # bioroebe-project.
   # ========================================================================= #
+  # /home/x/programming/ruby/src/bioroebe/lib/bioroebe/yaml/configuration/browser.yml
+  # ========================================================================= #
   if File.exist? "#{project_yaml_directory?}browser.yml"
     USE_THIS_BROWSER = YAML.load_file(FILE_BROWSER)
   elsif ENV['BROWSER']

data/lib/bioroebe/toplevel_methods/palindromes.rb

@@ -3,12 +3,86 @@
 # frozen_string_literal: true
 # =========================================================================== #
 # require 'bioroebe/toplevel_methods/palindromes.rb'
+# Bioroebe.plain_palindrome(ARGV)
 # puts Bioroebe.is_palindrome? ARGV
 # =========================================================================== #
 module Bioroebe
 
   require 'bioroebe/toplevel_methods/e.rb'
 
+  # ========================================================================= #
+  # === Bioroebe.plain_palindrome
+  #
+  # This method is simply than Bioroebe.is_palindrome?. It will simply
+  # check for the current sequence.
+  #
+  # Usage example:
+  #
+  #   Bioroebe.plain_palindrome('OTTO') # => true
+  #   Bioroebe.plain_palindrome('Saippuakivikauppias') # => true
+  #
+  # ========================================================================= #
+  def self.plain_palindrome(i)
+    if i.is_a? Array
+      i = i.join(' ').strip
+    end
+    i = i.dup.downcase
+    if i.size.even?
+      first_half  = i[0 .. (i.size / 2 - 1)]
+      second_half = i[(i.size / 2) .. -1]
+      return (first_half == second_half.reverse)
+    else # This is for odd numbers.
+      first_half  = i[0 .. (i.size / 2 - 1)]
+      second_half = i[(i.size / 2 + 1) .. -1]
+      return (first_half == second_half.reverse)
+    end
+  end
+
+  # ========================================================================= #
+  # === Bioroebe.is_palindrome?
+  #
+  # This method will return true if the target sequence is a palindrome,
+  # and false otherwise.
+  #
+  # When will a sequence be considered to be a "palindrome"?
+  #
+  # Firstly, it must have an even number of components. If it has an odd
+  # number then it can never be a Palindrome, by definition alone.
+  #
+  # So, "GATC" is a palindrome, but "GATCC" can never be. (GATC is a 
+  # palindrome because the reverse of GATC will bind to itself again.)
+  #
+  # Usage examples:
+  #
+  #   Bioroebe.is_palindrome? 'GAATTC'   # => true
+  #   Bioroebe.is_palindrome? 'GAATTCCC' # => false
+  #
+  # ========================================================================= #
+  def self.is_palindrome?(i)
+    require 'bioroebe/toplevel_methods/nucleotides.rb'
+    if i.is_a? Array
+      i = i.first
+    end
+    hash = ::Bioroebe.partner_nucleotide_hash
+    return_value = false
+    if i
+      if i.to_s.size.odd? # Then it can never be a Palindrome.
+      else # Ok, it may be a palindrome here.
+        first_half = i[0 .. (i.size / 2)-1]
+        _ = ''.dup
+        first_half.chars.reverse.each {|char|
+          _ << hash[char] if hash.has_key? char
+        }
+        if (first_half + _) == i # Compare it to the original input.
+          return_value = true
+        end
+      end
+      return return_value
+    else
+      :invalid_input
+    end
+  end; self.instance_eval { alias is_this_sequence_a_palindrome? is_palindrome? } # === Bioroebe.is_this_sequence_a_palindrome?
+
   # ========================================================================= #
   # === Bioroebe.return_every_substring_from_this_sequence
   # ========================================================================= #
@@ -67,56 +141,10 @@ module Bioroebe
     return array_containing_starting_index_and_length_of_reverse_palindromes
   end
 
-  # ========================================================================= #
-  # === Bioroebe.is_palindrome?
-  #
-  # This method will return true if the target sequence is a palindrome,
-  # and false otherwise.
-  #
-  # When will a sequence be considered to be a "palindrome"?
-  #
-  # Firstly, it must have an even number of components. If it has an odd
-  # number then it can never be a Palindrome, by definition alone.
-  #
-  # So, "GATC" is a palindrome, but "GATCC" can never be. (GATC is a 
-  # palindrome because the reverse of GATC will bind to itself again.)
-  #
-  # Usage examples:
-  #
-  #   Bioroebe.is_palindrome? 'GAATTC'   # => true
-  #   Bioroebe.is_palindrome? 'GAATTCCC' # => false
-  #
-  # ========================================================================= #
-  def self.is_palindrome?(i)
-    require 'bioroebe/toplevel_methods/nucleotides.rb'
-    if i.is_a? Array
-      i = i.first
-    end
-    hash = ::Bioroebe.partner_nucleotide_hash
-    return_value = false
-    if i
-      if i.to_s.size.odd? # Then it can never be a Palindrome.
-      else # Ok, it may be a palindrome here.
-        first_half = i[0 .. (i.size / 2)-1]
-        _ = ''.dup
-        first_half.chars.reverse.each {|char|
-          _ << hash[char] if hash.has_key? char
-        }
-        if (first_half + _) == i # Compare it to the original input.
-          return_value = true
-        end
-      end
-      return return_value
-    else
-      :invalid_input
-    end
-  end; self.instance_eval { alias is_this_sequence_a_palindrome? is_palindrome? } # === Bioroebe.is_this_sequence_a_palindrome?
-
 end
 
 if __FILE__ == $PROGRAM_NAME
-pp Bioroebe.every_reverse_palindrome_in_this_string(ARGV)
-exit
+  pp Bioroebe.every_reverse_palindrome_in_this_string(ARGV)
   if ARGV.empty?
     p 'GAATTC: '+Bioroebe.is_palindrome?('GAATTC').to_s   # => true
     p 'GAATTCCC: '+Bioroebe.is_palindrome?('GAATTCCC').to_s # => false

data/lib/bioroebe/toplevel_methods/taxonomy.rb

@@ -131,7 +131,7 @@ module Taxonomy # === Bioroebe::Taxonomy
     else # Safeguard here.
       if at_home?
         if be_verbose
-          this_dir = '/home/Temp/' # Hardcoded.
+          this_dir = temp_dir?
           e "The directory at #{sdir(this_dir)} does not "\
             "exist, thus trying to"
           e 'use '+sdir(this_dir)+' instead.'
@@ -141,8 +141,8 @@ module Taxonomy # === Bioroebe::Taxonomy
       end
     end
     if be_verbose
-      e 'Now trying to change to the base directory at '+
-        ::Bioroebe.sdir(this_dir)+'.'
+      e "Now trying to change to the base directory at "\
+        "#{::Bioroebe.sdir(this_dir)}."
     end
     cd this_dir
     e N+'We will next attempt to download the file `'+

data/lib/bioroebe/toplevel_methods/to_camelcase.rb

@@ -11,6 +11,11 @@ module Bioroebe
   # === Bioroebe.to_camelcase
   #
   # Convert the given String (the input) into a camelcased variant.
+  #
+  # Usage example:
+  #
+  #   Bioroebe.to_camelcase('foo_bar') # => "FooBar"
+  #
   # ========================================================================= #
   def self.to_camelcase(i)
     if i.is_a? Array

data/lib/bioroebe/utility_scripts/align_open_reading_frames.rb

@@ -35,11 +35,6 @@ class AlignOpenReadingFrames < ::Bioroebe::CommandlineApplication # === Bioroebe
   require 'bioroebe/regexes/regexes.rb'
   require 'bioroebe/codons/codons.rb'
 
-  # ========================================================================= #
-  # === NAMESPACE
-  # ========================================================================= #
-  NAMESPACE = inspect
-
   # ========================================================================= #
   # === START_CODON
   # ========================================================================= #
@@ -67,10 +62,7 @@ class AlignOpenReadingFrames < ::Bioroebe::CommandlineApplication # === Bioroebe
   # ========================================================================= #
   def reset
     super()
-    # ======================================================================= #
-    # === @namespace
-    # ======================================================================= #
-    @namespace = NAMESPACE
+    infer_the_namespace
   end
 
   # ========================================================================= #

data/lib/bioroebe/utility_scripts/check_for_mismatches/check_for_mismatches.rb

@@ -19,11 +19,6 @@ module Bioroebe
 
 class CheckForMismatches < ::Bioroebe::CommandlineApplication # === Bioroebe::CheckForMismatches
 
-  # ========================================================================= #
-  # === NAMESPACE
-  # ========================================================================= #
-  NAMESPACE = inspect
-
   # ========================================================================= #
   # === COLOUR_TO_BE_USED_FOR_A_MISMATCH
   #
@@ -49,10 +44,7 @@ class CheckForMismatches < ::Bioroebe::CommandlineApplication # === Bioroebe::Ch
   # ========================================================================= #
   def reset
     super()
-    # ======================================================================= #
-    # === @namespace
-    # ======================================================================= #
-    @namespace         = NAMESPACE
+    infer_the_namespace
     # ======================================================================= #
     # === @first_sequence
     # ======================================================================= #