wrnap 0.10.0 → 0.11.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: ce3134651886e323b97794153a83b97ada50a5db
-  data.tar.gz: a01c0eb283ca43609e06997deee79787dc98de00
+  metadata.gz: 29f26144274a4bd80974e243be7cf969b5f2f49a
+  data.tar.gz: 79793475465dacb80644623212f352010a07c910
 SHA512:
-  metadata.gz: 4c5ed38ddcc0570d2ec46f41e46332d4e71d5b5c756f3c027c8e9e2afddca3e8f7766912246af8cf39bd44c7b78c2a89983a4e9af629902ccaebbff4f576ca1c
-  data.tar.gz: 91d22c1f48cc245ba1135324f874858d8f2ffc0834e4b9d0383d44ed8425ecf53a3070ca8e189d9a9cbd2ce467803022185eb26deb1f1c948e2caca7c5ec97c1
+  metadata.gz: e614c3d69a0dbe91fe8c623c0246e90ddf0fa22fc2f31dccd847fd4bc6394899f6726e606e773927222e6d7707d1261fb2d1f71d952468fe27230cb140704806
+  data.tar.gz: 39640135b688f94e711bc956ea81dad208008a1a0a5bc5ca21ce6515c9641b6d66d1b5a86648fe34a97a8d436385c908b9c75dd2d6aa7a5b6ed71e962eaad545

data/lib/wrnap/etl/infernal.rb

@@ -2,15 +2,34 @@ module Wrnap
   module Etl
     module Infernal
       class << self
+        def parse_file(file)
+          output = File.exist?(file) ? File.read(file) : file
+
+          if output =~ /No hits detected that satisfy reporting thresholds/
+            []
+          else
+            output.
+              gsub(/^(.*\n)*Hit alignments:\n/, "").
+              gsub(/Internal CM pipeline statistics summary:\n(.*\n)*$/, "").
+              strip.split(?\n).reject(&:empty?).each_slice(10).map { |lines| parse_hit(lines.join(?\n)) }
+          end
+        end
+
         def parse_hit(output)
+          name = if output =~ (identifier_regex = />>\s+(\S+)(.*\n){3}.*\s(\d+)\s+(\d+)\s+[\+-].*\n/)
+            # This is a pretty fancy regex, and there's no guarantee that the data has this info, so let's just test the waters here.
+            _, id, _, seq_from, seq_to, _ = output.match(identifier_regex).to_a
+            "%s %d %d" % [id.split(?|).last, seq_from, seq_to]
+          end
+
           Stockholm.fit_structure_to_sequence(
             *output.split(?\n).as do |infernal|
               [
-                infernal.select { |line| line =~ /^.*\d+\s+.*\s+\d+\s*$/ }.last.match(/^.*\s+(.*)\s+\d+\s*$/)[1].upcase.gsub(/[^AUGC]/, ?.),
+                infernal.select { |line| line =~ /^.*\d+\s+.*\s+\d+\s*$/ }.last.match(/^.*\s+(\S+)\s+\d+\s*$/)[1].upcase.gsub(/[^AUGC]/, ?.),
                 convert_infernal_to_dot_bracket(infernal.find { |line| line =~ /CS\s*$/ }.gsub(/\s+CS\s*$/, "").strip)
               ]
             end
-          )
+          ).tap { |rna| rna.comment = name if name }
         end
 
         def convert_infernal_to_dot_bracket(structure)

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

@@ -5,27 +5,29 @@ module Wrnap
         attr_reader :accession, :from, :to, :coord_options
 
         class << self
-          def init_from_entrez(accession, from, to, options = {})
+          def init_from_entrez(accession, from, to, options = {}, &block)
             new(
               accession: accession,
               from:      from,
               to:        to,
-              options:   options
+              options:   options,
+              &block
             )
           end
 
-          def init_from_string(sequence, accession, from, to, options = {})
+          def init_from_string(sequence, accession, from, to, options = {}, &block)
             new(
               sequence:  sequence,
               accession: accession,
               from:      from,
               to:        to,
-              options:   options
+              options:   options,
+              &block
             )
           end
         end
 
-        def initialize(sequence: nil, accession: nil, from: nil, to: nil, options: {})
+        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]
@@ -36,12 +38,13 @@ module Wrnap
             @raw_sequence = (sequence.is_a?(String) ? Bio::Sequence::NA.new(sequence) : sequence).upcase
           end
 
-          super({
+          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
-          })
+            comment:          options[:rna][:comment]          || options[:rna][:name] || identifier,
+            &block
+          )
 
           remove_instance_variable(:@sequence)
         end

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

@@ -1,113 +1,115 @@
 module Wrnap
   module Global
-    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))
+    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
-          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))
+            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
-        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)] })
+          base.send(:include, InstanceMethods)
         end
 
-        def shuffle(sequence, token_length = 2)
-          Shuffle.new(sequence).shuffle(token_length)
-        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 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
+          def shuffle(sequence, token_length = 2)
+            Shuffle.new(sequence).shuffle(token_length)
+          end
 
-      module InstanceMethods
-        def dishuffle
-          self.class.shuffle(sequence, 2)
+          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
 
-        def gc_content
-          seq.split(//).select { |i| i =~ /[GC]/i }.size.to_f / seq.size
-        end
+        module InstanceMethods
+          def dishuffle
+            self.class.shuffle(sequence, 2)
+          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)
+          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
-      end
 
