vienna_rna 0.8.6 → 0.9.0

data/lib/vienna_rna/package/fold.rb

@@ -0,0 +1,31 @@
+module ViennaRna
+  module Package
+    class Fold < Base
+      BASE_FLAGS = {
+        "-noPS" => :empty
+      }
+    
+      attr_reader :mfe_rna, :structure, :mfe
+    
+      def post_process
+        structure = ViennaRna::Global::Parser.rnafold_mfe_structure(@response)
+      
+        unless data.seq.length == structure.length
+          raise "Sequence: '#{data.seq}'\nStructure: '#{structure}'"
+        else
+          @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/heat.rb

@@ -0,0 +1,15 @@
+module ViennaRna
+  module Package
+    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
+end

data/lib/vienna_rna/package/rna2dfold.rb

@@ -0,0 +1,27 @@
+module ViennaRna
+  module Package
+    class Rna2dfold < EnergyGrid2d
+      BASE_FLAGS = {
+        d:         0,
+        p:         :empty,
+        "-noBT" => :empty
+      }
+
+      self.executable_name = "RNA2Dfold"
+
+      def run_command(flags = {})
+        ViennaRna.debugger { "Running RNA2Dfold on #{data.inspect}" }
+      
+        "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))
+        ]
+      end
+    
+      def distribution
+        response.split(/\n/)[6..-1].map { |line| line.split(/\t/).at_indexes([0, 1, 2, 6]) }
+      end
+    end
+  end
+end

data/lib/vienna_rna/package/rnabor.rb

@@ -0,0 +1,32 @@
+module ViennaRna
+  module Package
+    class Rnabor < Xbor
+      FLAGS = {
+        nodangle: :empty
+      }
+    
+      def partition
+        non_zero_shells.inject(&:+)
+      end
+    
+      def total_count
+        counts.inject(&:+)
+      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)
+      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.map { |value| options[:precision].zero? ? value : (value * 10 ** options[:precision]).truncate / 10.0 ** options[:precision] }
+      end
+    
+      def non_zero_shells
+        self.class.parse(response).map { |row| BigDecimal.new(row[1]) }
+      end
+    end
+  end
+end

data/lib/vienna_rna/package/subopt.rb

@@ -0,0 +1,19 @@
+module ViennaRna
+  module Package
+    class Subopt < Base
+      attr_reader :structures
+    
+      def post_process
+        @structures = @response.split(/\n/)[1..-1].map { |output| RNA.from_string(data.seq, output.split(/\s+/).first) }
+      end
+    
+      def bin(count = 1)
+        run(p: count).structures.inject(Hash.new { |hash, key| hash[key] = 0 }) do |hash, structure|
+          hash.tap do
+            hash[structure] += 1
+          end
+        end
+      end
+    end
+  end
+end

data/lib/vienna_rna/package/xbor.rb

@@ -0,0 +1,63 @@
+module ViennaRna
+  module Package
+    class Xbor < Base
+      BASE_FLAGS = {
+        E: "/usr/local/bin/energy.par"
+      }
+    
+      self.executable_name = -> { name.demodulize.gsub(/^([A-Z].*)bor$/) { |match| $1.upcase + "bor" } }
+    
+      def run_command(flags = {})
+        file = Tempfile.new("rna")
+        file.write("%s\n" % data.seq)
+        file.write("%s\n" % data.str)
+        file.close
+      
+        ViennaRna.debugger { "Running FFTbor 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)), 
+          file.path
+        ]
+      end
+    
+      def self.bootstrap_from_file(path, klass = self)
+        log       = File.read(path)
+        sequence  = log.split(/\n/).first.split(/\s+/)[1]
+        structure = log.split(/\n/).first.split(/\s+/)[2]
+      
+        klass.bootstrap(RNA.from_string(sequence, structure), log)
+      end
+    
+      def self.parse(response)
+        response.split(/\n/).select { |line| line =~ /^\d+\t-?\d+/ }.map { |line| line.split(/\t/) }
+      end
+    
+      def full_distribution
+        distribution      = run.distribution
+        full_distribution = distribution + ([0.0] * ((differnece = data.seq.length - distribution.length + 1) < 0 ? 0 : differnece))
+      end
+    
+      def k_p_points
+        full_distribution.each_with_index.to_a.map(&:reverse)[0..data.seq.length]
+      end
+    
+      def expected_k
+        k_p_points.map { |array| array.inject(&:*) }.inject(&:+)
+      end
+    
+      def quick_plot(options = {})
+        ViennaRna::Graphing::Gnuplot.quick_plot(
+          k_p_points,
+          options[:title] || "%s\\n%s\\n%s" % [self.class.name, data.seq, data.safe_structure],
+          options
+        )
+      end
+    
+      def inspect
+        "#<#{self.class.name} #{data.inspect}>"
+      end
+    end
+  end
+end

data/lib/vienna_rna.rb

@@ -1,33 +1,46 @@
+require "benchmark"
 require "set"
 require "bio"
 require "shuffle"
 require "matrix"
