wrnap 0.12.2 → 1.0.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 1a389b503ea7faf4bfb02eb55a8ec8d5802e4b9b
-  data.tar.gz: 3bcbe5611e4c409f7aa3c1f4dd730fde6ff9e24d
+  metadata.gz: 5a49216040e651785e22f2fe010a08ad6ace0800
+  data.tar.gz: beb5164b299e498a0a0c1d59ca579efb723aef46
 SHA512:
-  metadata.gz: d3d2dcd9a391a7ef41c0e76562132168847a0968c95cb2fc8b359349cffed8445677e0699d5758ec779b144676750304b9b8103cc616154a3b8ca5afd0c9069e
-  data.tar.gz: b34295c88b411d8195fbff6ef60ad863a9607a927c5e2eb94e8f326c76932c5ffd2d37cbc4919e56083e0d08b6fb76e7f6fb6a6d38ac70ee9ae45cf3c696204e
+  metadata.gz: b4262912d96fa147269069032324e0319cc8deb5391dd56376acdea9165c9cc48ddf3d3755c221d9bdc1d503d6bda8840962b5437dc7522a1244571ed089d017
+  data.tar.gz: 29c9eb3b9c20d32c6cdda08a6629fbf5917bfb482a3b76e2ac1f9150ecc54c799320789387a9d97fc4f8b35810fc4877d0e1667fc3166834a548b7f43d0f06eb

data/lib/wrnap.rb

@@ -3,7 +3,6 @@ require "benchmark"
 require "set"
 require "tree"
 require "shuffle"
-require "rinruby"
 require "tempfile"
 require "bigdecimal"
 require "rroc"
@@ -13,31 +12,30 @@ require "entrez"
 require "active_support/inflector"
 require "active_support/core_ext/class"
 
+unless %x[which R].empty?
+  require "rinruby"
+  # RinRuby opens up a connection to R by default, we don't want that. Connections are opened on-demand.
+  begin; R.quit; rescue IOError; end
+end
+
 require "wrnap/version"
-require "wrnap/global/rna/extensions"
-require "wrnap/global/rna/metadata"
-require "wrnap/global/rna/tree"
-require "wrnap/global/rna/helix"
-require "wrnap/global/rna"
-require "wrnap/global/rna/context"
-require "wrnap/global/chainer"
-require "wrnap/global/entrez"
-require "wrnap/global/parser"
-require "wrnap/global/runner"
-require "wrnap/etl/infernal"
-require "wrnap/etl/stockholm"
-require "wrnap/graphing/r"
-require "wrnap/package/base"
 
-begin; R.quit; rescue IOError; end
+%w|global rna etl graphing|.each do |subfolder|
+  Dir[File.join(File.dirname(__FILE__), "wrnap", subfolder, "*.rb")].each do |file|
+    require file
+  end
+end
+
+require "wrnap/rna"
+require "wrnap/package/base"
 
 module Wrnap
   RT     = 1e-3 * 1.9872041 * (273.15 + 37) # kcal / K / mol @ 37C
   @debug = true
 
   module Package
-    Dir[File.join(File.dirname(__FILE__), "wrnap", "package", "*.rb")].reject { |file| file =~ /\/base.rb/ }.each do |file|
-      autoload(File.basename(file, ".rb").camelize.to_sym, "wrnap/package/#{File.basename(file, '.rb')}")
+    Dir[File.join(File.dirname(__FILE__), "wrnap", "package", "*.rb")].reject { |file| file =~ /\/base.rb$/ }.each do |file|
+      autoload(File.basename(file, ".rb").camelize.to_sym, File.join("wrnap", "package", File.basename(file, ".rb")))
     end
 
     def self.const_missing(name)
@@ -51,10 +49,6 @@ module Wrnap
     end
   end
 
-  def self.deserialize(string)
-    YAML.load(File.exist?(string) ? File.read(string) : string)
-  end
-
   def self.debugger
     STDERR.puts yield if Wrnap.debug
   end
@@ -68,25 +62,30 @@ module Wrnap
   end
 end
 
-# This dirties up the public namespace, but I use it so many times that I want a shorthand to it
+# -----------------------------------------------------------------------------------------------
+# This dirties up the public namespace, but I use it so many times that I want a shorthand to it.
+# -----------------------------------------------------------------------------------------------
+
+class Array; include Wrnap::Rna::Wrnapper; end
+
 unless defined? RNA
   def RNA(*args, &block)
     RNA.from_array(args, &block)
   end
-end
 
-module RNA
-  def self.load_all(pattern = "*.fa", &block)
-    Dir[File.directory?(pattern) ? pattern + "/*.fa" : pattern].map { |file| RNA.from_fasta(file, &block) }
-  end
+  module RNA
+    def self.load_all(pattern = "*.fa", &block)
+      Wrnap::Rna::Box.load_all(pattern, &block)
+    end
 
