mutagem 0.1.3

data/.gitattributes

@@ -0,0 +1 @@
+*.rb diff=ruby

data/.gitignore

@@ -0,0 +1,11 @@
+pkg/*
+*.gem
+.bundle
+coverage
+rdoc
+.yardoc
+rerun.txt
+tags
+tmp/fixtures
+tmp/aruba
+

data/.yardopts

@@ -0,0 +1,5 @@
+--verbose
+--list-undoc
+-
+LICENSE
+HISTORY.markdown

data/Gemfile

@@ -0,0 +1,4 @@
+source :gemcutter
+
+# Specify your gem's dependencies in the .gemspec file
+gemspec

data/Gemfile.lock

@@ -0,0 +1,44 @@
+PATH
+  remote: .
+  specs:
+    mutagem (0.1.3)
+
+GEM
+  remote: http://rubygems.org/
+  specs:
+    aruba (0.2.3)
+      background_process
+      cucumber (~> 0.9.0)
+    background_process (1.2)
+    builder (2.1.2)
+    cucumber (0.9.0)
+      builder (~> 2.1.2)
+      diff-lcs (~> 1.1.2)
+      gherkin (~> 2.2.2)
+      json (~> 1.4.6)
+      term-ansicolor (~> 1.0.5)
+    diff-lcs (1.1.2)
+    gherkin (2.2.4)
+      json (~> 1.4.6)
+      term-ansicolor (~> 1.0.5)
+      trollop (~> 1.16.2)
+    json (1.4.6)
+    rake (0.8.7)
+    rdiscount (1.6.5)
+    rspec (1.3.0)
+    term-ansicolor (1.0.5)
+    trollop (1.16.2)
+    yard (0.6.1)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  aruba (>= 0.2.0)
+  bundler (>= 1.0.0)
+  cucumber (>= 0.6)
+  mutagem!
+  rake (>= 0.8.7)
+  rdiscount (>= 1.6.5)
+  rspec (>= 1.2.9)
+  yard (>= 0.6.1)

data/HISTORY.markdown

@@ -0,0 +1,11 @@
+History
+=======
+Most recent changes are at the top
+
+
+Changes
+-------
+
+### 0.1.3 - 10/01/2010 ###
+
+* initial release

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2010 GearheadForHire, LLC
+
+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.markdown

@@ -0,0 +1,119 @@
+Mutagem
+========
+
+A Ruby gem for file based mutexes with a simple external process management wrapper.
+
+
+Overview
+--------
+The Mutagem library provides file based mutexes for recursion protection and wrapper classes for 
+threading of external processes with support for output and exit status capturing. 
+
+A test suite is provided for both unit testing with [RSpec](http://github.com/dchelimsky/rspec) 
+and functional testing with [Cucumber](http://github.com/aslakhellesoy/cucumber).  The code is 
+documented using [YARD](http://github.com/lsegal/yard).
+
+
+Example Usage
+-------------
+The following Ruby code is used to run a word by word diff on two folders of comma delimited data.
+Each folder contains before and after CSV dumps from a SQL database.  The CSV files have the same name
+in each of the two folders.
+
+Mutagem is providing recursion protection.  The recursion protection is very useful if the script is 
+run in an automated environment (ex. cron).  Mutagem is also capturing output and exit status for the 
+diff processes allowing customized output.  
+
+Standard diff is quick but it can't give you a word by word diff of CSV data.  Word by word 
+colorized diffing with support for custom delimiters is provided 
+by [dwdiff](http://os.ghalkes.nl/dwdiff.html). 
+
+
+    #!/usr/bin/env ruby
+
+    require 'rubygems'
+    require 'mutagem'
+    require 'pathname'
+    require 'term/ansicolor'
+
+    class String
+      include Term::ANSIColor
+    end
+
+    lock_was_sucessful = Mutagem::Mutex.new('diff.lck').execute do
+
+      $stdout.sync = true # force screen updates
+      before_files = Dir.glob('test/dump/before/*.csv')
+
+      before_files.each do |bf|
+
+        af = 'test/dump/after/' + Pathname.new(bf).basename.to_s
+        
+        # quick diff
+        cmd = "diff #{bf} #{af}"
+        task = Mutagem::Task.new(cmd)
+        task.join
+
+        if (task.exitstatus == 0)
+          # no changes, show a "still working" indicator
+          print ".".green
+        else
+          # we have changes, slow diff, word based and CSV (comma) sensitive 
+          print "D".red
+          puts "\n#{af}"
+         
+          cmd = "dwdiff --color --context=0 --delimiters=, #{bf} #{af}"
+          task = Mutagem::Task.new(cmd)
+          task.join
+
+          puts task.output
+        end
+
+      end
+      puts "\n"
+
+    end
+    puts "process locked" unless lock_was_sucessful
+
+
+System Requirements
+-------------------
+* POSIX system (tested on Linux and Windows/Cygwin environments)
+
+
+Installation
+------------
+Mutagem is avaliable on [RubyGems.org](http://rubygems.org/gems/mutagem)
+
+    gem install mutagem
+
+
+Development
+-----------
+
+Mutagem uses [Bundler](http://github.com/carlhuda/bundler) to manage dependencies, the gemspec
+file is maintained by hand. 
+
+    git clone http://github.com/robertwahler/mutagem
+    cd mutagem
+
+Use bundle to install development dependencies
+
+    bundle install
+
+rake -T
+
+    rake build         # Build mutagem-0.1.2.gem into the pkg directory
+    rake doc:clean     # Remove generated documenation
+    rake doc:generate  # Generate YARD Documentation
+    rake features      # Run Cucumber features
+    rake install       # Build and install mutagem-0.1.2.gem into system gems
+    rake release       # Create tag v0.1.2 and build and push mutagem-0.1.2.gem to Rubygems
+    rake spec          # Run specs
+    rake test          # Run specs and features
+
+
+Copyright
+---------
+
+Copyright (c) 2010 GearheadForHire, LLC. See [LICENSE](LICENSE) for details.

data/Rakefile

@@ -0,0 +1,55 @@
+# encoding: utf-8
+
+# bundler/setup is managing $LOAD_PATH, any gem needed by this Rakefile must 
+# be listed as a development dependency in the gemspec
+
+require 'rubygems'
+require 'bundler/setup' 
+
+Bundler::GemHelper.install_tasks
+
+def gemspec
+  @gemspec ||= begin
+    file = File.expand_path('../mutagem.gemspec', __FILE__)
+    eval(File.read(file), binding, file)
+  end
+end
+
+require 'spec'
+require 'spec/rake/spectask'
+Spec::Rake::SpecTask.new(:spec) do |spec|
+  spec.libs << 'lib' << 'spec'
+  spec.spec_files = FileList['spec/**/*_spec.rb']
+end
+
+require 'cucumber'
+require 'cucumber/rake/task'
+Cucumber::Rake::Task.new(:features) do |task|
+  task.cucumber_opts = ["features"]
+end
+
+desc "Run specs and features"
+task :test => [:spec, :features]
+
+task :default => :test
+
+namespace :doc do
+  project_root = File.expand_path(File.dirname(__FILE__))
+  doc_destination = File.join(project_root, 'rdoc')
+
+  require 'yard'
+  require 'yard/rake/yardoc_task'
+
+  YARD::Rake::YardocTask.new(:generate) do |yt|
+    yt.options = ['--markup-provider', 'rdiscount', 
+                  '--output-dir', doc_destination
+                 ] +
+                 gemspec.rdoc_options - ['--line-numbers', '--inline-source']
+  end
+
+  desc "Remove generated documenation"
+  task :clean do
+    rm_r doc_destination if File.exists?(doc_destination)
+  end
+
+end

