protk 1.1.0.pre

data/bin/omssa_search.rb

@@ -0,0 +1,205 @@
+#!/usr/bin/env ruby
+#
+# This file is part of protk
+# Created by Ira Cooke 14/12/2010
+#
+# Runs an MS/MS search using the OMSSA search engine
+#
+$VERBOSE=nil
+
+require 'protk/constants'
+require 'protk/command_runner'
+require 'protk/search_tool'
+
+
+# Setup specific command-line options for this tool. Other options are inherited from SearchTool
+#
+search_tool=SearchTool.new({:msms_search=>true,:background=>false,:glyco=>true,:database=>true,:explicit_output=>true,:over_write=>true,:msms_search_detailed_options=>true})
+search_tool.option_parser.banner = "Run an OMSSA msms search on a set of mgf input files.\n\nUsage: omssa_search.rb [options] file1.mgf file2.mgf ..."
+search_tool.options.output_suffix="_omssa"
+
+search_tool.options.add_retention_times=true
+search_tool.option_parser.on( '-R', '--no-add-retention-times', 'Don\'t post process the output to add retention times' ) do 
+  search_tool.options.add_retention_times=false
+end
+
+search_tool.options.max_hit_expect=1
+search_tool.option_parser.on(  '--max-hit-expect exp', 'Expect values less than this are considered to be hits' ) do |exp|
+  search_tool.options.max_hit_expect=exp
+end
+
+search_tool.options.intensity_cut_off=0.0005
+search_tool.option_parser.on(  '--intensity-cut-off co', 'Peak intensity cut-off as a fraction of maximum peak intensity' ) do |co|
+  search_tool.options.intensity_cut_off=co
+end
+
+
+search_tool.option_parser.parse!
+
+# Environment with global constants
+#
+genv=Constants.new
+
+# Set search engine specific parameters on the SearchTool object
+#
+rt_correct_bin="#{File.dirname(__FILE__)}/correct_omssa_retention_times.rb"
+repair_script_bin="#{File.dirname(__FILE__)}/repair_run_summary.rb"
+
+case 
+when Pathname.new(search_tool.database).exist? # It's an explicitly named db
+  current_db=Pathname.new(search_tool.database).realpath.to_s
+else
+  current_db=search_tool.current_database :fasta
+end
+
+fragment_tol = search_tool.fragment_tol
+precursor_tol = search_tool.precursor_tol
+
+
+throw "When --output is set only one file at a time can be run" if  ( ARGV.length> 1 ) && ( search_tool.explicit_output!=nil ) 
+
+# Run the search engine on each input file
+#
+ARGV.each do |filename|
+
+  if ( search_tool.explicit_output!=nil)
+    output_path=search_tool.explicit_output
+  else
+    output_path="#{search_tool.output_base_path(filename.chomp)}.pep.xml"
+  end
+  
+  # We always perform searches on mgf files so 
+  #
+  input_path="#{search_tool.input_base_path(filename.chomp)}.mgf"
+  input_ext=Pathname.new(filename).extname
+
+  if ( input_ext==".dat" )
+    # This is a file provided by galaxy so we need to leave the .dat extension
+    input_path="#{search_tool.input_base_path(filename.chomp)}.dat"
+  end
+
+
+  # Only proceed if the output file is not present or we have opted to over-write it
+  #
+  if ( search_tool.over_write || !Pathname.new(output_path).exist? )
+  
+    # The basic command
+    #
+    cmd= "#{genv.omssacl} -d #{current_db} -fm #{input_path} -op #{output_path} -w"
+
+    #Missed cleavages
+    #
+    cmd << " -v #{search_tool.missed_cleavages}"
+
+    # Precursor tolerance
+    #
+    if ( search_tool.precursor_tolu=="ppm")
+      cmd << " -teppm"
+    end
+    cmd << " -te #{search_tool.precursor_tol}"
+    
+    # Fragment ion tolerance
+    #
+    cmd << " -to #{fragment_tol}" #Always in Da
+    
+    # Set the search type (monoisotopic vs average masses) and whether to use strict monoisotopic masses
+    #
+    if ( search_tool.precursor_search_type=="monoisotopic")
+      if ( search_tool.strict_monoisotopic_mass )
+        cmd << " -tem 0"
+      else
+        cmd << " -tem 4 -ti #{search_tool.num_peaks_for_multi_isotope_search}"        
+      end
+    else
+      cmd << " -tem 1"
+    end
+    
+    # Enzyme
+    #
+    if ( search_tool.enzyme!="Trypsin")
+      cmd << " -e #{search_tool.enzyme}"
+    end
+
+    # Variable Modifications
+    #
+    if ( search_tool.var_mods !="" && !search_tool.var_mods =~/None/) # Checking for none is to cope with galaxy input
+      var_mods = search_tool.var_mods.split(",").collect { |mod| mod.lstrip.rstrip }.reject {|e| e.empty? }.join(",")
+      if ( var_mods !="" )
+        cmd << " -mv #{var_mods}"
+      end
+    else 
+      # Add options related to peptide modifications
+      #
+      if ( search_tool.glyco )
+        cmd << " -mv 119 "
+      end
+    end
+
+    if ( search_tool.fix_mods !="" && !search_tool.fix_mods=~/None/)
+      fix_mods = search_tool.fix_mods.split(",").collect { |mod| mod.lstrip.rstrip }.reject { |e| e.empty? }.join(",")
+      if ( fix_mods !="")
+        cmd << " -mf #{fix_mods}"    
+      end
+    else
+      if ( search_tool.has_modifications )
+        cmd << " -mf "
+        if ( search_tool.carbamidomethyl )
+          cmd<<"3 "
+        end
+
+        if ( search_tool.methionine_oxidation )
+          cmd<<"1 "
+        end
+
+      end
+    end
+    
+    if ( search_tool.searched_ions !="" && !search_tool.searched_ions=~/None/)
+      searched_ions=search_tool.searched_ions.split(",").collect{ |mod| mod.lstrip.rstrip }.reject { |e| e.empty? }.join(",")
+      if ( searched_ions!="")
+        cmd << " -i #{searched_ions}"
+      end
+      
+    end
+    
+    # Infer precursor charges or respect charges in input file
+    #
+    if ( search_tool.respect_precursor_charges )
+      cmd << " -zcc 1"
+    end
+    
+    
+    # Max expect
+    #
+    cmd << " -he #{search_tool.max_hit_expect}"
+    
+    # Intensity cut-off
+    cmd << " -ci #{search_tool.intensity_cut_off}"
+    
+    # Up to here we've formulated the omssa command. The rest is cleanup
+    p "Running:#{cmd}"
+    
+    # Add retention time corrections
+    #
+    if (search_tool.options.add_retention_times)
+      cmd << "; #{rt_correct_bin} #{output_path} #{input_path} "
+    end
+    
+    # Correct the pepXML file 
+    #
+    cmd << "; #{repair_script_bin} -N #{input_path} -R mgf #{output_path} --omssa-itol #{search_tool.fragment_tol}"
+    genv.log("Running repair script command #{cmd}",:info)
+    
+    # Run the search
+    #
+    job_params= {:jobid => search_tool.jobid_from_filename(filename) }
+    job_params[:queue]="lowmem"
+    job_params[:vmem]="900mb"    
+    search_tool.run(cmd,genv,job_params)
+
+
+  else
+    genv.log("Skipping search on existing file #{output_path}",:warn)       
+  end
+
+end

