wrnap 0.12.2 → 1.0.1

data/lib/wrnap/rna/motifs.rb

@@ -0,0 +1,72 @@
+module Wrnap
+  class Rna
+    module Motifs
+      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(lonely_bp: false)
+        helices.map { |((i, j), *rest)| Helix.new(i, j, rest.length + 1) }.select { |helix| lonely_bp ? helix : helix.length > 1 }
+      end
+    end
+
+    class Helix
+      attr_reader :i, :j, :length
+
+      def initialize(i, j, length)
+        @i, @j, @length = i, j, length
+      end
+      
+      def k; i + length - 1; end
+      def l; j - length + 1; end
+      
+      def to_loops
+        [Loop.new(i, k), Loop.new(l, j)]
+      end
+
+      def reindex!(rna)
+        tap do
+          if i < 0 && j < 0
+            @i = rna.len + i
+            @j = rna.len + j
+          else
+            @i = i - rna.len
+            @j = j - rna.len
+          end
+        end
+      end
+
+      def name
+        "(%d..%d, %d..%d)" % [i, k, l, j]
+      end
+
+      def inspect
+        "#<Helix: %s>" % name
+      end
+    end
+    
+    class Loop
+      attr_reader :i, :j
+      
+      def initialize(i, j)
+        @i, @j = i, j
+      end
+      
+      def name
+        "(%d, %d)" % [i, j]
+      end
+      
+      def inspect
+        "#<Loop: %s>" % name
+      end
+    end
+  end
+end

data/lib/wrnap/rna/tree.rb

@@ -0,0 +1,136 @@
+module Wrnap
+  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 TreeStem < Tree::TreeNode
+      extend Forwardable
+      include Enumerable
+
+      STEM_NOTATION_REGEX = /^p((\d+_)*(\d+))(_?([ijkl]))?$/
+
+      def_delegators :@content, :i, :j
+      def_delegator  :@content, :length, :stem_length
+
+      def method_missing(name, *args, &block)
+        if name.to_s =~ STEM_NOTATION_REGEX
+          if $2 && child = children[$2.to_i - 1]
+            child.send("p%s" % name.to_s.gsub(/^p\d+_/, ""))
+          elsif child = children[$1.to_i - 1]
+            $5 ? child.content.send($5) : child.content
+          else
+            nil
+          end
+        else super end
+      end
+    end
+
+    class TreePlanter
+      attr_reader :rna, :root
+
+      def initialize(rna, tree = false)
+        @rna  = rna
+        @root = tree || build_tree(rna.collapsed_helices)
+      end
+
+      def build_tree(helices)
+        helices.inject(TreeStem.new(:root, rna)) do |tree, helix|
+          add_node(tree, TreeStem.new(helix.name, helix))
+        end.root
+      end
+
+      def extend_tree(*helices)
+        self.class.new(rna, rebuild_tree(helices))
+      end
+
+      def extend_tree!(*helices)
+        tap { @root = rebuild_tree(helices) }
+      end
+
+      def rebuild_tree(helices)
+        build_tree((root.map(&:content).select { |helix| helix.is_a?(Helix) } + helices.flatten).sort_by(&:i))
+      end
+
+      def add_node(subtree, node)
+        # This function has an implicit, *very important* expectation that nodes are added in a depth-first, preorder traversal fashion.
+        # What this means is that given a tree containing two sibling nodes (i, j), (k, l), you can't later add another node (m, n) which
+        # makes (i, j), (k, l) into a multiloop. (m, n) *must* be added before any of it's children for the resulting structure to be accurate.
+
+        # Case 1: the tree is empty.
+        if subtree.is_root? && subtree.size == 1
+          subtree << node
+        # Case 2: the node to add is after the current stem.
+        elsif node.i > subtree.j
+          # It's a sibling, pop up until we're at its parent node.
+          subtree = subtree.parent until subtree.is_root? || subtree.j > node.i
+          node.tap { subtree << node }
+        # Case 3: the node to add is within the current stem.
+        elsif node.j < subtree.j
+          # Going deeper.
+          subtree << node
+        end
+      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
+          
+          extend_tree!
+        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
+
+      def method_missing(name, *args, &block)
+        if name.to_s =~ TreeStem::STEM_NOTATION_REGEX
+          root.send(name, *args, &block)
+        else super end
+      end
+
+      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

data/lib/wrnap/rna/wrapper.rb

@@ -0,0 +1,9 @@
+module Wrnap
+  class Rna
+    module Wrnapper
+      def wrnap
+        Wrnap::Rna::Box.new(self)
+      end
+    end
+  end
+end