data/TODO.markdown

@@ -0,0 +1,6 @@
+TODO
+====
+
+* update readme with examples of dwdiff usage
+* add tasker
+* test under Windows/Cygwin

data/config/cucumber.yml

@@ -0,0 +1,7 @@
+<%
+rerun = File.file?('rerun.txt') ? IO.read('rerun.txt') : ""
+rerun_opts = rerun.to_s.strip.empty? ? "--format pretty features" : "--format #{ENV['CUCUMBER_FORMAT'] || 'pretty'} #{rerun}"
+std_opts = "#{rerun_opts} --format rerun --out rerun.txt --strict --tags ~@wip"
+%>
+default: <%= std_opts %>
+wip: --tags @wip:3 --wip features

data/features/mutex.feature

@@ -0,0 +1,22 @@
+@announce
+Feature: File based mutexes
+
+  Automated processes need locking to prevent recursion on long running commands
+
+  Scenario: Process runs with no lock file present
+    Given a Ruby source file that uses Mutagem::Mutex named "test.rb"
+    When I run "ruby test.rb"
+    Then the exit status should be 0
+    And the output should contain:
+      """
+      hello world
+      """
+
+  Scenario: Process runs with a lock file present
+    Given a Ruby source file that uses Mutagem::Mutex named "test.rb"
+    When I run with a lock file present "ruby test.rb"
+    Then the exit status should be 1
+    And the output should not contain:
+      """
+      hello world
+      """