-      module OneStructureBasedMethods
-        def helices(structure)
-          array = base_pairs(structure).sort_by(&:first).map(&:to_a)
+        module OneStructureBasedMethods
+          def helices(structure)
+            array = base_pairs(structure).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]] }
+            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
-          else
-            []
           end
-        end
 
-        def max_bp_distance(structure)
-          base_pairs(structure).count + ((structure.length - 3) / 2.0).floor
-        end
+          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
+          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
-        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
+          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
-      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
+        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 = base_pairs(structure_1), base_pairs(structure_2)
 
-          ((bp_set_1 - bp_set_2) + (bp_set_2 - bp_set_1)).count
+            ((bp_set_1 - bp_set_2) + (bp_set_2 - bp_set_1)).count
+          end
         end
       end
     end

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

@@ -0,0 +1,42 @@
+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 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.rb

@@ -1,43 +1,47 @@
 module Wrnap
   module Global
     class Rna
+      extend Forwardable
       include Extensions
+      include Metadata
 
       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
+      attr_reader :sequence, :structure, :second_structure, :metadata
 
       class << self
-        def init_from_string(sequence, structure = nil, second_structure = nil, comment = nil)
+        def init_from_string(sequence, structure = nil, second_structure = nil, comment = nil, &block)
           new(
             sequence:         sequence,
             structure:        structure,
             second_structure: second_structure,
-            comment:          comment
+            comment:          comment,
+            &block
           )
         end
 
-        def init_from_hash(hash)
+        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]
+            comment:          hash[:comment]          || hash[:name],
+            &block
           )
         end
 
-        def init_from_array(array)
-          init_from_string(*array)
+        def init_from_array(array, &block)
+          init_from_string(*array, &block)
         end
 
-        def init_from_fasta(string)
+        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]).tap do |rna|
+          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
@@ -46,25 +50,26 @@ module Wrnap
           end
         end
 
-        def init_from_context(*context, coords: {}, rna: {})
-          Context.init_from_entrez(*context, coords: coords, rna: rna)
+        def init_from_context(*context, coords: {}, rna: {}, &block)
+          Context.init_from_entrez(*context, coords: coords, rna: rna, &block)
         end
 
-        def init_from_self(rna)
+        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
+            comment:          rna.comment,
+            &block
           )
         end
 
         alias_method :placeholder, :new
       end
 
-      def initialize(sequence: "", structure: "", second_structure: "", comment: "")
-        @sequence, @comment = (sequence.kind_of?(Rna) ? sequence.seq : sequence).upcase, comment
+      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(
@@ -83,6 +88,8 @@ module Wrnap
           )
         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
@@ -126,13 +133,6 @@ module Wrnap
 
       alias :two_str :two_structures
 
-      def print_full
-        puts name  if name
-        puts seq   if seq
-        puts str_1 if str_1
-        puts str_2 if str_2
-      end
-
       def write_fa!(filename)
         filename.tap do |filename|
           File.open(filename, ?w) do |file|
@@ -162,11 +162,20 @@ module Wrnap
         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)   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.to_json unless md.empty?),
           (name ? name : "#{self.class.name}")
         ].compact.join(", ")
       end

data/lib/wrnap/version.rb

@@ -1,3 +1,3 @@
 module Wrnap
-  VERSION = "0.10.0"
+  VERSION = "0.11.0"
 end

data/lib/wrnap.rb

@@ -14,6 +14,7 @@ require "active_support/core_ext/class"
 
 require "wrnap/version"
 require "wrnap/global/rna/extensions"
+require "wrnap/global/rna/metadata"
 require "wrnap/global/rna"
 require "wrnap/global/rna/context"
 require "wrnap/global/chainer"
@@ -66,23 +67,23 @@ end
 
 # This dirties up the public namespace, but I use it so many times that I want a shorthand to it
 unless defined? RNA
-  def RNA(*args)
-    RNA.from_array(args)
+  def RNA(*args, &block)
+    RNA.from_array(args, &block)
   end
 end
 
 module RNA
-  def self.load_all(pattern = "*.fa")
-    Dir[File.directory?(pattern) ? pattern + "/*.fa" : pattern].map { |file| RNA.from_fasta(file) }
+  def self.load_all(pattern = "*.fa", &block)
+    Dir[File.directory?(pattern) ? pattern + "/*.fa" : pattern].map { |file| RNA.from_fasta(file, &block) }
   end
 
-  def self.random(size, *args)
-    RNA.from_array(args.unshift(Wrnap::Global::Rna.generate_sequence(size).seq))
+  def self.random(size, *args, &block)
+    RNA.from_array(args.unshift(Wrnap::Global::Rna.generate_sequence(size).seq), &block)
   end
 
   def self.method_missing(name, *args, &block)
     if "#{name}" =~ /^from_\w+$/
-      Wrnap::Global::Rna.send("init_#{name}", *args)
+      Wrnap::Global::Rna.send("init_#{name}", *args, &block)
     else super end
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: wrnap
 version: !ruby/object:Gem::Version
-  version: 0.10.0
+  version: 0.11.0
 platform: ruby
 authors:
 - Evan Senter
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-07-03 00:00:00.000000000 Z
+date: 2014-07-16 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -157,6 +157,7 @@ files:
 - lib/wrnap/global/rna.rb
 - lib/wrnap/global/rna/context.rb
 - lib/wrnap/global/rna/extensions.rb
+- lib/wrnap/global/rna/metadata.rb
 - lib/wrnap/global/runner.rb
 - lib/wrnap/graphing/r.rb
 - lib/wrnap/package/base.rb