bioroebe 0.10.80 → 0.11.12

data/lib/bioroebe/shell/assign.rb

@@ -1,360 +0,0 @@
-#!/usr/bin/ruby -w
-# Encoding: UTF-8
-# frozen_string_literal: true
-# =========================================================================== #
-# require 'bioroebe/shell/assign.rb'
-# =========================================================================== #
-module Bioroebe
-
-class Shell < ::Bioroebe::CommandlineApplication
-
-  # ========================================================================= #
-  # === set_dna_sequence                          (assign tag, assigning tag)
-  #
-  # This method can be used to set/assign the main DNA string.
-  #
-  # It is a fairly long method, mostly because it will do lots of
-  # additional tasks, way aside from setting/assigning to a DNA
-  # sequence only.
-  #
-  # As of June 2016, the method will also keep a backup of the
-  # generated sequence in a local file as well. This will allow
-  # us to "replay" the given sequence on startup of the shell.
-  #
-  # Note that as of Jun 2016, we will chop off any '"' found in
-  # the input String.
-  # ========================================================================= #
-  def set_dna_sequence(
-      i          = nil,
-      be_verbose = true,
-      do_upcase  = :check_for_config_value_here
-    )
-    if is_the_main_sequence_frozen?
-      report_that_the_main_sequence_is_frozen
-      return
-    end
-    case do_upcase
-    # ======================================================================= #
-    # === :check_for_config_value_here
-    # ======================================================================= #
-    when :check_for_config_value_here,
-         :default
-      if @config and @config.respond_to?(:upcase_nucleotides)
-        do_upcase = @config.upcase_nucleotides
-      else
-        do_upcase = false
-      end
-    # ======================================================================= #
-    # === :do_not_upcase
-    # ======================================================================= #
-    when :do_not_upcase
-      do_upcase = false
-    end
-    if do_upcase
-      shall_we_upcase = do_upcase if @config
-    end
-    # ======================================================================= #
-    # === Sanitize the second variable next
-    # ======================================================================= #
-    case be_verbose
-    # ======================================================================= #
-    # === :be_verbose
-    # ======================================================================= #
-    when :be_verbose
-      be_verbose = true
-    # ======================================================================= #
-    # === :do_not_upcase
-    # ======================================================================= #
-    when :do_not_upcase,
-         :no_upcase,
-         :no_upcasing,
-      shall_we_upcase = false
-      be_verbose = true # Sync this.
-    # ======================================================================= #
-    # === :be_silent
-    # ======================================================================= #
-    when :be_silent,
-         :be_quiet
-      be_verbose = false
-    end
-    if i.nil?
-      # ===================================================================== #
-      # === Hande nil value for the variable i next:
-      #
-      # Here in this entry point, we will handle if the first input
-      # argument is nil.
-      #
-      # If @internal_hash[:misc_sequence] is NOT nil, then it will be used
-      # once, then cleared. Otherwise, we will use dna_sequence?.
-      # ===================================================================== #
-      if @internal_hash[:misc_sequence]
-        i = @internal_hash[:misc_sequence]
-        @internal_hash[:misc_sequence] = nil # Set it to nil again.
-      else
-        i = dna_sequence?
-      end
-    end
-    # ======================================================================= #
-    # === Convert Array into String next
-    # ======================================================================= #
-    i = i.join if i.is_a? Array
-    i = i.to_s # Work on a String past this point here.
-    if i.include? ' ' # Sanitize the input a little bit.
-      i = i.strip.delete(' ')
-    end
-    if i.include? '|' # I think we will not need '|' in our main string.
-      i.delete!('|')
-    end
-    # ======================================================================= #
-    # === If the input has only numbers
-    # ======================================================================= #
-    if i =~ /^\d+$/
-      i = random_dna_sequence(i)
-    end
-    # ======================================================================= #
-    # === Handle Fasta format next
-    # ======================================================================= #
-    if i.start_with?('>') and i.include?(N)
-      erev 'It seems as if you have a FASTA sequence there, as it starts with '\
-           'a > character.'
-      erev 'We will omit this first section (the header) though.'
-      i[0 .. i.index(N)] = '' # This does the chop-off action.
-    end
-    i.delete!('-') if i.include? '-'
-    i.delete!('_') if i.include? '_' # Don't want '_' characters.
-    i.delete!('?') if i.include? '?'
-    i.delete!('#') if i.include? '#' # This was added at 08.05.2016.
-    i.delete!('"') if i.include? '"' # This was added at 02.06.2016.
-    i.gsub!(/\^C/,'') if i.include? '^C'
-    i = i.to_s.dup
-    case i
-    # ======================================================================= #
-    # === :GFP
-    # ======================================================================= #
-    when ':GFP' # ← This means the default GFP sequence.
-      i = return_default_GFP_sequence
-    # ======================================================================= #
-    # === random
-    # ======================================================================= #
-    when /^random$/i,
-         '' # As of 04.01.2015, we will try '' too here.
-      i = random :do_not_show_the_string
-    # ======================================================================= #
-    # === multiline
-    # ======================================================================= #
-    when 'multiline' # Handle multiline input.
-      erev 'Multiline input detected.'
-      erev 'Finish by issuing __ on an empty line. (These are 2 "_" tokens.)'
-      i  = $stdin.gets('__')
-      # ===================================================================== #
-      # Next, sanitize it a bit if it starts with a '>' identifier.
-      # ===================================================================== #
-      if i.strip.start_with? '>'
-        i = i[(i.index(N)+1)..-1]
-      end
-    else
-      if i
-        # =================================================================== #
-        # === Next upcase the input if the flag was set
-        # =================================================================== #
-        i.upcase! if shall_we_upcase
-        case mode?
-        # =================================================================== #
-        # === :dna
-        # =================================================================== #
-        when :dna,
-             :rna
-          dna_sequence_object?.set_mode(mode?)
-        # =================================================================== #
-        # === :aminoacids
-        # =================================================================== #
-        when :aminoacids
-          set_aminoacids(i)
-        end
-      else # else input is nil.
-        erev 'Missing Input to assign_sequence(). Please input '\
-             'your DNA string now (Hitting the enter key will '\
-             'finish this):'
-        i = $stdin.gets.chomp
-        i = i.upcase if shall_we_upcase
-      end
-    end
-    i = '' unless i
-    # ======================================================================= #
-    # === Remove possible newlines in the given input
-    # ======================================================================= #
-    i.delete!(N)   if i.include? N
-    i.delete!('_') if i.include? '_'
-    # ======================================================================= #
-    # Is faster than .gsub()# if i
-    #   i.upcase! # Since as of Feb 2016. Nope, disabled again as of May 2016.
-    # end
-    # ======================================================================= #
-    if File.exist?(i) # Assume a file was given. Read its content then.
-      if i.end_with? '.yml'
-        i = YAML.load_file(i)
-      else
-        i = File.readlines(i).reject {|line|
-          line.start_with? '>'
-        }.join
-      end
-    end
-    # ======================================================================= #
-    # Also get rid of numbers.
-    # ======================================================================= #
-    i = i.dup if i.frozen?
-    i.gsub!(/\d/,'')
-    # ======================================================================= #
-    # The DNA Sequence will be stored in the Sequence object directly.
-    # The nil is required for now, because otherwise set_input() will
-    # upcase the input by default.
-    # ======================================================================= #
-    if dna_sequence_object?.nil?
-      _ = Bioroebe::Sequence.new(i.dup) { :is_DNA }
-      @internal_hash[:array_dna_sequence] << _
-    else
-      # ===================================================================== #
-      # Assign it here.
-      # ===================================================================== #
-      dna_sequence_object?.set_input(i.dup, nil) # We can re-use the old @sequence object.
-    end
-    # ======================================================================= #
-    # === :coding_area
-    #
-    # Whenever the DNA sequence is modified like that, we will also reset
-    # the "coding_area" entry in the internal Hash to the initial nil state.
-    # ======================================================================= #
-    @internal_hash[:coding_area] = nil
-    # ======================================================================= #
-    # === Report that we will perform an assignment next
-    # ======================================================================= #
-    if be_verbose # Check for verbosity
-      case mode?
-      when :dna
-        if i.empty?
-          erev 'Nothing was assigned yet.'
-        else
-          erev 'Setting DNA sequence to ('+
-                sfancy(i.size.to_s)+
-                rev+' nucleotides):'
-          show_string
-        end
-      end
-    end
-    # ======================================================================= #
-    # === Set the Xorg Buffer next
-    # ======================================================================= #
-    if @config and @config.respond_to?(:additionally_set_xorg_buffer) and
-       @config.additionally_set_xorg_buffer
-      begin
-        set_xorg_buffer(i)
-      rescue NoMethodError; end
-    end
-    unless i.empty? # We do not save empty nucleotide Strings.
-      result = i.to_s.dup
-      # ===================================================================== #
-      # We will save into a file next.
-      # ===================================================================== #
-      this_file = "#{log_dir?}dna_string.yml"
-      dna_sequence_object?.save_sequence_to_this_file(this_file) # Save it here.
-      # ===================================================================== #
-      # Since as of Jun 2016, we will also create a new RNA string.
-      #
-      # This has been disabled as of December 2021. It was too strange
-      # to automatically create a RNA string.
-      # ===================================================================== #
-      # if @internal_hash[:array_rna_sequence]
-      #   @internal_hash[:array_rna_sequence].last.set_sequence(result)
-      # end
-      # ===================================================================== #
-      # === Automatically assign the aminoacid sequence as well
-      # ===================================================================== #
-      _ = translate_dna_into_aminoacid(result)
-      set_aminoacids(_, nil, :be_quiet)
-      return result
-    end
-  end; alias set_dna_string           set_dna_sequence # === set_dna_string
-       alias set_string               set_dna_sequence # === set_dna_sequence
-       alias set_main_sequence        set_dna_sequence # === set_main_sequence (set_main_sequence tag)
-       alias set_sequence             set_dna_sequence # === set_sequence (set_sequence tag)
-       alias set_dna                  set_dna_sequence # === set_dna
-       alias set_assign               set_dna_sequence # === set_dna
-       alias assign_sequence          set_dna_sequence # === assign_sequence
-       alias assign_dna_sequence      set_dna_sequence # === assign_dna_sequence
-       alias assign_this_dna_sequence set_dna_sequence # === assign_this_dna_sequence
-       alias assign                   set_dna_sequence # === assign
-
-  require 'bioroebe/aminoacids/create_random_aminoacids.rb'
-  # ========================================================================= #
-  # === set_aminoacids               (assign protein tag, set aminoacids tag)
-  #
-  # Assign a protein sequence here. The first argument shall be the
-  # aminoacid sequence in question.
-  #
-  # Usage example:
-  #
-  #   assign_protein FLIMVSPTAYHQNKDECWRGX*
-  #
-  # ========================================================================= #
-  def set_aminoacids(
-      i                    = :random,
-      how_many_to_generate = 1000, # Will only be applied if the input is :random or :generate
-      be_verbose           = true
-    )
-    # ======================================================================= #
-    # === Sanitize the third argument next
-    # ======================================================================= #
-    case be_verbose
-    when :be_silent,
-         :be_quiet
-      be_verbose = false
-    end
-    i = :random unless i
-    case i
-    # ======================================================================= #
-    # === :random
-    # ======================================================================= #
-    when :random,
-         :generate 
-      i = Bioroebe.create_random_aminoacids(how_many_to_generate) # Generate them here.
-    end
-    i = i.join if i.is_a? Array
-    if i =~ /^\d+$/ # only numbers
-      i = Bioroebe.create_random_aminoacids(i)
-    end
-    if be_verbose
-      erev "Now assigning aminoacid sequence to: #{sfancy(i.to_s)}"
-    end
-    if i.is_a? String # Convert it into a Sequence object here.
-      i = ::Bioroebe.sequence(i) { :aminoacid }
-    end
-    # ======================================================================= #
-    # Do the assignment next.
-    # ======================================================================= #
-    if @internal_hash[:array_aminoacid_sequence].empty?
-      @internal_hash[:array_aminoacid_sequence] << i
-    else
-      @internal_hash[:array_aminoacid_sequence].pop
-      @internal_hash[:array_aminoacid_sequence] << i
-    end 
-  end; alias assign_aminoacid_sequence set_aminoacids # === assign_aminoacid_sequence
-       alias assign_protein_sequence   set_aminoacids # === assign_protein_sequence
-       alias set_aminoacid_sequence    set_aminoacids # === set_aminoacid_sequence
-
-  # ========================================================================= #
-  # === report_that_a_string_must_be_assigned_first
-  # ========================================================================= #
-  def report_that_a_string_must_be_assigned_first
-    erev 'No sequence has been assigned yet. Please first "'+
-         sfancy('assign')+rev+'" a string.'
-  end
-
-  # ========================================================================= #
-  # === assign_sequence2
-  # ========================================================================= #
-  def assign_sequence2(i)
-    i = i.join(' ') if i.is_a? Array
-    @internal_hash[:sequence2] = Bioroebe::Sequence.new(i)
-  end
-
-end; end