data/features/step_definitions/mutagem_steps.rb

@@ -0,0 +1,51 @@
+
+Given /^a Ruby source file that uses Mutagem::Mutex named "([^\"]*)"$/ do |filename|
+  steps %Q{
+    Given a file named "#{filename}" with:
+      """
+      $LOAD_PATH.unshift File.expand_path('../../../lib', __FILE__) unless
+        $LOAD_PATH.include? File.expand_path('../../../lib', __FILE__)
+
+      require 'mutagem'
+
+      # make sure we are working with the expected gem
+      raise "unexpected mutagem version" unless Mutagem::VERSION == '#{Mutagem::VERSION}'
+
+      mutext = Mutagem::Mutex.new
+      mutext.execute do
+        puts "hello world"
+        exit 0
+      end
+      exit 1
+      """
+  }
+end
+
+Given /^a Ruby source file that uses Mutagem::Task named "([^\"]*)"$/ do |filename|
+  steps %Q{
+    Given a file named "#{filename}" with:
+      """
+      $LOAD_PATH.unshift File.expand_path('../../../lib', __FILE__) unless
+        $LOAD_PATH.include? File.expand_path('../../../lib', __FILE__)
+
+      require 'mutagem'
+
+      # make sure we are working with the expected gem
+      raise "unexpected mutagem version" unless Mutagem::VERSION == '#{Mutagem::VERSION}'
+
+      cmd = %q[ruby -e 'puts "hello world"; exit 2']
+      task = Mutagem::Task.new(cmd)
+      task.join
+
+      puts task.output
+      exit task.exitstatus 
+      """
+  }
+end
+
+When /^I run with a lock file present "(.*)"$/ do |cmd|
+  lockfile = File.join(current_dir, 'mutagem.lck')
+  Mutagem::Mutex.new(lockfile).execute do
+    run(unescape(cmd), false)
+  end
+end

data/features/support/env.rb

@@ -0,0 +1,4 @@
+$LOAD_PATH.unshift(File.dirname(__FILE__) + '/../../lib')
+require 'mutagem'
+require 'aruba'
+require 'spec/expectations'

data/features/task.feature

@@ -0,0 +1,15 @@
+@announce
+Feature: Simple process management wrapper
+
+  Manage subprocess tasks in a separate thread
+  in order to capture the output and manage additional tasks
+  based on the subprocess exit status
+
+  Scenario: Sucessfully run a subprocess
+    Given a Ruby source file that uses Mutagem::Task named "tasker.rb"
+    When I run "ruby tasker.rb"
+    Then the exit status should be 2
+    And the output should contain:
+      """
+      hello world
+      """

data/lib/mutagem/lockfile.rb