-require "gnuplot"
 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/graphing/r"
+require "vienna_rna/package/base"
+
 begin; R.quit; rescue IOError; end
 
 module ViennaRna
   @debug = true
   
-  Dir[File.join(File.dirname(__FILE__), "vienna_rna", "modules", "*.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/modules/#{File.basename(file, '.rb')}")
-  end
-  
-  def self.const_missing(name)
-    if const_defined?(name)
-      const_get(name)
-    elsif Base.exec_exists?(name)
-      module_eval do
-        const_set(name, Class.new(Base))
+  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
+    
+    def self.const_missing(name)
+      if Base.exec_exists?(name)
+        module_eval do
+          const_set(name, Class.new(Base))
+        end
       end
     end
   end
+  
+  def self.deserialize(string)
+    YAML.load(File.exist?(string) ? File.read(string) : string)
+  end
 
   def self.debugger
     STDERR.puts yield if ViennaRna.debug
@@ -52,7 +65,7 @@ end
 module RNA
   def self.method_missing(name, *args, &block)
     if "#{name}" =~ /^from_\w+$/
-      ViennaRna::Rna.send("init_#{name}", *args)
+      ViennaRna::Global::Rna.send("init_#{name}", *args)
     else super end
   end
-end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: vienna_rna
 version: !ruby/object:Gem::Version
-  version: 0.8.6
+  version: 0.9.0
 platform: ruby
 authors:
 - Evan Senter
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-09-04 00:00:00.000000000 Z
+date: 2013-09-19 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bio
@@ -52,20 +52,6 @@ dependencies:
     - - '>='
       - !ruby/object:Gem::Version
         version: 0.1.0
-- !ruby/object:Gem::Dependency
-  name: gnuplot
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - '>='
-      - !ruby/object:Gem::Version
-        version: 2.5.0
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - '>='
-      - !ruby/object:Gem::Version
-        version: 2.5.0
 - !ruby/object:Gem::Dependency
   name: rinruby
   requirement: !ruby/object:Gem::Requirement
@@ -94,31 +80,28 @@ dependencies:
     - - '>='
       - !ruby/object:Gem::Version
         version: 0.1.1
-description: A Ruby 2.0 API for interacting with the Vienna RNA package.
+description: A Ruby 2.0 API for interacting with command line tools involving RNA
+  molecules through a standard interface.
 email: evansenter@gmail.com
 executables: []
 extensions: []
 extra_rdoc_files: []
 files:
-- lib/vienna_rna/modules/base.rb
-- lib/vienna_rna/modules/batch.rb
-- lib/vienna_rna/modules/energy_grid_2d.rb
-- lib/vienna_rna/modules/eval.rb
-- lib/vienna_rna/modules/fftbor.rb
-- lib/vienna_rna/modules/fftbor2d.rb
-- lib/vienna_rna/modules/ffthairpin.rb
-- lib/vienna_rna/modules/fftmultiloop.rb
-- lib/vienna_rna/modules/fold.rb
-- lib/vienna_rna/modules/graphing.rb
-- lib/vienna_rna/modules/heat.rb
-- lib/vienna_rna/modules/parser.rb
-- lib/vienna_rna/modules/rna.rb
-- lib/vienna_rna/modules/rna2dfold.rb
-- lib/vienna_rna/modules/rna_extensions.rb
-- lib/vienna_rna/modules/rnabor.rb
-- lib/vienna_rna/modules/subopt.rb
-- lib/vienna_rna/modules/utils.rb
-- lib/vienna_rna/modules/xbor.rb
+- lib/vienna_rna/global/parser.rb
+- lib/vienna_rna/global/rna.rb
+- lib/vienna_rna/global/rna_extensions.rb
+- lib/vienna_rna/graphing/r.rb
+- lib/vienna_rna/package/base.rb
+- lib/vienna_rna/package/energy_grid_2d.rb
+- lib/vienna_rna/package/eval.rb
+- lib/vienna_rna/package/fftbor.rb
+- lib/vienna_rna/package/fftbor2d.rb
+- lib/vienna_rna/package/fold.rb
+- lib/vienna_rna/package/heat.rb
+- lib/vienna_rna/package/rna2dfold.rb
+- lib/vienna_rna/package/rnabor.rb
+- lib/vienna_rna/package/subopt.rb
+- lib/vienna_rna/package/xbor.rb
 - lib/vienna_rna.rb
 - README.md
 homepage: http://rubygems.org/gems/vienna_rna
@@ -140,8 +123,9 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.0.6
+rubygems_version: 2.1.2
 signing_key: 
 specification_version: 4
-summary: Bindings to the Vienna RNA package.
+summary: Bindings to the Vienna RNA package, and other major command line utilities
+  for RNA.
 test_files: []

data/lib/vienna_rna/modules/base.rb

@@ -1,124 +0,0 @@
-require "benchmark"
-
-module ViennaRna
-  class Base
-    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
-      
-      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
-      
-      def bootstrap(data: nil, output: "")
-        new(data).tap do |object|
-          object.instance_variable_set(:@response, File.exist?(output) ? File.read(output).chomp : output)
-        end
-      end
-      
-      # Time to redo batch stuff.
-      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 :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)
-      
-      @data = case data.map(&:class)
-      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)
-      when [NilClass]                       then Rna.placeholder
-      else raise TypeError.new("Unsupported ViennaRna::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 }
-        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 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 debugger(&block)
-      self.class.debugger(&block)
-    end
-  end
-end

data/lib/vienna_rna/modules/batch.rb

@@ -1,26 +0,0 @@
-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/vienna_rna/modules/energy_grid_2d.rb

@@ -1,63 +0,0 @@
-module ViennaRna
-  class EnergyGrid2d < Base
-    include Enumerable
-    
-    def self.inherited(subclass)
-      subclass.class_eval { prepend EnergyGrid2dWrapper }
-    end
-    
-    module EnergyGrid2dWrapper
-      def distribution
-        super.map { |row| Row2d.new(*row) }.select { |row| row.p > 0 }.sort
-      end
-    end
-    
-    class Row2d
-      attr_reader :i, :j, :p, :ensemble
-  
-      def initialize(i, j, p, ensemble)
-        @i, @j, @p, @ensemble = i.to_i, j.to_i, BigDecimal.new(p.to_s), BigDecimal.new(ensemble.to_s)
-      end
-      
-      def position
-        [i, j]
-      end
-    
-      def <=>(other_row)
-        i == other_row.i ? j <=> other_row.j : i <=> other_row.i
-      end
-      
-      def inspect
-        "#<Row2d (%d, %d), p: %+f, ensemble: %+f>" % [i, j, p, ensemble]
-      end
-    end
-    
-    def self.aligned_distributions(*energy_grids)
-      point_set = set_of_points(*energy_grids)
-      
-      energy_grids.map do |grid|
-        (grid.distribution + (point_set - grid.map(&:position)).map { |i, j| Row2d.new(i, j, 0, Float::INFINITY) }).sort
-      end
-    end
-    
-    def self.set_of_points(*energy_grids)
-      energy_grids.inject([]) { |list, grid| list + grid.map(&:position) }.uniq.sort
-    end
-    
-    def each(&block)
-      distribution.each(&block)
-    end
-    
-    def quick_plot(num_colors: 8)
-      Graphing::R.matrix_heatmap(
-        distribution.map(&:i), 
-        distribution.map(&:j), 
-        distribution.map { |row| Math.log(row.p) },
-        title:      "#{self.class.name} Matrix Heatmap",
-        x_label:    "Distance from structure 2",
-        y_label:    "Distance from structure 1",
-        num_colors: num_colors
-      )
-    end
-  end
-end

data/lib/vienna_rna/modules/eval.rb

@@ -1,9 +0,0 @@
-module ViennaRna
-  class Eval < Base
-    attr_reader :mfe
-    
-    def post_process
-      @mfe = Parser.rnafold_mfe(@response)
-    end
-  end
-end

data/lib/vienna_rna/modules/fftbor.rb

@@ -1,21 +0,0 @@
-require "tempfile"
-require "bigdecimal"
-require "diverge"
-
-module ViennaRna
-  class Fftbor < Xbor
-    def partition
-      response.split(/\n/).find { |line| line =~ /^Scaling factor.*:\s+(\d+\.\d+)/ }
-      BigDecimal.new($1)
-    end
-    
-    def total_count
-      response.split(/\n/).find { |line| line =~ /^Number of structures: (\d+)/ }
-      $1.to_i
-    end
-    
-    def distribution
-      self.class.parse(response).map { |row| BigDecimal.new(row[1]) }
-    end
-  end
-end

data/lib/vienna_rna/modules/fftbor2d.rb

@@ -1,23 +0,0 @@
-module ViennaRna
-  class Fftbor2d < EnergyGrid2d
-    BASE_FLAGS = {
-      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 { |line| line.split(/\t/) }
-    end
-  end
-end

data/lib/vienna_rna/modules/ffthairpin.rb

@@ -1,4 +0,0 @@
-module ViennaRna
-  class Ffthairpin < Fftbor
-  end
-end

data/lib/vienna_rna/modules/fftmultiloop.rb

@@ -1,4 +0,0 @@
-module ViennaRna
-  class Fftmultiloop < Fftbor
-  end
-end

data/lib/vienna_rna/modules/fold.rb

@@ -1,29 +0,0 @@
-module ViennaRna
-  class Fold < Base
-    BASE_FLAGS = {
-      "-noPS" => :empty
-    }
-    
-    attr_reader :mfe_rna, :structure, :mfe
-    
-    def post_process
-      structure = Parser.rnafold_mfe_structure(@response)
-      
-      unless data.seq.length == structure.length
-        raise "Sequence: '#{data.seq}'\nStructure: '#{structure}'"
-      else
-        @mfe_rna, @structure, @mfe = Rna.init_from_string(data.seq, structure), structure, 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

data/lib/vienna_rna/modules/heat.rb

@@ -1,13 +0,0 @@
-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