rput 0.1.0

data/.document

@@ -0,0 +1,5 @@
+lib/**/*.rb
+bin/*
+- 
+features/**/*.feature
+LICENSE.txt

data/Gemfile

@@ -0,0 +1,16 @@
+source "http://rubygems.org"
+# Add dependencies required to use your gem here.
+# Example:
+#   gem "activesupport", ">= 2.3.5"
+
+# Add dependencies to develop your gem here.
+# Include everything needed to run rake, tests, features, etc.
+group :development do
+  gem "shoulda", ">= 0"
+  gem "rdoc", "~> 3.12"
+  gem "bundler", "~> 1.0.0"
+  gem "jeweler", "~> 1.8.3"
+  gem "rcov", ">= 0"
+  # own dependencies
+  gem "rraxml", "~> 0.1.2"
+end

data/Gemfile.lock

@@ -0,0 +1,31 @@
+GEM
+  remote: http://rubygems.org/
+  specs:
+    git (1.2.5)
+    jeweler (1.8.3)
+      bundler (~> 1.0)
+      git (>= 1.2.5)
+      rake
+      rdoc
+    json (1.6.6)
+    rake (0.9.2.2)
+    rcov (1.0.0)
+    rdoc (3.12)
+      json (~> 1.4)
+    rraxml (0.1.2)
+    shoulda (3.0.1)
+      shoulda-context (~> 1.0.0)
+      shoulda-matchers (~> 1.0.0)
+    shoulda-context (1.0.0)
+    shoulda-matchers (1.0.0)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  bundler (~> 1.0.0)
+  jeweler (~> 1.8.3)
+  rcov
+  rdoc (~> 3.12)
+  rraxml (~> 0.1.2)
+  shoulda

data/LICENSE.txt

@@ -0,0 +1,20 @@
+Copyright (c) 2012 Fernando Izquierdo-Carrasco
+
+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.rdoc

@@ -0,0 +1,19 @@
+= rput
+
+Description goes here.
+
+== Contributing to rput
+ 
+* Check out the latest master to make sure the feature hasn't been implemented or the bug hasn't been fixed yet.
+* Check out the issue tracker to make sure someone already hasn't requested it and/or contributed it.
+* Fork the project.
+* Start a feature/bugfix branch.
+* Commit and push until you are happy with your contribution.
+* Make sure to add tests for it. This is important so I don't break it in a future version unintentionally.
+* Please try not to mess with the Rakefile, version, or history. If you want to have your own version, or is otherwise necessary, that is fine, but please isolate to its own commit so I can cherry-pick around it.
+
+== Copyright
+
+Copyright (c) 2012 Fernando Izquierdo-Carrasco. See LICENSE.txt for
+further details.
+

data/Rakefile

@@ -0,0 +1,53 @@
+# encoding: utf-8
+
+require 'rubygems'
+require 'bundler'
+begin
+  Bundler.setup(:default, :development)
+rescue Bundler::BundlerError => e
+  $stderr.puts e.message
+  $stderr.puts "Run `bundle install` to install missing gems"
+  exit e.status_code
+end
+require 'rake'
+
+require 'jeweler'
+Jeweler::Tasks.new do |gem|
+  # gem is a Gem::Specification... see http://docs.rubygems.org/read/chapter/20 for more options
+  gem.name = "rput"
+  gem.homepage = "http://github.com/fizquierdo/rput"
+  gem.license = "MIT"
+  gem.summary = "Raxml-based perpetually updated tree"
+  gem.description = "Automated iterations of raxml runs over externally-extended phylip files"
+  gem.email = "fer.izquierdo@gmail.com"
+  gem.authors = ["Fernando Izquierdo-Carrasco"]
+  # dependencies defined in Gemfile
+end
+Jeweler::RubygemsDotOrgTasks.new
+
+require 'rake/testtask'
+Rake::TestTask.new(:test) do |test|
+  test.libs << 'lib' << 'test'
+  test.pattern = 'test/**/test_*.rb'
+  test.verbose = true
+end
+
+require 'rcov/rcovtask'
+Rcov::RcovTask.new do |test|
+  test.libs << 'test'
+  test.pattern = 'test/**/test_*.rb'
+  test.verbose = true
+  test.rcov_opts << '--exclude "gems/*"'
+end
+
+task :default => :test
+
+require 'rdoc/task'
+Rake::RDocTask.new do |rdoc|
+  version = File.exist?('VERSION') ? File.read('VERSION') : ""
+
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = "rput #{version}"
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end