@@ -0,0 +1,58 @@
+module Mutagem
+
+  # File locking wrapper for Flock
+  class Lockfile
+    # filename for the lockfile, can include path
+    attr_accessor :lockfile
+
+    # Create a new LockFile
+    #
+    # @param [String] lockfile filename
+    def initialize(lockfile=nil)
+      raise ArgumentError, "lockfile not specified" unless lockfile
+      @lockfile = lockfile
+    end
+
+    # Does another process have a lock?
+    # True if we can't get an exclusive lock
+    def locked?
+      return false unless File.exists?(lockfile)
+      result = false
+      open(lockfile, 'w') do |f|
+        # exclusive non-blocking lock
+        result = !lock(f, File::LOCK_EX | File::LOCK_NB)
+      end
+      result
+    end
+
+    # Get a file lock with flock and ensure the 
+    # lock is removed (but not the lockfile).  Accepts an optional
+    # code block.
+    #
+    # @example
+    #
+    #     open('output', 'w') do |f|
+    #       # exclusive blocking lock
+    #       lock(f, File::LOCK_EX) do |f|
+    #       f << "write to file while blocking other processes"
+    #       end
+    #     end
+    #
+    # @param [Object] file the file IO object returned from a call to "open(filename, mode_string)"
+    # @param [Constant] mode locking_constant, see File
+    # @return [Boolean] 0 or false if unable to sucessfully lock
+    def lock(file, mode)
+      result = file.flock(mode)
+      if result
+        begin
+          yield file if block_given?  # may not have block if called by locked?
+        ensure
+          # unlock but leave the file on the filesystem
+          file.flock(File::LOCK_UN)
+        end
+      end
+      return result
+    end
+  end
+
+end

data/lib/mutagem/mutex.rb

@@ -0,0 +1,47 @@
+module Mutagem
+
+  # File based mutex
+  class Mutex < Lockfile
+
+    # Creates a new Mutex
+    #
+    # @param [String] lockfile filename
+    def initialize(lockfile='mutagem.lck')
+      super lockfile
+    end
+
+    # Protect a block 
+    #
+    # @example
+    #
+    #    require 'rubygems'
+    #    require 'mutagem'
+    #
+    #    mutex = Mutagem::Mutex.new("my_process_name.lck")
+    #    mutex.execute do
+    #      puts "this block is protected from recursion"
+    #    end
+    #
+    # @param block the block of code to protect with the mutex
+    # @return [Boolean] 0 if lock sucessful, otherwise false
+    def execute(&block)
+      result = false
+      raise ArgumentError, "missing block" unless block_given?
+
+      begin
+        open(lockfile, 'w') do |f|
+          # exclusive non-blocking lock
+          result = lock(f, File::LOCK_EX | File::LOCK_NB) do |f|
+            yield
+          end
+        end
+      ensure
+        # clean up but only if we have a positive result meaning we wrote the lockfile
+        FileUtils.rm(lockfile) if (result && File.exists?(lockfile))
+      end
+
+      result
+    end
+  end
+
+end

data/lib/mutagem/task.rb

@@ -0,0 +1,66 @@
+require 'thread'
+
+module Mutagem
+  
+  #  A simple external process management wrapper
+  #
+  # @example
+  #
+  #     cmd = "diff file1.txt file2.txt"
+  #     task = Mutagem::Task.new(cmd)
+  #     task.join
+  #
+  #     if (task.exitstatus == 0)
+  #       puts "files match"
+  #     end
+  class Task
+    # @return [String] command to run
+    attr_reader :cmd
+    attr_accessor :thread
+
+    # Create a new Task
+    #
+    # @param [String] cmd the cmd to execute
+    def initialize(cmd)
+      @cmd = cmd
+      @thread = Thread.new do
+        pipe = IO.popen(cmd + " 2>&1")
+        @pid = pipe.pid
+        begin
+          @output = pipe.readlines
+          pipe.close
+          @exitstatus = $?.exitstatus
+        rescue => e
+          @exception = e
+        end
+      end 
+    end
+     
+    # @return [Array] array of strings from the subprocess output
+    def output
+      @output
+    end
+
+    # @return subprocess exit status
+    def exitstatus
+      @exitstatus
+    end
+
+    # @return subprocess pid 
+    def pid
+      @pid
+    end
+
+    # @return [Exception] exception returned if one is thrown by Task
+    def exception
+      @exception
+    end
+    
+    # join the task's thead and wait for it to finish
+    def join
+      thread.join
+    end
+
+  end
+
+end

data/lib/mutagem/version.rb

@@ -0,0 +1,3 @@
+module Mutagem
+  VERSION = "0.1.3" unless defined?(::Mutagem::VERSION)
+end

