vienna_rna 0.0.2 → 0.0.4

data/lib/modules/base.rb

@@ -1,6 +1,6 @@
 module ViennaRna
   class Base
-    class_inheritable_accessor :exec_name
+    class_attribute :executable_name
     
     class << self
       def method_added(name)
@@ -17,15 +17,34 @@ module ViennaRna
       def exec_exists?(name)
         !%x[which rna#{name.to_s.downcase}].empty?
       end
+      
+      def run(data, flags = {})
+        new(data).run(flags)
+      end
+      
+      def batch(fastas = [])
+        ViennaRna::Batch.new(self, fastas).tap do |batch|
+          if const_defined?(:Batch)
+            @@me = self
+            
+            batch.singleton_class.class_eval { include @@me.const_get(:Batch) }
+          end
+        end
+      end
     end
     
-    attr_reader :fasta
+    attr_reader :fasta, :response
     
     def exec_name
-      @exec_name || "rna#{self.class.name.split('::').last.underscore}"
+      executable_name || "rna#{self.class.name.split('::').last.underscore}"
+    end
+    
+    def exec_sequence_format
+      fasta.seq
     end
     
     def initialize(data)
+      # Doesn't support structures on the third line yet.
       @fasta = case data
       when Bio::FastaFormat then data
       when String           then Bio::FastaFormat.new(data.split(/\n/).length > 1 ? data : ">\n%s" % data)
@@ -33,9 +52,11 @@ module ViennaRna
     end
     
     def run_with_hooks(flags = {})
-      pre_run_check
-      response = run_without_hooks(flags)
-      self.class.method_defined?(:post_process) ? post_process(response) : response  
+      tap do
+        pre_run_check unless respond_to?(:run_command)
+        @response = run_without_hooks(flags)
+        post_process if respond_to?(:post_process)
+      end
     end
     
     def pre_run_check
@@ -45,11 +66,15 @@ module ViennaRna
     end
     
     def stringify_flags(flags)
-      flags.inject("") { |string, flag| (string + (" -%s %s" % flag)).strip }
+      flags.inject("") { |string, (flag, value)| (string + (value == :empty ? " -%s" % flag : " -%s %s" % [flag, value])).strip }
     end
     
     def run(flags = {})
-      %x[echo #{fasta.seq} | #{exec_name} #{stringify_flags(flags)}]
+      if respond_to?(:run_command)
+        %x[#{method(:run_command).arity.zero? ? run_command : run_command(flags)}]
+      else
+        %x[echo #{exec_sequence_format} | #{exec_name} #{stringify_flags(flags)}]
+      end
     end
   end
 end

data/lib/modules/batch.rb

@@ -1 +1,26 @@
-# This should be a meta-overlord class that runs the same command on a collection of subclasses of base.rb
+module ViennaRna
+  class Batch
+    include Enumerable
+    
+    attr_reader :type, :collection
+    
+    def initialize(type, data)
+      @type       = type
+      @collection = data.map(&type.method(:new))
+    end
+    
+    def each
+      collection.each { |element| yield element }
+    end
+    
+    def run(flags = {})
+      tap do
+        if (@memo ||= {})[flags]
+          @memo[flags]
+        else
+          @memo[flags] = map { |element| element.run(flags) }
+        end
+      end
+    end
+  end
+end

data/lib/modules/fold.rb

@@ -2,23 +2,24 @@ module ViennaRna
   class Fold < Base
     attr_reader :structure, :mfe
     
-    def post_process(response)
-      tap do
-        structure = response.split(/\n/).last.gsub(/ \(\s*(-?\d*\.\d*)\)$/, "")
+    def post_process
+      structure = @response.split(/\n/).last.gsub(/ \(\s*(-?\d*\.\d*)\)$/, "")
       
-        unless fasta.seq.length == structure.length
-          raise "Sequence: '#{fasta.seq}'\nStructure: '#{structure}'"
-        else
-          @structure, @mfe = structure, $1
-        end
+      unless fasta.seq.length == structure.length
+        raise "Sequence: '#{fasta.seq}'\nStructure: '#{structure}'"
+      else
+        @structure, @mfe = structure, $1.to_f
       end
     end
-  end
-  
-  # Mix this baby into the Batch class after I write it for great cleanness!
-  module Batch
-    def prune_same_structures
-      
+    
+    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

data/lib/modules/heat.rb

@@ -0,0 +1,13 @@
+module ViennaRna
+  class Heat < Base
+    attr_reader :specific_heats
+    
+    def post_process
+      @specific_heats = @response.split(/\n/).map { |line| line.split(/\s+/).map(&:to_f) }.inject({}) do |hash, (temp, specific_heat)|
+        hash.tap do
+          hash[temp] = specific_heat
+        end
+      end
+    end
+  end
+end

data/lib/modules/rnabor.rb

@@ -0,0 +1,31 @@
+module ViennaRna
+  class Rnabor < Base
+    def run_command(flags)
+      "./RNAbor -s %s -c %s" % [fasta.seq, flags[:scaling_factor]]
+    end
+    
+    def parse_total_count
+      response.split(/\n/).find { |line| line =~ /^Z\[\d+\]\[1\]:/ }.match(/^Z\[\d+\]\[1\]:\s*(.*)/)[1].to_i
+    end
+    
+    def parse_points
+      self.class.parse(response, "ROOTS AND SOLUTIONS") { |line| line.strip.split(/\s\s+/).map { |value| eval("Complex(#{value})") } }
+    end
+    
+    def parse_counts
+      self.class.parse(response, "UNSCALED SUM") { |line| line.strip.split(/:\s*/).map(&:to_f) }
+    end
+    
+    def self.parse(response, delimiter)
+      response.split(/\n/).reject do |line| 
+        line.empty?
+      end.drop_while do |line|
+        line !~ /^START #{delimiter}/i
+      end.reverse.drop_while do |line|
+        line !~ /^END #{delimiter}/i
+      end.reverse[1..-2].map do |line|
+        yield line
+      end
+    end
+  end
+end

data/lib/modules/subopt.rb

@@ -2,10 +2,8 @@ module ViennaRna
   class Subopt < Base
     attr_reader :structures
     
-    def post_process(response)
-      tap do
-        @structures = response.split(/\n/)
-      end
+    def post_process
+      @structures = @response.split(/\n/)
     end
     
     def bin(count = 1)

data/lib/modules/utils.rb

@@ -7,6 +7,22 @@ module ViennaRna
         # Force it to not be lazy.
         Bio::FlatFile.auto(path).to_enum.map { |fasta| fasta }
       end
+      
+      def write_fastas!(fastas, directory, base_name, group_size = 10)
+        fastas.each_slice(group_size).each_with_index do |fasta_group, i|
+          path = File.join(directory, base_name + "_#{i}.fa")
+          
+          unless File.exists?(path)
+            File.open(path, "w") do |file|
+              fasta_group.each do |folding|
+                file.write(">%s\n%s\n" % [folding.fasta.definition, folding.fasta.seq])
+              end
+            end
+          else
+            puts "Warning: file '#{path}' exists. Skipping."
+          end
+        end
+      end
     end
   end
 end

data/lib/vienna_rna.rb

@@ -1,7 +1,7 @@
 require "bio"
 require "active_support/inflector"
 require "active_support/core_ext/class"
-require "active_support/core_ext/module"
+require "active_support/core_ext/module/aliasing"
 
 # Clean up this include order.
 Dir[File.join(File.dirname(__FILE__), "/modules/*")].each do |file|

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: vienna_rna
 version: !ruby/object:Gem::Version
-  version: 0.0.2
+  version: 0.0.4
   prerelease: 
 platform: ruby
 authors:
@@ -13,7 +13,7 @@ date: 2012-03-26 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bio
-  requirement: &70120459237640 !ruby/object:Gem::Requirement
+  requirement: !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -21,18 +21,28 @@ dependencies:
         version: '0'
   type: :runtime
   prerelease: false
-  version_requirements: *70120459237640
-- !ruby/object:Gem::Dependency
-  name: active_support
-  requirement: &70120459237200 !ruby/object:Gem::Requirement
+  version_requirements: !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 3.2.5
   type: :runtime
   prerelease: false
-  version_requirements: *70120459237200
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 3.2.5
 description: A Ruby API for interacting with the Vienna RNA package.
 email: evansenter@gmail.com
 executables: []
@@ -45,6 +55,10 @@ files:
   Li9saWIvbW9kdWxlcy9iYXRjaC5yYg==
 - !binary |-
   Li9saWIvbW9kdWxlcy9mb2xkLnJi
+- !binary |-
+  Li9saWIvbW9kdWxlcy9oZWF0LnJi
+- !binary |-
+  Li9saWIvbW9kdWxlcy9ybmFib3IucmI=
 - !binary |-
   Li9saWIvbW9kdWxlcy9zdWJvcHQucmI=
 - !binary |-
@@ -71,7 +85,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 1.8.11
+rubygems_version: 1.8.24
 signing_key: 
 specification_version: 3
 summary: Bindings to the Vienna RNA package.