bioroebe 0.10.80

data/lib/bioroebe/shell/startup.rb

@@ -0,0 +1,127 @@
+#!/usr/bin/ruby -w
+# Encoding: UTF-8
+# frozen_string_literal: true
+# =========================================================================== #
+# require 'bioroebe/shell/startup.rb'
+# =========================================================================== #
+module Bioroebe
+
+class Shell < ::Bioroebe::CommandlineApplication
+
+  # ========================================================================= #
+  # === ensure_that_the_bioshell_log_directory_exists
+  # ========================================================================= #
+  def ensure_that_the_bioshell_log_directory_exists
+    # ======================================================================= #
+    # We must check whether we really wish to create directories on startup
+    # or not.
+    # ======================================================================= #
+    if @internal_hash and
+       @internal_hash.has_key?(:create_directories_on_startup_of_the_shell) and
+       @internal_hash[:create_directories_on_startup_of_the_shell]
+      _ = bioshell_log_dir?
+      unless File.directory? _
+        unless @internal_hash[:silent_startup]
+          erev "Next creating the directory #{sdir(_)}#{rev}."
+        end
+        mkdir(_)
+      end
+      # ===================================================================== #
+      # Determine the path of the .yml file.
+      # ===================================================================== #
+      yaml_file = ::Bioroebe.project_yaml_directory?+
+                  'create_these_directories_on_startup/'\
+                  'create_these_directories_on_startup.yml'
+      if File.exist? yaml_file
+        YAML.load_file(yaml_file).each {|entry|
+          # ================================================================= #
+          # Create all specified subdirectories next.
+          # ================================================================= #
+          _ = "#{log_dir?}#{entry}/"
+          unless File.directory? _
+            unless @internal_hash[:silent_startup]
+              erev "Next creating the directory #{sdir(rds(_))}#{rev}."
+            end
+            mkdir(_)
+          end
+        }
+      end
+    end
+  end
+
+  # ========================================================================= #
+  # === perform_startup_actions                                 (startup tag)
+  #
+  # Currently, the only startup-action we perform is to add
+  # to the statistics.yml file.
+  #
+  # We must check whether we have proper permissions though.
+  # ========================================================================= #
+  def perform_startup_actions
+    # ======================================================================= #
+    # Initialize the default stop codons, if they are empty.
+    # ======================================================================= #
+    if ::Bioroebe.stop_codons?.empty?
+      ::Bioroebe.initialize_default_stop_codons
+    end
+    _ = Bioroebe.file_statistics? # Assign a shorter handle to it.
+    _ = bioshell_log_dir?+File.basename(_)
+    # ======================================================================= #
+    # We must check here if we can write into the base directory.
+    # ======================================================================= #
+    base_directory = File.dirname(_)
+    if File.writable?(base_directory)
+      if File.exist? _ # If it exists, add one to it.
+        what = YAML.load_file(_)
+        what[:n_times] = what[:n_times]+1
+        write_what_into(YAML.dump(what), _)
+      else # else the file does not yet exist, so we create it.
+        hash = { n_times: 1 }
+        write_what_into(YAML.dump(hash), _)
+        if may_we_show_the_startup_information?
+          show_startup_information
+        end
+      end
+    else
+      e "Can not write into the directory `#{sdir(base_directory)}`."
+    end
+    ensure_that_the_bioshell_log_directory_exists
+    consider_analysing_the_local_dataset_on_startup
+    check_for_local_vectors # Also check for local vectors, such as pBR322 datasets stored in fasta files.
+    considering_changing_the_title_of_the_kde_konsole_tab
+    if is_on_roebe?
+      if dna_sequence?.nil? or
+         dna_sequence?.empty?
+        # =================================================================== #
+        # On my home system, we use a sequence of 150 by default.
+        # =================================================================== #
+        set_dna_sequence(150, :be_quiet)
+      end
+    end
+  end
+
+  # ========================================================================= #
+  # === do_a_silent_startup
+  #
+  # Use this method when you want to perform a silent startup.
+  # ========================================================================= #
+  def do_a_silent_startup
+    @internal_hash[:silent_startup] = true
+  end; alias do_silent_startup do_a_silent_startup # === do_silent_startup
+
+  require 'bioroebe/utility_scripts/analyse_local_dataset.rb'
+  # ========================================================================= #
+  # === consider_analysing_the_local_dataset_on_startup
+  #
+  # This method will analyse the local dataset (should it exist), and
+  # then display some information to the user about it.
+  # ========================================================================= #
+  def consider_analysing_the_local_dataset_on_startup
+    if @internal_hash and
+       @internal_hash.has_key?(:analyse_the_local_dataset_on_startup) and
+       @internal_hash[:analyse_the_local_dataset_on_startup]
+      Bioroebe::AnalyseLocalDataset.new
+    end
+  end
+
+end; end

