vienna_rna 0.9.2 → 0.10.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 75269157e25be08827f08546fffdb90af43be397
-  data.tar.gz: a8b2094c492af287894e3219e3328233ecf31340
+  metadata.gz: 064267b829cc8e40a82c40eec4db4acb4f710fb8
+  data.tar.gz: 2e6ec0c50d34abe789ea52cb2a77c9e6ab248840
 SHA512:
-  metadata.gz: 26a7068d00b8181041fc0ea12d38a25b65724ff3eb0dd2e910821bbea27c4bfa7317835956242881cac3e1cc64442e6cfc3a23e3135d5e16f2382c0648dbaa7a
-  data.tar.gz: bd6799d8ca85f2ddf712fac00e97eb17700b01218e2a99579a0aba94ee2d0fd7a899bff56a473b8b719f7eec8112ab110dd02372a43f5326b19d107aac4ea829
+  metadata.gz: 9e0a39db0c7c85a01604f2bea3bff2ca5dd7119556d25c734883805f8d22fd2ea50511f4d446bdd91f3dff4947caf7f5e1a2abcba06c3e0f0d0c660a89a97174
+  data.tar.gz: cdc48b4f2457ed25eac73a3d8031662b5bad97de71c38980b3d9780dccef4e96120801f35cb9a183dc33a989eb2629156d6221ac123c1d3f201eca8487e80289

data/README.md

@@ -20,3 +20,18 @@ Simple use case:
     #=> echo CCUCGAGGGGAACCCGAAAGGGACCCGAGAGG | rnafold --noPS
     #=> Total runtime: 0.013 sec.
     #=> #<ViennaRna::Rna CCUCGAGGGGAACCCGAAAG... ((((..(((...(((....) [truncated]>
+
+... and now you can even do crazy stuff like this (taking a sequence, inferring the MFE, calculating the 2D energy landscape and computing the MFPT by chaining commands)!
+
+    RNA("GGGGGCCCCC", :empty, fold: { d: 0 }).run(:fftbor2d).chain(:mfpt).mfpt
+    #=> ViennaRna::Package::Fold: {"-noPS"=>:empty, :d=>0}
+    #=> echo 'GGGGGCCCCC' | RNAfold --noPS -d 0
+    #=> Total runtime: 0.014 sec.
+    #=> ViennaRna::Package::Fftbor2d: {:S=>:empty}
+    #=> Running FFTbor2D on #<ViennaRna::Global::Rna GGGGGCCCCC .......... (((....)))>
+    #=> FFTbor2D -S /var/folders/_2/0js_xvm95zz8jv0lxlh8p__40000gn/T/rna20131103-7845-1ok9xnt
+    #=> Total runtime: 0.041 sec.
+    #=> ViennaRna::Package::Mfpt: {:X=>:empty, :H=>:empty, :N=>10, :Q=>"1e-8"}
+    #=> RNAmfpt -X -H -N 10 -Q 1e-8 /var/folders/_2/0js_xvm95zz8jv0lxlh8p__40000gn/T/rna20131103-7845-1h1uz0l
+    #=> Total runtime: 0.012 sec.
+    #=> 2160.58769316

data/lib/vienna_rna.rb

@@ -1,31 +1,29 @@
 require "benchmark"
 require "set"
-require "bio"
 require "shuffle"
-require "matrix"
 require "rinruby"
-require "rroc"
 require "tempfile"
 require "bigdecimal"
 require "diverge"
 require "active_support/inflector"
 require "active_support/core_ext/class"
-require "active_support/core_ext/module/aliasing"
 
 require "vienna_rna/global/rna_extensions"
 require "vienna_rna/global/rna"
 require "vienna_rna/global/parser"
+require "vienna_rna/global/run_extensions"
+require "vienna_rna/global/chain_extensions"
 require "vienna_rna/graphing/r"
 require "vienna_rna/package/base"
 
 begin; R.quit; rescue IOError; end
 
 module ViennaRna
+  RT     = 1e-3 * 1.9872041 * (273.15 + 37) # kcal / K / mol @ 37C
   @debug = true
   
   module Package
     Dir[File.join(File.dirname(__FILE__), "vienna_rna", "package", "*.rb")].reject { |file| file =~ /\/base.rb/ }.each do |file|
-      # Doesn't support autoloading modules that are of the form: TwoWords
       autoload(File.basename(file, ".rb").camelize.to_sym, "vienna_rna/package/#{File.basename(file, '.rb')}")
     end
     

data/lib/vienna_rna/global/chain_extensions.rb