data/lib/mutagem.rb

@@ -0,0 +1,9 @@
+require 'mutagem/version'
+require 'mutagem/lockfile'
+require 'mutagem/mutex'
+require 'mutagem/task'
+
+module Mutagem
+
+end
+

data/mutagem.gemspec

@@ -0,0 +1,40 @@
+# -*- encoding: utf-8 -*-
+require File.expand_path("../lib/mutagem/version", __FILE__)
+
+Gem::Specification.new do |s|
+  s.name        = "mutagem"
+  s.version     = Mutagem::VERSION
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = ["Robert Wahler"]
+  s.email       = ["robert@gearheadforhire.com"]
+  s.homepage    = "http://rubygems.org/gems/mutagem"
+  s.summary     = "File based mutexes with a simple external process management wrapper"
+  s.description = "The Mutagem library provides file based mutexes for recursion protection and 
+                   classes for threading of external processes with support for output and 
+                   exit status capturing. A test suite is provided for both unit and functional testing.
+                   The code is documented using YARD."
+
+  s.required_rubygems_version = ">= 1.3.6"
+  s.rubyforge_project         = "mutagem"
+
+  s.add_development_dependency "bundler", ">= 1.0.0"
+  s.add_development_dependency "rspec", ">= 1.2.9"
+  s.add_development_dependency "cucumber", ">= 0.6"
+  s.add_development_dependency "aruba", ">= 0.2.0"
+  s.add_development_dependency "rake", ">= 0.8.7"
+  s.add_development_dependency "yard", ">= 0.6.1"
+  s.add_development_dependency "rdiscount", ">= 1.6.5"
+
+  s.files        = `git ls-files`.split("\n")
+  s.executables  = `git ls-files`.split("\n").map{|f| f =~ /^bin\/(.*)/ ? $1 : nil}.compact
+  s.test_files   = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.require_path = 'lib'
+
+  s.has_rdoc = 'yard'
+  s.rdoc_options     = [ 
+                         '--title', 'Mutagem Documentation', 
+                         '--main', 'README.markdown', 
+                         '--line-numbers',
+                         '--inline-source' 
+                       ]
+end

data/spec/basic_gem/basic_gem_spec.rb

@@ -0,0 +1,13 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+describe Mutagem do
+  
+  describe 'VERSION' do
+
+    it "should return a string formatted '#.#.#'" do
+      Mutagem::VERSION.should match(/(^[\d]+\.[\d]+\.[\d]+$)/)
+    end
+
+  end
+
+end

data/spec/mutagem/lockfile_spec.rb

@@ -0,0 +1,19 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+describe Mutagem::Lockfile do
+  
+  before(:each) do
+    # remove tmp/aruba
+    FileUtils.rm_rf(current_dir)
+  end
+  
+  it "should raise ArgumentError if initialized without a lock filename" do
+    in_current_dir do
+      lambda {Mutagem::Lockfile.new}.should raise_error(ArgumentError, 'lockfile not specified')
+      lambda {Mutagem::Lockfile.new('mylock.lock')}.should_not raise_error
+    end
+  end
+
+end
+
+

data/spec/mutagem/mutex_spec.rb

@@ -0,0 +1,49 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+describe Mutagem::Mutex do
+  
+  before(:each) do
+    # remove tmp/aruba
+    FileUtils.rm_rf(current_dir)
+  end
+  
+  it "should create a mutex, yield, and clean up" do
+    in_current_dir do
+      mutex = Mutagem::Mutex.new
+      result = mutex.execute do
+        File.should be_file('mutagem.lck')
+        mutex.should be_locked
+      end
+      result.should be_true
+      mutex.should_not be_locked
+      File.should_not be_file('mutagem.lck')
+    end
+  end
+
+  it "should prevent recursion but not block" do
+    in_current_dir do
+      Mutagem::Mutex.new.execute do
+        File.should be_file('mutagem.lck')
+
+        mutex = Mutagem::Mutex.new
+        result = mutex.execute do
+          # This block is protected, should not be here
+          true.should be(false)
+        end
+        result.should be_false
+        mutex.should be_locked
+      end
+      File.should_not be_file('mutagem.lck')
+    end
+  end
+
+  it "should raise ArgumentError unless a block is given" do
+    in_current_dir do
+      mutex = Mutagem::Mutex.new
+      lambda {result = mutex.execute}.should raise_error(ArgumentError, 'missing block')
+    end
+  end
+
+end
+
+