data/lib/wrnap/version.rb

@@ -1,3 +1,3 @@
 module Wrnap
-  VERSION = "0.12.2"
+  VERSION = "1.0.1"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: wrnap
 version: !ruby/object:Gem::Version
-  version: 0.12.2
+  version: 1.0.1
 platform: ruby
 authors:
 - Evan Senter
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-07-18 00:00:00.000000000 Z
+date: 2014-07-31 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -168,13 +168,8 @@ files:
 - lib/wrnap/global/chainer.rb
 - lib/wrnap/global/entrez.rb
 - lib/wrnap/global/parser.rb
-- lib/wrnap/global/rna.rb
-- lib/wrnap/global/rna/context.rb
-- lib/wrnap/global/rna/extensions.rb
-- lib/wrnap/global/rna/helix.rb
-- lib/wrnap/global/rna/metadata.rb
-- lib/wrnap/global/rna/tree.rb
 - lib/wrnap/global/runner.rb
+- lib/wrnap/global/yaml.rb
 - lib/wrnap/graphing/r.rb
 - lib/wrnap/package/base.rb
 - lib/wrnap/package/energy_grid_2d.rb
@@ -188,6 +183,7 @@ files:
 - lib/wrnap/package/ffthairpin.rb
 - lib/wrnap/package/fftmultiloop.rb
 - lib/wrnap/package/fold.rb
+- lib/wrnap/package/fold_constrained.rb
 - lib/wrnap/package/heat.rb
 - lib/wrnap/package/kinwalker.rb
 - lib/wrnap/package/mfpt.rb
@@ -199,6 +195,15 @@ files:
 - lib/wrnap/package/tabu_path.rb
 - lib/wrnap/package/varna.rb
 - lib/wrnap/package/xbor.rb
+- lib/wrnap/rna.rb
+- lib/wrnap/rna/box.rb
+- lib/wrnap/rna/constraints.rb
+- lib/wrnap/rna/context.rb
+- lib/wrnap/rna/extensions.rb
+- lib/wrnap/rna/metadata.rb
+- lib/wrnap/rna/motifs.rb
+- lib/wrnap/rna/tree.rb
+- lib/wrnap/rna/wrapper.rb
 - lib/wrnap/version.rb
 - wrnap.gemspec
 homepage: ''
@@ -221,7 +226,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.3.0
+rubygems_version: 2.2.2
 signing_key: 
 specification_version: 4
 summary: A comprehensive wrapper (wRNApper) for various RNA CLI programs.

data/lib/wrnap/global/rna.rb