@@ -0,0 +1,29 @@
+module ViennaRna
+  module Global
+    module ChainExtensions
+      def self.included(base)
+        base.send(:include, InstanceMethods)
+      end
+      
+      module InstanceMethods
+        def chain(package, flags = {})
+          class_chaining_to = ViennaRna::Package.lookup(package)
+          
+          unless instance_variable_defined?(:@response)
+            raise ArgumentError.new("Can only chain a package that is not the first to be called")
+          end
+          
+          unless class_chaining_to.instance_methods.include?(:transform_for_chaining)
+            raise ArgumentError.new("#{class_chaining_to.name} doesn't support chaining because it doesn't define transform_for_chaining")
+          end
+          
+          unless [chains_from].flatten.any? { |chaining_from| kind_of?(chaining_from) }
+            raise ArgumentError.new("#{class_chaining_to.name} doesn't support chaining from #{self.class.name} because it isn't in the chains_from list")
+          end
+          
+          class_chaining_to.new(self, chaining: true).run(flags)
+        end
+      end
+    end
+  end
+end

data/lib/vienna_rna/global/rna.rb

@@ -97,15 +97,11 @@ module ViennaRna
       end
     
       def temp_fa_file!
-        write_fa!(Tempfile.new("")).path
+        write_fa!(Tempfile.new("rna")).path
       end
 
-      def run(module_name, options = {})
-        if rna_module = ViennaRna::Package.const_missing("#{module_name}".camelize)
-          rna_module.run(self, options)
-        else
-          raise ArgumentError.new("#{module_name} can't be resolved as an executable")
-        end
+      def run(package_name, options = {})
+        ViennaRna::Package.lookup(package_name).run(self, options)
       end
 
       def inspect

data/lib/vienna_rna/global/rna_extensions.rb

@@ -89,21 +89,7 @@ module ViennaRna
         
           ((bp_set_1 - bp_set_2) + (bp_set_2 - bp_set_1)).count
         end
-      
-        def symmetric_bp_distance(structure_1, structure_2)
-          # Takes two structures and calculates the distance between them by: sum { ((x_j - x_i) - (y_j - y_i)).abs }
-          raise "The two structures are not the same length" unless structure_1.length == structure_2.length
-  
-          bp_dist = ->(array, i) { array[i] == -1 ? 0 : array[i] - i }
-  
-          structure_1_pairings = get_pairings(structure_1)
-          structure_2_pairings = get_pairings(structure_2)
-  
-          structure_1.length.times.inject(0) do |distance, i|
-            distance + (bp_dist[structure_1_pairings, i] - bp_dist[structure_2_pairings, i]).abs
-          end
-        end
       end
     end
   end
-end
+end

data/lib/vienna_rna/global/run_extensions.rb