data/bin/peptide_prophet.rb

@@ -0,0 +1,245 @@
+#!/usr/bin/env ruby
+#
+# This file is part of protk
+# Created by Ira Cooke 18/1/2011
+#
+# A wrapper for PeptideProphet
+#
+#
+
+require 'protk/constants'
+require 'protk/command_runner'
+require 'protk/prophet_tool'
+
+# Setup specific command-line options for this tool. Other options are inherited from ProphetTool
+#
+prophet_tool=ProphetTool.new({:glyco=>true,:explicit_output=>true,:maldi=>true})
+prophet_tool.option_parser.banner = "Run PeptideProphet on a set of pep.xml input files.\n\nUsage: peptide_prophet.rb [options] file1.pep.xml file2.pep.xml ..."
+prophet_tool.options.output_suffix="_pproph"
+
+prophet_tool.options.useicat = false
+prophet_tool.option_parser.on( '--useicat',"Use icat information" ) do 
+  prophet_tool.options.useicat = true
+end
+
+prophet_tool.options.nouseicat = false
+prophet_tool.option_parser.on( '--no-useicat',"Do not use icat information" ) do 
+  prophet_tool.options.nouseicat = true
+end
+
+prophet_tool.options.phospho = false
+prophet_tool.option_parser.on( '--phospho',"Use phospho information" ) do 
+  prophet_tool.options.phospho = true
+end
+
+prophet_tool.options.usepi = false
+prophet_tool.option_parser.on( '--usepi',"Use pI information" ) do 
+  prophet_tool.options.usepi = true
+end
+
+prophet_tool.options.usert = false
+prophet_tool.option_parser.on( '--usert',"Use hydrophobicity / RT information" ) do 
+  prophet_tool.options.usert = true
+end
+
+prophet_tool.options.accurate_mass = false
+prophet_tool.option_parser.on( '--accurate-mass',"Use accurate mass binning" ) do 
+  prophet_tool.options.accurate_mass = true
+end
+
+prophet_tool.options.no_ntt = false
+prophet_tool.option_parser.on( '--no-ntt',"Don't use NTT model" ) do 
+  prophet_tool.options.no_ntt = true
+end
+
+prophet_tool.options.no_nmc = false
+prophet_tool.option_parser.on( '--no-nmc',"Don't use NMC model" ) do 
+  prophet_tool.options.no_nmc = true
+end
+
+prophet_tool.options.usegamma = false
+prophet_tool.option_parser.on( '--usegamma',"Use Gamma distribution to model the negatives" ) do 
+  prophet_tool.options.usegamma = true
+end
+
+prophet_tool.options.use_only_expect = false
+prophet_tool.option_parser.on( '--use-only-expect',"Only use Expect Score as the discriminant" ) do 
+  prophet_tool.options.use_only_expect = true
+end
+
+prophet_tool.options.force_fit = false
+prophet_tool.option_parser.on( '--force-fit',"Force fitting of mixture model and bypass checks" ) do 
+  prophet_tool.options.force_fit = true
+end
+
+prophet_tool.options.allow_alt_instruments=false
+prophet_tool.option_parser.on( '--allow-alt-instruments',"Warning instead of exit with error if instrument types between runs is different" ) do 
+  prophet_tool.options.allow_alt_instruments = true
+end
+
+prophet_tool.options.one_ata_time = false
+prophet_tool.option_parser.on( '-F', '--one-ata-time', 'Create a separate pproph output file for each analysis' ) do 
+  prophet_tool.options.one_ata_time = true
+end
+
+
+prophet_tool.option_parser.parse!
+
+throw "When --output and -F options are set only one file at a time can be run" if  ( ARGV.length> 1 ) && ( prophet_tool.explicit_output!=nil ) && (prophet_tool.one_ata_time!=nil)
+
+# Obtain a global environment object
+genv=Constants.new
+
+
+# Interrogate all the input files to obtain the database and search engine from them
+#
+genv.log("Determining search engine and database used to create input files ...",:info)
+file_info={}
+ARGV.each {|file_name| 
+  name=file_name.chomp
+  
+  engine=prophet_tool.extract_engine(name)
+  db_path=prophet_tool.extract_db(name)
+  
+  
+  file_info[name]={:engine=>engine , :database=>db_path } 
+}
+
+# Check that all searches were performed with the same engine and database
+#
+#
+engine=nil
+database=nil
+inputs=file_info.collect do |info|
+  if ( engine==nil)
+    engine=info[1][:engine]
+  end
+  if ( database==nil)
+    database=info[1][:database]
+  end
+  throw "All files to be analyzed must have been searched with the same database and search engine" unless (info[1][:engine]==engine) && (info[1][:database])
+
+  retname=  "#{prophet_tool.input_base_path(info[0],".pep.xml")}.pep.xml"
+  if ( info[0]=~/\.dat$/)
+    retname=info[0]
+  end
+      
+  retname
+
+end
+
+def generate_command(genv,prophet_tool,inputs,output,database,engine)
+  
+  cmd="#{genv.xinteract} -N#{output}  -l7 -eT -D#{database} "
+
+  if prophet_tool.glyco 
+    cmd << " -Og "
+  end
+
+  if prophet_tool.phospho 
+    cmd << " -OH "
+  end
+
+  if prophet_tool.usepi
+    cmd << " -OI "
+  end
+  
+  if prophet_tool.usert
+    cmd << " -OR "
+  end
+  
+  if prophet_tool.accurate_mass
+    cmd << " -OA "
+  end
+
+  if prophet_tool.no_ntt
+    cmd << " -ON "
+  end
+  
+  if prophet_tool.no_nmc
+    cmd << " -OM "
+  end
+  
+  if prophet_tool.usegamma
+    cmd << " -OG "
+  end
+  
+  if prophet_tool.use_only_expect
+    cmd << " -OE "
+  end
+  
+  if prophet_tool.force_fit
+    cmd << " -OF "
+  end
+  
+  if prophet_tool.allow_alt_instruments
+    cmd << " -Ow "
+  end
+  
+  if prophet_tool.useicat
+    cmd << " -Oi "
+  end
+  
+  if prophet_tool.nouseicat
+    cmd << " -Of"
+  end
+  
+  if prophet_tool.maldi
+    cmd << " -I2 -T3 -I4 -I5 -I6 -I7 "
+  end
+
+  if engine=="omssa" || engine=="phenyx"
+    cmd << "-Op -P -ddecoy "
+  else
+    cmd << "-ddecoy "
+  end
+  
+  
+  if ( inputs.class==Array)
+    cmd << " #{inputs.join(" ")}"  
+  else
+    cmd << " #{inputs}"
+  end 
+  
+  cmd
+end
+
+def run_peptide_prophet(genv,prophet_tool,cmd,output_path,engine)
+  if ( !prophet_tool.over_write && Pathname.new(output_path).exist? )
+    genv.log("Skipping analysis on existing file #{output_path}",:warn)   
+  else
+    jobscript_path="#{output_path}.pbs.sh"
+    job_params={:jobid=>engine, :vmem=>"900mb", :queue => "lowmem"}
+    code=prophet_tool.run(cmd,genv,job_params,jobscript_path)
+    throw "Command failed with exit code #{code}" unless code==0
+  end
+end
+
+
+cmd=""
+if ( prophet_tool.one_ata_time )
+  inputs.each { |input|
+    
+    output_file_name="#{prophet_tool.output_prefix}#{input}_#{engine}_interact#{prophet_tool.output_suffix}.pep.xml"
+    
+    cmd=generate_command(genv,prophet_tool,input,output_file_name,database,engine)
+
+    run_peptide_prophet(genv,prophet_tool,cmd,output_file_base_name,engine)
+    
+        
+  }
+else  
+  if (prophet_tool.explicit_output==nil)
+    output_file_name="#{prophet_tool.output_prefix}#{engine}_interact#{prophet_tool.output_suffix}.pep.xml"
+  else
+
+    output_file_name=prophet_tool.explicit_output
+
+  end
+  cmd=generate_command(genv,prophet_tool,inputs,output_file_name,database,engine)
+
+  run_peptide_prophet(genv,prophet_tool,cmd,output_file_name,engine)
+    
+end
+
+