@@ -1,190 +0,0 @@
-module Wrnap
-  module Global
-    class Rna
-      extend  Forwardable
-      include Extensions
-      include Metadata
-      include TreeFunctions
-      include HelixFunctions
-
-      CANONICAL_BASES = Set.new << Set.new([?G, ?C]) << Set.new([?A, ?U]) << Set.new([?G, ?U])
-
-      attr_accessor :comment
-      attr_reader :sequence, :structure, :second_structure, :metadata
-
-      class << self
-        def init_from_string(sequence, structure = nil, second_structure = nil, comment = nil, &block)
-          new(
-            sequence:         sequence,
-            structure:        structure,
-            second_structure: second_structure,
-            comment:          comment,
-            &block
-          )
-        end
-
-        def init_from_hash(hash, &block)
-          new(
-            sequence:         hash[:sequence]         || hash[:seq],
-            structure:        hash[:structure]        || hash[:str_1] || hash[:str],
-            second_structure: hash[:second_structure] || hash[:str_2],
-            comment:          hash[:comment]          || hash[:name],
-            &block
-          )
-        end
-
-        def init_from_array(array, &block)
-          init_from_string(*array, &block)
-        end
-
-        def init_from_fasta(string, &block)
-          if File.exist?(string)
-            comment = File.basename(string, string.include?(?.) ? ".%s" % string.split(?.)[-1] : "")
-            string  = File.read(string).chomp
-          end
-
-          init_from_string(*string.split(/\n/).reject { |line| line.start_with?(">") }[0, 3], &block).tap do |rna|
-            if (line = string.split(/\n/).first).start_with?(">") && !(file_comment = line.gsub(/^>\s*/, "")).empty?
-              rna.comment = file_comment
-            elsif comment
-              rna.comment = comment
-            end
-          end
-        end
-
-        def init_from_context(*context, coords: {}, rna: {}, &block)
-          Context.init_from_entrez(*context, coords: coords, rna: rna, &block)
-        end
-
-        def init_from_self(rna, &block)
-          # This happens when you call a Wrnap library function with the output of something like Wrnap::Fold.run(...).mfe
-          new(
-            sequence:         rna.sequence,
-            strucutre:        rna.structure,
-            second_strucutre: rna.second_structure,
-            comment:          rna.comment,
-            &block
-          )
-        end
-
-        alias_method :placeholder, :new
-      end
-
-      def initialize(sequence: "", structure: "", second_structure: "", comment: "", &block)
-        @sequence, @comment, @metadata = (sequence.kind_of?(Rna) ? sequence.seq : sequence).upcase, comment, Metadata::Container.new(self)
-
-        [:structure, :second_structure].each do |structure_symbol|
-          instance_variable_set(
-            :"@#{structure_symbol}",
-            case structure_value = eval("#{structure_symbol}")
-            when :empty then empty_structure
-            when :mfe   then RNA(sequence).run(:fold).mfe_rna.structure
-            when String then structure_value
-            when Hash   then
-              if structure_value.keys.count > 1
-                Wrnap.debugger { "The following options hash has more than one key. This will probably produce unpredictable results: %s" % structure_value.inspect }
-              end
-
-              RNA(sequence).run(*structure_value.keys, *structure_value.values).mfe_rna.structure
-            end
-          )
-        end
-
-        metadata.instance_eval(&block) if block_given?
-
-        if str && seq.length != str.length
-          Wrnap.debugger { "The sequence length (%d) doesn't match the structure length (%d)" % [seq, str].map(&:length) }
-        end
-
-        if str_2 && str_1.length != str_2.length
-          Wrnap.debugger { "The first structure length (%d) doesn't match the second structure length (%d)" % [str_1, str_2].map(&:length) }
-        end
-      end
-
-      alias :seq   :sequence
-      alias :str   :structure
-      alias :str_1 :structure
-      alias :str_2 :second_structure
-      alias :name  :comment
-
-      def copy_name_from(rna)
-        tap { @comment = rna.name }
-      end
-
-      def empty_structure
-        "." * seq.length
-      end
-
-      alias :empty_str :empty_structure
-
-      def no_structure
-        self.class.init_from_string(seq, nil, nil, name)
-      end
-
-      alias :no_str :no_structure
-
-      def one_structure(structure_1)
-        self.class.init_from_string(seq, structure_1.is_a?(Symbol) ? send(structure_1) : structure_1, nil, name)
-      end
-
-      alias :one_str :one_structure
-
-      def two_structures(structure_1, structure_2)
-        self.class.init_from_string(
-          seq,
-          *[structure_1, structure_2].map { |argument| argument.is_a?(Symbol) ? send(argument) : argument },
-          name
-        )
-      end
-
-      alias :two_str :two_structures
-
-      def write_fa!(filename)
-        filename.tap do |filename|
-          File.open(filename, ?w) do |file|
-            file.write("> %s\n" % name) if name
-            file.write("%s\n" % seq)    if seq
-            file.write("%s\n" % str_1)  if str_1
-            file.write("%s\n" % str_2)  if str_2
-          end
-        end
-      end
-
-      def temp_fa_file!
-        write_fa!(Tempfile.new("rna")).path
-      end
-
-      def run(package_name, options = {})
-        Wrnap::Package.lookup(package_name).run(self, options)
-      end
-
-      def ==(other_rna)
-        other_rna.kind_of?(Wrnap::Global::Rna) ? [seq, str_1, str_2] == [other_rna.seq, other_rna.str_1, other_rna.str_2] : super
-      end
-
-      def method_missing(name, *args, &block)
-        if (name_str = "#{name}") =~ /^run_\w+$/
-          run(name_str.gsub(/^run_/, ""), *args)
-        else super end
-      end
-
-      def pp
-        puts("> %s" % name)       if name
-        puts("%s" % seq)          if seq
-        puts("%s" % str_1)        if str_1
-        puts("%s" % str_2)        if str_2
-        puts("%s" % meta.inspect) if meta
-      end
-
-      def inspect
-        "#<RNA: %s>" % [
-          ("#{seq[0, 20]   + (seq.length > 20   ? '... [%d]' % seq.length : '')}" if seq   && !seq.empty?),
-          ("#{str_1[0, 20] + (str_1.length > 20 ? ' [%d]'    % seq.length : '')}" if str_1 && !str_1.empty?),
-          ("#{str_2[0, 20] + (str_2.length > 20 ? ' [%d]'    % seq.length : '')}" if str_2 && !str_1.empty?),
-          (md.inspect unless md.nil? || md.empty?),
-          (name ? name : "#{self.class.name}")
-        ].compact.join(", ")
-      end
-    end
-  end
-end