@@ -0,0 +1,86 @@
+module ViennaRna
+  module Global
+    module RunExtensions
+      def self.included(base)
+        base.send(:include, InstanceMethods)
+        base.extend(ClassMethods)
+      end
+      
+      module ClassMethods
+        def exec_exists?(name)
+          !%x[which RNA#{name.to_s.downcase}].empty?
+        end
+        
+        def run(*data)
+          flags = data.length > 1 && data.last.is_a?(Hash) ? data.pop : {}
+          new(data).run(flags)
+        end
+      end
+      
+      module InstanceMethods
+        def run(flags = {})
+          unless @response
+            tap do
+              @runtime = Benchmark.measure do
+                pre_run_check
+                merged_flags     = recursively_merge_flags(flags)
+                runnable_command = run_command(merged_flags)
+                
+                ViennaRna.debugger { runnable_command }
+                
+                @response        = %x[#{runnable_command}]
+                post_process if respond_to?(:post_process)
+              end
+        
+              ViennaRna.debugger { "Total runtime: %.3f sec." % runtime.real }
+            end
+          else
+            self
+          end
+        end
+    
+        def pre_run_check
+          if %x[which #{exec_name}].empty?
+            raise RuntimeError.new("#{exec_name} is not defined on this machine")
+          end
+        end
+        
+        def exec_name
+          executable_name.respond_to?(:call) ? executable_name[self] : executable_name
+        end
+        
+        def recursively_merge_flags(flags)
+          rmerge = ->(old_hash, new_hash) do
+            inner_hash = {}
+        
+            old_hash.merge(new_hash) do |key, old_value, new_value|
+              inner_hash[key] = [old_value, new_value].map(&:class).uniq == [Hash] ? rmerge[old_value, new_value] : new_value
+            end
+          end
+          
+          rmerge[base_flags(flags), flags].tap do |merged_flags|
+            ViennaRna.debugger { "%s: %s" % [self.class.name, merged_flags.inspect] }
+          end
+        end
+        
+        def base_flags(flags)
+          default_flags.respond_to?(:call) ? default_flags[self, flags] : default_flags
+        end
+      
+        def run_command(flags)
+          "echo %s | %s %s" % [
+            "'%s'" % call_with.map { |datum| data.send(datum) }.join(?\n),
+            exec_name,
+            stringify_flags(flags)
+          ]
+        end
+    
+        def stringify_flags(flags)
+          flags.inject("") do |string, (flag, value)| 
+            (string + (value == :empty ? " -%s" % flag : " -%s %s" % [flag, value])).strip
+          end
+        end
+      end
+    end
+  end
+end

data/lib/vienna_rna/graphing/r.rb

@@ -77,6 +77,10 @@ module ViennaRna
           overlay([{ data: data }], title: title, type: type, x_label: x_label, y_label: y_label, legend: false, filename: filename)
         end
         
+        def scatterplot(data, title: nil, x_label: "Independent", y_label: "Dependent", filename: false)
+          line_graph(data, title: title, type: ?p, x_label: x_label, y_label: y_label, filename: filename)
+        end
+        
         def histogram(data, title: nil, x_label: "Bins", num_bins: false, bin_size: 1, x_arrow: false, relative: false, filename: false)
           half     = bin_size / 2.0
           range    = Range.new((data.min - half).floor, (data.max + half).ceil)

data/lib/vienna_rna/package/base.rb

@@ -1,29 +1,26 @@
 module ViennaRna
   module Package
+    def self.lookup(package_name)
+      const_missing("#{package_name}".camelize) || raise(ArgumentError.new("#{package_name} can't be resolved as an executable"))
+    end
+    
     class Base
+      include ViennaRna::Global::RunExtensions
+      include ViennaRna::Global::ChainExtensions
+      
       class_attribute :executable_name
-    
-      class << self
-        def method_added(name)
-          if name == :run
-            unless @chaining
-              @chaining = true
-              alias_method_chain :run, :hooks
-            else
-              remove_instance_variable(:@chaining)
-            end
-          end
-        end
+      self.executable_name = ->(context) { "RNA#{context.class.name.split('::').last.underscore}" }
       
-        def exec_exists?(name)
-          !%x[which RNA#{name.to_s.downcase}].empty?
-        end
+      class_attribute :call_with
+      self.call_with = [:seq]
       
-        def run(*data)
-          flags = data.length > 1 && data.last.is_a?(Hash) ? data.pop : {}
-          new(data).run(flags)
-        end
+      class_attribute :default_flags
+      self.default_flags = {}
       
+      class_attribute :chains_from
+      self.chains_from = Object
+    
+      class << self
         def bootstrap(data: nil, output: "")
           new(data).tap do |object|
             object.instance_variable_set(:@response, File.exist?(output) ? File.read(output).chomp : output)
@@ -33,78 +30,23 @@ module ViennaRna
     
       attr_reader :data, :response, :runtime
     
-      def exec_name
-        if executable_name
-          executable_name.respond_to?(:call) ? self.class.module_exec(&executable_name) : executable_name
-        else
-          "RNA#{self.class.name.split('::').last.underscore}"
-        end
-      end
-    
-      def exec_sequence_format
-        if data.str
-          '"%s
-          %s"' % [data.seq, data.str]
-        else
-          data.seq
-        end
-      end
-    
-      def initialize(data)
-        data  = [data] unless data.is_a?(Array)
+      def initialize(data, chaining: false)
+        unless chaining
+          data  = [data] unless data.is_a?(Array)
       
-        @data = case data.map(&:class)
-        when [ViennaRna::Global::Rna]         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 ViennaRna::Global::Rna.placeholder
-        else raise TypeError.new("Unsupported ViennaRna::Global::Rna#initialize format: #{data}")
-        end
-      end
-    
-      def run_with_hooks(flags = {})
-        unless @response
-          tap do
-            @runtime = Benchmark.measure do
-              pre_run_check unless respond_to?(:run_command)
-              @response = run_without_hooks(flags)
-              post_process if respond_to?(:post_process)
-            end
-        
-            ViennaRna.debugger { "Total runtime: %.3f sec." % runtime.real }
+          @data = case data.map(&:class)
+          when [ViennaRna::Global::Rna]         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 ViennaRna::Global::Rna.placeholder
+          else raise TypeError.new("Unsupported ViennaRna::Global::Rna#initialize format: #{data}")
           end
         else
-          self
+          @data = transform_for_chaining(data)
         end
       end
     
-      def pre_run_check
-        if %x[which #{exec_name}].empty?
-          raise RuntimeError.new("#{exec_name} is not defined on this machine")
-        end
-      end
-    
-      def stringify_flags(flags)
-        base_flags = self.class.const_defined?(:BASE_FLAGS) ? self.class.const_get(:BASE_FLAGS) : {}
-      
-        flags.merge(base_flags).inject("") do |string, (flag, value)| 
-          (string + (value == :empty ? " -%s" % flag : " -%s %s" % [flag, value])).strip
-        end
-      end
-    
-      def run(flags = {})
-        command = if respond_to?(:run_command)
-          method(:run_command).arity.zero? ? run_command : run_command(flags)
-        else
-          "echo #{exec_sequence_format} | #{exec_name} #{stringify_flags(flags)}"
-        end
-      
-        ViennaRna.debugger { command }
-        
-        %x[#{command}]
-      end
-    
       def serialize
         YAML.dump(self)
       end
@@ -114,4 +56,4 @@ module ViennaRna
       end
     end
   end
-end
+end

data/lib/vienna_rna/package/energy_grid_2d.rb

@@ -27,6 +27,10 @@ module ViennaRna
         def <=>(other_row)
           i == other_row.i ? j <=> other_row.j : i <=> other_row.i
         end
+        
+        def to_csv(energy_term: :p)
+          "%d,%d,%.8f" % [i, j, instance_variable_get(:"@#{energy_term}")]
+        end
       
         def inspect
           "#<Row2d (%d, %d), p: %s, ensemble: %s>" % [i, j, p, ensemble]
@@ -60,6 +64,14 @@ module ViennaRna
           num_colors: num_colors
         )
       end
+      
+      def to_csv(energy_term: :p)
+        map { |row| row.to_csv(energy_term: energy_term) }.join(?\n) + ?\n
+      end
+      
+      def to_csv!(filename, energy_term: :p)
+        File.open(filename, ?w) { |file| file.write(to_csv(energy_term: energy_term)) }
+      end
     
       def inspect
         "#<#{self.class.name} on #{data.inspect}>"

data/lib/vienna_rna/package/eval.rb

@@ -1,6 +1,8 @@
 module ViennaRna
   module Package
     class Eval < Base
+      self.call_with = [:seq, :str]
+      
       attr_reader :mfe
     
       def post_process

data/lib/vienna_rna/package/fftbor2d.rb

@@ -1,18 +1,15 @@
 module ViennaRna
   module Package
     class Fftbor2d < EnergyGrid2d
-      BASE_FLAGS = {
-        S: :empty
-      }
-
       self.executable_name = "FFTbor2D"
+      self.default_flags   = ->(_, flags) { (flags.keys & %i|X M S|).empty? ? { S: :empty } : {} }
 
-      def run_command(flags = {})
+      def run_command(flags)
         ViennaRna.debugger { "Running #{exec_name} on #{data.inspect}" }
       
         "%s %s %s" % [
           exec_name, 
-          stringify_flags(BASE_FLAGS.merge(self.class.const_defined?(:FLAGS) ? self.class.const_get(:FLAGS) : {}).merge(flags)), 
+          stringify_flags(flags),
           data.temp_fa_file!
         ]
       end

data/lib/vienna_rna/package/fold.rb

@@ -1,7 +1,7 @@
 module ViennaRna
   module Package
     class Fold < Base
-      BASE_FLAGS = {
+      self.default_flags = {
         "-noPS" => :empty
       }
     
@@ -16,16 +16,6 @@ module ViennaRna
           @mfe_rna, @structure, @mfe = RNA.from_string(data.seq, structure), structure, ViennaRna::Global::Parser.rnafold_mfe(@response)
         end
       end
-    
-      module Batch
-        def with_different_structures
-          run.inject(Hash.new { |hash, key| hash[key] = [] }) do |hash, folded_sequence|
-            hash.tap do
-              hash[folded_sequence.structure] << folded_sequence
-            end
-          end.values.map(&:first)
-        end
-      end
     end
   end
 end

data/lib/vienna_rna/package/mfpt.rb

@@ -0,0 +1,35 @@
+module ViennaRna
+  module Package
+    class Mfpt < Base
+      self.chains_from   = ViennaRna::Package::EnergyGrid2d
+      self.default_flags = ->(context, flags) { { X: :empty, H: :empty, N: context.data.seq.length, Q: "1e-8" } }
+      # These flags aren't well setup for alternative options at the moment.
+      
+      attr_reader :mfpt
+      
+      def transform_for_chaining(previous_package)
+        previous_package.data.tap do |data|
+          data.instance_eval do
+            @energy_grid_csv = Tempfile.new("rna").path.tap do |energy_grid_csv|
+              previous_package.to_csv!(energy_grid_csv)
+            end
+          
+            def energy_grid_csv; @energy_grid_csv; end
+          end
+        end
+      end
+    
+      def run_command(flags)      
+        "%s %s %s" % [
+          exec_name, 
+          stringify_flags(flags), 
+          data.energy_grid_csv
+        ]
+      end
+    
+      def post_process
+        @mfpt = @response.to_f
+      end
+    end
+  end
+end

data/lib/vienna_rna/package/rna2dfold.rb

@@ -1,7 +1,7 @@
 module ViennaRna
   module Package
     class Rna2dfold < EnergyGrid2d
-      BASE_FLAGS = {
+      self.default_flags = {
         d:         0,
         p:         :empty,
         "-noBT" => :empty
@@ -9,13 +9,13 @@ module ViennaRna
 
       self.executable_name = "RNA2Dfold"
 
-      def run_command(flags = {})
+      def run_command(flags)
         ViennaRna.debugger { "Running RNA2Dfold on #{data.inspect}" }
       
-        "cat %s  | %s %s" % [
+        "cat %s | %s %s" % [
           data.temp_fa_file!,
           exec_name, 
-          stringify_flags(BASE_FLAGS.merge(self.class.const_defined?(:FLAGS) ? self.class.const_get(:FLAGS) : {}).merge(flags))
+          stringify_flags(flags)
         ]
       end
     

data/lib/vienna_rna/package/xbor.rb

@@ -1,13 +1,13 @@
 module ViennaRna
   module Package
     class Xbor < Base
-      BASE_FLAGS = {
+      self.default_flags = {
         E: "/usr/local/bin/energy.par"
       }
     
-      self.executable_name = -> { name.demodulize.gsub(/^([A-Z].*)bor$/) { |match| $1.upcase + "bor" } }
+      self.executable_name = ->(context) { context.class.name.demodulize.gsub(/^([A-Z].*)bor$/) { |match| $1.upcase + "bor" } }
     
-      def run_command(flags = {})
+      def run_command(flags)
         file = Tempfile.new("rna")
         file.write("%s\n" % data.seq)
         file.write("%s\n" % data.str)
@@ -17,7 +17,7 @@ module ViennaRna
       
         "%s %s %s" % [
           exec_name, 
-          stringify_flags(BASE_FLAGS.merge(self.class.const_defined?(:FLAGS) ? self.class.const_get(:FLAGS) : {}).merge(flags)), 
+          stringify_flags(flags), 
           file.path
         ]
       end

metadata

@@ -1,29 +1,15 @@
 --- !ruby/object:Gem::Specification
 name: vienna_rna
 version: !ruby/object:Gem::Version
-  version: 0.9.2
+  version: 0.10.0
 platform: ruby
 authors:
 - Evan Senter
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-10-07 00:00:00.000000000 Z
+date: 2013-11-03 00:00:00.000000000 Z
 dependencies:
-- !ruby/object:Gem::Dependency
-  name: bio
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: 1.4.2
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: 1.4.2
 - !ruby/object:Gem::Dependency
   name: activesupport
   requirement: !ruby/object:Gem::Requirement
@@ -66,20 +52,6 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: 2.0.3
-- !ruby/object:Gem::Dependency
-  name: rroc
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: 0.1.1
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: 0.1.1
 description: A Ruby 2.0 API for interacting with command line tools involving RNA
   molecules through a standard interface.
 email: evansenter@gmail.com
@@ -87,9 +59,11 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- lib/vienna_rna/global/chain_extensions.rb
 - lib/vienna_rna/global/parser.rb
 - lib/vienna_rna/global/rna.rb
 - lib/vienna_rna/global/rna_extensions.rb
+- lib/vienna_rna/global/run_extensions.rb
 - lib/vienna_rna/graphing/r.rb
 - lib/vienna_rna/package/base.rb
 - lib/vienna_rna/package/energy_grid_2d.rb
@@ -98,6 +72,7 @@ files:
 - lib/vienna_rna/package/fftbor2d.rb
 - lib/vienna_rna/package/fold.rb
 - lib/vienna_rna/package/heat.rb
+- lib/vienna_rna/package/mfpt.rb
 - lib/vienna_rna/package/rna2dfold.rb
 - lib/vienna_rna/package/rnabor.rb
 - lib/vienna_rna/package/subopt.rb
@@ -123,7 +98,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.1.4
+rubygems_version: 2.1.9
 signing_key: 
 specification_version: 4
 summary: Bindings to the Vienna RNA package, and other major command line utilities