wrnap 0.12.2 → 1.0.1

data/lib/wrnap/global/rna/context.rb

@@ -1,141 +0,0 @@
-module Wrnap
-  module Global
-    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 = 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
-end

data/lib/wrnap/global/rna/extensions.rb

@@ -1,104 +0,0 @@
-module Wrnap
-  module Global
-    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
-end

data/lib/wrnap/global/rna/helix.rb

@@ -1,36 +0,0 @@
-module Wrnap
-  module Global
-    class Rna
-      module HelixFunctions
-        def helices
-          array = base_pairs.sort_by(&:first).map(&:to_a)
-
-          unless array.empty?
-            array[1..-1].inject([[array.first]]) do |bins, (i, j)|
-              bins.tap { bins[-1][-1] == [i - 1, j + 1] ? bins[-1] << [i, j] : bins << [[i, j]] }
-            end
-          else
-            []
-          end
-        end
-
-        def collapsed_helices
-          helices.map { |((i, j), *rest)| Helix.new(i, j, rest.length + 1) }
-        end
-      end
-
-      class Helix
-        attr_reader :i, :j
-        attr_accessor :length
-
-        def initialize(i, j, length)
-          @i, @j, @length = i, j, length
-        end
-
-        def name
-          "(%d, %d)" % [i, j]
-        end
-      end
-    end
-  end
-end

data/lib/wrnap/global/rna/metadata.rb

@@ -1,48 +0,0 @@
-module Wrnap
-  module Global
-    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
-end

data/lib/wrnap/global/rna/tree.rb

@@ -1,87 +0,0 @@
-module Wrnap
-  module Global
-    class Rna
-      module TreeFunctions
-        def with_tree
-          meta_rna { |metadata| tree(TreePlanter.new(metadata.__rna__)) }
-        end
-
-        def trunk
-          md[:tree] || with_tree.trunk
-        end
-      end
-
-      class TreePlanter
-        attr_reader :rna, :root
-
-        def initialize(rna, tree = false)
-          @rna  = rna
-          @root = tree || build_tree
-        end
-
-        def build_tree
-          rna.collapsed_helices.inject(Tree::TreeNode.new(:root, rna)) do |tree, helix|
-            node = Tree::TreeNode.new(helix.name, helix)
-
-            if tree.is_root?
-              tree << node
-            elsif helix.i > tree.content.j
-              # It's a sibling, pop up until we're at its parent node.
-              tree = tree.parent until tree.is_root? || tree.content.j > helix.i
-              node.tap { tree << node }
-            elsif helix.j < tree.content.j
-              # Going deeper.
-              tree << node
-            end
-          end.root
-        end
-
-        def coalesce
-          self.class.new(rna, root.dup).tap { |tree| tree.merge_interior_loops! }
-        end
-
-        def coalesce!
-          tap { merge_interior_loops! }
-        end
-
-        def merge_interior_loops!
-          root.tap do
-            self.class.postorder_traversal(root) do |node|
-              if node.children.count == 1 && !node.is_root?
-                child = node.children.first
-                node.parent.add(child)
-                node.remove_from_parent!
-              end
-            end
-          end
-        end
-
-        def depth_signature
-          root.map(&:node_depth)
-        end
-
-        def pp
-          root.print_tree and nil
-        end
-
-        def inspect
-          "#<TreePlanter: %s>" % depth_signature.inspect
-        end
-
-        alias :to_s :inspect
-
-        class << self
-          def preorder_traversal(node, &block)
-            node.children.map { |child| preorder_traversal(child, &block) }
-            yield node
-          end
-
-          def postorder_traversal(node, &block)
-            node.children.map { |child| postorder_traversal(child, &block) }
-            yield node
-          end
-        end
-      end
-    end
-  end
-end