once-only 0.0.1

data/.document

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

data/.rspec

@@ -0,0 +1 @@
+--color

data/.travis.yml

@@ -0,0 +1,13 @@
+language: ruby
+rvm:
+  - 1.9.2
+  - 1.9.3
+  - jruby-19mode # JRuby in 1.9 mode
+
+# - rbx-19mode
+#  - 1.8.7
+#  - jruby-18mode # JRuby in 1.8 mode
+#  - rbx-18mode
+
+# uncomment this line if your project needs to run something other than `rake`:
+# script: bundle exec rspec spec

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 "rspec", "~> 2.8.0"
+  # gem "rdoc", "~> 3.12"
+  gem "cucumber", ">= 0"
+  gem "jeweler", "~> 1.8.4", :git => "https://github.com/technicalpickles/jeweler.git"
+  gem "bundler", ">= 1.0.21"
+  # gem "bio", ">= 1.4.2"
+  # gem "rdoc", "~> 3.12"
+end

data/LICENSE.txt

@@ -0,0 +1,20 @@
+Copyright (c) 2013 Pjotr Prins
+
+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,199 @@
+# once-only
+
+[![Build Status](https://secure.travis-ci.org/pjotrp/once-only.png)](http://travis-ci.org/pjotrp/once-only)
+
+Relax with PBS!
+
+* Computations only happen once
+* A completed job does not get submitted again to PBS
+* A job already in the queue does not get submitted again to PBS
+
+Once-only makes a program or script run only *once*, provided the inputs don't
+change (in a functional style!). This is very useful when running a range of
+jobs on a compute cluster or GRID. It may even be useful in the context of
+webservices.  Once-only makes it relaxed to run many jobs on compute clusters!
+A mistake, interruption, or even a parameter tweak, does not mean everything
+has to be run again.
+
+Instead of running a tool or script directly, such as
+
+```sh
+  bowtie -t e_coli reads/e_coli_1000.fq e_coli.map
+```
+
+Prepend once-only
+
+```sh
+  once-only bowtie -t e_coli reads/e_coli_1000.fq e_coli.map
+```
+
+and once-only will parse the command line for existing files and run a checksum
+on them (here the binary executable 'bowtie' and data files
+reads/e_coli_1000.fq and e_coli.map).  This checksum, in fact an MD5
+cryptographic hash, or optionally [pfff](https://github.com/pfff/pfff) for
+large files, is a unique identifier (aka fingerprint) and saved in a file in the running
+directory.  When the checksum file does not exist in the directory the command
+'bowtie -t e_coli reads/e_coli_1000.fq e_coli.map' is executed.
+
+When the file already exists execution is skipped. In other words, the checksum
+file guarantees the program is only run once with the same inputs. Really
+simple! 
+
+In combination with PBS this could be
+
+```sh
+  echo "once-only bowtie -t e_coli reads/e_coli_1000.fq e_coli.map" |qsub -k oe -d path
+```
+
+Interestingly once-only also comes with PBS support, which won't add a job to
+the queue if it is already in the queue, or if it has been executed
+successfully:
+
+```sh
+  once-only --pbs '-k oe' bowtie -t e_coli reads/e_coli_1000.fq e_coli.map
+```
+
+The PBS job will be named and identified according to the checksum value.  This
+can be used to query PBS and clean up based on queued jobs.
+
+The file once-only writes contains a list of the input files with
+their individual checksum values. E.g. on
+
+```sh
+./bin/once-only -v ../bioruby-table/bin/bio-table ../bioruby-table/test/data/input/table1.csv 
+
+cat bio-table-25e51f9297b43b5dacf687b4158f0b79e69c6817.txt 
+
+  MD5     53bcceee564c47cebff8160ab734313f          ../bioruby-table/bin/bio-table
+  MD5     9868b63e3624023a176c29bb80eb54f5          ../bioruby-table/test/data/input/table1.csv
+  SHA1    46ae0f4af8c2566185954bb07d4eeb18c1867077  ../bioruby-table/bin/bio-table ../bioruby-table/test/data/input/table1.csv
+```
+
+This list can also be used to distinguish between input and output files after
+completion of the program. To check the validity of input files you could run
+md5sum on the one-only has file, for example
+
+```sh
+grep MD5 bio-table-ce4ceee0d2ee08ef235662c35b8238ad47fed030.txt |awk 'BEGIN { FS = "[ \t\n]+" }{ print $2,"",$3 }'|md5sum -c
+```
+
+Once-only is inspired by the Lisp once-only function, which wraps another
+function and calculates a result only once, based on the same inputs. It is
+also inspired by the NixOS software deployment system, which guarantees
+packages are uniquely deployed, based on the source code inputs and the
+configuration at compile time.
+
+## Installation
+
+Note: once-only is written in Ruby, but you don't need to understand
+Ruby programming to use it! 
+
+With Ruby 1.9 or later on your system you can run
+
+```sh
+gem install once-only
+```
+
+### Dependencies
+
+'md5sum' is used for calculating MD5 hash values.
+
+'pfff' is optional and used for calculating pfff hash values on very large files.
+
+When you are using PBS, once-only requires the 'qsub' and 'qstat' commands.
+
+## Usage (command line)
+
+To get a full list of command options 
+
+```sh
+once-only --help
+```
+
+Useful switches can be -v (verbose) and -q (quiet).
+
+If you want to skip scanning the executable file (useful in heterogenous environments, 
+such as the GRID) use the --skip-exe switch:
+
+```sh
+once-only --skip-exe muscle -in aa.fa -out out-alignment.fa -tree1 first.ph -tree2 tree.ph
+```
+
+where only aa.fa is the scanned input file in the first round. To prevent the second run
+of once-only to include the output files (out-alignment.fa, first.ph and tree.ph) you
+can specify them the first round on the command line as
+
+```sh
+once-only --skip out-alignment.fa --skip first.ph --skip tree.ph muscle -in aa.fa -out out-alignment.fa -tree1 first.ph -tree2 tree.ph
+```
+
+a regular expression on output filenames may be the nicer option
+
+```sh
+once-only --skip-exe --skip-regex 'out|\.ph$' muscle -in aa.fa -out out-alignment.fa -tree1 first.ph -tree2 tree.ph
+```
+
+or if you are more comfortable with shell style pattern matching use
+
+```sh
+once-only --skip-exe --skip-glob 'out*' --skip-glob '*.ph' muscle -in aa.fa -out out-alignment.fa -tree1 first.ph -tree2 tree.ph
+```
+
+For a full range of glob patterns, see this [page](http://ruby.about.com/od/beginningruby/a/dir2.htm).
+
+Sometimes you want to include input files that are not on the command line for generating the hash. Maybe some default input file name is being picked up, or it is defined in a 
+configuration file. In that case use the --include/--in options.
+
+Another once-only command line option is to change directory before executing the script
+
+```sh
+once-only -d run001 --skip-regex 'out|\.ph$' muscle -in aa.fa -out out-alignment.fa -tree1 first.ph -tree2 tree.ph
+```
+
+which is useful with PBS and in scripted environments.
+
+### PBS
+
+Once-only has PBS support built-in. It only uses the 'qsub' and 'qstat' commands.
+
+Basically use the --pbs option:
+
+```sh
+once-only --pbs /bin/cat ~/.bashrc
+```
+
+Will submit 'cat ~/.bashrc' to the queue. If the job is already in the queue it 
+won't be submitted, thanks to the unique job ID once-only generates.
+
+In fact, this is an interesting example, because
+both /bin/cat and ~/.bashrc files may differ on the submission machine and the cluster
+nodes. Only when both are the same you can expect once-only to run properly. In 
+this case it is wise to add at least
+
+```sh
+once-only --pbs --skip-exe /bin/cat ~/.bashrc
+```
+
+so once-only won't check the file /bin/cat.
+
+## Project home page
+
+Information on the source tree, documentation, examples, issues and
+how to contribute, see
+
+  http://github.com/pjotrp/once-only
+
+## Cite
+
+If you use this software, please cite 
+  
+* [Biogem: an effective tool-based approach for scaling up open source software development in bioinformatics](http://dx.doi.org/10.1093/bioinformatics/bts080)
+
+## Biogems.info
+
+This Biogem is published at http://biogems.info/
+
+## Copyright
+
+Copyright (c) 2013 Pjotr Prins. See LICENSE.txt for further details.
+

data/Rakefile

@@ -0,0 +1,54 @@
+# 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 = "once-only"
+  gem.homepage = "http://github.com/pjotrp/once-only"
+  gem.license = "MIT"
+  gem.summary = %Q{Run commands once only if inputs do not change}
+  gem.description = %Q{Run programs and scripts once only. Especially
+  useful for PBS and GRID computing}
+  gem.email = "pjotr.public01@thebird.nl"
+  gem.authors = ["Pjotr Prins"]
+  # dependencies defined in Gemfile
+end
+Jeweler::RubygemsDotOrgTasks.new
+
+require 'rspec/core'
+require 'rspec/core/rake_task'
+RSpec::Core::RakeTask.new(:spec) do |spec|
+  spec.pattern = FileList['spec/**/*_spec.rb']
+end
+
+RSpec::Core::RakeTask.new(:rcov) do |spec|
+  spec.pattern = 'spec/**/*_spec.rb'
+  spec.rcov = true
+end
+
+require 'cucumber/rake/task'
+Cucumber::Rake::Task.new do |features|
+end
+
+task :default => [:cucumber]
+
+require 'rdoc/task'
+Rake::RDocTask.new do |rdoc|
+  version = File.exist?('VERSION') ? File.read('VERSION') : ""
+
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = "once-only #{version}"
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end

data/VERSION

@@ -0,0 +1 @@
+0.0.1

data/bin/once-only

@@ -0,0 +1,208 @@
+#!/usr/bin/env ruby
+#
+# Once-only  Run applications once with the same inputs
+# Author:: Pjotr Prins
+# Copyright:: 2013
+
+USAGE =<<EOB
+
+once-only runs a command once only when inputs don't change!
+
+Usage:
+
+   -d path             change to directory before executing
+   --pbs [opts]        convert to PBS command with optional options
+   --skip|--out file   skip making a checksum of the named file (multiple allowed)
+   --skip-exe          skip making a checksum of the executable command/script
+   --skip-cli          skip making a checksum of full command line
+   --skip-regex regex  skip making checksumes of filenames that match the regex (multiple allowed)
+   --skip-glob regex   skip making checksumes of filenames that match the glob (multiple allowed)
+   --include|--in file include input filename for making the checksumes
+   -v                  increase verbosity
+   -q                  run quietly
+   --debug             give debug information
+   --dry-run           do not execute command
+   --force             force execute command
+
+See the README for examples
+
+EOB
+
+original_commands = ARGV.join(' ')
+
+gempath = File.dirname(File.dirname(__FILE__))
+$: << File.join(gempath,'lib')
+
+VERSION_FILENAME=File.join(gempath,'VERSION')
+version = File.new(VERSION_FILENAME).read.chomp
+
+$stderr.print "once-only #{version} (using Ruby #{RUBY_VERSION}) by Pjotr Prins 2013\n"
+
+require 'once-only'
+
+if ARGV.size == 0
+  print USAGE
+  exit 1
+end
+
+def exit_error errval = 1
+  $stderr.print "\nonce-only returned error #{errval}\n"
+  exit errval
+end
+
+def parse_args(args)
+  options = { :skip => [], :skip_regex => [], :skip_glob => [], :include => [] }
+
+  consume = lambda { |args|
+    return args if File.exist?(args[0]) # reached the executable command
+    case args[0]
+      when '-d'
+        options[:dir] = File.expand_path(args[1])
+        consume.call(args[2..-1])
+      when '--pbs'
+        if args[1] =~ /\s+/ # optional argument
+          options[:pbs] = args[1]
+          consume.call(args[2..-1])
+        else
+          options[:pbs] = "''"
+          consume.call(args[1..-1])
+        end
+      when '--skip','--out'
+        options[:skip] << args[1]
+        consume.call(args[2..-1])
+      when '--skip-exe'
+        options[:skip_exe] = true
+        consume.call(args[1..-1])
+      when '--skip-cli'
+        options[:skip_cli] = true
+        consume.call(args[1..-1])
+      when '--skip-regex'
+        options[:skip_regex] << args[1]
+        consume.call(args[2..-1])
+      when '--skip-glob'
+        options[:skip_glob] << args[1]
+        consume.call(args[2..-1])
+      when '--include','--in'
+        options[:include] << args[1]
+        consume.call(args[2..-1])
+      when '-h', '--help'
+        print USAGE
+        exit 1
+      when '--debug' 
+        options[:debug] = true
+        consume.call(args[1..-1])
+      when '-v' 
+        options[:verbose] = true
+        consume.call(args[1..-1])
+      when '-q' 
+        options[:quiet] = true
+        consume.call(args[1..-1])
+      when '--dry-run' 
+        options[:dry_run] = true
+        consume.call(args[1..-1])
+      when '--force' 
+        options[:force] = true
+        consume.call(args[1..-1])
+      else
+        $stderr.print "Can not parse arguments",args
+        exit_error(1)
+      end
+  }
+
+  return consume.call(args),options
+end
+
+args,options = parse_args(ARGV)
+once_only_args = OnceOnly::Check.requote([ __FILE__ ] + ( ARGV[0..ARGV.size-args.size-1] ))
+
+if options[:debug]
+  print "Full:    "
+  p ARGV
+  print "Prefix:  "
+  p once_only_args
+  print "Postfix: "
+  p args
+  print "Options: "
+  p options   
+end
+
+once_only_args = OnceOnly::Check.drop_pbs_option(once_only_args)
+once_only_args = OnceOnly::Check.drop_dir_option(once_only_args)
+once_only_command = once_only_args.join(' ')
+
+command = args.join(' ')
+command_sorted = args.sort.join(' ')
+command_sha1 = OnceOnly::Check::calc_checksum(command_sorted)
+
+# change dir
+if options[:dir]
+  $stderr.print "Changing dir to ",options[:dir],"\n" if !options[:quiet]
+  Dir.chdir options[:dir] 
+end
+
+executable = args[0]
+args = args[1..-1] if options[:skip_exe]
+
+file_list = OnceOnly::Check::get_file_list(args)
+options[:skip_regex].each { |regex|
+  file_list = OnceOnly::Check::filter_file_list(file_list,regex)
+}
+options[:skip_glob].each { |glob|
+  file_list = OnceOnly::Check::filter_file_list_glob(file_list,glob)
+}
+file_list -= options[:skip] 
+
+OnceOnly::Check::check_files_exist(options[:include])
+file_list += options[:include]
+
+checksums = OnceOnly::Check::calc_file_checksums(file_list)
+checksums.push ['SHA1',command_sha1,command_sorted] if not options[:skip_cli]
+
+once_only_filename = OnceOnly::Check::make_once_filename(checksums,File.basename(executable))
+$stderr.print "Check file name ",once_only_filename,"\n" if options[:verbose]
+error_filename = once_only_filename + '.err'
+$stderr.print "Job file exists ",once_only_filename,"!\n" if options[:debug] and File.exist?(once_only_filename)
+
+dirname = File.basename(Dir.pwd).rjust(8,"-") # make sure it is long enough
+
+job_name = (dirname[-5..-1] + once_only_filename.split(/-/).map{|s|s[0..5]}.join).gsub(/[_-]/,'')[0..15]
+$stderr.print "Job name ",job_name,"\n" if options[:verbose]
+
+if options[:force] or not File.exist?(once_only_filename)
+  $stderr.print "Running #{command}\n" if not options[:quiet]
+  if options[:pbs]
+    # --- Check if job is already queued in PBS
+    qstat = `/usr/bin/qstat`
+    if qstat =~ /#{job_name}/
+      $stderr.print "Job #{job_name} already in queue!\n"
+      exit 0
+    end
+    # --- Submit PBS job
+    pbs_command = 'echo "' + once_only_command + ' ' + command + "\"|qsub -N #{job_name} "+options[:pbs]+' '
+    pbs_command += '-d ' + (options[:dir] ? options[:dir] : Dir.pwd) 
+ 
+    $stderr.print(pbs_command,"\n") if options[:verbose]
+    if !options[:dry_run]
+      if not system(pbs_command) 
+        OnceOnly::Check::write_file(error_filename,checksums)
+        exit_error($?.exitstatus)
+      end
+    end
+  else
+    # --- Run on command line
+    if !options[:dry_run]
+      if not system(command)
+        OnceOnly::Check::write_file(error_filename,checksums)
+        exit_error($?.exitstatus)
+      else
+        # --- Success!
+        File.unlink(error_filename) if File.exist?(error_filename)
+        OnceOnly::Check::write_file(once_only_filename,checksums)
+     end
+    end
+  end
+else
+  $stderr.print "Inputs unchanged. No need to rerun '#{original_commands}'!\n" if not options[:quiet]
+end
+
+exit 0  # success!

data/features/once-only.feature

@@ -0,0 +1,22 @@
+Feature: Execute command line
+
+  Once-only asserts a command in only run once, based on the inputs on the 
+  command line.
+
+  Scenario: Test first run and skip execute of second run
+    Given a command '/bin/cat LICENSE.txt'
+    When I run the command the first time
+    Then once-only should create a checksum
+    When I run the command the second time with the same inputs
+    Then once-only should not recreate the checksum and skip the run
+
+  Scenario: Run gives an error
+    Given a command '/bin/cat LICENSE.txt.none'
+    When I run the command the first time
+    Then once-only should pass back an error
+    Then once-only should have created an error file
+
+  Scenario: Executable does not exist
+    Given a command '/binxx/cat LICENSE.txt'
+    When I run the non-existing command
+    Then once-only should pass back a wrong command error

data/features/step_definitions/once-only_steps.rb

@@ -0,0 +1,20 @@
+Given(/^a command '\/bin\/cat LICENSE.txt'$/) do
+  @cmd = '/bin/cat LICENSE.txt'
+end
+
+When(/^I run the command the first time$/) do
+  pending # express the regexp above with the code you wish you had
+end
+
+Then(/^once\-only should create a checksum$/) do
+  pending # express the regexp above with the code you wish you had
+end
+
+When(/^I run the command the second time with the same inputs$/) do
+  pending # express the regexp above with the code you wish you had
+end
+
+Then(/^once\-only should not recreate the checksum and skip the run$/) do
+  pending # express the regexp above with the code you wish you had
+end
+

data/features/support/env.rb

@@ -0,0 +1,13 @@
+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
+
+$LOAD_PATH.unshift(File.dirname(__FILE__) + '/../../lib')
+require 'once-only'
+
+require 'rspec/expectations'

data/lib/once-only.rb

@@ -0,0 +1,4 @@
+require 'once-only/once-only.rb'
+require 'once-only/sha1.rb'
+require 'once-only/check.rb'
+

data/lib/once-only/check.rb

@@ -0,0 +1,100 @@
+begin
+  require "digest" 
+  Digest::SHA1.hexdigest('test')
+rescue LoadError
+  $stderr.print "Using native Ruby SHA1 (slow)\n"
+  $ruby_sha1 = true
+end
+
+module OnceOnly
+    
+  module Check
+    # filter out all arguments that reflect existing files
+    def Check::get_file_list list
+      list.map { |arg| get_existing_filename(arg) }.compact
+    end
+
+    def Check::check_files_exist list
+      list.each { |fn| 
+        raise "File #{fn} does not exist!" if not File.exist?(fn)
+      }
+    end
+
+    # filter out all names accoding to filters
+    def Check::filter_file_list list, regex
+      list.map { |name| ( name =~ /#{regex}/ ? nil : name ) }.compact
+    end
+
+    # filter out all names accoding to glob (this is not an efficient
+    # implementation, as the glob runs for every listed file!)
+    def Check::filter_file_list_glob list, glob
+      list.map { |name| ( Dir.glob(glob).index(name) ? nil : name ) }.compact
+    end
+
+    # Calculate the checksums for each file in the list
+    def Check::calc_file_checksums list
+      list.map { |fn|
+        ['MD5'] + `/usr/bin/md5sum #{fn}`.split
+      }
+    end
+
+    def Check::calc_checksum(buf)
+      if $ruby_sha1
+        Sha1::sha1(buf)
+      else
+        Digest::SHA1.hexdigest(buf)
+      end
+    end
+
+    # Create a file name out of the content of checksums
+    def Check::make_once_filename checksums, prefix = 'once-only'
+      buf = checksums.map { |entry| entry }.join("\n")
+      prefix + '-' + calc_checksum(buf) + '.txt'
+    end
+
+    def Check::write_file fn, checksums
+      File.open(fn,'w') { |f|
+        checksums.each { |items| f.print items[0],"\t",items[1],"\t",items[2],"\n" }
+      }
+    end
+   
+    # Put quotes around regexs and globs 
+    def Check::requote list
+      a = [ list[0] ]
+      list.each_cons(2) { |pair| a << (['--skip-glob','--skip-regex'].index(pair[0]) ? "'#{pair[1]}'" : pair[1]) }
+      a
+    end
+
+    # Drop --pbs and optional argument from list
+    def Check::drop_pbs_option(list)
+      is_part_of_pbs_arg = lambda { |p1, p2|
+        (p1 == '--pbs' and p2 =~ /\s+/) or p2 == '--pbs'
+      }
+      a = [ list[0] ]
+      list.each_cons(2) { |pair| a << pair[1] if not is_part_of_pbs_arg.call(pair[0],pair[1])}
+      a
+    end
+
+    # Drop -d argument from list
+    def Check::drop_dir_option(list)
+      is_part_of_arg = lambda { |p1, p2|
+        (p1 == '-d' or p2 == '-d')
+      }
+      a = [ list[0] ]
+      list.each_cons(2) { |pair| a << pair[1] if not is_part_of_arg.call(pair[0],pair[1])}
+      a
+    end
+
+
+protected
+
+    def Check::get_existing_filename arg
+      return arg if File.exist?(arg)
+      # sometimes arguments are formed as -in=file
+      (option,filename) = arg.split(/=/)
+      return filename if filename and File.exist?(filename)
+      nil
+    end
+  end
+
+end

data/lib/once-only/once-only.rb

@@ -0,0 +1,3 @@
+
+module OnceOnly
+end

data/lib/once-only/sha1.rb

@@ -0,0 +1,91 @@
+require 'stringio'
+
+module OnceOnly
+
+  module Sha1
+ 
+    # Calculates SHA-1 message digest of _string_. Returns binary digest.
+    # For hexadecimal digest, use +*sha1(string).unpack('H*')+.
+    #--
+    # This is a simple, pure-Ruby implementation of SHA-1, following
+    # the algorithm in FIPS 180-1.
+    # 
+    # (lifted from Rosetta code http://rosettacode.org)
+    #++
+    def Sha1::sha1(string)
+      # functions and constants
+      mask = (1 << 32) - 1
+      s = proc{|n, x| ((x << n) & mask) | (x >> (32 - n))}
+      f = [
+        proc {|b, c, d| (b & c) | (b.^(mask) & d)},
+        proc {|b, c, d| b ^ c ^ d},
+        proc {|b, c, d| (b & c) | (b & d) | (c & d)},
+        proc {|b, c, d| b ^ c ^ d},
+      ].freeze
+      k = [0x5a827999, 0x6ed9eba1, 0x8f1bbcdc, 0xca62c1d6].freeze
+     
+      # initial hash
+      h = [0x67452301, 0xefcdab89, 0x98badcfe, 0x10325476, 0xc3d2e1f0]
+     
+      io = StringIO.new(string)
+      block = ""
+      term = false  # appended "\x80" in second-last block?
+      last = false  # last block?
+      until last
+        # Read next block of 16 words (64 bytes, 512 bits).
+        io.read(64, block) or (
+          # Work around a bug in Rubinius 1.2.4. At eof,
+          # MRI and JRuby already replace block with "".
+          block.replace("")
+        )
+     
+        # Unpack block into 32-bit words "N".
+        case len = block.length
+        when 64
+          # Unpack 16 words.
+          w = block.unpack("N16")
+        when 56..63
+          # Second-last block: append padding, unpack 16 words.
+          block.concat("\x80"); term = true
+          block.concat("\0" * (63 - len))
+          w = block.unpack("N16")
+        when 0..55
+          # Last block: append padding, unpack 14 words.
+          block.concat(term ? "\0" : "\x80")
+          block.concat("\0" * (55 - len))
+          w = block.unpack("N14")
+     
+          # Append bit length, 2 words.
+          bit_len = string.length << 3
+          w.push(bit_len >> 32, bit_len & mask)
+          last = true
+        else
+          fail "impossible"
+        end
+     
+        # Process block.
+        (16..79).each {|t|
+          w[t] = s[1, w[t - 3] ^ w[t - 8] ^ w[t - 14] ^ w[t - 16]]}
+     
+        a, b, c, d, e = h[0..4]
+        t = 0
+        (0..3).each {|i|
+          20.times {
+            temp = (s[5, a] + f[i][b, c, d] + e + w[t] + k[i]) & mask
+            e = d; d = c; c = s[30, b]; b = a; a = temp
+            t += 1}}
+     
+        h[0] = (h[0] + a) & mask
+        h[1] = (h[1] + b) & mask
+        h[2] = (h[2] + c) & mask
+        h[3] = (h[3] + d) & mask
+        h[4] = (h[4] + e) & mask
+      end
+     
+      # h.join('').hex.to_s
+      # p h p sprintf("%08X","10") -> 0000000A
+      h.map { |n| sprintf("%08x",n) }.join('')
+    end
+  end
+
+end 

data/spec/bio-once-only_spec.rb

@@ -0,0 +1,7 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+describe "BioOnceOnly" do
+  it "fails" do
+    fail "hey buddy, you should probably rename this file and start specing for real"
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,12 @@
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+require 'rspec'
+require 'once-only'
+
+# Requires supporting files with custom matchers and macros, etc,
+# in ./support/ and its subdirectories.
+Dir["#{File.dirname(__FILE__)}/support/**/*.rb"].each {|f| require f}
+
+RSpec.configure do |config|
+  
+end

metadata

@@ -0,0 +1,114 @@
+--- !ruby/object:Gem::Specification
+name: once-only
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- Pjotr Prins
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-05-12 00:00:00.000000000Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: &17265660 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 2.8.0
+  type: :development
+  prerelease: false
+  version_requirements: *17265660
+- !ruby/object:Gem::Dependency
+  name: cucumber
+  requirement: &17264920 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *17264920
+- !ruby/object:Gem::Dependency
+  name: jeweler
+  requirement: &17264040 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.8.4
+  type: :development
+  prerelease: false
+  version_requirements: *17264040
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: &17263420 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 1.0.21
+  type: :development
+  prerelease: false
+  version_requirements: *17263420
+description: ! "Run programs and scripts once only. Especially\n  useful for PBS and
+  GRID computing"
+email: pjotr.public01@thebird.nl
+executables:
+- once-only
+extensions: []
+extra_rdoc_files:
+- LICENSE.txt
+- README.md
+files:
+- .document
+- .rspec
+- .travis.yml
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- VERSION
+- bin/once-only
+- features/once-only.feature
+- features/step_definitions/once-only_steps.rb
+- features/support/env.rb
+- lib/once-only.rb
+- lib/once-only/check.rb
+- lib/once-only/once-only.rb
+- lib/once-only/sha1.rb
+- spec/bio-once-only_spec.rb
+- spec/spec_helper.rb
+homepage: http://github.com/pjotrp/once-only
+licenses:
+- MIT
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+      segments:
+      - 0
+      hash: -995396904619724027
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.10
+signing_key: 
+specification_version: 3
+summary: Run commands once only if inputs do not change
+test_files: []