data/VERSION

@@ -0,0 +1 @@
+0.1.0

data/lib/experiment.rb

@@ -0,0 +1,113 @@
+#!/usr/bin/env ruby
+#require 'rphylip'
+require 'fileutils'
+require 'yaml'
+
+class Experiment
+  def initialize(name)
+    @name = name
+    @base_dir = File.join File.expand_path(File.dirname(__FILE__)), '../'
+  end
+  def dirname(a)
+    File.join @base_dir, 'experiments', @name, a
+  end
+  def last_bunch_dir
+    dirs = Dir.entries(dirname("output")).select{|f| f =~ /^bunch/}
+    dirs.sort_by{|s| s.split("_").last.to_i}.last
+  end
+  def setup_dirs
+    setup_ready = true
+    %w(alignment output).map{|n| self.dirname n}.each do |dir|
+      if File.exist?(dir)
+        puts "Exists #{dir}"
+        setup_ready = false # to avoid overwrite
+      else
+        FileUtils.mkdir_p dir
+      end
+    end
+    setup_ready
+  end
+  def expand_with_updates(opts, updates_are_full_alignments = true)
+    ali = self.dirname("alignment")
+    phy = opts[:phylip]
+    raise "phylip file not available" if phy.nil? or not File.exist?(phy)
+    FileUtils.copy phy, ali 
+    p = Phylip.new(File.join ali, File.basename(phy))
+    p.subdivide_random opts 
+  end
+end
+
+class ExperimentList
+  # Persistent storage in .yml file of the experiment status
+  attr_accessor :name, :date
+  def initialize(expfile)
+    @expfile = expfile
+    File.open(expfile, "w"){|f| f.puts "---"} unless File.exist?(expfile)
+    @list = YAML.load_file(expfile) || Array.new
+  end
+  def add(opts)
+    name_available = self.name_available?(opts[:name]) 
+    if name_available
+      #newexp = {:name => opts[:name], :date => Time.now, :fake_phy => opts[:fake_phy]}
+      newexp = {:name => opts[:name], :date => Time.now}
+      newexp.merge!({:fake_phy => opts[:fake_phy]}) unless opts[:fake_phy].nil?
+      newexp.merge!({:initial_phy => opts[:initial_phy]}) unless opts[:initial_phy].nil?
+      @list.push newexp
+      self.save
+      true
+    end
+  end
+  def update(name, step, state)
+    e = self.find_by_name(name) 
+    unless e.nil?
+      @list.each do |item|
+        if item[:name] == name
+          if item[step].nil?
+            item[step] = state
+          else
+            item[step] += " " + state
+          end
+        end
+      end
+    end
+    self.save
+  end
+  def show
+    puts "Current Experiments"
+    puts "ID\tname"
+    @list.each_with_index  do |item, i|
+      fake_name = item[:fake_phy].nil? ? "-" : File.basename(item[:fake_phy]) 
+      initial_name = item[:initial_phy].nil? ? "-" : File.basename(item[:initial_phy]) 
+      puts "#{i}\t#{item[:name]}\t fake: #{fake_name} \t init: #{initial_name} Best LH: #{item["bestLH"]}"
+      item.keys.select{|k| k =~ /^u\d+$/}.sort.each do |update_key|
+        puts "  #{update_key}: #{item[update_key]}"
+      end
+    end
+  end
+  def remove(name)
+    item = find_by_name(name)
+    unless item.nil?
+      @list.delete(item) 
+      self.save
+    end
+  end
+  def save
+    File.open(@expfile, "w"){|f| f.write @list.to_yaml}
+    puts "Experiment list updated"
+  end
+  def name_available?(name)
+    existing_items = find_by_name(name)
+    unless existing_items.nil?
+       if existing_items.size >= 1
+         puts "A expremient with this name exists already"
+         p existing_items
+         return false
+       end
+    end
+    return true
+  end
+  protected
+  def find_by_name(name)
+    @list.find{|e| e[:name] == name}
+  end
+end

data/lib/starter.rb

