wrnap 0.3.0 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 886697f970124a5b27d1149141ebaadfd8f275c2
-  data.tar.gz: 19afc74cff392c61f3c84bf12b39db74252fcb96
+  metadata.gz: 62bce1f01b0068d45befe18bcb9bb5b6891de764
+  data.tar.gz: 2ec02f8b44890f19b75995949b9146776642da9f
 SHA512:
-  metadata.gz: cd86a11763b4770bc7d4af245c36dc647b326870c0e2c9e3f0ab39b0c9a99cfd6db2722c5f72ee176635b4c5f99ffd33ea7cc8805fc24bf411f736eeef0efc0d
-  data.tar.gz: 085d7434dbe7669336a9e858e7dc11c6a12d856e837306bc703596539923a1919f97b819a2878173cb84f02995d585b2b134ab4d2bd7aaa22238753466d6dff0
+  metadata.gz: 28e711a4fd54857a15fa5ce3beac1f3b3d5e99824883d44b20ec5a73deff48e6191ef38f64c4d85a8198e481736c0a467ca1b88bea2f1fb243610913d47e79e7
+  data.tar.gz: 0dcdb3c401989fe413270b27334a91ee5a21f27c4f7ec9307251e2549c7bdde12c950c2757764a1d27e82618883245d56557fc3aea4550828e597fff0ca4cf18

data/lib/wrnap/global/{chain_extensions.rb → chainer.rb}

@@ -1,26 +1,26 @@
 module Wrnap
   module Global
-    module ChainExtensions
+    module Chainer
       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

data/lib/wrnap/global/entrez.rb

@@ -0,0 +1,36 @@
+module Wrnap
+  module Global
+    module Entrez
+      class << self
+        def simple_rna_sequence(id, from, to)
+          sequence = rna_sequence_from_entrez(id, [from, to].min, 0..((to - from).abs))
+
+          to < from ? sequence.complement : sequence
+        end
+
+        def rna_sequence_from_entrez(id, position, window, buffer_size = 0)
+          na_sequence_from_entrez(id, position, window, buffer_size).rna
+        end
+
+        def na_sequence_from_entrez(id, position, window, buffer_size = 0)
+          Bio::Sequence::NA.new(sequence_from_entrez(id, position, Range.new(window.min - buffer_size, window.max + buffer_size)).seq)
+        end
+
+        def sequence_from_entrez(id, position, window)
+          Wrnap.debugger { "Retrieving sequence from Entrez: using nuccore DB (id: #{id}, seq_start: #{position + window.min}, seq_stop: #{position + window.max})" }
+          Wrnap.debugger { "> True starting position: #{position} with window #{window.min} to #{window.max}" }
+
+          fasta = ::Entrez.EFetch("nuccore", {
+            id:        id,
+            seq_start: position + window.min,
+            seq_stop:  position + window.max,
+            retmode:   :fasta,
+            rettype:   :text
+          }).response.body
+
+          Bio::FastaFormat.new(fasta)
+        end
+      end
+    end
+  end
+end

data/lib/wrnap/global/rna/context.rb

