wrnap 0.12.2 → 1.0.1

data/lib/wrnap/rna/box.rb

@@ -0,0 +1,43 @@
+module Wrnap
+  class Rna
+    class Box
+      extend Forwardable
+      include Enumerable
+      include Wrnap::Global::Yaml
+
+      attr_reader :rnas
+
+      class << self
+        def load_all(pattern = "*.fa", &block)
+          new(Dir[File.directory?(pattern) ? pattern + "/*.fa" : pattern].map { |file| RNA.from_fasta(file, &block) })
+        end
+      end
+
+      def initialize(rnas)
+        @rnas = rnas.kind_of?(Array) ? rnas : [rnas]
+      end
+
+      def pp
+        rnas.each(&:pp) and nil
+      end
+
+      def +(arrayish)
+        self.class.new(rnas + (arrayish.is_a?(Box) ? arrayish.rnas : arrayish))
+      end
+
+      def_delegators :@rnas, *%i|size length [] []= <<|
+
+      def each(&block)
+        rnas.each(&block)
+      end
+
+      def kind_of?(klass)
+        klass == Array ? true : super
+      end
+
+      def inspect
+        "#<Wrnap::Rna::Box with %d RNAs>" % rnas.size
+      end
+    end
+  end
+end

data/lib/wrnap/rna/constraints.rb