data/lib/bioroebe/shell/taxonomy.rb

@@ -0,0 +1,14 @@
+#!/usr/bin/ruby -w
+# Encoding: UTF-8
+# frozen_string_literal: true
+# =========================================================================== #
+# This file will contain code that is specific to Taxonomy-related aspects,
+# in particular browsing these from the NCBI taxonomy base.
+# =========================================================================== #
+# require 'bioroebe/shell/taxonomy.rb'
+# =========================================================================== #
+module Bioroebe
+
+class Shell < ::Bioroebe::CommandlineApplication
+
+end; end

data/lib/bioroebe/shell/tk.rb

@@ -0,0 +1,23 @@
+#!/usr/bin/ruby -w
+# Encoding: UTF-8
+# frozen_string_literal: true
+# =========================================================================== #
+# require 'bioroebe/shell/tk.rb'
+# =========================================================================== #
+require 'bioroebe/base/commandline_application/commandline_application.rb'
+
+module Bioroebe
+
+class Shell < ::Bioroebe::CommandlineApplication
+
+  # ========================================================================= #
+  # === start_three_to_one
+  #
+  # Mostly an ad-hoc way to load up a specific ruby-tk widget.
+  # ========================================================================= #
+  def tk_start_three_to_one
+    require 'bioroebe/gui/tk/three_to_one/three_to_one.rb'
+    Bioroebe::GUI::Tk::ThreeToOne.new(ARGV)
+  end
+
+end; end

data/lib/bioroebe/shell/user_input.rb

@@ -0,0 +1,88 @@
+#!/usr/bin/ruby -w
+# Encoding: UTF-8
+# frozen_string_literal: true
+# =========================================================================== #
+# require 'bioroebe/shell/user_input.rb'
+# =========================================================================== #
+require 'bioroebe/shell/readline/readline.rb'
+
+module Bioroebe
+
+class Shell < ::Bioroebe::CommandlineApplication
+
+  # ========================================================================= #
+  # === user_input?
+  # ========================================================================= #
+  def user_input?
+    @internal_hash[:user_input]
+  end
+
+  # ========================================================================= #
+  # === read_user_input                                           (input tag)
+  #
+  # This method is used to fetch/read user input. The user input
+  # will be kept in an instance variable (called @internal_hash[:user_input],
+  # which is actually a Hash).
+  # ========================================================================= #
+  def read_user_input
+    if readline_is_available?
+      # ===================================================================== #
+      # This clause is the case for the Readline module.
+      # ===================================================================== #
+      user_input = Readline.readline(
+        # =================================================================== #
+        # The second argument enables or disables history support.
+        # =================================================================== #
+        obtain_current_prompt_while_honouring_colours.to_s, true
+      )
+      # ===================================================================== #
+      # === Disallow empty lines to taint the Readline-History
+      #
+      # Ignore empty lines - or rather, remove them after they were input.
+      # ===================================================================== #
+      if user_input =~ /^\s*$/
+        Readline::HISTORY.pop
+      # ===================================================================== #
+      # If we did input the same command as before, on the previous
+      # run, then we will not record this into the readline-history
+      # session.
+      # ===================================================================== #
+      elsif last_inputted_command? == user_input
+        Readline::HISTORY.pop
+      end
+    else
+      # ===================================================================== #
+      # This entry point reads in user-input without depending on Readline.
+      # ===================================================================== #
+      print obtain_current_prompt_while_honouring_colours
+      user_input = $stdin.gets.chomp
+    end
+    user_input.strip! # We do not need or want trailing or leading whitespace.
+    unless user_input.strip.empty?
+      # ===================================================================== #
+      # First, let's get rid of input including '#' - these are assumed
+      # to be comments and are simply ignored.
+      # ===================================================================== #
+      if user_input.include?('#') and (user_input.size > 1)
+        user_input = user_input[0 .. (user_input.index('#')-1)]
+        user_input.rstrip!
+      end
+      # ===================================================================== #
+      # Next sanitize the situation where the user input consists of only
+      # nucleotides, such as ATCG and so forth.
+      # ===================================================================== #
+      if user_input.include?(' ') and only_nucleotides?(user_input.delete(' '))
+        user_input.delete!(' ') # We chop off ' ' tokens, if we only input a nucleotide sequence.
+      end
+      # ===================================================================== #
+      # === Enable multiline input separated via ; next
+      # ===================================================================== #
+      if user_input.include? ';'
+        user_input = user_input.split(';')
+      end
+      @internal_hash[:user_input] = user_input
+      return user_input # Not strictly necessary, but we return anyway.
+    end
+  end; alias get_user_input read_user_input # === get_user_input
+
+end; end