@@ -0,0 +1,307 @@
+#!/usr/bin/env ruby
+#
+#gem 'rraxml','0.1.2'
+#require 'rraxml'
+#require 'rnewick'
+#require 'rphylip'
+require 'logger'
+
+class CycleController
+  def initialize(opts)
+    @opts = opts
+    @opts[:num_ptrees] ||= @opts[:num_parsi_trees]
+    @script = "raxml_batch_cycle.sh"
+    @numtaxa, @seqlen  = File.open(@opts[:phy]).readlines.first.split.map{|w| w.to_i}
+    raise "#{@script} missing" unless File.exist?(@script)
+  end
+  def parsimonator_requirements
+   bytes_inner =  @numtaxa.to_f * @seqlen.to_f
+   security_factor = 3.0
+   required_MB = bytes_inner * security_factor * 1E-6
+   required_MB = 16 unless required_MB > 16 
+   puts required_MB
+   required_MB.to_i.to_s
+  end
+  def raxmllight_requirements
+   #(n-2) * m * ( 8 * 4 )
+   bytes_inner =  @numtaxa.to_f * @seqlen.to_f  * 8 * 4
+   security_factor = 1.3
+   required_MB = bytes_inner * security_factor * 1E-6
+   required_MB = 16 unless required_MB > 16 
+   puts required_MB
+   required_MB.to_i.to_s
+  end
+  def run_as_batch
+    raise "User Number of parsimony trees not set" unless @opts[:num_parsi_trees] > 0
+    raise "Total Number of parsimony trees not set" unless @opts[:num_ptrees] > 0
+    opts = @opts[:iter].to_s
+    opts += " " + File.expand_path(@opts[:phy])
+    opts += " " + parsimonator_requirements
+    opts += " " + raxmllight_requirements
+    opts += " " + @opts[:num_parsi_trees].to_s   # -N parameter -p for suer
+    opts += " " + @opts[:num_ptrees].to_s # total number of parsimony trees
+    opts += " " + @opts[:num_bestML_trees].to_s
+    opts += " " + @opts[:exp_name].to_s
+    opts += " " + @opts[:base_dir].to_s
+    puts "./#{@script} #{opts}"
+    system "./#{@script} #{opts}"
+  end
+end
+
+class TreeBunchStarter 
+  # Given an initial alignment, it creates a initial bunch of ML trees in bunch_0 dir
+  # should log results
+  attr_reader :cluster
+  def initialize(opts)
+    @phylip = opts[:phylip]
+    @base_dir = opts[:base_dir]
+    @prev_dir = opts[:prev_dir]
+    @update_id = opts[:update_id] || 0
+    @num_threads = opts[:num_threads] || 0 
+    # create dirs if required
+    @alignment_dir = File.join @base_dir, "alignments"
+    @parsimony_trees_dir = File.join @base_dir, "parsimony_trees"
+    @parsimony_trees_out_dir = File.join @parsimony_trees_dir, "output"
+    @ml_trees_dir = File.join @base_dir, "ml_trees"
+    @bestML_trees_dir = File.join @base_dir, "best_ml_trees"
+    # the new phylip
+    @phylip_updated = File.join @alignment_dir, "phy_#{@update_id.to_s}"
+    # defaults
+    @num_parsi_trees = 4 
+    @num_bestML_trees = @num_parsi_trees / 2 
+    @CAT_topology_bunch = File.join @ml_trees_dir, "CAT_topology_bunch.nw"
+    @CAT_topology_bunch_order = File.join @ml_trees_dir, "CAT_topology_bunch_order.txt"
+    @bestML_bunch = File.join @bestML_trees_dir, "best_bunch.nw"
+    @prev_bestML_bunch = File.join @prev_dir, "best_ml_trees", "best_bunch.nw" unless @prev_dir.nil?
+    @cluster = opts[:cluster] || false 
+  end
+  def logput(msg, error = false)
+    @logger ||= Logger.new(File.join @base_dir, "starter.log")
+    if error
+      @logger.error msg
+    else
+      @logger.info msg
+    end
+    puts msg
+  end
+  def ready?
+    ready = true
+    dirs = [@alignment_dir, @parsimony_trees_dir, @parsimony_trees_out_dir,@ml_trees_dir, @bestML_trees_dir]
+    dirs.each do |d|
+      if not File.exist?(d)
+        FileUtils.mkdir_p d
+        logput "Created #{d}"
+      else
+        logput "Exists #{d}"
+        ready = false
+      end
+    end
+    if @update_id == 0
+      FileUtils.cp @phylip, @alignment_dir 
+    else
+      logput "Copying new update alignment (not expanding) from #{@phylip} to #{@phylip_updated}"
+      FileUtils.cp @phylip, @phylip_updated 
+    end
+    ready
+  end
+  def add_update(opts)
+    check_options(opts)
+    begin
+      num_parsi_trees = opts[:num_parsi_trees] || @num_parsi_trees
+      num_bestML_trees = opts[:num_bestML_trees] || @num_bestML_trees
+      # prepare the parsimony starting trees
+      raise "prev bunch not ready #{@prev_bestML_bunch}" unless File.exist?(@prev_bestML_bunch)
+      last_best_bunch = NewickFile.new(@prev_bestML_bunch)
+      last_best_bunch.save_each_newick_as(File.join(@parsimony_trees_dir, 'prev_parsi_tree'), "nw") 
+      prev_trees = Dir.entries(@parsimony_trees_dir).select{|f| f =~ /^prev_parsi_tree/}
+      if num_bestML_trees > num_parsi_trees * prev_trees.size
+        raise "#bestML trees (#{num_bestML_trees}) is too higher than trees from previous round"
+      end
+      if @cluster
+        logput "Exp #{opts[:exp_name]}, your cluster will take care of this update no #{@update_id}. stay tuned"
+              c = CycleController.new(:iter => @update_id, 
+				      :phy => @phylip_updated, 
+                                      :num_parsi_trees => num_parsi_trees, 
+                                      :num_ptrees => num_parsi_trees * prev_trees.size, 
+                                      :num_bestML_trees => num_bestML_trees,
+                                      :base_dir => @base_dir,
+                                      :exp_name => opts[:exp_name]
+                                     )
+              c.run_as_batch
+        "cluster"
+      else
+        logput "****** Start update no #{@update_id} ********"
+        logput "step 1 of 3 : Parsimony starting trees #{num_parsi_trees} each\n----"
+        update_parsimony_trees(num_parsi_trees, prev_trees)
+        # raxml light phase (2/3): use threads here? / each tree could be computed in paralell
+        logput "step 2 of 3 : ML trees\n----"
+        # generate_ML_trees
+        generate_ML_trees(@parsimony_trees_out_dir, @phylip_updated)
+        # raxml scoring of initial bunch (needs to be done after step 2, or not?)
+        logput "step 3 of 3 : Score bunch of initial ML trees and select best #{num_bestML_trees}\n----"
+        best_lh = score_ML_trees(num_bestML_trees, @phylip_updated) 
+        logput "Bunch of initial ML trees #{num_bestML_trees}, ready at #{@bestML_bunch}\n----"
+        best_lh
+      end
+    rescue Exception => e
+      logput(e, error = true)
+      raise e
+    end
+  end
+  def search_std(num_gamma_trees = nil)
+        search_opts = {
+          :phylip => @phylip,
+          :outdir => @ml_trees_dir,
+          :num_gamma_trees => num_gamma_trees || 1, 
+          :stderr => File.join(@ml_trees_dir, "err"),
+          :stdout => File.join(@ml_trees_dir, "info"),
+          :name => "std_GAMMA_search" 
+        }
+        search_opts.merge!({:num_threads => @num_threads}) if @num_threads.to_i > 0
+        r = RaxmlGammaSearch.new(search_opts)
+        logput "Start ML search from scratch with #{num_gamma_trees} trees"
+        r.run
+        bestLH = File.open(r.stdout).readlines.find{|l| l =~ /^Final GAMMA-based Score of best/}.chomp.split("tree").last
+        logput "Done ML search from scratch with #{num_gamma_trees} trees"
+        bestLH
+  end
+  def generate_initial_bunch(opts)
+    check_options(opts)
+    begin
+      num_parsi_trees = opts[:num_parsi_trees] || @num_parsi_trees
+      num_bestML_trees = opts[:num_bestML_trees] || @num_bestML_trees
+      if num_bestML_trees > num_parsi_trees
+        raise "#bestML trees (#{num_bestML_trees}) cant be higher than #parsi trees(#{num_parsi_trees})"
+      end
+      # phases 2 and 3 can be done in paralell
+      if @cluster 
+              logput "your cluster will take care of this start #{@update_id}. Stay tuned"
+              c = CycleController.new(:iter => 0, 
+				      :phy => @phylip, 
+                                      :num_parsi_trees => num_parsi_trees, 
+                                      :num_bestML_trees => num_bestML_trees,
+                                      :base_dir => @base_dir,
+                                      :exp_name => opts[:exp_name]
+                                     )
+              c.run_as_batch
+              "cluster"
+      else
+	      logput "Start generating initial bunch"
+	      logput "step 1 of 3 : Parsimony starting trees #{num_parsi_trees}\n----"
+	      generate_parsimony_trees(num_parsi_trees)
+	      # raxml light phase (2/3): use threads here? / each tree could be computed in paralell
+	      logput "step 2 of 3 : ML trees\n----"
+	      generate_ML_trees(@parsimony_trees_dir, @phylip)
+	      # raxml scoring of initial bunch (needs to be done after step 2, or not?)
+	      logput "step 3 of 3 : Score bunch of initial ML trees and select best #{num_bestML_trees}\n----"
+	      best_lh = score_ML_trees(num_bestML_trees, @phylip) 
+	      logput "Bunch of initial ML trees #{num_bestML_trees}, ready at #{@bestML_bunch}\n----"
+	      best_lh
+      end
+    rescue Exception => e
+      logput(e, error = true)
+      raise e
+    end
+  end
+  private
+    def check_options(opts)
+      supported_opts = [:num_parsi_trees, :num_bestML_trees, :exp_name]
+      opts.keys.each do |key|
+        unless supported_opts.include?(key)
+          logput "Option #{key} is unknwon"
+        end
+      end
+    end
+    def generate_parsimony_trees(num_parsi_trees)
+      logput "Starting parsimony with #{num_parsi_trees} trees" 
+      parsimonator_opts = {
+        :phylip => @phylip,
+        :num_trees => num_parsi_trees,
+        :outdir => @parsimony_trees_dir,
+        :stderr => File.join(@parsimony_trees_dir, "err"),
+        :stdout => File.join(@parsimony_trees_dir, "info"),
+        :name => "parsimony_initial"
+      }
+      parsi = Parsimonator.new(parsimonator_opts)  
+      logput "Start computing parsimony trees of initial bunch"
+      parsi.run
+      logput "Done with parsimony trees of initial bunch"
+    end
+    def update_parsimony_trees(num_parsi_trees, trees)
+      trees.each_with_index do |parsi_start_tree, i|
+        logput "Starting new parsimony tree with #{parsi_start_tree} trees" 
+        parsimonator_opts = {
+          :phylip => @phylip_updated,
+          :num_trees => num_parsi_trees,
+          :newick => File.join(@parsimony_trees_dir, parsi_start_tree),
+          :outdir => @parsimony_trees_out_dir,
+          :stderr => File.join(@parsimony_trees_out_dir, "err_#{parsi_start_tree}"),
+          :stdout => File.join(@parsimony_trees_out_dir, "info_#{parsi_start_tree}"),
+          :name => "u#{@update_id}_#{parsi_start_tree}"
+        }
+        parsi = Parsimonator.new(parsimonator_opts)  
+        logput "Start computing parsimony trees of #{parsi_start_tree}, #{i+1} of #{trees.size}"
+        parsi.run
+        logput "run with options #{parsi.ops.to_s}"
+        logput "Done with parsimony trees of #{parsi_start_tree}, #{i+1} of #{trees.size}"
+      end 
+    end
+    def generate_ML_trees(starting_trees_dir, phylip)
+      starting_trees = Dir.entries(starting_trees_dir).select{|f| f =~ /^RAxML_parsimonyTree/}
+      raise "no starting trees available" if starting_trees.nil? or starting_trees.size < 1 
+      starting_trees.each_with_index do |parsimony_tree, i|
+        # ideally we just submit here to the cluster...and start phase 3 when all are done
+        tree_id = parsimony_tree.split("parsimonyTree.").last
+        light_opts = {
+          :phylip => phylip,
+          :outdir => @ml_trees_dir,
+          :flags => " -D ", # default to a RF convergence criterion
+          :starting_newick => File.join(starting_trees_dir, parsimony_tree),
+          :stderr => File.join(@ml_trees_dir, "err#{tree_id}"),
+          :stdout => File.join(@ml_trees_dir, "info#{tree_id}"),
+          :name => "starting_parsimony_tree_" + tree_id
+        }
+        light_opts.merge!({:num_threads => @num_threads}) if @num_threads.to_i > 0
+        r = RaxmlLight.new(light_opts)
+        logput "Start ML search for #{parsimony_tree} (#{i+1} of #{starting_trees.size})"
+        r.run
+        logput "Done ML search for #{parsimony_tree} (#{i+1} of #{starting_trees.size})"
+        # add the result to the bunch
+        newick_str = NewickFile.new(File.join(r.outdir, "RAxML_result.#{r.name}")).newickStrings[0].str
+        append_to_file(@CAT_topology_bunch, newick_str)
+        append_to_file(@CAT_topology_bunch_order, r.name)
+      end
+    end
+    def score_ML_trees(num_bestML_trees, phylip)
+      logput "Starting scoring of ML trees" 
+      scorer_opts = {
+        :phylip => phylip,
+        :outdir => @ml_trees_dir,
+        :starting_newick => @CAT_topology_bunch,
+        :stderr => File.join(@ml_trees_dir, "err_scores"),
+        :stdout => File.join(@ml_trees_dir, "info_scores"),
+        :name => "SCORES"
+      }
+      scorer_opts.merge!({:num_threads => @num_threads}) if @num_threads.to_i > 0
+      scorer = GammaScorer.new(scorer_opts)
+      scorer.run
+      logput "Done scoring of ML trees, selecting the best #{num_bestML_trees}..." 
+      rank_file = File.join @ml_trees_dir, "RAxML_info.#{scorer.name}"
+      lh_lines = File.open(rank_file).readlines.select{|l| l =~ /^[0-9]+ -[0-9]+.[0-9]+$/}
+      rank_id = lh_lines.map{|l| l.split.first}
+      best_lh = lh_lines.first.split.last
+      newick_bunch = File.open(@CAT_topology_bunch).readlines
+      File.open(@bestML_bunch, "w") do |f|
+        rank_id[0...num_bestML_trees].each_with_index do |newick_id, i|
+          f.puts newick_bunch[newick_id.to_i]
+          logput "#{i+1}: Selected tree with id #{newick_id}" 
+        end
+      end
+      best_lh
+    end
+    def append_to_file(file, str)
+      File.open(file, "a+") do |f|
+        f.puts str
+      end
+    end
+end