@@ -0,0 +1,119 @@
+module Wrnap
+  class Rna
+    module Constraints
+      def self.included(base)
+        base.send(:include, InstanceMethods)
+      end
+
+      module InstanceMethods
+        def constraint_mask
+          md[:constraint_mask]
+        end
+
+        def build_constraints(&block)
+          meta_rna do |metadata|
+            constraint_mask(ConstraintBox.new(metadata.__rna__).tap { |box| box.instance_eval(&block) })
+          end
+        end
+      end
+
+      class ConstraintBox
+        attr_reader :rna, :constraints
+
+        def initialize(rna)
+          @rna, @constraints = rna, []
+        end
+
+        def between(i, j)
+          Loop.new(i, j)
+        end
+        
+        def inside(i, j)
+          between(i + 1, j - 1)
+        end
+        
+        def mask!(mask_object, *args)
+          case mask_object
+          when Helix then mask_helix!(mask_object, *args)
+          when Loop  then mask_loop!(mask_object, symbol: args[0][:symbol])
+          end
+        end
+
+        def mask_helix!(helix, side: :both, symbol: "()")
+          left_loop, right_loop = helix.to_loops
+
+          if symbol.length > 1
+            left_symbol, right_symbol = symbol.split(//)
+          else
+            left_symbol = right_symbol = symbol
+          end
+
+          mask_loop!(left_loop,  symbol: left_symbol)  if side == :left  || side == :both
+          mask_loop!(right_loop, symbol: right_symbol) if side == :right || side == :both
+        end
+        
+        def mask_loop!(l00p, symbol: "x")
+          mask_region!(l00p.i, l00p.j, symbol: symbol)
+        end
+        
+        def mask_region!(i, j, symbol: "x")
+          raise ArgumentError.new("Trying to apply symbol '%s' from %d to %d, all symbols must be 1 char long." % [symbol, i, j]) if symbol.length > 1
+          
+          constraints << ConstraintData.new(i, j, symbol)
+          prune!
+        end
+
+        def prune!
+          @constraints = constraints.group_by(&:name).map(&:last).map(&:first)
+        end
+
+        def inspect
+          "#<Constraints: %s>" % constraints.map(&:name).join(", ")
+        end
+
+        def to_s
+          (?. * rna.len).tap do |string|
+            constraints.each { |constraint| string[constraint.from..constraint.to] = constraint.symbol * constraint.length }
+          end
+        end
+        
+        alias :mask :to_s
+
+        def method_missing(name, *args, &block)
+          method_name = name.to_s
+          
+          if method_name =~ TreeStem::STEM_NOTATION_REGEX
+            rna.trunk.send(method_name)
+          elsif mask_type = method_name.match(/^(prohibit|force)(_(left|right)_stem)?$/)
+            side_symbol = mask_type[3] ? mask_type[3].to_sym : :both
+
+            case mask_type[1]
+            when "prohibit" then mask!(args[0], side: side_symbol, symbol: args[1] || ?x)
+            when "force"    then mask!(args[0], side: side_symbol, symbol: args[1] || "()")
+            end
+          else super end
+        end
+      end
+
+      class ConstraintData
+        attr_reader :from, :to, :symbol
+
+        def initialize(from, to, symbol)
+          @from, @to, @symbol = from, to, symbol
+        end
+
+        def name
+          "(%d to %d as '%s')" % [from, to, symbol]
+        end
+
+        def length
+          to - from + 1
+        end
+
+        def inspect
+          "#<Constraint: %s>" % name
+        end
+      end
+    end
+  end
+end

data/lib/wrnap/rna/context.rb

@@ -0,0 +1,139 @@
+module Wrnap
+  class Rna
+    class Context < Rna
+      attr_reader :accession, :from, :to, :coord_options
+
+      class << self
+        def init_from_entrez(accession, from, to, options = {}, &block)
+          new(
+            accession: accession,
+            from:      from,
+            to:        to,
+            options:   options,
+            &block
+          )
+        end
+
+        def init_from_string(sequence, accession, from, to, options = {}, &block)
+          new(
+            sequence:  sequence,
+            accession: accession,
+            from:      from,
+            to:        to,
+            options:   options,
+            &block
+          )
+        end
+      end
+
+      def initialize(sequence: nil, accession: nil, from: nil, to: nil, options: {}, &block)
+        options = { coords: {}, rna: {} }.merge(options)
+
+        @accession, @from, @to, @coord_options = accession, from, to, options[:coords]
+
+        validate_coord_options
+
+        if sequence
+          @raw_sequence = (sequence.is_a?(String) ? Bio::Sequence::NA.new(sequence) : sequence).upcase
+        end
+
+        super(
+          sequence:         self.sequence,
+          structure:        options[:rna][:structure]        || options[:rna][:str_1] || options[:rna][:str],
+          second_structure: options[:rna][:second_structure] || options[:rna][:str_2],
+          comment:          options[:rna][:comment]          || options[:rna][:name] || identifier,
+          &block
+        )
+
+        remove_instance_variable(:@sequence)
+      end
+
+      def validate_coord_options
+        unless coord_options.empty?
+          unless Set.new(coord_options.keys) == Set.new(%i|direction length|)
+            raise ArgumentError.new("coord_options keys must contain only [:direction, :length], found: %s" % coord_options.keys)
+          end
+
+          unless (length = coord_options[:length]).is_a?(Integer) && length > 0
+            raise ArgumentError.new("coord_options length must be greater than 0, found: %d" % length)
+          end
+
+          unless [:up, :down, :both, 5, 3].include?(direction = coord_options[:direction])
+            raise ArgumentError.new("coord_options directions is not a valid key, found: %s" % direction)
+          end
+        end
+      end
+
+      def up_coord
+        [from, to].min
+      end
+
+      def down_coord
+        [from, to].max
+      end
+
+      def seq_from
+        up_coord + coord_window.min
+      end
+
+      def seq_to
+        up_coord + coord_window.max
+      end
+
+      def strand
+        plus_strand? ? :plus : :minus
+      end
+
+      def plus_strand?
+        to > from
+      end
+
+      def minus_strand?
+        !plus_strand?
+      end
+
+      def sequence
+        if @raw_sequence
+          @raw_sequence
+        else
+          entrez_sequence = Wrnap::Global::Entrez.rna_sequence_from_entrez(accession, up_coord, coord_window)
+          @raw_sequence   = (minus_strand? ? entrez_sequence.complement : entrez_sequence).upcase
+        end
+      end
+
+      alias :seq :sequence
+
+      def extend!(coord_options = {})
+        self.class.init_from_entrez(accession, from, to, coords: coord_options)
+      end
+
+      def coord_window
+        # This does not support extending the range in both directions, though it should be easy to do.
+        # Options from coord_options ex: { length: 300, direction: 3 }, { length: 250, direction: :both }, { length: 200, direction: :down }
+        range = 0..(down_coord - up_coord)
+
+        if coord_options[:length] && coord_options[:direction]
+          if coord_options[:direction] == :both
+            Range.new(range.min - coord_options[:length], range.max + coord_options[:length])
+          else
+            case [coord_options[:direction], strand]
+            when [3, :plus], [:down, :plus], [5, :minus], [:up, :minus] then Range.new(range.min, range.max + coord_options[:length])
+            when [5, :plus], [:up, :plus], [3, :minus], [:down, :minus] then Range.new(range.min - coord_options[:length], range.max)
+            else Wrnap.debugger { "WARNING: value for :direction key in sequence retreival needs to be one of 5, 3, :both - found (%s)" % coord_options[:direction].inspect }
+            end
+          end
+        else
+          range
+        end
+      end
+
+      def identifier
+        "%s %d %s %d" % [accession, from, plus_strand? ? ?+ : ?-, to]
+      end
+
+      def inspect
+        super.gsub(/((\w(::)?)+)>$/) { |_| "%s %s>" % [identifier, $1] }
+      end
+    end
+  end
+end

data/lib/wrnap/rna/extensions.rb

@@ -0,0 +1,102 @@
+module Wrnap
+  class Rna
+    module Extensions
+      def self.included(base)
+        base.send(:include, InstanceMethods)
+        base.extend(ClassMethods)
+        base.extend(OneStructureBasedMethods)
+        base.extend(TwoStructureBasedMethods)
+        base.class_eval do
+          OneStructureBasedMethods.public_instance_methods.each do |class_method|
+            define_method(class_method) do |*args|
+              self.class.send(class_method, *[structure].concat(args))
+            end
+          end
+
+          TwoStructureBasedMethods.public_instance_methods.each do |class_method|
+            define_method(class_method) do |*args|
+              self.class.send(class_method, *[str_1, str_2].concat(args))
+            end
+          end
+        end
+
+        base.send(:include, InstanceMethods)
+      end
+
+      module ClassMethods
+        def generate_sequence(sequence_length)
+          # 0th order Markov chain w/ uniform probability distribution
+          Rna.init_from_string(sequence_length.times.inject("") { |string, _| string + %w[A U C G][rand(4)] })
+        end
+
+        def shuffle(sequence, token_length = 2)
+          Shuffle.new(sequence).shuffle(token_length)
+        end
+
+        def structure_from_bp_list(length, base_pairs)
+          base_pairs.to_a.map(&:to_a).map(&:sort).inject("." * length) { |structure, (i, j)| structure.tap { structure[i] = ?(; structure[j] = ?) } }
+        end
+      end
+
+      module InstanceMethods
+        def dishuffle
+          self.class.shuffle(sequence, 2)
+        end
+
+        def gc_content
+          seq.split(//).select { |i| i =~ /[GC]/i }.size.to_f / seq.size
+        end
+
+        def boltzmann_probability(dangle: 2)
+          Math.exp(-run(:eval, d: dangle).mfe / Wrnap::RT) / Math.exp(-run(:fold, d: dangle, p: 0).ensemble_energy / Wrnap::RT)
+        end
+      end
+
+      module OneStructureBasedMethods
+        def max_bp_distance(structure)
+          base_pairs(structure).count + ((structure.length - 3) / 2.0).floor
+        end
+
+        def base_pairs(structure)
+          get_pairings(structure).each_with_index.inject(Set.new) do |set, (j, i)|
+            j >= 0 ? set << Set[i, j] : set
+          end
+        end
+
+        def get_pairings(structure)
+        	stack = []
+
+          structure.each_char.each_with_index.inject(Array.new(structure.length, -1)) do |array, (symbol, index)|
+        	  array.tap do
+        	    case symbol
+        	    when "(" then stack.push(index)
+        	    when ")" then
+        	      if stack.empty?
+        	        raise "Too many ')' in '#{structure}'"
+        	      else
+        	        stack.pop.tap do |opening|
+        	          array[opening] = index
+        	          array[index]   = opening
+        	        end
+        	      end
+        	    end
+        	  end
+        	end.tap do
+        	  raise "Too many '(' in '#{structure}'" unless stack.empty?
+        	end
+        end
+      end
+
+      module TwoStructureBasedMethods
+        def bp_distance(structure_1, structure_2)
+          # Takes two structures and calculates the distance between them by |symmetric difference(bp_in_a, bp_in_b)|
+          raise "The two structures are not the same length" unless structure_1.length == structure_2.length
+
+          bp_set_1, bp_set_2 = base_pairs(structure_1), base_pairs(structure_2)
+
+          ((bp_set_1 - bp_set_2) + (bp_set_2 - bp_set_1)).count
+        end
+      end
+    end
+  end
+end

data/lib/wrnap/rna/metadata.rb

@@ -0,0 +1,46 @@
+module Wrnap
+  class Rna
+    module Metadata
+      def self.included(base)
+        base.send(:include, InstanceMethods)
+      end
+
+      module InstanceMethods
+        def self.included(base)
+          base.class_eval do
+            def_delegator :@metadata, :__data__, :md
+          end
+        end
+
+        def meta(&block)
+          metadata.tap { metadata.instance_eval(&block) if block_given? }
+        end
+
+        def meta_rna(&block)
+          metadata.__rna__.tap { meta(&block) }
+        end
+      end
+
+      class Container
+        attr_reader :__rna__, :__data__
+
+        def initialize(rna)
+          @__rna__, @__data__ = rna, {}
+        end
+
+        def inspect
+          "#<Metadata: %s>" % __data__.inspect
+        end
+
+        alias :to_s :inspect
+
+        def method_missing(name, *args, &block)
+          case args.size
+          when 0 then __data__[name]
+          when 1 then __data__[name.to_s.gsub(/=$/, "").to_sym] = args.first
+          else super end
+        end
+      end
+    end
+  end
+end