data/lib/bioroebe/shell/chop_and_cut.rb

@@ -1,281 +0,0 @@
-#!/usr/bin/ruby -w
-# Encoding: UTF-8
-# frozen_string_literal: true
-# =========================================================================== #
-# require 'bioroebe/shell/chop_and_cut.rb'
-# =========================================================================== #
-module Bioroebe
-
-class Shell < ::Bioroebe::CommandlineApplication
-
-  # ========================================================================= #
-  # === chop                                                       (chop tag)
-  #
-  # We use this method to get rid of some nucleotides, from the 3'
-  # end of a nucleotide sequence (aka the "right hand side" of it) by
-  # default.
-  #
-  # The first argument to this method tells us how many nucleotides are
-  # to be removed.
-  #
-  # The second argument determines whether to chop from the right side
-  # (the 3' side) or from the left side (the 5' side).
-  # ========================================================================= #
-  def chop(
-      i = 1,
-      chop_from_left_or_right_hand_side = :default # The default is the 3' end.
-    ) # Default will be to chop off one nucleotide.
-    if is_the_main_sequence_frozen?
-      report_that_the_main_sequence_is_frozen
-      return
-    end
-    i = i.first if i.is_a? Array
-    if i == '?'
-      e 'chop allows us to remove nucleotides from the main sequence.'
-      return
-    end
-    i = 1 if i.nil? # Assign to the default then.
-    i = i.to_i # Need a number past this point.
-    if i == 0
-      erev 'Please add a number, such as 1, or any other value.'
-    else
-      case chop_from_left_or_right_hand_side
-      # ===================================================================== #
-      # === :right
-      # ===================================================================== #
-      when :right,
-           :default
-        which_end = "3'"
-      # ===================================================================== #
-      # === :left
-      # ===================================================================== #
-      when :left
-        which_end = "5'"
-      end
-      if dna_sequence_object?.size > 0
-        erev "We will now remove some characters (#{simp(i.to_s)}#{rev}"\
-             ") from the #{which_end} end of our main string."
-      end
-      if dna_sequence_object?.size == 0
-        erev 'Can not remove anything as the sequence is empty.'
-      elsif i > dna_sequence_object?.size
-        erev 'We can not remove that many characters, thus we will'
-        erev 'simply remove all characters now.'
-        reset_string 
-      else
-        # =================================================================== #
-        # Finally do the manipulation. We need to honour from which
-        # side we will be operating on.
-        # =================================================================== #
-        case chop_from_left_or_right_hand_side
-        # =================================================================== #
-        # === :default
-        # =================================================================== #
-        when :default,
-             :right
-          # ================================================================= #
-          # We also store the chopped-away sequence, but we have to be
-          # mindful here since the sequence-object counts the nucleotides
-          # differently than ruby counts Arrays.
-          # ================================================================= #
-          @internal_hash[:array_these_sequences_were_chopped_away] << seq_object?[(-i)+1, i-1].dup
-          seq_object?[-i, i] = ''
-        # =================================================================== #
-        # === :left
-        # =================================================================== #
-        when :left
-          @internal_hash[:array_these_sequences_were_chopped_away] << seq_object?[0, i].dup
-          seq_object?[0, i+1] = ''
-        end
-      end
-      unless dna_sequence_object?.size == 0
-        erev "#{rev}The new length of the main string is now: "\
-             "#{simp(dna_sequence_object?.size.to_s)}#{rev}."
-      end
-      show_dna_sequence
-    end
-  end; alias remove_n_nucleotides chop # === remove_n_nucleotides
-
-  # ========================================================================= #
-  # === cut_sequence_in_slices_of
-  #
-  # This method cuts the sequence into slices of n, where n is the
-  # argument to this method.
-  #
-  # So if you input 10 as argument, then we will put the nucleotides
-  # into chunks of 10 nucleotides per row.
-  #
-  # Usage examples:
-  #
-  #   cut_sequence_in_slices_of 5
-  #   cut_sequence_in_slices_of 6
-  #   cut_sequence_in_slices_of 7
-  #
-  # ========================================================================= #
-  def cut_sequence_in_slices_of(threshold = '9')
-    _ = dna_sequence_object?
-    matches = _.scan(/.{#{threshold}}/)
-    matches.each {|entry|
-      erev '  '+entry
-    }
-  end
-
-  # ========================================================================= #
-  # === left_chop
-  # ========================================================================= #
-  def left_chop(i)
-    chop(i, :left)
-  end
-
-  # ========================================================================= #
-  # === cut_at
-  #
-  # Use this method to chop off or rather cut at a DNA sequence.
-  # ========================================================================= #
-  def cut_at(
-      this_sequence = 'GAATTC',
-      be_verbose    = true
-    )
-    main_sequence = dna_sequence_object?
-    this_sequence = this_sequence.join.strip if this_sequence.is_a? Array
-    if be_verbose
-      erev "We will chop away (at) the sequence #{simp(this_sequence)}#{rev}."
-      erev 'Note that the sequences all originated from the larger '\
-           'parent sequence.'
-    end
-    results = main_sequence.split(/#{this_sequence}/)
-    results.each {|sequence|
-      _ = properly_spaced_dna(sequence)
-      _ << (' ('+sequence.size.to_s+' nucleotides)').rjust(110 - sequence.size)
-      erev _
-    }
-  end
-
-  # ========================================================================= #
-  # === restore_the_last_chop_operation
-  #
-  # This method will "restore" the last chop operation.
-  #
-  # Presently it will only append onto the 3' area but in the future
-  # this may change, depending on whether we will store the position
-  # as well.
-  # ========================================================================= #
-  def restore_the_last_chop_operation
-    if @internal_hash[:array_these_sequences_were_chopped_away].empty?
-      erev 'Can not restore the last chop-operation as we have not yet'
-      erev 'chopped away any nucleotide from the main sequence.'
-    else
-      this_sequence = @internal_hash[:array_these_sequences_were_chopped_away].pop
-      erev 'Now adding the sequence '+
-           format_this_nucleotide_sequence(
-             this_sequence
-           )
-      erev 'to our main sequence.'
-      main_sequence?.append(this_sequence)
-    end
-  end
-
-  # ========================================================================= #
-  # === chop_to
-  #
-  # This method will chop up to the first occurence of the given input
-  # sequence.
-  #
-  # If the given input sequence can not be found, no change is made.
-  # ========================================================================= #
-  def chop_to(i)
-    if i.is_a? Array
-      i = i.first
-    end
-    case i
-    when 'start'
-      i = 'ATG'
-    end
-    _ = nucleotide_sequence?
-    if i.include? 'U'
-      # ===================================================================== #
-      # Convert Uracil to Thymine next.
-      # ===================================================================== #
-      erev "The given input sequence includes at the least one "\
-           "#{sfancy('U')}#{rev}, which we will convert to #{sfancy('T')}#{rev}."
-      i.tr!('U','T')
-    end
-    if _.include? i
-      # ===================================================================== #
-      # Ok, we found the search sequence, so now we can chop off the
-      # unnecessary sequences.
-      # ===================================================================== #
-      position = _.index(i)
-      erev "Chopping away #{sfancy(position.to_s)}#{rev} nucleotides from "\
-           "the left-hand side (5' end) next."
-      @internal_hash[:array_these_sequences_were_chopped_away] << seq_object?[0, position+1]
-      seq_object?[0, position+1] = ''
-      show_dna_sequence
-    else
-      erev 'No modification can be made as our target nucleotide sequence'
-      erev "does not include the given search string #{sfancy(i)}."
-    end
-  end
-
-  # ========================================================================= #
-  # === cut                                                         (cut tag)
-  #
-  # This method will cut away some part from the DNA string.
-  # ========================================================================= #
-  def cut(i)
-    i = i.to_i
-    @sequence[-i,i] = ''
-    show_dna_sequence
-  end
-
-  # ========================================================================= #
-  # === cutseq
-  #
-  # This can be used to modify the sequence object. It will cut some
-  # segment out from the nucleotide.
-  #
-  # Usage examples:
-  #
-  #   random 30; cutseq 5 8
-  #   random 30; cutseq 5-8
-  #
-  # ========================================================================= #
-  def cutseq(i = [1,3])
-    if i.is_a? Array
-      if i.size == 1 and i.first.is_a? String and i.first.include?('-')
-        i = [i.first.split('-')].flatten
-      end
-      if i.empty? # In this case we will ask the user for input.
-        erev 'No argument was provided. Please input the start nucleotide position next:'
-        start_position = $stdin.gets.chomp.to_i
-        erev 'Next, input the end nucleotide position:'
-        end_position   = $stdin.gets.chomp
-      elsif i.size > 1
-        start_position = i.first
-        end_position   = i.last
-      end
-    end
-    # ======================================================================= #
-    # === Handle +3 relational position given
-    # ======================================================================= #
-    if end_position.is_a? String and end_position.include?('+')
-      end_position = start_position + end_position.delete('+').to_i
-    end
-    n_nucleotides_will_be_deleted = (end_position.to_i - start_position.to_i)+1
-    # ======================================================================= #
-    # Notify the user what we will do next.
-    # ======================================================================= #
-    erev 'Next cutting away '+simp(n_nucleotides_will_be_deleted.to_s)+
-          rev+' nucleotides.'
-    sequence_object?[start_position, end_position] = ''
-  end
-
-  # ========================================================================= #
-  # === cut_with_enzyme
-  # ========================================================================= #
-  def cut_with_enzyme(i)
-    i = i.join(' ').strip if i.is_a? Array
-    pp sequence_object?.cut_with_enzyme(i)
-  end
-
-end; end