data/bin/pepxml_to_table.rb

@@ -0,0 +1,78 @@
+#!/usr/bin/env ruby
+#
+# This file is part of protk
+# Created by Ira Cooke 18/1/2011
+#
+# Convert a pepXML file to a tab delimited table
+#
+#
+
+require 'libxml'
+require 'protk/constants'
+require 'protk/command_runner'
+require 'protk/tool'
+
+include LibXML
+
+# Setup specific command-line options for this tool. Other options are inherited from ProphetTool
+#
+tool=Tool.new({:explicit_output=>true})
+tool.option_parser.banner = "Convert a pepXML file to a tab delimited table.\n\nUsage: pepxml_to_table.rb [options] file1.pep.xml"
+
+tool.option_parser.parse!
+
+# Obtain a global environment object
+#genv=Constants.new
+
+input_file=ARGV[0]
+
+output_file="#{input_file}.txt"
+
+output_file = tool.explicit_output if tool.explicit_output!=nil
+
+output_fh=File.new("#{output_file}",'w')
+
+output_fh.write "protein\tpeptide\tassumed_charge\tcalc_neutral_pep_mass\tneutral_mass\tretention_time\tstart_scan\tend_scan\tsearch_engine\tpeptideprophet_prob\tinterprophet_prob\n"
+
+pepxml_parser=XML::Parser.file("#{input_file}")
+pepxml_doc=pepxml_parser.parse
+
+spectrum_queries=pepxml_doc.find('//xmlns:spectrum_query','xmlns:http://regis-web.systemsbiology.net/pepXML')
+
+spectrum_queries.each do |query| 
+
+  retention_time=query.attributes['retention_time_sec']
+  neutral_mass=query.attributes['precursor_neutral_mass']
+  assumed_charge=query.attributes['assumed_charge']
+
+  top_search_hit=query.find('./xmlns:search_result/xmlns:search_hit','xmlns:http://regis-web.systemsbiology.net/pepXML')[0]
+  peptide=top_search_hit.attributes['peptide']
+  protein=top_search_hit.attributes['protein']
+  calc_neutral_pep_mass=top_search_hit.attributes['calc_neutral_pep_mass']
+  start_scan=query.attributes['start_scan']
+  end_scan=query.attributes['end_scan']
+
+  search_engine=""
+  search_score_names=top_search_hit.find('./xmlns:search_score/@name','xmlns:http://regis-web.systemsbiology.net/pepXML').collect {|s| s.to_s}
+
+  if ( search_score_names.length==2 && search_score_names.grep(/^name.*=.*pvalue/))
+    search_engine="omssa" 
+  elsif ( search_score_names.grep(/^name.*=.*ionscore/))
+    search_engine="mascot"
+  elsif ( search_score_names.grep(/^name.*=.*hyperscore/) )
+    search_engine="x!tandem"
+  end
+
+  pp_result=top_search_hit.find('./xmlns:analysis_result/xmlns:peptideprophet_result/@probability','xmlns:http://regis-web.systemsbiology.net/pepXML')
+  ip_result=top_search_hit.find('./xmlns:analysis_result/xmlns:interprophet_result/@probability','xmlns:http://regis-web.systemsbiology.net/pepXML')
+  
+  peptide_prophet_prob=""
+  interprophet_prob=""
+  peptide_prophet_prob=pp_result[0].value if ( pp_result.length>0 )
+  interprophet_prob=ip_result[0].value if ( ip_result.length>0)
+  
+  output_fh.write "#{protein}\t#{peptide}\t#{assumed_charge}\t#{calc_neutral_pep_mass}\t#{neutral_mass}\t#{retention_time}\t#{start_scan}\t#{end_scan}\t#{search_engine}\t#{peptide_prophet_prob}\t#{interprophet_prob}\n"
+
+end
+
+output_fh.close