data/rput.gemspec

@@ -0,0 +1,66 @@
+# Generated by jeweler
+# DO NOT EDIT THIS FILE DIRECTLY
+# Instead, edit Jeweler::Tasks in Rakefile, and run 'rake gemspec'
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{rput}
+  s.version = "0.1.0"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = [%q{Fernando Izquierdo-Carrasco}]
+  s.date = %q{2012-03-29}
+  s.description = %q{Automated iterations of raxml runs over externally-extended phylip files}
+  s.email = %q{fer.izquierdo@gmail.com}
+  s.extra_rdoc_files = [
+    "LICENSE.txt",
+    "README.rdoc"
+  ]
+  s.files = [
+    ".document",
+    "Gemfile",
+    "Gemfile.lock",
+    "LICENSE.txt",
+    "README.rdoc",
+    "Rakefile",
+    "VERSION",
+    "lib/experiment.rb",
+    "lib/starter.rb",
+    "rput.gemspec",
+    "test/helper.rb",
+    "test/test_rput.rb"
+  ]
+  s.homepage = %q{http://github.com/fizquierdo/rput}
+  s.licenses = [%q{MIT}]
+  s.require_paths = [%q{lib}]
+  s.rubygems_version = %q{1.8.6}
+  s.summary = %q{Raxml-based perpetually updated tree}
+
+  if s.respond_to? :specification_version then
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
+      s.add_development_dependency(%q<shoulda>, [">= 0"])
+      s.add_development_dependency(%q<rdoc>, ["~> 3.12"])
+      s.add_development_dependency(%q<bundler>, ["~> 1.0.0"])
+      s.add_development_dependency(%q<jeweler>, ["~> 1.8.3"])
+      s.add_development_dependency(%q<rcov>, [">= 0"])
+      s.add_development_dependency(%q<rraxml>, ["~> 0.1.2"])
+    else
+      s.add_dependency(%q<shoulda>, [">= 0"])
+      s.add_dependency(%q<rdoc>, ["~> 3.12"])
+      s.add_dependency(%q<bundler>, ["~> 1.0.0"])
+      s.add_dependency(%q<jeweler>, ["~> 1.8.3"])
+      s.add_dependency(%q<rcov>, [">= 0"])
+      s.add_dependency(%q<rraxml>, ["~> 0.1.2"])
+    end
+  else
+    s.add_dependency(%q<shoulda>, [">= 0"])
+    s.add_dependency(%q<rdoc>, ["~> 3.12"])
+    s.add_dependency(%q<bundler>, ["~> 1.0.0"])
+    s.add_dependency(%q<jeweler>, ["~> 1.8.3"])
+    s.add_dependency(%q<rcov>, [">= 0"])
+    s.add_dependency(%q<rraxml>, ["~> 0.1.2"])
+  end
+end
+

data/test/helper.rb

@@ -0,0 +1,18 @@
+require 'rubygems'
+require 'bundler'
+begin
+  Bundler.setup(:default, :development)
+rescue Bundler::BundlerError => e
+  $stderr.puts e.message
+  $stderr.puts "Run `bundle install` to install missing gems"
+  exit e.status_code
+end
+require 'test/unit'
+require 'shoulda'
+
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+require 'rput'
+
+class Test::Unit::TestCase
+end

data/test/test_rput.rb

@@ -0,0 +1,7 @@
+require 'helper'
+
+class TestRput < Test::Unit::TestCase
+  should "probably rename this file and start testing for real" do
+    flunk "hey buddy, you should probably rename this file and start testing for real"
+  end
+end

metadata

@@ -0,0 +1,167 @@
+--- !ruby/object:Gem::Specification 
+name: rput
+version: !ruby/object:Gem::Version 
+  hash: 27
+  prerelease: 
+  segments: 
+  - 0
+  - 1
+  - 0
+  version: 0.1.0
+platform: ruby
+authors: 
+- Fernando Izquierdo-Carrasco
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2012-03-29 00:00:00 Z
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  type: :development
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  version_requirements: *id001
+  name: shoulda
+  prerelease: false
+- !ruby/object:Gem::Dependency 
+  type: :development
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 31
+        segments: 
+        - 3
+        - 12
+        version: "3.12"
+  version_requirements: *id002
+  name: rdoc
+  prerelease: false
+- !ruby/object:Gem::Dependency 
+  type: :development
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 23
+        segments: 
+        - 1
+        - 0
+        - 0
+        version: 1.0.0
+  version_requirements: *id003
+  name: bundler
+  prerelease: false
+- !ruby/object:Gem::Dependency 
+  type: :development
+  requirement: &id004 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 49
+        segments: 
+        - 1
+        - 8
+        - 3
+        version: 1.8.3
+  version_requirements: *id004
+  name: jeweler
+  prerelease: false
+- !ruby/object:Gem::Dependency 
+  type: :development
+  requirement: &id005 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  version_requirements: *id005
+  name: rcov
+  prerelease: false
+- !ruby/object:Gem::Dependency 
+  type: :development
+  requirement: &id006 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 31
+        segments: 
+        - 0
+        - 1
+        - 2
+        version: 0.1.2
+  version_requirements: *id006
+  name: rraxml
+  prerelease: false
+description: Automated iterations of raxml runs over externally-extended phylip files
+email: fer.izquierdo@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- LICENSE.txt
+- README.rdoc
+files: 
+- .document
+- Gemfile
+- Gemfile.lock
+- LICENSE.txt
+- README.rdoc
+- Rakefile
+- VERSION
+- lib/experiment.rb
+- lib/starter.rb
+- rput.gemspec
+- test/helper.rb
+- test/test_rput.rb
+homepage: http://github.com/fizquierdo/rput
+licenses: 
+- MIT
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.8.6
+signing_key: 
+specification_version: 3
+summary: Raxml-based perpetually updated tree
+test_files: []
+