data/lib/bioroebe/shell/xorg.rb

@@ -0,0 +1,45 @@
+#!/usr/bin/ruby -w
+# Encoding: UTF-8
+# frozen_string_literal: true
+# =========================================================================== #
+# require 'bioroebe/shell/xorg.rb'
+# =========================================================================== #
+module Bioroebe
+
+class Shell < ::Bioroebe::CommandlineApplication
+
+  begin
+    require 'xorg_buffer/module'
+  rescue LoadError; end
+
+  # ========================================================================= #
+  # === toggle_xorg_buffer
+  # ========================================================================= #
+  def toggle_xorg_buffer
+    @config.additionally_set_xorg_buffer = !@config.additionally_set_xorg_buffer
+    @config.save
+  end
+
+  # ========================================================================= #
+  # === feedback_whether_we_will_also_set_the_xorg_buffer
+  # ========================================================================= #
+  def feedback_whether_we_will_also_set_the_xorg_buffer
+    erev "Will we also set the Xorg buffer? "\
+         "#{sfancy(vt(@config.additionally_set_xorg_buffer.to_s))}"
+  end
+
+  # ========================================================================= #
+  # === set_xclip                           (xclip tag, xorg tag, buffer tag)
+  #
+  # Use this method to assign to the Linux Xorg Buffer.
+  #
+  # By default we will assign the DNA nucleotide sequence to be
+  # the new buffer.
+  # ========================================================================= #
+  def set_xclip(
+      i = dna_string?
+    )
+    XorgBuffer.set_xorg_buffer(i)
+  end
+
+end; end

data/lib/bioroebe/siRNA/README.md

@@ -0,0 +1,2 @@
+This directory will include code that relates to siRNA (short
+interfering RNA).

data/lib/bioroebe/siRNA/siRNA.rb