@@ -0,0 +1,122 @@
+module Wrnap
+  module Global
+    class Context < Rna
+      attr_reader :accession, :from, :to, :coord_options
+
+      class << self
+        def init_from_entrez(accession, from, to, coord_options = {})
+          new(
+            accession:     accession,
+            from:          from,
+            to:            to,
+            coord_options: coord_options
+          )
+        end
+
+        def init_from_string(sequence, accession, from, to, coord_options = {})
+          new(
+            sequence:      sequence,
+            accession:     accession,
+            from:          from,
+            to:            to,
+            coord_options: coord_options
+          )
+        end
+      end
+
+      def initialize(sequence: nil, accession: nil, from: nil, to: nil, coord_options: {})
+        @accession, @from, @to, @coord_options = accession, from, to, coord_options
+
+        validate_coord_options
+
+        if sequence
+          @raw_sequence = (sequence.is_a?(String) ? Bio::Sequence::NA.new(sequence) : sequence).upcase
+        end
+      end
+
+      def validate_coord_options
+        unless coord_options.empty?
+          unless coord_options.keys == Set.new(%i|direction length|)
+            raise ArgumentError.new("coord_options keys must contain only :direction, :length, found: %s" % coord_options.keys)
+          end
+
+          unless (length = coord_options[:length]).is_a?(Integer) && length > 0
+            raise ArgumentError.new("coord_options length must be greater than 0, found: %d" % length)
+          end
+
+          unless [:up, :down, :both, 5, 3].include?(direction = coord_options[:direction])
+            raise ArgumentError.new("coord_options directions is not a valid key, found: %s" % direction)
+          end
+        end
+      end
+
+      def up_coord
+        [from, to].min
+      end
+
+      def down_coord
+        [from, to].max
+      end
+
+      def seq_from
+        up_coord + coord_window.min
+      end
+
+      def seq_to
+        up_coord + coord_window.max
+      end
+
+      def strand
+        plus_strand? ? :plus : :minus
+      end
+
+      def plus_strand?
+        to > from
+      end
+
+      def minus_strand?
+        !plus_strand?
+      end
+
+      def sequence
+        @raw_sequence ||= Entrez.rna_sequence_from_entrez(accession, up_coord, coord_window)
+        @raw_sequence   = minus_strand? ? @raw_sequence.complement : @raw_sequence
+      end
+
+      alias :seq :sequence
+
+      def extend!(coord_options = {})
+        tap do
+          @coord_options = coord_options unless coord_options.empty?
+          validate_coord_options
+          @extended      = true
+          remove_instance_variable(:@raw_sequence)
+        end
+      end
+
+      def extended?
+        @extended
+      end
+
+      def coord_window
+        # This does not support extending the range in both directions, though it should be easy to do.
+        # Options from coord_options ex: { length: 300, direction: 3 }, { length: 250, direction: :both }, { length: 200, direction: :down }
+        range = 0..(down_coord - up_coord)
+
+        if coord_options[:length] && coord_options[:direction]
+          if coord_options[:direction] == :both
+            Range.new(range.min - coord_options[:length], range.max + coord_options[:length])
+          else
+            case [coord_options[:direction], strand]
+            when [3, :plus], [:down, :plus], [5, :minus], [:up, :minus] then Range.new(range.min, range.max + coord_options[:length])
+            when [5, :plus], [:up, :plus], [3, :minus], [:down, :minus] then Range.new(range.min - coord_options[:length], range.max)
+            else Wrnap.debugger { "WARNING: value for :direction key in sequence retreival needs to be one of 5, 3, :both - found (%s)" % coord_options[:direction].inspect }
+            end
+          end
+        else
+          range
+        end
+      end
+    end
+  end
+end

data/lib/wrnap/global/{rna_extensions.rb → rna/extensions.rb}

@@ -1,35 +1,35 @@
 module Wrnap
   module Global
-    module RnaExtensions
+    module Extensions
       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
@@ -39,35 +39,35 @@ module Wrnap
         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      
+        	  array.tap do
         	    case symbol
         	    when "(" then stack.push(index)
-        	    when ")" then 
+        	    when ")" then
         	      if stack.empty?
         	        raise "Too many ')' in '#{structure}'"
         	      else
@@ -83,14 +83,14 @@ module Wrnap
         	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

data/lib/wrnap/global/rna.rb

@@ -1,7 +1,7 @@
 module Wrnap
   module Global
     class Rna
-      include RnaExtensions
+      include Extensions
 
       attr_accessor :comment
       attr_reader :sequence, :structure, :second_structure
@@ -44,6 +44,10 @@ module Wrnap
           end
         end
 