data/bin/protein_prophet.rb

@@ -0,0 +1,140 @@
+#!/usr/bin/env ruby
+#
+# This file is part of protk
+# Created by Ira Cooke 17/1/2011
+#
+# Runs the Protein Prophet tool on a set of pep.xml files. Accepts input from peptide_prophet or interprophet.
+#
+#
+
+require 'protk/constants'
+require 'protk/command_runner'
+require 'protk/prophet_tool'
+require 'protk/galaxy_stager'
+require 'protk/galaxy_util'
+
+for_galaxy = GalaxyUtil.for_galaxy
+
+if for_galaxy
+  # Stage files for galaxy
+  original_input_file = ARGV[0]
+  original_input_path = Pathname.new("#{original_input_file}")
+  input_stager = GalaxyStager.new("#{original_input_file}", :extension => '.pep.xml')
+  ARGV.push("-o")
+  ARGV.push("protein_prophet_results.prot.xml")  
+end
+
+# Setup specific command-line options for this tool. Other options are inherited from ProphetTool
+#
+prophet_tool=ProphetTool.new({:glyco=>true,:explicit_output=>true})
+prophet_tool.option_parser.banner = "Run ProteinProphet on a set of pep.xml input files.\n\nUsage: protein_prophet.rb [options] file1.pep.xml file2.pep.xml ..."
+prophet_tool.options.output_suffix="_protproph"
+
+prophet_tool.options.iproph = false
+prophet_tool.option_parser.on( '--iprophet-input',"Inputs are from iProphet" ) do 
+  prophet_tool.options.iproph = true
+end
+
+prophet_tool.options.nooccam = false
+prophet_tool.option_parser.on( '--no-occam',"Do not attempt to derive the simplest protein list explaining observed peptides" ) do 
+  prophet_tool.options.nooccam = true
+end
+
+prophet_tool.options.groupwts = false
+prophet_tool.option_parser.on( '--group-wts',"Check peptide's total weight (rather than actual weight) in the Protein Group against the threshold" ) do 
+  prophet_tool.options.groupwts = true
+end
+
+prophet_tool.options.normprotlen = false
+prophet_tool.option_parser.on( '--norm-protlen',"Normalize NSP using Protein Length" ) do 
+  prophet_tool.options.normprotlen = true
+end
+
+prophet_tool.options.logprobs = false
+prophet_tool.option_parser.on( '--log-prob',"Use the log of probability in the confidence calculations" ) do 
+  prophet_tool.options.logprobs = true
+end
+
+prophet_tool.options.confem = false
+prophet_tool.option_parser.on( '--confem',"Use the EM to compute probability given the confidence" ) do 
+  prophet_tool.options.confem = true
+end
+
+prophet_tool.options.allpeps = false
+prophet_tool.option_parser.on( '--allpeps',"Consider all possible peptides in the database in the confidence model" ) do 
+  prophet_tool.options.allpeps = true
+end
+
+prophet_tool.options.unmapped = false
+prophet_tool.option_parser.on( '--unmapped',"Report results for unmapped proteins" ) do 
+  prophet_tool.options.unmapped = true
+end
+
+prophet_tool.options.instances = false
+prophet_tool.option_parser.on( '--instances',"Use Expected Number of Ion Instances to adjust the peptide probabilities prior to NSP adjustment" ) do 
+  prophet_tool.options.instances = true
+end
+
+prophet_tool.options.delude = false
+prophet_tool.option_parser.on( '--delude',"Do NOT use peptide degeneracy information when assessing proteins" ) do 
+  prophet_tool.options.delude = true
+end
+
+prophet_tool.options.minprob = 0.05
+prophet_tool.option_parser.on( '--minprob mp',"Minimum peptide prophet probability for peptides to be considered" ) do |mp|
+  prophet_tool.options.minprob = mp
+end
+
+prophet_tool.options.minindep = 0
+prophet_tool.option_parser.on( '--minindep mp',"Minimum percentage of independent peptides required for a protein" ) do |mp|
+  prophet_tool.options.minindep = mp
+end
+
+prophet_tool.option_parser.parse!
+
+
+# Obtain a global environment object
+genv=Constants.new
+
+if ( prophet_tool.explicit_output==nil )
+	output_file="#{prophet_tool.output_prefix}interact#{prophet_tool.output_suffix}.prot.xml"
+ else 
+	output_file=prophet_tool.explicit_output 
+end
+
+p output_file
+
+if ( !Pathname.new(output_file).exist? || prophet_tool.over_write )
+
+  cmd="#{genv.proteinprophet} "
+
+  inputs = ARGV.collect {|file_name| 
+    file_name.chomp
+  }
+
+  cmd << " #{inputs.join(" ")} #{output_file}"
+
+  if ( prophet_tool.glyco )
+    cmd << " GLYC "
+  end
+
+  # Run the analysis
+  #
+  jobscript_path="#{output_file}.pbs.sh"
+  job_params={:jobid=>"protproph", :vmem=>"900mb", :queue => "lowmem"}
+  genv.log("Running #{cmd}",:info)
+  code = prophet_tool.run(cmd,genv,job_params,jobscript_path)
+  throw "Command failed with exit code #{code}" unless code==0
+else
+  genv.log("Protein Prophet output file #{output_file} already exists. Run with -r option to replace",:warn)   
+end
+
+if for_galaxy
+  # Restore references to peptide prophet xml so downstream tools like 
+  # libra can find it.
+  input_stager.restore_references("protein_prophet_results.prot.xml")
+end
+
+
+
+

data/bin/protk_setup.rb

@@ -0,0 +1,31 @@
+#!/usr/bin/env ruby
+#
+# This file is part of protk
+# Created by Ira Cooke 20/10/2012
+#
+# Post-install setup for protk. 
+# Installs third party tools
+#
+
+require 'protk/constants'
+require 'protk/setup_tool'
+require 'yaml'
+require 'pp'
+
+
+# Setup specific command-line options for this tool. Other options are inherited from Tool
+#
+tool=SetupTool.new
+if ( tool.option_parser.banner=="")
+  tool.option_parser.banner = "Post install tasks for protk.\nUsage: protk_setup.rb [options] toolname"
+end
+
+tool.option_parser.parse!
+
+# Create install directory if it doesn't already exist
+#
+env=Constants.new
+
+ARGV.each do |toolname|
+  tool.install toolname
+end