@@ -0,0 +1,93 @@
+#!/usr/bin/ruby -w
+# Encoding: UTF-8
+# frozen_string_literal: true
+# =========================================================================== #
+# === Bioroebe::SiRNA
+#
+# Kumiko Ui-Tei in 2004 specified four sequence conditions that are
+# capable of inducing highly effective gene silencing in mammalian
+# cells.
+#
+# These rules are as follows:
+#
+#   (1) A/U at the 5' end of the antisense strand
+#   (2) G/C at the 5' end of the sense strand
+#   (3) at least five A/U residues in the 5' terminal one-third
+#       of the antisense strand
+#   (4) the absence of any GC stretch of more than 9 nt in length
+#
+# =========================================================================== #
+# require 'bioroebe/siRNA/siRNA.rb'
+# =========================================================================== #
+module Bioroebe
+
+class SiRNA # === Bioroebe::SiRNA
+
+  require 'bioroebe/toplevel_methods/complement.rb'
+  require 'bioroebe/sequence/reverse_complement.rb'
+
+  # ========================================================================= #
+  # === initialize
+  # ========================================================================= #
+  def initialize(i = ARGV)
+    if i.is_a? Array
+      i = i.join(' ').strip
+    end
+    @sequence = i
+  end
+
+  # ========================================================================= #
+  # === uitei?
+  # ========================================================================= #
+  def uitei?(
+      i = @sequence, be_verbose = true
+    )
+    unless i.size == 23 # 21 nt target + 2 nt overhang
+      if be_verbose
+        puts 'The size should be 23; it is '+i.to_s.size.to_s+'.'
+      end
+      return false
+    end
+    seq19 = i[2 .. 20] # 19 nt double-stranded region of siRNA
+    complement_to_seq19 = ::Bioroebe.reverse_complement(seq19) # This is actually the reverse complement.
+    # ======================================================================= #
+    # === criterium 1
+    #
+    # (1) A/U at the 5' end of the antisense strand. This can be checked
+    #     if we take the last nucleotide from the sense strand. Note
+    #     that ineffective siRNAs are G or C here.
+    # ======================================================================= #
+    last_nucleotide = complement_to_seq19[0, 1]
+    return false unless last_nucleotide.match(/T|A|U/i) # Match either T or A.
+    # ======================================================================= #
+    # === criterium 2
+    #
+    # (2) G/C at the 5' end of the sense strand
+    # ======================================================================= #
+    return false unless seq19.start_with?(/G|C/i)
+    # ======================================================================= #
+    # === criterium 3
+    #
+    # (3) at least five A/U residues in the 5' terminal one-third
+    #     of the antisense strand (this means leading area, but
+    #     on the antisense strand, so T and A there)
+    # ======================================================================= #
+    one_third = (seq19.size / 3)+1
+    number_of_AU_residues = complement_to_seq19[0, one_third].scan(/A|T|U/i).size
+    return false unless number_of_AU_residues > 4
+    # ======================================================================= #
+    # === criterium 4
+    #
+    # (4) the absence of any GC stretch of more than 9 nt in length
+    # ======================================================================= #
+    return false if seq19.match(/G{10}|C{10}/i)
+    return true # This is then the new default return value here.
+  end; alias uitei_rule? uitei? # === uitei_rule?
+
+end; end
+
+if __FILE__ == $PROGRAM_NAME
+  alias e puts
+  e Bioroebe::SiRNA.new('GAGAAAATCATGCATGCATTTAT').uitei_rule?
+  e Bioroebe::SiRNA.new('GAAAAAAAAATGCATGCAAAAAA').uitei_rule?
+end # siRNA.rb

data/lib/bioroebe/string_matching/README.md

@@ -0,0 +1,13 @@
+In this directory we will store code that will help us with alignments
+of strings.
+
+Presently, the following classes reside in this directory:
+  
+  class HammingDistance
+  class PalindromeFinder
+  class FindLongestSubstring
+  class FindLongestSubstringViaLCSAlgorithm
+  class Levensthein
+  class SimpleStringComparer
+  class SmithWaterman
+

data/lib/bioroebe/string_matching/find_longest_substring.rb

