vienna_rna 0.6.0 → 0.7.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 16cb73b2fcfe880d27bc3754363cb986f12b9e93
-  data.tar.gz: a18ea5d222722e5512e8d46b3ecdb4a837c44bf8
+  metadata.gz: 80d4f6159bca186181c792f0a09d696db387a4e3
+  data.tar.gz: 50bc4db672365259c1c25f78659b268e5d3c60c6
 SHA512:
-  metadata.gz: 1e33cfffbe0538c3e6c887a8b18f65f9e74c2f26d1aa0255ffd079710770df8c4118804f9183969568cde1f65a703563a501cf899e136e312bc58e4bc0360c5c
-  data.tar.gz: 83153eae6e5c83f85cb30772ac1ae3134a99c226e4e84cd0a96ad1157087a633ef54cb66b5402bb99095d685bde334d7703c4fbf7738a9c8a964de8b98e10d9e
+  metadata.gz: e534a3181b7c41f6536a7e49ea2458d015944f1c7d6f0c66020839004a28c33d0004d649f237c1bb82d8bf8ec17bce7fd8d58f516307a58d0dc48aba2ee98d3c
+  data.tar.gz: c16e11c3a1e79b2b909692b173b90bf2a20568823376d270859fcbd5133ba09d751d409531ae5c8b1d9c4f44d1f6aced99148791ab98b9690cef5dbf511e73ee

data/lib/vienna_rna/modules/base.rb

@@ -65,10 +65,10 @@ module ViennaRna
       data  = [data] unless data.is_a?(Array)
       
       @data = case data.map(&:class)
-      when [Rna]                      then data.first
-      when [String], [String, String] then Rna.init_from_string(*data)
-      when [Hash]                     then Rna.init_from_hash(*data)
-      when [Array]                    then Rna.init_from_array(*data)
+      when [Rna]                            then data.first
+      when *(1..3).map { |i| [String] * i } then Rna.init_from_string(*data)
+      when [Hash]                           then Rna.init_from_hash(*data)
+      when [Array]                          then Rna.init_from_array(*data)
       else raise TypeError.new("Unsupported ViennaRna::Rna#initialize format: #{data}")
       end
     end

data/lib/vienna_rna/modules/fftbor.rb

@@ -4,11 +4,6 @@ require "diverge"
 
 module ViennaRna
   class Fftbor < Xbor
-    MODES = {
-      dispatch:   "RNAcentral",
-      standalone: "FFTbor"
-    }
-    
     def partition
       response.split(/\n/).find { |line| line =~ /^Scaling factor.*:\s+(\d+\.\d+)/ }
       BigDecimal.new($1)

data/lib/vienna_rna/modules/fftbor2d.rb

@@ -1,5 +1,28 @@
 module ViennaRna
-  class Fftbor2d < Fftbor
+  class Fftbor2d < Base
+    BASE_FLAGS = {
+      E: "/usr/local/bin/rna_turner1999.par",
+      P: 8,
+      S: :empty
+    }
+
+    self.executable_name = "FFTbor2D"
+
+    def run_command(flags = {})
+      ViennaRna.debugger { "Running FFTbor2D 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)), 
+        data.temp_fa_file!
+      ]
+    end
     
+    def distribution
+      response.split(/\n/).map do |line| 
+        i, j, p, ensemble = line.split(/\t/)
+        [i, j].map(&:to_i) + [p, ensemble].map(&:to_f)
+      end
+    end
   end
 end

data/lib/vienna_rna/modules/rna.rb

@@ -2,70 +2,97 @@ module ViennaRna
   class Rna
     include ViennaRna::RnaExtensions
     
-    attr_reader :sequence, :structure, :raw_data
+    attr_reader :sequence, :structure, :second_structure, :raw_data
       
     class << self
-      def init_from_string(sequence, structure = nil)
-        new(sequence, structure)
+      def init_from_string(sequence, structure = nil, second_structure = nil)
+        new(
+          sequence:         sequence, 
+          structure:        structure, 
+          second_structure: second_structure
+        )
       end
     
       def init_from_hash(hash)
-        new(hash[:sequence] || hash[:seq], hash[:structure] || hash[:str], hash)
+        new(
+          sequence:         hash[:sequence]         || hash[:seq], 
+          structure:        hash[:structure]        || hash[:str_1] || hash[:str], 
+          second_structure: hash[:second_structure] || hash[:str_2], 
+          raw_data:         hash
+        )
       end
       
       def init_from_array(array)