+        def init_from_context(context: [], rna: [])
+          init_from_string(Context.init_from_entrez(*context), *rna)
+        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(
@@ -102,6 +106,8 @@ module Wrnap
         self.class.init_from_string(seq, structure_1.is_a?(Symbol) ? send(structure_1) : structure_1, nil, name)
       end
 
+      alias :one_str :one_structure
+
       def two_structures(structure_1, structure_2)
         self.class.init_from_string(
           seq,
@@ -110,6 +116,8 @@ module Wrnap
         )
       end
 
+      alias :two_str :two_structures
+
       def write_fa!(filename)
         filename.tap do |filename|
           File.open(filename, ?w) do |file|

data/lib/wrnap/global/{run_extensions.rb → runner.rb}

@@ -1,6 +1,6 @@
 module Wrnap
   module Global
-    module RunExtensions
+    module Runner
       def self.included(base)
         base.send(:include, InstanceMethods)
         base.extend(ClassMethods)

data/lib/wrnap/graphing/r.rb

@@ -9,52 +9,52 @@ module Wrnap
             raise unless e.message == "Unsupported data type on R's end"
           end
         end
-        
+
         def overlay(data, title: nil, type: ?l, x_label: "Independent", y_label: "Dependent", legend: "topleft", filename: false)
           # data: [{ data: [[x_0, y_0], ..., [x_n, y_n]], legend: "Line 1" }, ...]
-          
+
           x_points = data.map { |hash| hash[:data].map(&:first) }
           y_points = data.map { |hash| hash[:data].map(&:last) }
           x_range  = Range.new(x_points.map(&:min).min.floor, x_points.map(&:max).max.ceil)
           y_range  = Range.new(y_points.map(&:min).min.floor, y_points.map(&:max).max.ceil)
-          
+
           graph do |r|
             r.eval("%s('%s', 6, 6)" % [
-              writing_file?(filename) ? "pdf" : "quartz", 
-              writing_file?(filename) ? filename : "Graph", 
+              writing_file?(filename) ? filetype(filename) : "quartz",
+              writing_file?(filename) ? filename : "Graph",
             ])
-            
+
             r.assign("legend.titles", data.each_with_index.map { |hash, index| hash[:legend] || "Line #{index + 1}" })
             r.eval("line.colors <- rainbow(%d)" % data.size)
             r.eval("plot(0, 0, type = 'n', cex = .75, cex.axis = .9, xlab = '', ylab = '', xlim = c(%d, %d), ylim = c(%d, %d))" % [
               x_range.min, x_range.max, y_range.min, y_range.max
             ])
-            
+
             data.each_with_index do |hash, index|
               r.assign("line_graph.x.%d" % index, x_points[index])
               r.assign("line_graph.y.%d" % index, y_points[index])
-              
+
               r.eval <<-STR
                 lines(
-                  line_graph.x.#{index}, 
-                  line_graph.y.#{index}, 
+                  line_graph.x.#{index},
+                  line_graph.y.#{index},
                   col  = line.colors[#{index + 1}],
                   type = "#{type}",
                   pch  = #{index}
                 )
               STR
             end
-            
+
             r.eval <<-STR
               title(
-                xlab     = #{expressionify(x_label)}, 
-                ylab     = #{expressionify(y_label)}, 
+                xlab     = #{expressionify(x_label)},
+                ylab     = #{expressionify(y_label)},
                 main     = #{expressionify(title || "Line Graph")},
                 cex.main = .9,
                 cex.lab  = .9
               )
             STR
-              
+
             if legend
               r.eval <<-STR
                 legend(
@@ -69,7 +69,7 @@ module Wrnap
                 )
               STR
             end
-            
+
             r.eval("dev.off()") if writing_file?(filename)
           end
         end
@@ -77,84 +77,84 @@ module Wrnap
         def line_graph(data, title: nil, type: ?l, x_label: "Independent", y_label: "Dependent", filename: false)
           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 || "Scatterplot", type: ?p, x_label: x_label, y_label: y_label, filename: filename)
         end
-        
+
         def roc(data, title: nil, baseline: true, filename: false)
           # data: [[-0.894, 1.0], [-0.950, 1.0], [0.516, -1.0], ..., [0.815, -1.0], [0.740, -1.0]]
           auc            = ROC.auc(data)
           title_with_auc = title ? "%s (AUC: %.4f)" % [title, auc] : "AUC: %.4f" % auc
           overlay(
-            [{ data: ROC.curve_points(data) }, { data: [[0, 0], [1, 1]] }], 
-            title:    title_with_auc, 
-            x_label:  "False positive rate", 
-            y_label:  "True positive rate", 
-            legend:   false, 
+            [{ data: ROC.curve_points(data) }, { data: [[0, 0], [1, 1]] }],
+            title:    title_with_auc,
+            x_label:  "False positive rate",
+            y_label:  "True positive rate",
+            legend:   false,
             filename: filename
           )
         end
-        
+
         def roc_overlay(data, title: nil, auc_in_legend: true, filename: false)
           # [{ data: [[-0.894, 1.0], [-0.950, 1.0], [0.516, -1.0], ..., [0.815, -1.0], [0.740, -1.0]], legend: "ROC 1" }, ...]
           formatted_data = data.map do |hash|
             curve_points = ROC.curve_points(hash[:data])
-            
+
             if auc_in_legend
               auc    = ROC.auc(hash[:data])
               legend = hash[:legend] ? "%s (AUC: %.4f)" % [hash[:legend], auc] : "AUC: %.4f" % auc
-              
+
               hash.merge({ data: curve_points, legend: legend })
             else
               hash.merge({ data: curve_points })
             end
           end
-          
-          
+
+
           overlay(
-            formatted_data, 
-            title:    title, 
-            x_label:  "False positive rate", 
-            y_label:  "True positive rate", 
-            legend:   "bottomright", 
+            formatted_data,
+            title:    title,
+            x_label:  "False positive rate",
+            y_label:  "True positive rate",
+            legend:   "bottomright",
             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)
           breaks   = num_bins ? num_bins : (range.min + half).step(range.max + half, bin_size).to_a
-          
+
           graph do |r|
             r.assign("histogram.data", data)
             r.assign("histogram.breaks", breaks)
-            
+
             r.eval("%s('%s', 6, 6)" % [
-              writing_file?(filename) ? "pdf" : "quartz", 
-              writing_file?(filename) ? filename : "Histogram", 
+              writing_file?(filename) ? filetype(filename) : "quartz",
+              writing_file?(filename) ? filename : "Graph",
             ])
-            
+
             r.eval <<-STR
               hist(
-                histogram.data, 
-                breaks   = histogram.breaks, 
-                xlab     = #{expressionify(x_label)}, 
-                main     = #{expressionify(title || "Histogram")}, 
+                histogram.data,
+                breaks   = histogram.breaks,
+                xlab     = #{expressionify(x_label)},
+                main     = #{expressionify(title || "Histogram")},
                 freq     = #{relative ? 'F' : 'T'},
                 cex.main = 0.9,
                 cex.lab  = 0.9,
                 cex.axis = 0.9
               )
             STR
-            
+
             r.eval("abline(v = #{x_arrow}, lty = 'dashed')") if x_arrow
-            
+
             r.eval("dev.off()") if writing_file?(filename)
           end
         end
-        
+
         def matrix_heatmap(x, y, z, title: nil, x_label: "Column index", y_label: "Row index", filename: false, num_colors: 64)
           graph do |r|
             if r.pull("ifelse('Matrix' %in% rownames(installed.packages()), 1, -1)") > 0
@@ -163,7 +163,7 @@ module Wrnap
                 y << [x, y].map(&:max).max
                 z << 0
               end
-              
+
               r.assign("matrix.i", x)
               r.assign("matrix.j", y)
               r.assign("matrix.x", z)
@@ -176,16 +176,16 @@ module Wrnap
                 index1 = F
                 )
               STR