-  def self.random(size, *args, &block)
-    RNA.from_array(args.unshift(Wrnap::Global::Rna.generate_sequence(size).seq), &block)
-  end
+    def self.random(size, *args, &block)
+      RNA.from_array(args.unshift(Wrnap::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, &block)
-    else super end
+    def self.method_missing(name, *args, &block)
+      if "#{name}" =~ /^from_\w+$/
+        Wrnap::Rna.send("init_#{name}", *args, &block)
+      else super end
+    end
   end
 end

data/lib/wrnap/etl/infernal.rb

@@ -1,9 +1,10 @@
 module Wrnap
   module Etl
     module Infernal
-      NAME_REGEX   = />>\s+(\S+)(.*\n){3}.*\s(\d+)\s+(\d+)\s+[\+-].*\n/
-      HIT_SEQUENCE = /^.*\d+\s+(.*)\s+\d+\s*$/
-      LOCAL_END    = /\*\[\s*\d+\s*\]\*/
+      NAME_REGEX    = />>\s+(\S+)(.*\n){3}.*\s(\d+)\s+(\d+)\s+[\+-].*\n/
+      HIT_SEQUENCE  = /^.*\d+\s+(.*)\s+\d+\s*$/
+      HIT_STRUCTURE = /([()<>{}\[\]\-_~,.:]+)\s+CS/
+      LOCAL_END     = /\*\[\s*\d+\s*\]\*/
 
       class << self
         def parse_file(file)
@@ -20,9 +21,9 @@ module Wrnap
         end
 
         def parse_hit(output)
-          name = if output =~ NAME_REGEX
+          name = if (name_match = output.match(NAME_REGEX))
             # 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(NAME_REGEX).to_a
+            _, id, _, seq_from, seq_to, _ = name_match.to_a
             "%s %d %d" % [id.split(?|).last, seq_from, seq_to]
           end
 
@@ -33,16 +34,16 @@ module Wrnap
 
         def pull_infernal_hit_sequence(output)
           # Dots are gaps in Stockholm format, and this uses the Stockholm parser underneath.
-          output.split(?\n).select { |line| line =~ HIT_SEQUENCE }.last.match(HIT_SEQUENCE)[1].upcase.gsub(?-, ?.)
+          output.scan(HIT_SEQUENCE)[-1][-1].upcase.gsub(?-, ?.)
         end
 
         def pull_infernal_hit_structure(output)
-          convert_infernal_to_dot_bracket(output.split(?\n).find { |line| line =~ /CS\s*$/ }.gsub(/\s+CS\s*$/, "").strip)
+          convert_infernal_to_dot_bracket(output.match(HIT_STRUCTURE)[1])
         end
 
         def convert_infernal_to_dot_bracket(structure)
           # http://jalview-rnasupport.blogspot.com/2010/06/parsing-wuss-notation-of-rna-secondary.html
-          structure.gsub(/[:,_-]/, ?.).gsub(/[<\[\{]/, ?().gsub(/[>\]\}]/, ?))
+          structure.gsub(/[_~,.:]/, ?.).gsub(/[(<{\[]/, ?().gsub(/[)>}\]]/, ?))
         end
       end
     end

data/lib/wrnap/etl/stockholm.rb

@@ -19,12 +19,12 @@ module Wrnap
         end
 
         def balanced_consensus_from_sequence(sequence, structure)
-          Wrnap::Global::Rna.init_from_string(
+          Wrnap::Rna.init_from_string(
             sequence,
-            Wrnap::Global::Rna.structure_from_bp_list(
+            Wrnap::Rna.structure_from_bp_list(
               sequence.length,
               sequence.split(//).zip(structure.split(//)).each_with_index.inject(
-                Wrnap::Global::Rna.base_pairs(structure).map(&:to_a).select { |i, j| Wrnap::Global::Rna::CANONICAL_BASES.include?(Set.new([sequence[i], sequence[j]])) }
+                Wrnap::Rna.base_pairs(structure).map(&:to_a).select { |i, j| Wrnap::Rna::CANONICAL_BASES.include?(Set.new([sequence[i], sequence[j]])) }
               ) do |valid_bases, ((bp, symbol), i)|
                 valid_bases - (bp == ?. && symbol != ?. ? (valid_bases.select { |bps| bps.any? { |j| i == j } }) : [])
               end
@@ -33,14 +33,14 @@ module Wrnap
         end
 
         def prune_gaps(rna)
-          Wrnap::Global::Rna.init_from_array(rna.seq.split(//).zip(rna.str.split(//)).reject { |nucleotide, _| nucleotide == ?. }.transpose.map(&:join))
+          Wrnap::Rna.init_from_array(rna.seq.split(//).zip(rna.str.split(//)).reject { |nucleotide, _| nucleotide == ?. }.transpose.map(&:join))
         end
 
         def theta_filter(rna)
           # Needs to happen after gap pruning.
-          Wrnap::Global::Rna.init_from_string(
+          Wrnap::Rna.init_from_string(
             rna.seq,
-            Wrnap::Global::Rna.structure_from_bp_list(rna.seq.length, rna.base_pairs.map(&:to_a).select { |i, j| (j - i).abs > 3 })
+            Wrnap::Rna.structure_from_bp_list(rna.len, rna.base_pairs.map(&:to_a).select { |i, j| (j - i).abs > 3 })
           )
         end
       end

data/lib/wrnap/global/yaml.rb

@@ -0,0 +1,14 @@
+module Wrnap
+  module Global
+    module Yaml
+      def serialize(filename = false)
+        cereal = YAML.dump(self)
+        filename ? File.open(filename, ?w) { |file| file.write(cereal) } : cereal
+      end
+
+      def deserialize(string)
+        YAML.load(File.exist?(string) ? File.read(string) : string)
+      end
+    end
+  end
+end

data/lib/wrnap/graphing/r.rb

@@ -3,10 +3,14 @@ module Wrnap
     module R
       class << self
         def graph(&block)
-          begin
-            (yield (r_instance = RinRuby.new)).tap { r_instance.close }
-          rescue RuntimeError => e
-            raise unless e.message == "Unsupported data type on R's end"
+          if const_defined?(:RinRuby)
+            begin
+              (yield (r_instance = RinRuby.new(false))).tap { r_instance.close }
+            rescue RuntimeError => e
+              raise unless e.message == "Unsupported data type on R's end"
+            end
+          else
+            raise RuntimeError.new("Your system does not appear to have R installed, and thus the RinRuby gem was not loaded.")
           end
         end
 

data/lib/wrnap/package/base.rb

@@ -7,6 +7,7 @@ module Wrnap
     class Base
       include Wrnap::Global::Runner
       include Wrnap::Global::Chainer
+      include Wrnap::Global::Yaml
 
       class_attribute :executable_name
       self.executable_name = ->(context) { "RNA#{context.class.name.split('::').last.underscore}" }
@@ -39,22 +40,18 @@ module Wrnap
           data  = [data] unless data.is_a?(Array)
 
           @data = case data.map(&:class)
-          when [Wrnap::Global::Rna], [Wrnap::Global::Rna::Context] then data.first
+          when [Wrnap::Rna], [Wrnap::Rna::Context] then data.first
           when *(1..3).map { |i| [String] * i }                    then RNA.from_string(*data)
           when [Hash]                                              then RNA.from_hash(*data)
           when [Array]                                             then RNA.from_array(*data)
-          when [NilClass]                                          then Wrnap::Global::Rna.placeholder
-          else raise TypeError.new("Unsupported Wrnap::Global::Rna#initialize format: #{data}")
+          when [NilClass]                                          then Wrnap::Rna.placeholder
+          else raise TypeError.new("Unsupported Wrnap::Rna#initialize format: #{data}")
           end
         else
           @data = transform_for_chaining(data)
         end
       end
 
-      def serialize
-        YAML.dump(self)
-      end
-
       def debugger(&block)
         self.class.debugger(&block)
       end

data/lib/wrnap/package/fold.rb

@@ -10,7 +10,7 @@ module Wrnap
       def post_process
         structure = Wrnap::Global::Parser.rnafold_mfe_structure(response)
       
-        unless data.seq.length == structure.length
+        unless data.len == structure.length
           raise "Sequence: '#{data.seq}'\nStructure: '#{structure}'"
         else
           @mfe_rna, @structure, @mfe = RNA.from_string(data.seq, structure), structure, Wrnap::Global::Parser.rnafold_mfe(response)

data/lib/wrnap/package/fold_constrained.rb

@@ -0,0 +1,24 @@
+module Wrnap
+  module Package
+    class FoldConstrained < Base
+      self.executable_name = "RNAfold"
+      self.call_with       = [:seq, :constraint_mask]
+      self.default_flags   = {
+        :C      => true,
+        "-noPS" => :empty
+      }
+
+      attr_reader :mfe_rna, :structure, :mfe, :ensemble_energy
+
+      def post_process
+        structure = Wrnap::Global::Parser.rnafold_mfe_structure(response)
+
+        unless data.len == structure.length
+          raise "Sequence: '#{data.seq}'\nStructure: '#{structure}'"
+        else
+          @mfe_rna, @structure, @mfe = RNA.from_string(data.seq, structure), structure, Wrnap::Global::Parser.rnafold_mfe(response)
+        end
+      end
+    end
+  end
+end

data/lib/wrnap/package/mfpt.rb

@@ -5,7 +5,7 @@ module Wrnap
   module Package
     class Mfpt < Base
       self.chains_from   = Wrnap::Package::EnergyGrid2d
-      self.default_flags = ->(context, flags) { { X: :empty, H: :empty, N: context.data.seq.length, D: context.data.bp_distance, Q: "1e-8" } }
+      self.default_flags = ->(context, flags) { { X: :empty, H: :empty, N: context.data.len, D: context.data.bp_distance, Q: "1e-8" } }
       # These flags aren't well setup for alternative options at the moment.
       
       attr_reader :mfpt

data/lib/wrnap/package/rnabor.rb

@@ -14,13 +14,13 @@ module Wrnap
       end
     
       def counts
-        (non_zero_counts = self.class.parse(response).map { |row| BigDecimal.new(row[2]).to_i }) + [0] * (data.seq.length - non_zero_counts.length + 1)
+        (non_zero_counts = self.class.parse(response).map { |row| BigDecimal.new(row[2]).to_i }) + [0] * (data.len - non_zero_counts.length + 1)
       end
     
       def distribution(options = {})
         options = { precision: 4 }.merge(options)
       
-        distribution_before_precision = (non_zero_distribution = non_zero_shells.map { |i| i / partition }) + [0.0] * (data.seq.length - non_zero_distribution.length + 1)
+        distribution_before_precision = (non_zero_distribution = non_zero_shells.map { |i| i / partition }) + [0.0] * (data.len - non_zero_distribution.length + 1)
         distribution_before_precision.map { |value| options[:precision].zero? ? value : (value * 10 ** options[:precision]).truncate / 10.0 ** options[:precision] }
       end
     

data/lib/wrnap/package/varna.rb

@@ -3,15 +3,16 @@ module Wrnap
     class Varna < Base
       self.executable_name = "java"
       self.default_flags   = ->(context, flags) do
-        {
+        defaults = {
           sequenceDBN:  context.data.seq,
           structureDBN: context.data.str,
-          title:        context.data.name,
           titleSize:    8,
           resolution:   2
         }
+
+        context.data.name ? defaults.merge(title: context.data.name) : defaults
       end
-      self.quote_flag_params = %w|sequenceDBN structureDBN|
+      self.quote_flag_params = %w|sequenceDBN structureDBN title|
 
       def run_command(flags)
         "java fr.orsay.lri.varna.applications.VARNAcmd %s" % stringify_flags(flags)

data/lib/wrnap/package/xbor.rb

@@ -28,11 +28,11 @@ module Wrnap
     
       def full_distribution
         distribution      = run.distribution
-        full_distribution = distribution + ([0.0] * ((differnece = data.seq.length - distribution.length + 1) < 0 ? 0 : differnece))
+        full_distribution = distribution + ([0.0] * ((differnece = data.len - distribution.length + 1) < 0 ? 0 : differnece))
       end
     
       def k_p_points
-        full_distribution.each_with_index.to_a.map(&:reverse)[0..data.seq.length]
+        full_distribution.each_with_index.to_a.map(&:reverse)[0..data.len]
       end
     
       def expected_k

data/lib/wrnap/rna.rb

@@ -0,0 +1,197 @@
+module Wrnap
+  class Rna
+    extend Forwardable
+    include Wrnap::Global::Yaml
+    include Wrnap::Rna::Extensions
+    include Wrnap::Rna::Wrnapper
+    include Wrnap::Rna::Metadata
+    include Wrnap::Rna::Motifs
+    include Wrnap::Rna::TreeFunctions
+    include Wrnap::Rna::Constraints
+
+    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 && len != 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_delegator :@sequence, :length, :len
+
+    def copy_name_from(rna)
+      tap { @comment = rna.name }
+    end
+
+    def empty_structure
+      "." * len
+    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 eql?(other_rna)
+      self == other_rna
+    end
+
+    def ==(other_rna)
+      other_rna.kind_of?(Wrnap::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]   + (len          > 20 ? '... [%d]' % len : '')}" if seq   && !seq.empty?),
+        ("#{str_1[0, 20] + (str_1.length > 20 ? ' [%d]'    % len : '')}" if str_1 && !str_1.empty?),
+        ("#{str_2[0, 20] + (str_2.length > 20 ? ' [%d]'    % len : '')}" if str_2 && !str_1.empty?),
+        (md.inspect unless md.nil? || md.empty?),
+        (name ? name : "#{self.class.name}")
+      ].compact.join(", ")
+    end
+  end
+end