data/spec/spec.opts

@@ -0,0 +1,2 @@
+--color
+--format nested

data/spec/spec_helper.rb

@@ -0,0 +1,19 @@
+$LOAD_PATH.unshift File.expand_path('..', __FILE__) unless
+  $LOAD_PATH.include? File.expand_path('..', __FILE__)
+$LOAD_PATH.unshift File.expand_path('../../lib', __FILE__) unless
+  $LOAD_PATH.include? File.expand_path('../../lib', __FILE__)
+
+require 'rubygems'
+require 'mutagem'
+require 'spec'
+require 'spec/autorun'
+require 'aruba/api'
+
+# aruba helper, returns full path to files in the aruba tmp folder
+def fullpath(filename)
+  File.expand_path(File.join(current_dir, filename))
+end
+
+Spec::Runner.configure do |config|
+   config.include Aruba::Api
+end

data/spec/watchr.rb

@@ -0,0 +1,142 @@
+# Watchr: Autotest like functionality
+#
+# Run me with:
+#
+#   $ watchr spec/watchr.rb
+
+require 'term/ansicolor'
+
+$c = Term::ANSIColor
+
+def getch
+  state = `stty -g`
+  begin
+    `stty raw -echo cbreak`
+    $stdin.getc
+  ensure
+    `stty #{state}`
+  end
+end
+
+# --------------------------------------------------
+# Convenience Methods
+# --------------------------------------------------
+def all_feature_files
+  Dir['features/*.feature']
+end
+
+def all_spec_files
+  files = Dir['spec/revenc/*.rb']
+end
+
+def run(cmd)
+
+  pid = fork do
+    puts "\n"
+    print $c.cyan, cmd, $c.clear, "\n"
+    exec(cmd)
+  end
+  Signal.trap('INT') do
+    puts "sending KILL to pid: #{pid}"
+    Process.kill("KILL", pid)
+  end
+  Process.waitpid(pid)
+
+  prompt
+end
+
+def run_all
+  run_all_specs
+  run_default_cucumber
+end
+
+# allow cucumber rerun.txt smarts
+def run_default_cucumber
+  cmd = "cucumber"
+  run(cmd)
+end
+
+def run_all_features
+  cmd = "cucumber #{all_feature_files.join(' ')}"
+  run(cmd)
+end
+
+def run_feature(feature)
+  cmd = "cucumber #{feature}"
+  $last_feature = feature
+  run(cmd)
+end
+
+def run_last_feature
+  run_feature($last_feature) if $last_feature
+end
+
+def run_default_spec
+  cmd = "spec --color --format s ./spec"
+  run(cmd)
+end
+
+def run_all_specs
+  cmd = "spec --color --format s #{all_spec_files.join(' ')}"
+  p cmd
+  run(cmd)
+end
+
+def run_spec(spec)
+  cmd = "spec --color --format s #{spec}"
+  $last_spec = spec
+  run(cmd)
+end
+
+def run_last_spec
+  run_spec($last_spec) if $last_spec
+end
+
+def prompt
+  puts "Ctrl-\\ for menu, Ctrl-C to quit"
+end
+
+# init
+$last_feature = nil
+prompt
+
+# --------------------------------------------------
+# Watchr Rules
+# --------------------------------------------------
+#watch( '^features/(.*)\.feature'   )   { |m| run_feature(m[0]) }
+watch( '^features/(.*)\.feature'   )   { run_default_cucumber }
+
+watch( '^bin/(.*)'   )   { run_default_cucumber }
+watch( '^lib/(.*)'   )   { run_default_cucumber }
+
+watch( '^features/step_definitions/(.*)\.rb' )   { run_default_cucumber }
+watch( '^features/support/(.*)\.rb' )   { run_default_cucumber }
+
+watch( '^spec/(.*)_spec\.rb'   )   { |m| run_spec(m[0]) }
+# watch( '^lib/revenc/io.rb'   )   { run_default_spec }
+watch( '^lib/revenc/errors.rb'   )   { run_default_spec }
+watch( '^lib/revenc/lockfile.rb'   )   { run_default_spec }
+
+# --------------------------------------------------
+# Signal Handling
+# --------------------------------------------------
+
+# Ctrl-\
+Signal.trap('QUIT') do
+
+  puts "\n\nMENU: a = all , f = features  s = specs, l = last feature (#{$last_feature ? $last_feature : 'none'}), q = quit\n\n"
+  c = getch
+  puts c.chr
+  if c.chr == "a"
+    run_all
+  elsif c.chr == "f"
+    run_default_cucumber
+  elsif c.chr == "s"
+    run_all_specs
+  elsif c.chr == "q"
+    abort("exiting\n")
+  elsif c.chr == "l"
+    run_last_feature
+  end
+
+end