-              
+
               generate_graph("Heatmap") do
                 <<-STR
                   filtered.values <- Filter(function(i) { is.finite(i) & i != 0 }, matrix.x)
                   print(apply(as.matrix(matrix.data), 2, rev))
                   print(c(sort(filtered.values)[2], max(filtered.values)))
-                
+
                   image(
-                    x    = 1:max(c(dim(matrix.data)[[1]], dim(matrix.data)[[2]])), 
-                    y    = 1:max(c(dim(matrix.data)[[1]], dim(matrix.data)[[2]])), 
+                    x    = 1:max(c(dim(matrix.data)[[1]], dim(matrix.data)[[2]])),
+                    y    = 1:max(c(dim(matrix.data)[[1]], dim(matrix.data)[[2]])),
                     z    = as.matrix(matrix.data),
                     col  = rev(heat.colors(#{num_colors})),
                     zlim = #{forced_square ? "c(sort(filtered.values)[2], max(filtered.values))" : "c(min(filtered.values), max(filtered.values))"},
@@ -200,30 +200,37 @@ module Wrnap
             end
           end
         end
-        
+
         private
-        
+
         def generate_graph(window_title = "ViennaRNA Graph in R", &block)
           r, filename = block.binding.eval("[r, filename]")
-          
+
           r.eval("%s('%s', 6, 6)" % [
-            writing_file?(filename) ? "pdf" : "quartz", 
-            writing_file?(filename) ? filename : window_title, 
+            writing_file?(filename) ? filetype(filename) : "quartz",
+            writing_file?(filename) ? filename : "Graph",
           ])
-          
+
           r.eval(yield)
-          
+
           r.eval("dev.off()") if writing_file?(filename)
         end
-        
+
+        def filetype(filename)
+          case File.extname(filename || "")
+          when ".pdf" then :pdf
+          when ".eps" then :eps
+          else raise(ArgumentError.new("You must explicitly provide an extension of .pdf or .eps so we know what type of file to make.")) end
+        end
+
         def writing_file?(filename)
-          filename && (filename = filename.end_with?(".pdf") ? filename : filename + ".pdf")
+          filename
         end
-        
+
         def expressionify(string)
           %w|expression paste|.any?(&string.method(:start_with?)) ? string : string.inspect
         end
       end
     end
   end
-end
+end

data/lib/wrnap/package/base.rb

@@ -5,8 +5,8 @@ module Wrnap
     end
 
     class Base
-      include Wrnap::Global::RunExtensions
-      include Wrnap::Global::ChainExtensions
+      include Wrnap::Global::Runner
+      include Wrnap::Global::Chainer
 
       class_attribute :executable_name
       self.executable_name = ->(context) { "RNA#{context.class.name.split('::').last.underscore}" }

data/lib/wrnap/package/population.rb

@@ -3,7 +3,7 @@ module Wrnap
     class Population < Base
       THREE_COLUMN_REGEX = /^([+-]\d+\.\d+\t){2}[+-]\d+\.\d+$/
 
-      attr_reader :str_1_to_str_2, :str_1_to_str_1
+      attr_reader :str_1_to_str_2, :str_1_to_str_1, :equilibrium
 
       self.default_flags = ->(context, flags) do
         {
@@ -82,9 +82,13 @@ module Wrnap
       end
 
       def post_process
-        time_points, str_1_to_str_2, str_1_to_str_1 = response.split(/\n/).select { |line| line =~ THREE_COLUMN_REGEX }.map { |line| line.split(/\t/).map(&:to_f) }.transpose
-        @str_1_to_str_2 = PopulationProportion.new(time_points, str_1_to_str_2)
-        @str_1_to_str_1 = PopulationProportion.new(time_points, str_1_to_str_1)
+        if flags.include?("-spectral-e")
+          @equilibrium = 10 ** response.strip.to_f
+        else
+          time_points, str_1_to_str_2, str_1_to_str_1 = response.split(/\n/).select { |line| line =~ THREE_COLUMN_REGEX }.map { |line| line.split(/\t/).map(&:to_f) }.transpose
+          @str_1_to_str_2 = PopulationProportion.new(time_points, str_1_to_str_2)
+          @str_1_to_str_1 = PopulationProportion.new(time_points, str_1_to_str_1)
+        end
       end
     end
   end

data/lib/wrnap/version.rb

@@ -1,3 +1,3 @@
 module Wrnap
-  VERSION = "0.3.0"
+  VERSION = "0.4.0"
 end

data/lib/wrnap.rb

@@ -6,15 +6,19 @@ require "rinruby"
 require "tempfile"
 require "bigdecimal"
 require "rroc"
+require "bio"
+require "entrez"
 require "active_support/inflector"
 require "active_support/core_ext/class"
 
 require "wrnap/version"
-require "wrnap/global/rna_extensions"
+require "wrnap/global/rna/extensions"
 require "wrnap/global/rna"
+require "wrnap/global/rna/context"
+require "wrnap/global/chainer"
+require "wrnap/global/entrez"
 require "wrnap/global/parser"
-require "wrnap/global/run_extensions"
-require "wrnap/global/chain_extensions"
+require "wrnap/global/runner"
 require "wrnap/graphing/r"
 require "wrnap/package/base"
 

data/wrnap.gemspec

@@ -27,4 +27,6 @@ Gem::Specification.new do |spec|
   spec.add_runtime_dependency "shuffle",       "~> 0.1"
   spec.add_runtime_dependency "rinruby",       "~> 2.0"
   spec.add_runtime_dependency "rroc",          "~> 0.1"
+  spec.add_runtime_dependency "bio",           "~> 1.4"
+  spec.add_runtime_dependency "entrez",        "~> 0.5"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: wrnap
 version: !ruby/object:Gem::Version
-  version: 0.3.0
+  version: 0.4.0
 platform: ruby
 authors:
 - Evan Senter
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-04-15 00:00:00.000000000 Z
+date: 2014-05-06 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -94,6 +94,34 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '0.1'
+- !ruby/object:Gem::Dependency
+  name: bio
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.4'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.4'
+- !ruby/object:Gem::Dependency
+  name: entrez
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.5'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.5'
 description: ''
 email:
 - evansenter@gmail.com
@@ -107,11 +135,13 @@ files:
 - README.md
 - Rakefile
 - lib/wrnap.rb
-- lib/wrnap/global/chain_extensions.rb
+- lib/wrnap/global/chainer.rb
+- lib/wrnap/global/entrez.rb
 - lib/wrnap/global/parser.rb
 - lib/wrnap/global/rna.rb
-- lib/wrnap/global/rna_extensions.rb
-- lib/wrnap/global/run_extensions.rb
+- lib/wrnap/global/rna/context.rb
+- lib/wrnap/global/rna/extensions.rb
+- lib/wrnap/global/runner.rb
 - lib/wrnap/graphing/r.rb
 - lib/wrnap/package/base.rb
 - lib/wrnap/package/energy_grid_2d.rb