wrnap 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 78511600a0ab8cc9fc08c3a64c677794744fee4d
+  data.tar.gz: 2b940a1ccf7159bb14d5d53d22c7c58c1466a1b1
+SHA512:
+  metadata.gz: e6e3f134d8b2724af60d26fc07b62077489844c2d74a0258fb82a3753e0c6196ec7f029f88186985bf52bc075acdea55427b7d514133c8073aa645918d73d90e
+  data.tar.gz: 5da6d3dfe4888a5c1b7092ab1e1e93fa0cfd8504f9153cf2fc4cc62c9a65a823f3c3eff5194a17e3481a711fbead3abdba7d28b97c34fd1e5936d4d6b49982d9

data/.gitignore

@@ -0,0 +1,22 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+*.bundle
+*.so
+*.o
+*.a
+mkmf.log

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in wrnap.gemspec
+gemspec

data/LICENSE.md

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) {{{year}}} {{{fullname}}}
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/README.md

@@ -0,0 +1,47 @@
+# Wrnap
+
+[![Gem Version](https://badge.fury.io/rb/wrnap.png)](http://badge.fury.io/rb/wrnap)
+
+A simple gem for facilitating bindings to various RNA CLI packages (namely http://www.tbi.univie.ac.at/~ivo/RNA/). Note that this gem makes no effort to build and install any wrapped packages at install-time, and instead relies on its presence on the host machine. Also includes a lot of utilities surrounding RNA sequence / structure parsing, graphing using R (via RinRuby) and other analysis tools. Used privately as the foundation for much of the research I do at http://bioinformatics.bc.edu/clotelab/
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'wrnap'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install wrnap
+
+## Usage
+
+Simple use case:
+
+    > require "wrnap"
+    #=> true
+    > rna = Wrnap::Package::Fold.run(seq: "CCUCGAGGGGAACCCGAAAGGGACCCGAGAGG")
+    #=> #<Wrnap::Fold:0x007f9c48839dc0>
+    > rna.structure
+    #=> "((((..(((...(((....))).)))..))))"
+    > rna.mfe
+    #=> -19.7
+
+... now an even easier way ...
+
+    > mfe_rna = RNA("CCUCGAGGGGAACCCGAAAGGGACCCGAGAGG").run(:fold).mfe_rna
+    #=> echo CCUCGAGGGGAACCCGAAAGGGACCCGAGAGG | rnafold --noPS
+    #=> Total runtime: 0.013 sec.
+    #=> #<Wrnap::Rna CCUCGAGGGGAACCCGAAAG... ((((..(((...(((....) [truncated]>
+
+## Contributing
+
+1. Fork it ( https://github.com/[my-github-username]/wrnap/fork )
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create a new Pull Request

data/Rakefile

@@ -0,0 +1,2 @@
+require "bundler/gem_tasks"
+

data/lib/wrnap/global/chain_extensions.rb

@@ -0,0 +1,29 @@
+module Wrnap
+  module Global
+    module ChainExtensions
+      def self.included(base)
+        base.send(:include, InstanceMethods)
+      end
+      
+      module InstanceMethods
+        def chain(package, flags = {})
+          class_chaining_to = Wrnap::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?(&method(:kind_of?))
+            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/wrnap/global/parser.rb

@@ -0,0 +1,24 @@
+module Wrnap
+  module Global
+    module Parser
+      REGEXP = {
+        number: /-?\d*\.\d*/,
+        mfe:    / \(\s*(-?\d*\.\d*)\)$/
+      }
+    
+      class << self
+        def rnafold_mfe_structure(response)
+          response.split(/\n/)[1].split(/\s+/).first
+        end
+      
+        def rnafold_mfe(response)
+          response.split(/\n/)[1].match(REGEXP[:mfe])[1].to_f
+        end
+        
+        def rnafold_ensemble_energy(response)
+          response.split(/\n/)[2].split(/\s/).last.match(REGEXP[:number])[0].to_f
+        end
+      end
+    end
+  end
+end

data/lib/wrnap/global/rna.rb

@@ -0,0 +1,148 @@
+module Wrnap
+  module Global
+    class Rna
+      include RnaExtensions
+    
+      attr_accessor :comment
+      attr_reader :sequence, :structure, :second_structure
+      
+      class << self
+        def init_from_string(sequence, structure = nil, second_structure = nil, comment = nil)
+          new(
+            sequence:         sequence, 
+            structure:        structure, 
+            second_structure: second_structure,
+            comment:          comment
+          )
+        end
+    
+        def init_from_hash(hash)
+          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]
+          )
+        end
+      
+        def init_from_array(array)
+          init_from_string(*array)
+        end
+      
+        def init_from_fasta(string)
+          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]).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_self(rna)
+          # 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
+          )
+        end
+      
+        alias_method :placeholder, :new
+      end
+    
+      def initialize(sequence: "", structure: "", second_structure: "", comment: "")
+        @sequence, @comment = sequence.kind_of?(Rna) ? sequence.seq : sequence, comment
+      
+        [: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
+
+        if str && seq.length != 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 empty_structure
+        "." * seq.length
+      end
+      
+      alias :empty_str :empty_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
+      
+      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
+    
+      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 method_missing(name, *args, &block)
+        if (name_str = "#{name}") =~ /^run_\w+$/
+          run(name_str.gsub(/^run_/, ""), *args)
+        else super end
+      end
+
+      def inspect
+        "#<RNA: %s>" % [
+          ("#{seq[0, 20]   + (seq.length > 20   ? '... [%d]' % seq.length : '')}" if seq   && !seq.empty?),
+          ("#{str_1[0, 20] + (str_1.length > 20 ? ' [%d]'    % seq.length : '')}" if str_1 && !str_1.empty?),
+          ("#{str_2[0, 20] + (str_2.length > 20 ? ' [%d]'    % seq.length : '')}" if str_2 && !str_1.empty?),
+          (name ? name : "#{self.class.name}")
+        ].compact.join(", ")
+      end
+    end
+  end
+end

data/lib/wrnap/global/rna_extensions.rb

@@ -0,0 +1,99 @@
+module Wrnap
+  module Global
+    module RnaExtensions
+      def self.included(base)
+        base.send(:include, InstanceMethods)
+        base.extend(ClassMethods)
+        base.extend(OneStructureBasedMethods)
+        base.extend(TwoStructureBasedMethods)
+             
+        base.class_eval do
+          OneStructureBasedMethods.public_instance_methods.each do |class_method|
+            define_method(class_method) do |*args|
+              self.class.send(class_method, *[structure].concat(args))
+            end
+          end
+        
+          TwoStructureBasedMethods.public_instance_methods.each do |class_method|
+            define_method(class_method) do |*args|
+              self.class.send(class_method, *[str_1, str_2].concat(args))
+            end
+          end
+        end
+      
+        base.send(:include, InstanceMethods)
+      end
+    
+      module ClassMethods
+        def generate_sequence(sequence_length)
+          # 0th order Markov chain w/ uniform probability distribution
+          Rna.init_from_string(sequence_length.times.inject("") { |string, _| string + %w[A U C G][rand(4)] })
+        end
+      
+        def shuffle(sequence, token_length = 2)
+          Shuffle.new(sequence).shuffle(token_length)
+        end
+      end
+
+      module InstanceMethods
+        def dishuffle
+          self.class.shuffle(sequence, 2)
+        end
+      
+        def gc_content
+          seq.split(//).select { |i| i =~ /[GC]/i }.size.to_f / seq.size
+        end
+        
+        def boltzmann_probability(dangle: 2)
+          Math.exp(-run(:eval, d: dangle).mfe / Wrnap::RT) / Math.exp(-run(:fold, d: dangle, p: 0).ensemble_energy / Wrnap::RT)
+        end
+      end
+    
+      module OneStructureBasedMethods
+        def max_bp_distance(structure)
+          base_pairs(structure).count + ((structure.length - 3) / 2.0).floor
+        end
+      
+        def base_pairs(structure)
+          get_pairings(structure).each_with_index.inject(Set.new) do |set, (j, i)|
+            j >= 0 ? set << Set[i, j] : set
+          end
+        end
+    
+        def get_pairings(structure)
+        	stack = []
+      
+          structure.each_char.each_with_index.inject(Array.new(structure.length, -1)) do |array, (symbol, index)|
+        	  array.tap do      
+        	    case symbol
+        	    when "(" then stack.push(index)
+        	    when ")" then 
+        	      if stack.empty?
+        	        raise "Too many ')' in '#{structure}'"
+        	      else
+        	        stack.pop.tap do |opening|
+        	          array[opening] = index
+        	          array[index]   = opening
+        	        end
+        	      end
+        	    end
+        	  end
+        	end.tap do
+        	  raise "Too many '(' in '#{structure}'" unless stack.empty?
+        	end
+        end
+      end
+    
+      module TwoStructureBasedMethods
+        def bp_distance(structure_1, structure_2)
+          # Takes two structures and calculates the distance between them by |symmetric difference(bp_in_a, bp_in_b)|
+          raise "The two structures are not the same length" unless structure_1.length == structure_2.length
+        
+          bp_set_1, bp_set_2 = base_pairs(structure_1), base_pairs(structure_2)
+        
+          ((bp_set_1 - bp_set_2) + (bp_set_2 - bp_set_1)).count
+        end
+      end
+    end
+  end
+end

data/lib/wrnap/global/run_extensions.rb

@@ -0,0 +1,98 @@
+module Wrnap
+  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? || !%x[which #{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)
+
+                Wrnap.debugger { runnable_command }
+
+                @response        = %x[#{runnable_command}]
+                post_process if respond_to?(:post_process)
+              end
+
+              Wrnap.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|
+            Wrnap.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)|
+            parameter = if value == :empty || value.class == TrueClass
+              " -%s" % flag
+            else
+              if quote_flag_params.include?(flag)
+                " -%s '%s'" % [flag, value.to_s.gsub(/'/) { %|\'| }]
+              else
+                " -%s %s" % [flag, value]
+              end
+            end
+
+            (string + parameter).strip
+          end.tap do
+            @flags = flags
+          end
+        end
+      end
+    end
+  end
+end