-        new(*array)
+        init_from_string(*array)
       end
       
       def init_from_fasta(string)
         string = File.read(string).chomp if File.exist?(string)
-        init_from_string(*string.split(/\n/).reject { |line| line.start_with?(">") }[0, 2])
+        init_from_string(*string.split(/\n/).reject { |line| line.start_with?(">") }[0, 3])
       end
     
       def init_from_self(rna)
         # This happens when you call a ViennaRna library function with the output of something like ViennaRna::Fold.run(...).mfe
-        new(rna.sequence, rna.structure, rna.raw_data)
+        new(
+          sequence:         rna.sequence, 
+          strucutre:        rna.structure, 
+          second_strucutre: rna.second_structure, 
+          raw_data:         rna.raw_data
+        )
       end
     end
     
-    def initialize(sequence, structure, raw_data = {})
+    def initialize(sequence: "", structure: "", second_structure: "", raw_data: {})
       @sequence, @raw_data = sequence, raw_data
       
-      @structure = case structure
-      when :empty then empty_structure
-      when :mfe   then ViennaRna::Fold.run(Rna.init_from_string(seq)).structure
-      when String then structure
+      [: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
+          end
+        )
       end
 
       if str && seq.length != str.length
-        ViennaRna.debugger { "The sequence length (%d) doesn't match the structure length (%d)" % [seq.length, str.length] }
+        ViennaRna.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
+        ViennaRna.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 :seq   :sequence
+    alias :str   :structure
+    alias :str_1 :structure
+    alias :str_2 :second_structure
     
     def inspect
-      case [!(seq || "").empty?, !(str || "").empty?]
-      when [true, true] then
-        "#<#{self.class.name} #{seq[0, 20] + (seq.length > 20 ? '...' : '')} #{str[0, 20] + (str.length > 20 ? ' [truncated]' : '')}>"
-      when [true, false] then
-        "#<#{self.class.name} #{seq[0, 20] + (seq.length > 20 ? '...' : '')}>"
-      when [false, false] then
-        "#<#{self.class.name}>"
-      end
+      "#<%s>" % [
+        "#{self.class.name}",
+        ("#{seq[0, 20]   + (seq.length > 20   ? '...' : '')}"          if seq),
+        ("#{str_1[0, 20] + (str_1.length > 20 ? ' [truncated]' : '')}" if str_1),
+        ("#{str_2[0, 20] + (str_2.length > 20 ? ' [truncated]' : '')}" if str_2),
+      ].compact.join(" ")
     end
     
     def write_fa!(filename, comment = "")
-      (File.basename(filename, ".fa") + ".fa").tap do |filename|
-        File.open(filename, "w") do |file|
+      filename.tap do |filename|
+        File.open(filename, ?w) do |file|
           file.write("> %s\n" % comment) if comment
           file.write("%s\n" % seq)       if seq
-          file.write("%s\n" % str)       if str
+          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("")).path
+    end
 
     def run(module_name, options = {})
       if rna_module = ViennaRna.const_missing("#{module_name}".camelize)
@@ -74,11 +101,11 @@ module ViennaRna
         raise ArgumentError.new("#{module_name} can't be resolved as an executable")
       end
     end
-    
-    private
-      
+
     def empty_structure
       "." * seq.length
     end
+
+    alias :empty_str :empty_structure
   end
 end

data/lib/vienna_rna.rb

@@ -44,8 +44,8 @@ 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(sequence, structure = nil)
-    RNA.from_string(sequence, structure)
+  def RNA(*args)
+    RNA.from_array(args)
   end
 end
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: vienna_rna
 version: !ruby/object:Gem::Version
-  version: 0.6.0
+  version: 0.7.0
 platform: ruby
 authors:
 - Evan Senter
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-07-30 00:00:00.000000000 Z
+date: 2013-08-23 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bio
@@ -94,7 +94,7 @@ dependencies:
     - - '>='
       - !ruby/object:Gem::Version
         version: 0.1.1
-description: A Ruby API for interacting with the Vienna RNA package.
+description: A Ruby 2.0 API for interacting with the Vienna RNA package.
 email: evansenter@gmail.com
 executables: []
 extensions: []
@@ -138,7 +138,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.0.5
+rubygems_version: 2.0.6
 signing_key: 
 specification_version: 4
 summary: Bindings to the Vienna RNA package.