metadata

@@ -0,0 +1,207 @@
+--- !ruby/object:Gem::Specification 
+name: mutagem
+version: !ruby/object:Gem::Version 
+  prerelease: false
+  segments: 
+  - 0
+  - 1
+  - 3
+  version: 0.1.3
+platform: ruby
+authors: 
+- Robert Wahler
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-10-01 00:00:00 -04:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: bundler
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 1
+        - 0
+        - 0
+        version: 1.0.0
+  type: :development
+  prerelease: false
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: rspec
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 1
+        - 2
+        - 9
+        version: 1.2.9
+  type: :development
+  prerelease: false
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: cucumber
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        - 6
+        version: "0.6"
+  type: :development
+  prerelease: false
+  version_requirements: *id003
+- !ruby/object:Gem::Dependency 
+  name: aruba
+  requirement: &id004 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        - 2
+        - 0
+        version: 0.2.0
+  type: :development
+  prerelease: false
+  version_requirements: *id004
+- !ruby/object:Gem::Dependency 
+  name: rake
+  requirement: &id005 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        - 8
+        - 7
+        version: 0.8.7
+  type: :development
+  prerelease: false
+  version_requirements: *id005
+- !ruby/object:Gem::Dependency 
+  name: yard
+  requirement: &id006 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        - 6
+        - 1
+        version: 0.6.1
+  type: :development
+  prerelease: false
+  version_requirements: *id006
+- !ruby/object:Gem::Dependency 
+  name: rdiscount
+  requirement: &id007 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 1
+        - 6
+        - 5
+        version: 1.6.5
+  type: :development
+  prerelease: false
+  version_requirements: *id007
+description: |-
+  The Mutagem library provides file based mutexes for recursion protection and 
+                     classes for threading of external processes with support for output and 
+                     exit status capturing. A test suite is provided for both unit and functional testing.
+                     The code is documented using YARD.
+email: 
+- robert@gearheadforhire.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- .gitattributes
+- .gitignore
+- .yardopts
+- Gemfile
+- Gemfile.lock
+- HISTORY.markdown
+- LICENSE
+- README.markdown
+- Rakefile
+- TODO.markdown
+- config/cucumber.yml
+- features/mutex.feature
+- features/step_definitions/.gitignore
+- features/step_definitions/mutagem_steps.rb
+- features/support/env.rb
+- features/task.feature
+- lib/mutagem.rb
+- lib/mutagem/lockfile.rb
+- lib/mutagem/mutex.rb
+- lib/mutagem/task.rb
+- lib/mutagem/version.rb
+- mutagem.gemspec
+- spec/basic_gem/basic_gem_spec.rb
+- spec/mutagem/lockfile_spec.rb
+- spec/mutagem/mutex_spec.rb
+- spec/spec.opts
+- spec/spec_helper.rb
+- spec/watchr.rb
+has_rdoc: yard
+homepage: http://rubygems.org/gems/mutagem
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --title
+- Mutagem Documentation
+- --main
+- README.markdown
+- --line-numbers
+- --inline-source
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 723877775
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 1
+      - 3
+      - 6
+      version: 1.3.6
+requirements: []
+
+rubyforge_project: mutagem
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: File based mutexes with a simple external process management wrapper
+test_files: []
+