bioroebe 0.10.80 → 0.11.12

data/lib/bioroebe/shell/search.rb

@@ -1,337 +0,0 @@
-#!/usr/bin/ruby -w
-# Encoding: UTF-8
-# frozen_string_literal: true
-# =========================================================================== #
-# require 'bioroebe/shell/search.rb'
-# =========================================================================== #
-module Bioroebe
-
-class Shell < ::Bioroebe::CommandlineApplication
-
-  require 'bioroebe/toplevel_methods/matches.rb'
-  # ========================================================================= #
-  # === search_sequence_for_open_reading_frames
-  #
-  # Use this method to search for Open Reading Frames (i.e. "AUG" codons).
-  #
-  # Since we use Bioroebe.start_codon?, this may also default to another
-  # start codon.
-  # ========================================================================= #
-  def search_sequence_for_open_reading_frames(
-      i                    = string?,
-      use_which_frame      = :frame1,
-      use_this_start_codon = ::Bioroebe.start_codon?
-    )
-    i.upcase!
-    if i
-      if i.include? use_this_start_codon # This asks whether the string includes 'ATG'.
-        report_n_start_codons # Will report how many Start sequences we have.
-        e
-        erev "These can be found (and will start) at these positions):#{N}#{N}"
-        copy = i.to_s.dup # Work on a copy here.
-        if use_which_frame == :frame2 # Chop off the first entry then.
-          copy[0,1] = ''
-        end
-        # =================================================================== #
-        # We will search for both ATG and AUG though, respectively the
-        # input variants given to us. If the following regex appears to
-        # be complicated to you, here is the old variant for the regex:
-        #
-        #   use_this_regex = /(ATG|AUG)/i
-        #
-        # =================================================================== #
-        array_results = []
-        array_results << Bioroebe.return_array_of_sequence_matches(copy, use_this_start_codon)
-        if use_this_start_codon.include? 'T'
-          array_results << Bioroebe.return_array_of_sequence_matches(copy, use_this_start_codon.tr('T','U'))
-        end
-        array_results.flatten!
-        array_results.compact!
-        # =================================================================== #
-        # This will hold data such as:
-        #   [16, ["ATG"]]
-        # At the least up until April 2020, before it was changed.
-        # =================================================================== #
-        return array_results
-      else
-        []
-      end
-    else
-      ewarn 'It seems as if you have not yet assigned a string.'
-      ewarn 'You could run "random" to assign a random string.'
-    end
-  end
-
-  # ========================================================================= #
-  # === show_ccaat_sites
-  #
-  # Use this method to locate CCAAT sites in the DNA string (the main
-  # string).
-  #
-  # A CCAAT box, sometimes abbreviated a "CAAT box" or a "CAT box",
-  # is a distinct pattern of nucleotides with the sequence
-  # "GGCCAATCT" or a sequence similar to that string.
-  #
-  # This sequence usually occurs upstream by 60-100 bases to the
-  # initial transcription start site. 
-  #
-  # To test this method, you can try:
-  #
-  #   assign ATTTACGCGCCCGGCCAATCTGGCCGCGTACCCCCCCCCCGGCCAATCTATTTACGCGCCCGGCCAATCTGGCCGCGTACCCCCCCCCCGGCCAATCT; ccaat?
-  #
-  # ========================================================================= #
-  def show_ccaat_sites(
-      search_for_this_sequence = 'CCAAT' # 'GGCCAATCT'
-    )
-    find_this_sequence(search_for_this_sequence)
-    n_entries = raw_sequence?.scan("#{search_for_this_sequence}").size
-    erev "The main sequence has #{simp(n_entries)}#{rev} CCAAT sites."
-  end; alias show_CCAAT_sites show_ccaat_sites # === show_CCAAT_sites
-
-  # ========================================================================= #
-  # === search_for?
-  #
-  # This method can be queried from the interactive-bioshell via:
-  #
-  #   search_for?
-  #
-  # ========================================================================= #
-  def search_for?
-    @internal_hash[:search_for]
-  end
-
-  # ========================================================================= #
-  # === show_cpg_islands
-  #
-  # Use this method to "search" for CpG islands in a sequence. These will
-  # then be highlighted, sort of.
-  #
-  # To invoke this, try:
-  #
-  #   CG?
-  #
-  # ========================================================================= #
-  def show_cpg_islands
-    display_nucleotide_sequence(main_sequence?.to_str) {{
-      colourize_this_subsequence: 'CG'
-    }}
-  end
-
-  # ========================================================================= #
-  # === search_for_known_promoters
-  #
-  # This method will attempt to identify promoter elements.
-  # ========================================================================= #
-  def search_for_known_promoters
-    erev 'Next searching for known promoters.'
-    e
-    erev "35S Promoter (#{sfancy('TGAGACTTTT')}#{rev}):"
-    how_many_35S_promoters_are_in_the_sequence = 
-      search_for 'TGAGACTTTT', :be_quiet
-    if how_many_35S_promoters_are_in_the_sequence > 0
-      erev 'There appears to be at the least one 35S promoter '\
-           'in the target sequence.' 
-    end
-  end
-
-  # ========================================================================= #
-  # === search_for                                           (search_for tag)
-  #
-  # This method essentially combines the two methods set_search_for()
-  # and start_search().
-  # ========================================================================= #
-  def search_for(
-      i, be_verbose = true
-    )
-    if i.is_a? Array
-      i = i.join(' ').strip
-    end
-    set_search_for(i, be_verbose)
-    start_search(be_verbose)
-  end
-
-  # ========================================================================= #
-  # === run_nls_search
-  #
-  # Search the sequence for NLS.
-  # ========================================================================= #
-  def run_nls_search
-    if @aminoacids
-      erev 'We will try to run a NLS search on '+simp(aminoacids?.to_s)+':'
-      e
-      erev "  #{sfancy(aminoacids?.to_s)}"
-      e
-      ARRAY_NLS_SEQUENCES.each {|sequence|
-        if @aminoacids.include? sequence
-          erev 'We found a result for -> '+swarn(sequence)
-        else
-          e sfancy(sequence)+' <- This NLS is not included.'
-        end
-      }
-    else
-      erev 'Please first assign an '+sfancy('aminoacid sequence')+
-           ' such as by doing:'
-      e
-      erev '  set_aminoacids '+
-           ::Bioroebe.colourize_aa('PAAKRVKLKKKKKKKKKRKKKPPKLKVKVKLKLKAA')
-      e
-    end
-  end
-
-  # ========================================================================= #
-  # === search_for_tata_consensus_sequence
-  #
-  # Use this method to search for a TATA consensus sequence in the target
-  # string (the so-called "TATA box"). The TATA box is an AT-rich
-  # sequence that can be found upstream of the transcription start site. 
-  #
-  # A short overview of this sequence format can be found here:
-  #
-  #   https://en.wikiversity.org/wiki/Gene_transcriptions/Boxes/TATA#Consensus_sequence
-  #
-  # The major consensus sequence is:
-  #
-  #   3'-TATAAA-5'
-  #
-  # This is just the major one; there are variants of this sequences such as
-  #
-  #   3'-TATAAA(A)AAA-5'
-  #
-  # And similar variants.
-  #
-  # Usage example:
-  #
-  #   set_string GGGCTATAAAAATTGGGATATAAAATTGTATATA; find_TATA?
-  #
-  # ========================================================================= #
-  def search_for_tata_consensus_sequence
-    full_sequence = sequence? # Grab hold of the sequence.
-    # ======================================================================= #
-    # Next define our TATA box which we will try to discover:
-    # ======================================================================= #
-    tata_box_sequence = 'TATAAA'
-    results = full_sequence.scan(/#{tata_box_sequence}/)
-    if results.empty?
-      erev 'Our target string does not include `'+
-           simp(tata_box_sequence)+rev+'`.'
-    else
-      n_results = results.size.to_s # <- Determine how many matches were found.
-      erev "We did find #{simp(n_results)} "\
-           "#{sfancy(tata_box_sequence)}#{rev} entries."
-      erev 'Their starting positions are at:'
-      array = []
-      splitted_sequence = full_sequence.split(//)
-      splitted_sequence.each_with_index {|entry, index|
-        case entry
-        when 'T' # This could be a TATA sequence.
-          # ================================================================= #
-          # Next we will compare whether the sequence matches.
-          # ================================================================= #
-          subsequence = full_sequence[index, tata_box_sequence.size]
-          if tata_box_sequence == subsequence
-            array << index # <- Append into our Array here.
-          end
-        end
-      }
-      e
-      print '  '
-      pp array
-      # ===================================================================== #
-      # As of May 2016 we will also use find() to find the TATA box.
-      # ===================================================================== #
-      e
-      erev 'We will also show the sequence in a highlighted manner next:'
-      e
-      try_to_find_restriction_enzymes_for(tata_box_sequence)
-    end
-  end
-
-  # ========================================================================= #
-  # === ncbi_nucleotide_search_for
-  # ========================================================================= #
-  def ncbi_nucleotide_search_for(i = '')
-    i = '' if i.nil? # Reset to default then, in this case.
-    i = i.join('+') if i.is_a? Array
-    i.strip!
-    _ = 'https://www.ncbi.nlm.nih.gov/'.dup
-    _ << 'nucgss?term="'+i+'"' unless i.empty? # Use "" quotes to escape shell-code.
-    erev 'Now opening '+simp(_)+rev
-    open_in_browser _
-  end
-
-  # ========================================================================= #
-  # === start_search                                       (start_search tag)
-  #
-  # This will attempt to locate @search_for substring in the main
-  # nucleotide sequence.
-  # ========================================================================= #
-  def start_search(
-      be_verbose = true
-    )
-    case be_verbose
-    when :be_quiet
-      be_verbose = false
-    end
-    _ = search_for? # Obtain a handle to the sequence we are trying to find.
-    if _
-      results = sequence?.scan(_)
-      if be_verbose
-        erev "Trying to now find `#{simp(_)}#{rev}`."
-        pp results
-      end
-      msg = "We found `#{simp(results.size.to_s)}#{rev}` entr".dup
-      if (results.size > 1) or (results.size == 0)
-        msg << 'ies' # Plural form.
-      else
-        msg << 'y'   # Singular form.
-      end
-      msg << '.'
-      erev msg
-      return results.size
-    else
-      erev "No value for #{paleturquoise('@search_for')}#{rev} was "\
-           "set yet. Please set one via invoking:"
-      e
-      erev '  set_search_for'
-      e
-    end
-  end
-
-  # ========================================================================= #
-  # === search_for_nucleotide_sequence
-  #
-  # This method will use the NCBI interface to search for
-  # nucleotide sequences.
-  #
-  # Usage example:
-  #
-  #   snuc lady slipper orchid
-  #
-  # ========================================================================= #
-  def search_for_nucleotide_sequence(i)
-    i = i.join '+' if i.is_a? Array
-    open_in_browser "https://www.ncbi.nlm.nih.gov/nucgss?term=#{i}"
-  end
-
-  # ========================================================================= #
-  # === set_search_for
-  #
-  # This setter-method can be used to designate for which subsequence
-  # we may search-for, if this is necessary, e. g. to detect "AUG"
-  # in a sequence of "GGCAUGGGC".
-  # ========================================================================= #
-  def set_search_for(
-      i, be_verbose = true
-    )
-    case be_verbose
-    when :be_quiet
-      be_verbose = false
-    end
-    i = i.join if i.is_a? Array
-    if be_verbose
-      erev "We will now search for: #{simp(i.to_s)}" if i
-    end
-    @internal_hash[:search_for] = i
-  end; alias set_search_string set_search_for # === set_search_string
-
-end; end

data/lib/bioroebe/shell/sequences.rb

@@ -1,200 +0,0 @@
-#!/usr/bin/ruby -w
-# Encoding: UTF-8
-# frozen_string_literal: true
-# =========================================================================== #
-# require 'bioroebe/shell/sequence.rb'
-# =========================================================================== #
-module Bioroebe
-
-class Shell < ::Bioroebe::CommandlineApplication
-
-  # ========================================================================= #
-  # === dna_sequence?                                           (string? tag)
-  #
-  # Return the DNA sequence in question.
-  #
-  # Must always return a String.
-  #
-  # Several aliases exist. It is recommended to use the more explicit name,
-  # since this will more accurately reflect the name (and intent) of this
-  # method.
-  # ========================================================================= #
-  def dna_sequence?
-    @internal_hash[:array_dna_sequence].last.to_str
-  end; alias dna_string?                    dna_sequence? # === dna_string?
-       alias dna_string?                    dna_sequence? # === dna_string?
-       alias seq?                           dna_sequence? # === seq?
-       alias sequence_1                     dna_sequence? # === sequence_1
-       alias seq1                           dna_sequence? # === seq1
-       alias seq1?                          dna_sequence? # === seq1?
-       alias dna_seq?                       dna_sequence? # === dna_seq?
-       alias string?                        dna_sequence? # === string?
-       alias main_string?                   dna_sequence? # === main_string?
-       alias nucleotide_sequence?           dna_sequence? # === nucleotide_sequence?
-       alias sequence_as_string?            dna_sequence? # === sequence_as_string?
-       alias dna_sequence_as_string?        dna_sequence? # === dna_sequence_as_string?
-       alias dna_sequence_object_as_string? dna_sequence? # === dna_sequence_object_as_string?
-
-  # ========================================================================= #
-  # === return_dna_sequence_as_sequence_object
-  #
-  # This method will always return the main "sequence object" in question,
-  # which is (almost always) a DNA sequence (dsDNA).
-  # ========================================================================= #
-  def return_dna_sequence_as_sequence_object
-    @internal_hash[:array_dna_sequence].last
-  end; alias main_sequence?       return_dna_sequence_as_sequence_object # === main_sequence?
-       alias dna_sequence_object? return_dna_sequence_as_sequence_object # === dna_sequence_object?
-       alias sequence_object?     return_dna_sequence_as_sequence_object # === sequence_object?
-       alias sequence?            return_dna_sequence_as_sequence_object # === sequence?
-       alias seq_object?          return_dna_sequence_as_sequence_object # === seq_object?
-       alias sequence             return_dna_sequence_as_sequence_object # === sequence (sequence? tag)
-       alias seq_obj?             return_dna_sequence_as_sequence_object # === seq_obj?
-
-  # ========================================================================= #
-  # === dna_sequences?
-  # ========================================================================= #
-  def dna_sequences?
-    @internal_hash[:array_dna_sequence]
-  end
-
-  # ========================================================================= #
-  # === is_any_nucleotide_assigned?
-  # ========================================================================= #
-  def is_any_nucleotide_assigned?
-    !sequence_object?.empty? # If the sequence is not empty, it is assigned.
-  end
-
-  # ========================================================================= #
-  # === assign_sequence
-  # ========================================================================= #
-  def assign_sequence(
-      i, be_verbose = true
-    )
-    case be_verbose
-    when :be_silent
-      be_verbose = false
-    end
-    if be_verbose
-      e 'Now assigning a sequence.'
-    end
-    set_sequence(i)
-  end
-
-  # ========================================================================= #
-  # === sequence?
-  # ========================================================================= #
-  def sequence?
-    @sequence
-  end; alias dna_sequence? sequence? # === dna_sequence?
-
-  # ========================================================================= #
-  # === sequence3
-  # ========================================================================= #
-  def sequence_3
-    @sequence_3.to_str
-  end; alias seq3  sequence_3 # === seq3
-       alias seq3? sequence_3 # === seq3?
-
-  # ========================================================================= #
-  # === sequence4
-  # ========================================================================= #
-  def sequence_4
-    @sequence_4.to_str
-  end; alias seq4  sequence_4 # === seq4
-       alias seq4? sequence_4 # === seq4?
-
-  # ========================================================================= #
-  # === sequence5
-  # ========================================================================= #
-  def sequence_5
-    @sequence_5.to_str
-  end; alias seq5  sequence_5 # === seq5
-       alias seq5? sequence_5 # === seq5?
-
-  # ========================================================================= #
-  # === sequence6
-  # ========================================================================= #
-  def sequence_6
-    @sequence_6.to_str
-  end; alias seq6  sequence_6 # === seq6
-       alias seq6? sequence_6 # === seq6?
-
-  # ========================================================================= #
-  # === sequence2
-  # ========================================================================= #
-  def sequence_2
-    @sequence_2.to_str
-  end; alias seq2  sequence_2 # === seq2
-       alias seq2? sequence_2 # === seq2?
-
-  # ========================================================================= #
-  # === set_sequence_2
-  # ========================================================================= #
-  def set_sequence_2(i = '')
-    i = i.join(' ').strip if i.is_a? Array
-    i.delete!(N)
-    i = i.to_str unless i.is_a? String
-    @sequence_2 = ::Bioroebe.sequence(i)
-  end
-
-  # ========================================================================= #
-  # === set_sequence_3
-  # ========================================================================= #
-  def set_sequence_3(i = '')
-    i = i.join(' ').strip if i.is_a? Array
-    i.delete!(N)
-    i = i.to_str unless i.is_a? String
-    @sequence_3 = ::Bioroebe.sequence(i)
-  end
-
-  # ========================================================================= #
-  # === set_sequence_4
-  # ========================================================================= #
-  def set_sequence_4(i = '')
-    i = i.join(' ').strip if i.is_a? Array
-    i.delete!(N)
-    i = i.to_str unless i.is_a? String
-    @sequence_4 = ::Bioroebe.sequence(i)
-  end
-
-  # ========================================================================= #
-  # === set_sequence_5
-  # ========================================================================= #
-  def set_sequence_5(i = '')
-    i = i.join(' ').strip if i.is_a? Array
-    i.delete!(N)
-    i = i.to_str unless i.is_a? String
-    @sequence_5 = ::Bioroebe.sequence(i)
-  end
-
-  # ========================================================================= #
-  # === set_sequence_6
-  # ========================================================================= #
-  def set_sequence_6(i = '')
-    i = i.join(' ').strip if i.is_a? Array
-    i.delete!(N)
-    i = i.to_str unless i.is_a? String
-    @sequence_6 = ::Bioroebe.sequence(i)
-  end
-
-  require 'bioroebe/codons/codons.rb'
-  # ========================================================================= #
-  # === aminoacid_sequence?
-  #
-  # This here will return the most likely aminoacid sequence of the target
-  # main sequence.
-  # ========================================================================= #
-  # def aminoacid_sequence?(
-  #     main_sequence = @sequence
-  #   )
-  #   if main_sequence.respond_to? :sequence?
-  #     main_sequence = main_sequence.sequence?
-  #   end
-  #   _ = ::Bioroebe.dna_to_aa(
-  #     main_sequence
-  #   )
-  #   return _ # .join.strip
-  # end
-
-end; end