@@ -0,0 +1,162 @@
+#!/usr/bin/ruby -w
+# Encoding: UTF-8
+# frozen_string_literal: true
+# =========================================================================== #
+# === Bioroebe::FindLongestSubstring
+#
+# This class will compare two strings. This class is not working very
+# well due to some assumptions that it makes. If you need a better
+# class for that, try class Bioroebe::FindLongestSubstringViaLCSalgorithm.
+#
+# Usage examples:
+#
+#   Bioroebe::FindLongestSubstring.new(ARGV)
+#
+# =========================================================================== #
+# require 'bioroebe/string_matching/find_longest_substring.rb'
+# =========================================================================== #
+require 'bioroebe/base/commandline_application/commandline_application.rb'
+
+module Bioroebe
+
+class FindLongestSubstring < ::Bioroebe::CommandlineApplication # === Bioroebe::FindLongestSubstring
+
+  # ========================================================================= #
+  # === NAMESPACE
+  # ========================================================================= #
+  NAMESPACE = inspect
+
+  # ========================================================================= #
+  # === STRING1
+  # ========================================================================= #
+  STRING1 = 'AAAAGATAAACAAAAGGGG'
+
+  # ========================================================================= #
+  # === STRING2
+  # ========================================================================= #
+  STRING2 = 'ATATCCTAAACAAAAGGGG'
+
+  # ========================================================================= #
+  # === initialize
+  # ========================================================================= #
+  def initialize(
+      string1     = nil,
+      string2     = nil,
+      run_already = true
+    )
+    super()
+    reset
+    set_string1(string1)
+    set_string2(string2)
+    run if run_already
+  end
+
+  # ========================================================================= #
+  # === reset                                                     (reset tag)
+  # ========================================================================= #
+  def reset
+    super()
+    # ======================================================================= #
+    # === @namespace
+    # ======================================================================= #
+    @namespace = NAMESPACE
+    # ======================================================================= #
+    # === @start_position
+    # ======================================================================= #
+    @start_position = nil
+    # ======================================================================= #
+    # === @longest_substring
+    # ======================================================================= #
+    @longest_substring = ''
+    # ======================================================================= #
+    # === @_
+    # ======================================================================= #
+    @_ = ''.dup # Throwaway string.
+  end
+
+  # ========================================================================= #
+  # === set_string1
+  # ========================================================================= #
+  def set_string1(i = :default)
+    i = i.first if i.is_a? Array
+    case i
+    when nil, :default
+      i = STRING1
+    end
+    @string1 = i
+  end
+
+  # ========================================================================= #
+  # === set_string2
+  # ========================================================================= #
+  def set_string2(i = :default)
+    i = i.first if i.is_a? Array
+    case i
+    when nil, :default
+      i = STRING2
+    end 
+    @string2 = i
+  end
+
+  # ========================================================================= #
+  # === result?
+  # ========================================================================= #
+  def result? # query method.
+    @longest_substring
+  end; alias result result? # === result
+
+  # ========================================================================= #
+  # === record
+  # ========================================================================= #
+  def record(
+      i = @_, start_position = nil
+    )
+    if i.size > @longest_substring.size
+      @longest_substring = i
+      @start_position = (start_position-1) if start_position
+    end
+  end
+
+  # ========================================================================= #
+  # === startup_message
+  # ========================================================================= #
+  def startup_message
+    opnn
+    e
+    e 'We will try to find the longest common substring between'
+    e "  string1 `#{sfancy(@string1)}` and "
+    e "  string2 `#{sfancy(@string2)}` now."
+  end
+
+  # ========================================================================= #
+  # === report_longest_substring
+  # ========================================================================= #
+  def report_longest_substring
+    e "The longest substring is: #{sfancy(@longest_substring)}"
+    if @start_position
+      e "It starts after position: #{sfancy(@start_position)}"
+    end
+  end; alias report report_longest_substring # === report
+
+  # ========================================================================= #
+  # === run                                                         (run tag)
+  # ========================================================================= #
+  def run
+    startup_message
+    @string1.chars.each_with_index {|entry, index|
+      if entry == @string2[index]
+        @_ << entry
+        record(@_, index)
+      else
+        @_ = ''
+      end
+    }
+    report_longest_substring
+  end
+
+end; end
+
+if __FILE__ == $PROGRAM_NAME
+  _ = Bioroebe::FindLongestSubstring.new(ARGV[0], ARGV[1])
+  # _.report # This is no longer required, I think.
+end # findlongestsubstring ATTG ATTT