0.40.0

Provide a useful error if `foreman check` fails to find a Procfile

.env

@@ -1 +0,0 @@
-FOO=bar

.gitignore

@@ -1,8 +1,9 @@
 /.bundle
+/.rbenv-version
 /coverage
 /example/log/*
 /man/*.html
 /man/*.markdown
 /pkg
 /tags
-/vendor
+/vendor

.travis.yml

@@ -11,4 +11,4 @@ notifications:
     on_success: always
     on_failure: always
     urls:
-      - https://dx-helper.herokuapp.com/travis
+      - http://dx-helper.herokuapp.com/travis

Changelog

@@ -1,11 +0,0 @@
-0.26.1 12/05/2011 6160246da0fafe9cf8fde188d94bbc6babc667dc
-==========================================================
-
-Merge pull request #103 from csquared/load_env_from_irb   [David Dollar]
-refactor load_env to apply_environment   [Chris Continanza]
-rename load! to load_env!   [Chris Continanza]
-use ./.env as default   [Chris Continanza]
-load contents from env file   [Chris Continanza]
-refactor engine to expose env methods   [Chris Continanza]
-disable email notifications   [David Dollar]
-add travis config   [David Dollar]

Changelog.md

@@ -0,0 +1,167 @@
+## 0.39.0 (2012-02-07)
+
+* rename bin/runner to bin/foreman-runner  [David Dollar]
+* fix tgz release  [David Dollar]
+* bundle update hpricot  [John Firebaugh]
+* touch up .pkg release tasks  [David Dollar]
+
+## 0.38.0 (2012-02-02)
+
+* bring back single process starting  [David Dollar]
+* more attempts at getting ci working with jruby  [David Dollar]
+* ignore .rbenv-version  [David Dollar]
+* force to binary encoding if supported  [David Dollar]
+
+## 0.37.2 (2012-01-29)
+
+* handle directories with spaces in runner  [David Dollar]
+* update docs  [David Dollar]
+
+## 0.37.1 (2012-01-29)
+
+* use binary pipes to better handle UTF-8 data  [David Dollar]
+* set up example procfile with UTF-8 item  [David Dollar]
+* remove autotest  [David Dollar]
+* fix up authors generation  [David Dollar]
+* fix up packaging after moving tasks  [David Dollar]
+* fix up changelog tasks  [David Dollar]
+
+## 0.37.0 (2012-01-29)
+
+* put an entire line of output inside a single mutex so we don't cross the streams  [David Dollar]
+* fix race condition with process termination  [David Dollar]
+* allow external custom exporters [Chris Lowder]
+* fix the test for an empty string in bin/runner  [Florian Apolloner]
+* ensure we have non-nil data, fixes #111  [David Dollar]
+* make sure error method exists, fixes #104  [David Dollar]
+* clean up chdir usage  [David Dollar]
+* normalize platform names  [David Dollar]
+* add windows support  [David Dollar]
+* add jruby support  [David Dollar]
+* pass basedir along to the runner script  [David Dollar]
+* harden runner script  [David Dollar]
+* add many missing specs  [brainopia]
+* clean up fakefs usage in specs  [brainopia]
+* runit creates a full path to export directory.  [Fletcher Nichol]
+
+## 0.36.1 (2012-01-18)
+
+* 0.36.1  [David Dollar]
+* bump term-ansicolor in gemspec  [David Dollar]
+
+## 0.36.0 (2012-01-17)
+
+* 0.36.0  [David Dollar]
+* sync the writer stream  [David Dollar]
+* capture stderr as well  [David Dollar]
+
+## 0.35.0 (2012-01-16)
+
+* update rake  [David Dollar]
+* 0.35.0  [David Dollar]
+* Merge pull request #132 from Viximo/feature/concurrency  [David Dollar]
+* Fix export specs  [Matt Griffin]
+* Merge branch 'master' of https://github.com/michaeldwan/foreman into feature/concurrency  [Matt Griffin]
+* default process concurrency is 0 when concurrency options specified, otherwise default concurrency is 1  [Michael Dwan]
+
+## 0.34.1 (2012-01-16)
+
+* 0.34.1  [David Dollar]
+* fix missing start desc  [David Dollar]
+
+## 0.34.0 (2012-01-16)
+
+* 0.34.0  [David Dollar]
+* update man page  [David Dollar]
+* update docs for -d  [David Dollar]
+* Merge pull request #101 from ndbroadbent/foreman  [David Dollar]
+* Wrap around to the first colour when all the colours are used  [Craig R Webster]
+* run specs in random order  [David Dollar]
+* update rspec  [David Dollar]
+* pedantry  [David Dollar]
+* Set executable bit on runit run scripts.  [Matthijs Langenberg]
+* Merge pull request #114 from gburt/master  [David Dollar]
+* add more colors  [Gabriel Burt]
+* Added option to specify app_root, if executing a Procfile from a shared location  [Nathan Broadbent]
+
+## 0.33.1 (2012-01-16)
+
+* 0.33.1  [David Dollar]
+* Merge pull request #129 from fnichol/resolve-home-template  [David Dollar]
+* Expand template path under user's home directory.  [Fletcher Nichol]
+
+## 0.33.0 (2012-01-15)
+
+* 0.33.0  [David Dollar]
+* Revert "Merge pull request #125 from brainopia/master"  [David Dollar]
+
+## 0.32.0 (2012-01-12)
+
+* 0.32.0  [David Dollar]
+* Merge pull request #125 from brainopia/master  [David Dollar]
+* Merge pull request #121 from Viximo/feature/run  [David Dollar]
+* Return some whitespace that was accidentally removed  [Matt Griffin]
+* Steal the run method back from Thor so that it can be used in place for exec for running commands in the foreman environment.  [Matt Griffin]
+* Remove old cruft  [brainopia]
+* In case someone wants to use bin/runner directly  [brainopia]
+* Fix for double fork  [brainopia]
+* Use ruby exec which works with escaped cmd and replaces shell  [brainopia]
+* Fix foreman to work with cmds containing pipes and redirects  [brainopia]
+* Add "exec" action to allow execution of arbitrary commands with the app's environment.  [Matt Griffin]
+* tweak readme  [David Dollar]
+
+## 0.31.0 (2012-01-04)
+
+* 0.31.0  [David Dollar]
+* make fork more robust  [David Dollar]
+* remove unnecessary debug  [David Dollar]
+* add more information when shutting down  [David Dollar]
+* Merge pull request #110 from lstoll/master  [David Dollar]
+* Use different port ranges for each process type  [Lincoln Stoll]
+
+## 0.30.1 (2011-12-23)
+
+* 0.30.1  [David Dollar]
+* require thread for mutex  [David Dollar]
+
+## 0.30.0 (2011-12-22)
+
+* 0.30.0  [David Dollar]
+* compatibility with ruby 1.8  [David Dollar]
+
+## 0.29.0 (2011-12-22)
+
+* 0.29.0  [David Dollar]
+* 0.28.0.pre2  [David Dollar]
+* fix pipe error  [David Dollar]
+* 0.28.0.pre1  [David Dollar]
+* Merge branch 'fork'  [David Dollar]
+* wip  [David Dollar]
+* wip  [David Dollar]
+* wip  [David Dollar]
+* wip  [David Dollar]
+* wip  [David Dollar]
+
+## 0.27.0 (2011-12-05)
+
+* 0.27.0  [David Dollar]
+* add changelog  [David Dollar]
+* Merge pull request #103 from csquared/load_env_from_irb  [David Dollar]
+* refactor load_env to apply_environment  [Chris Continanza]
+* rename load! to load_env!  [Chris Continanza]
+* use ./.env as default  [Chris Continanza]
+* load contents from env file  [Chris Continanza]
+* refactor engine to expose env methods  [Chris Continanza]
+* disable email notifications  [David Dollar]
+* add travis config  [David Dollar]
+
+## 0.26.1 2011-12-05
+
+* Merge pull request #103 from csquared/load_env_from_irb   [David Dollar]
+* refactor load_env to apply_environment   [Chris Continanza]
+* rename load! to load_env!   [Chris Continanza]
+* use ./.env as default   [Chris Continanza]
+* load contents from env file   [Chris Continanza]
+* refactor engine to expose env methods   [Chris Continanza]
+* disable email notifications   [David Dollar]
+* add travis config   [David Dollar]

Gemfile

@@ -11,13 +11,12 @@ platform :jruby do
 end
 
 group :development do
+  gem 'aws-s3'
   gem 'parka'
   gem 'rake'
   gem 'ronn'
   gem 'fakefs', '~> 0.3.2'
-  gem 'rcov',   '~> 0.9.8'
   gem 'rr',     '~> 1.0.2'
   gem 'rspec',  '~> 2.0'
-  gem 'aws-s3'
-  gem "rubyzip"
+  gem "simplecov", :require => false
 end

Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    foreman (0.37.0.pre3)
+    foreman (0.40.0)
       term-ansicolor (~> 1.0.7)
       thor (>= 0.13.6)
 
@@ -16,9 +16,10 @@ GEM
     crack (0.1.8)
     diff-lcs (1.1.3)
     fakefs (0.3.2)
-    hpricot (0.8.2)
-    hpricot (0.8.2-java)
+    hpricot (0.8.6)
+    hpricot (0.8.6-java)
     mime-types (1.16)
+    multi_json (1.0.4)
     mustache (0.11.2)
     parka (0.6.2)
       crack
@@ -26,8 +27,6 @@ GEM
       thor
     posix-spawn (0.3.6)
     rake (0.9.2.2)
-    rcov (0.9.8)
-    rcov (0.9.8-java)
     rdiscount (1.6.5)
     rest-client (1.6.1)
       mime-types (>= 1.16)
@@ -44,7 +43,10 @@ GEM
     rspec-expectations (2.8.0)
       diff-lcs (~> 1.1.2)
     rspec-mocks (2.8.0)
-    rubyzip (0.9.4)
+    simplecov (0.5.4)
+      multi_json (~> 1.0.3)
+      simplecov-html (~> 0.5.3)
+    simplecov-html (0.5.3)
     term-ansicolor (1.0.7)
     thor (0.14.6)
     win32console (1.3.0-x86-mingw32)
@@ -62,9 +64,8 @@ DEPENDENCIES
   parka
   posix-spawn (~> 0.3.6)
   rake
-  rcov (~> 0.9.8)
   ronn
   rr (~> 1.0.2)
   rspec (~> 2.0)
-  rubyzip
+  simplecov
   win32console (~> 1.3.0)

README.markdown

@@ -1,50 +0,0 @@
-# Foreman
-
-## Installation
-
-* Rubygems
-
-    gem install foreman
-
-* OSX
-
-    http://assets.foreman.io/foreman/foreman.pkg
-
-* Standalone Tarball
-
-    http://assets.foreman.io/foreman/foreman.tgz
-
-## Description
-
-http://blog.daviddollar.org/2011/05/06/introducing-foreman.html
-
-## Manual
-
-* [man page](http://ddollar.github.com/foreman)
-* [wiki](http://github.com/ddollar/foreman/wiki)
-
-## Authorship
-
-Created by David Dollar
-
-Patches contributed by:
-
-* Adam Wiggins
-* Dan Peterson
-* Hunter Nield
-* Jay Zeschin
-* Keith Rarick
-* Khaja Minhajuddin
-* Matt Haynes
-* Michael van Rooijen
-* Mike Javorski
-* Nathan L Smith
-* Nick Zadrozny
-* Ricardo Chimal, Jr
-* Thom May
-* clifff
-* Greg Reinacker
-
-## License
-
-MIT

README.md

@@ -0,0 +1,40 @@
+# Foreman
+
+Manage Procfile-based applications
+
+<table>
+  <tr>
+    <th>If you have...</th>
+    <th>Install with...</th>
+  </tr>
+  <tr>
+    <td>Ruby (MRI, JRuby, Windows)</td>
+    <td><pre>$ gem install foreman</pre></td>
+  </tr>
+  <tr>
+    <td>Mac OS X</td>
+    <td><a href="http://assets.foreman.io/foreman/foreman.pkg">foreman.pkg</a></td>
+  </tr>
+</table>
+
+## Getting Started
+
+* http://blog.daviddollar.org/2011/05/06/introducing-foreman.html
+
+## Documentation
+
+* [man page](http://ddollar.github.com/foreman)
+* [wiki](http://github.com/ddollar/foreman/wiki)
+* [changelog](https://github.com/ddollar/foreman/blob/master/Changelog.md)
+
+## Authors
+
+#### Created and maintained by
+David Dollar
+
+#### Patches contributed by
+Adam Wiggins, Chris Continanza, Chris Lowder, Craig R Webster, Dan Farina, Dan Peterson, David Dollar, Fletcher Nichol, Florian Apolloner, Gabriel Burt, Gamaliel Toro, Greg Reinacker, Hugues Le Gendre, Hunter Nield, Iain Hecker, Jay Zeschin, John Firebaugh, Keith Rarick, Khaja Minhajuddin, Lincoln Stoll, Marcos Muino Garcia, Mark McGranaghan, Matt Griffin, Matt Haynes, Matthijs Langenberg, Michael Dwan, Michael van Rooijen, Mike Javorski, Nathan Broadbent, Nathan L Smith, Nick Zadrozny, Phil Hagelberg, Ricardo Chimal, Jr, Thom May, Tom Ward, brainopia, clifff, jc00ke
+
+## License
+
+MIT

Rakefile

@@ -1,187 +1,8 @@
-require "rake"
-require "rspec"
-require "rspec/core/rake_task"
-
 $:.unshift File.expand_path("../lib", __FILE__)
 require "foreman"
 
-task :default => :spec
-task :release => :man
+require "bundler/setup"
 
-desc "Run all specs"
-RSpec::Core::RakeTask.new(:spec) do |t|
-  t.pattern = 'spec/**/*_spec.rb'
-end
-
-desc "Generate RCov code coverage report"
-task :rcov => "rcov:build" do
-  %x{ open coverage/index.html }
-end
-
-RSpec::Core::RakeTask.new("rcov:build") do |t|
-  t.pattern = 'spec/**/*_spec.rb'
-  t.rcov = true
-  t.rcov_opts = [ "--exclude", ".bundle", "--exclude", "spec" ]
-end
-
-desc 'Build the manual'
-task :man do
-  ENV['RONN_MANUAL']  = "Foreman Manual"
-  ENV['RONN_ORGANIZATION'] = "Foreman #{Foreman::VERSION}"
-  sh "ronn -w -s toc -r5 --markdown man/*.ronn"
-end
-
-desc "Commit the manual to git"
-task "man:commit" => :man do
-  sh "git add README.markdown"
-  sh "git commit -m 'update readme' || echo 'nothing to commit'"
-end
-
-desc "Generate the Github docs"
-task :pages => "man:commit" do
-  sh %{
-    cp man/foreman.1.html /tmp/foreman.1.html
-    git checkout gh-pages
-    rm ./index.html
-    cp /tmp/foreman.1.html ./index.html
-    git add -u index.html
-    git commit -m "saving man page to github docs"
-    git push origin -f gh-pages
-    git checkout master
-  }
-end
-
-## dist
-
-require "erb"
-require "fileutils"
-require "tmpdir"
-
-def assemble(source, target, perms=0644)
-  FileUtils.mkdir_p(File.dirname(target))
-  File.open(target, "w") do |f|
-    f.puts ERB.new(File.read(source)).result(binding)
-  end
-  File.chmod(perms, target)
-end
-
-def assemble_distribution(target_dir=Dir.pwd)
-  distribution_files.each do |source|
-    target = source.gsub(/^#{project_root}/, target_dir)
-    FileUtils.mkdir_p(File.dirname(target))
-    FileUtils.cp(source, target)
-  end
-end
-
-GEM_BLACKLIST = %w( bundler foreman )
-
-def assemble_gems(target_dir=Dir.pwd)
-  lines = %x{ bundle show }.strip.split("\n")
-  raise "error running bundler" unless $?.success?
-
-  %x{ env BUNDLE_WITHOUT="development:test" bundle show }.split("\n").each do |line|
-    if line =~ /^  \* (.*?) \((.*?)\)/
-      next if GEM_BLACKLIST.include?($1)
-      puts "vendoring: #{$1}-#{$2}"
-      gem_dir = %x{ bundle show #{$1} }.strip
-      FileUtils.mkdir_p "#{target_dir}/vendor/gems"
-      %x{ cp -R "#{gem_dir}" "#{target_dir}/vendor/gems" }
-    end
-  end.compact
-end
-
-def beta?
-  Foreman::VERSION.to_s =~ /pre/
-end
-
-def clean(file)
-  rm file if File.exists?(file)
-end
-
-def distribution_files(type=nil)
-  require "foreman/distribution"
-  base_files = Foreman::Distribution.files
-  type_files = type ?
-    Dir[File.expand_path("../dist/resources/#{type}/**/*", __FILE__)] :
-    []
-  base_files.concat(type_files)
-end
-
-def mkchdir(dir)
-  FileUtils.mkdir_p(dir)
-  Dir.chdir(dir) do |dir|
-    yield(File.expand_path(dir))
-  end
-end
-
-def pkg(filename)
-  File.expand_path("../pkg/#{filename}", __FILE__)
-end
-
-def project_root
-  File.dirname(__FILE__)
-end
-
-def resource(name)
-  File.expand_path("../dist/resources/#{name}", __FILE__)
-end
-
-def s3_connect
-  return if @s3_connected
-
-  require "aws/s3"
-
-  unless ENV["DAVID_RELEASE_ACCESS"] && ENV["DAVID_RELEASE_SECRET"]
-    puts "please set DAVID_RELEASE_ACCESS and DAVID_RELEASE_SECRET in your environment"
-    exit 1
-  end
-
-  AWS::S3::Base.establish_connection!(
-    :access_key_id => ENV["DAVID_RELEASE_ACCESS"],
-    :secret_access_key => ENV["DAVID_RELEASE_SECRET"]
-  )
-
-  @s3_connected = true
-end
-
-def store(package_file, filename, bucket="assets.foreman.io")
-  s3_connect
-  puts "storing: #{filename}"
-  AWS::S3::S3Object.store(filename, File.open(package_file), bucket, :access => :public_read)
-end
-
-def tempdir
-  Dir.mktmpdir do |dir|
-    Dir.chdir(dir) do
-      yield(dir)
-    end
-  end
-end
-
-def version
-  require "foreman/version"
-  Foreman::VERSION
-end
-
-Dir[File.expand_path("../dist/**/*.rake", __FILE__)].each do |rake|
-  import rake
-end
-
-task :changelog do
-  timestamp = Time.now.utc.strftime('%m/%d/%Y')
-  sha = `git log | head -1`.split(' ').last
-  changelog = ["#{version} #{timestamp} #{sha}"]
-  changelog << ('=' * changelog[0].length)
-  changelog << ''
-
-  last_sha = `cat Changelog | head -1`.split(' ').last
-  shortlog = `git log #{last_sha}..HEAD --pretty=format:'%s   [%an]'`
-  changelog << shortlog.split("\n")
-  changelog.concat ['', '', '']
-
-  old_changelog = File.read('Changelog')
-  File.open('Changelog', 'w') do |file|
-    file.write(changelog.join("\n"))
-    file.write(old_changelog)
-  end
+Dir[File.expand_path("../tasks/*.rake", __FILE__)].each do |task|
+  load task
 end

autotest/discover.rb

@@ -1 +0,0 @@
-Autotest.add_discovery { "rspec2" }

bin/foreman-runner

@@ -1,6 +1,6 @@
 #!/bin/sh
 #
-#/ Usage: runner [-d <dir>] <command>
+#/ Usage: foreman-runner [-d <dir>] <command>
 #/
 #/ Run a command with exec, optionally changing directory first
 
@@ -18,7 +18,7 @@ usage() {
 
 while getopts ":hd:" OPT; do
   case $OPT in
-     d) cd $OPTARG ;;
+     d) cd "$OPTARG" ;;
      h) usage ;;
     \?) error "invalid option: -$OPTARG" ;;
      :) error "option -$OPTARG requires an argument" ;;
@@ -29,7 +29,7 @@ shift $((OPTIND-1))
 
 command=$1
 
-if [ "$1" == "" ]; then
+if [ -z "$1" ]; then
   usage
 fi
 

data/example/Procfile

@@ -1,2 +1,3 @@
 ticker: ruby ./ticker $PORT
 error:  ruby ./error
+utf8:   ruby ./utf8

data/example/utf8

@@ -0,0 +1,11 @@
+#!/usr/bin/env ruby
+# encoding: BINARY
+
+$stdout.sync = true
+
+while true
+  puts "\u65e5\u672c\u8a9e\u6587\u5b57\u5217"
+  puts "\u0915\u0932\u094d\u0907\u0928\u0643\u0637\u0628\u041a\u0430\u043b\u0438\u043d\u0430"
+  puts "\xff\x03"
+  sleep 1
+end

data/export/bluepill/master.pill.erb

@@ -5,7 +5,7 @@ Bluepill.application("<%= app %>", :foreground => false, :log_file => "/var/log/
 
 <% engine.procfile.entries.each do |process| %>
 <% 1.upto(concurrency[process.name]) do |num| %>
-<% port = engine.port_for(process, num, options[:port]) %>
+<% port = engine.port_for(process, num, self.port) %>
   app.process("<%= process.name %>-<%=num%>") do |process|
     process.start_command = "<%= process.command.gsub("$PORT", port.to_s) %>"
 

dist/deb.rake

@@ -4,7 +4,7 @@ file pkg("/apt-#{version}/foreman-#{version}.deb") => distribution_files("deb")
       assemble_distribution
       assemble_gems
       assemble resource("deb/foreman"), "bin/foreman", 0755
-      File.chmod 0755, "bin/runner"
+      File.chmod 0755, "bin/foreman-runner"
     end
 
     assemble resource("deb/control"), "control"
@@ -20,12 +20,6 @@ file pkg("/apt-#{version}/foreman-#{version}.deb") => distribution_files("deb")
     deb = File.basename(t.name)
 
     sh "ar -r #{t.name} debian-binary control.tar.gz data.tar.gz"
-
-    touch "Sources"
-    sh "apt-ftparchive packages . > Packages"
-    sh "gzip -c Packages > Packages.gz"
-    sh "apt-ftparchive release . > Release"
-    sh "gpg -abs -u 0F1B0520 -o Release.gpg Release"
   end
 end
 
@@ -37,12 +31,3 @@ task "deb:clean" do
   clean pkg("foreman-#{version}.deb")
   FileUtils.rm_rf("pkg/apt-#{version}") if Dir.exists?("pkg/apt-#{version}")
 end
-
-desc "Publish .deb to S3."
-task "deb:release" => "deb:build" do |t|
-  Dir["pkg/apt-#{version}/*"].each do |file|
-    unless File.directory?(file)
-      store file, "apt/#{File.basename(file)}"
-    end
-  end
-end

dist/jruby.rake

@@ -1,5 +1,7 @@
 file pkg("foreman-#{version}-jruby.gem") => distribution_files do |t|
-  sh "env PLATFORM=java gem build foreman.gemspec"
+  Bundler.with_clean_env do
+    sh "env PLATFORM=java gem build foreman.gemspec"
+  end
   sh "mv foreman-#{version}-java.gem #{t.name}"
 end
 

dist/mingw32.rake

@@ -1,5 +1,7 @@
 file pkg("foreman-#{version}-mingw32.gem") => distribution_files do |t|
-  sh "env PLATFORM=mingw32 gem build foreman.gemspec"
+  Bundler.with_clean_env do
+    sh "env PLATFORM=mingw32 gem build foreman.gemspec"
+  end
   sh "mv foreman-#{version}-mingw32.gem #{t.name}"
 end
 

dist/pkg.rake

@@ -13,7 +13,7 @@ file pkg("foreman-#{version}.pkg") => distribution_files do |t|
 
     mkdir_p "pkg"
     mkdir_p "pkg/Resources"
-    mkdir_p "pkg/foreman-#{version}.pkg"
+    mkdir_p "pkg/foreman.pkg"
 
     dist = File.read(resource("pkg/Distribution.erb"))
     dist = ERB.new(dist).result(binding)
@@ -21,20 +21,21 @@ file pkg("foreman-#{version}.pkg") => distribution_files do |t|
 
     dist = File.read(resource("pkg/PackageInfo.erb"))
     dist = ERB.new(dist).result(binding)
-    File.open("pkg/foreman-#{version}.pkg/PackageInfo", "w") { |f| f.puts dist }
+    File.open("pkg/foreman.pkg/PackageInfo", "w") { |f| f.puts dist }
 
-    mkdir_p "pkg/foreman-#{version}.pkg/Scripts"
-    cp resource("pkg/postinstall"), "pkg/foreman-#{version}.pkg/Scripts/postinstall"
-    chmod 0755, "pkg/foreman-#{version}.pkg/Scripts/postinstall"
+    mkdir_p "pkg/foreman.pkg/Scripts"
+    cp resource("pkg/postinstall"), "pkg/foreman.pkg/Scripts/postinstall"
+    chmod 0755, "pkg/foreman.pkg/Scripts/postinstall"
 
-    sh %{ mkbom -s foreman pkg/foreman-#{version}.pkg/Bom }
+    sh %{ mkbom -s foreman pkg/foreman.pkg/Bom }
 
     Dir.chdir("foreman") do
-      sh %{ pax -wz -x cpio . > ../pkg/foreman-#{version}.pkg/Payload }
+      sh %{ pax -wz -x cpio . > ../pkg/foreman.pkg/Payload }
     end
 
     sh %{ pkgutil --flatten pkg foreman-#{version}.pkg }
 
+    FileUtils.mkdir_p(File.dirname(t.name))
     cp_r "foreman-#{version}.pkg", t.name
   end
 end

dist/resources/pkg/Distribution.erb

@@ -10,14 +10,14 @@
   ]]></script>
   <choices-outline>
     <line choice="git"/>
-    <line choice="foreman-<%= version %>"/>
+    <line choice="foreman"/>
   </choices-outline>
   <choice id="git" title="git" start_selected="false" start_enabled="false" selected="needs_git()" enabled="needs_git()">
     <pkg-ref id="git.pkg" />
   </choice>
-  <choice id="foreman-<%= version %>" title="foreman">
+  <choice id="foreman" title="foreman">
     <pkg-ref id="io.foreman.installer"/>
   </choice>
-  <pkg-ref id="io.foreman.installer" installKBytes="<%= kbytes %>" version="<%= version %>" auth="Root">#foreman-<%= version %>.pkg</pkg-ref>
+  <pkg-ref id="io.foreman.installer" installKBytes="<%= kbytes %>" version="<%= version %>" auth="Root">#foreman.pkg</pkg-ref>
 </installer-script>
 

dist/resources/pkg/PackageInfo.erb

@@ -4,4 +4,3 @@
     <postinstall file="./postinstall"/>
   </scripts>
 </pkg-info>
-

dist/tgz.rake

@@ -3,7 +3,7 @@ file pkg("foreman-#{version}.tgz") => distribution_files do |t|
     mkchdir("foreman") do
       assemble_distribution
       assemble_gems
-      rm_rf "bin"
+      rm_f "bin/foreman"
       assemble resource("tgz/foreman"), "foreman", 0755
     end
 

lib/foreman.rb

@@ -4,14 +4,8 @@ module Foreman
 
   class AppDoesNotExist < Exception; end
 
-  # load contents of env_file into ENV
-  def self.load_env!(env_file = './.env')
-    require 'foreman/engine'
-    Foreman::Engine.load_env!(env_file)
-  end
-
   def self.runner
-    File.expand_path("../../bin/runner", __FILE__)
+    File.expand_path("../../bin/foreman-runner", __FILE__)
   end
 
   def self.jruby?

lib/foreman/cli.rb

@@ -1,12 +1,16 @@
 require "foreman"
+require "foreman/helpers"
 require "foreman/engine"
 require "foreman/export"
 require "thor"
 require "yaml"
 
 class Foreman::CLI < Thor
+  include Foreman::Helpers
 
-  desc "start", "Start the application"
+  class_option :procfile, :type => :string, :aliases => "-f", :desc => "Default: Procfile"
+
+  desc "start [PROCESS]", "Start the application (or a specific PROCESS)"
 
   class_option :procfile, :type => :string, :aliases => "-f", :desc => "Default: Procfile"
   class_option :app_root, :type => :string, :aliases => "-d", :desc => "Default: Procfile directory"
@@ -23,8 +27,9 @@ class Foreman::CLI < Thor
     end
   end
 
-  def start
+  def start(process=nil)
     check_procfile!
+    engine.options[:concurrency] = "#{process}=1" if process
     engine.start
   end
 
@@ -36,22 +41,12 @@ class Foreman::CLI < Thor
   method_option :port,        :type => :numeric, :aliases => "-p"
   method_option :user,        :type => :string,  :aliases => "-u"
   method_option :template,    :type => :string,  :aliases => "-t"
-  method_option :concurrency, :type => :string,  :aliases => "-c",
-    :banner => '"alpha=5,bar=3"'
+  method_option :concurrency, :type => :string,  :aliases => "-c", :banner => '"alpha=5,bar=3"'
 
   def export(format, location=nil)
     check_procfile!
-
-    formatter = case format
-      when "inittab" then Foreman::Export::Inittab
-      when "upstart" then Foreman::Export::Upstart
-      when "bluepill" then Foreman::Export::Bluepill
-      when "runit"    then Foreman::Export::Runit
-      else error "Unknown export format: #{format}."
-    end
-
-    formatter.new(engine).export(location, options)
-
+    formatter = Foreman::Export.formatter(format)
+    formatter.new(location, engine, options).export
   rescue Foreman::Export::Exception => ex
     error ex.message
   end
@@ -59,8 +54,9 @@ class Foreman::CLI < Thor
   desc "check", "Validate your application's Procfile"
 
   def check
+    check_procfile!
     error "no processes defined" unless engine.procfile.entries.length > 0
-    display "valid procfile detected (#{engine.procfile.process_names.join(', ')})"
+    puts "valid procfile detected (#{engine.procfile.process_names.join(', ')})"
   end
 
   desc "run COMMAND", "Run a command using your application's environment"
@@ -90,19 +86,11 @@ private ######################################################################
     options[:procfile] || "Procfile"
   end
 
-  def display(message)
-    puts message
-  end
-
   def error(message)
     puts "ERROR: #{message}"
     exit 1
   end
 
-  def procfile_exists?(procfile)
-    File.exist?(procfile)
-  end
-
   def options
     original_options = super
     return original_options unless File.exists?(".foreman")

lib/foreman/engine.rb

@@ -10,6 +10,7 @@ require "thread"
 
 class Foreman::Engine
 
+  attr_reader :environment
   attr_reader :procfile
   attr_reader :directory
   attr_reader :options
@@ -23,16 +24,11 @@ class Foreman::Engine
   def initialize(procfile, options={})
     @procfile  = Foreman::Procfile.new(procfile)
     @directory = options[:app_root] || File.expand_path(File.dirname(procfile))
-    @options = options
+    @options = options.dup
     @environment = read_environment_files(options[:env])
     @output_mutex = Mutex.new
   end
 
-  def self.load_env!(env_file)
-    @environment = read_environment_files(env_file)
-    apply_environment!
-  end
-
   def start
     proctitle "ruby: foreman master"
     termtitle "#{File.basename(@directory)} - foreman"
@@ -52,13 +48,17 @@ class Foreman::Engine
     base_port.to_i + offset + num - 1
   end
 
+  def apply_environment!
+    environment.each { |k,v| ENV[k] = v }
+  end
+
 private ######################################################################
 
   def spawn_processes
     concurrency = Foreman::Utils.parse_concurrency(@options[:concurrency])
 
     procfile.entries.each do |entry|
-      reader, writer = IO.pipe
+      reader, writer = (IO.method(:pipe).arity == 0 ? IO.pipe : IO.pipe("BINARY"))
       entry.spawn(concurrency[entry.name], writer, @directory, @environment, port_for(entry, 1, base_port)).each do |process|
         running_processes[process.pid] = process
         readers[process] = reader
@@ -73,30 +73,45 @@ private ######################################################################
   def kill_all(signal="SIGTERM")
     running_processes.each do |pid, process|
       info "sending #{signal} to pid #{pid}"
-      Process.kill(signal, pid) rescue Errno::ESRCH
+      process.kill signal
     end
   end
 
   def terminate_gracefully
+    return if @terminating
+    @terminating = true
     info "sending SIGTERM to all processes"
     kill_all "SIGTERM"
-    Timeout.timeout(5) { Process.waitall }
+    Timeout.timeout(5) do
+      while running_processes.length > 0
+        pid, status = Process.wait2
+        process = running_processes.delete(pid)
+        info "process terminated", process.name
+      end
+    end
   rescue Timeout::Error
     info "sending SIGKILL to all processes"
     kill_all "SIGKILL"
   end
 
+  def poll_readers
+    rs, ws = IO.select(readers.values, [], [], 1)
+    (rs || []).each do |r|
+      data = r.gets
+      next unless data
+      data.force_encoding("BINARY") if data.respond_to?(:force_encoding)
+      ps, message = data.split(",", 2)
+      color = colors[ps.split(".").first]
+      info message, ps, color
+    end
+  end
+
   def watch_for_output
     Thread.new do
       require "win32console" if Foreman.windows?
       begin
         loop do
-          rs, ws = IO.select(readers.values, [], [], 1)
-          (rs || []).each do |r|
-            ps, message = r.gets.split(",", 2)
-            color = colors[ps.split(".").first]
-            info message, ps, color
-          end
+          poll_readers
         end
       rescue Exception => ex
         puts ex.message
@@ -110,16 +125,16 @@ private ######################################################################
     process = running_processes.delete(pid)
     info "process terminated", process.name
     terminate_gracefully
-    kill_all
   rescue Errno::ECHILD
   end
 
   def info(message, name="system", color=Term::ANSIColor.white)
-    print color
-    print "#{Time.now.strftime("%H:%M:%S")} #{pad_process_name(name)} | "
-    print Term::ANSIColor.reset
-    print message.chomp
-    puts ""
+    output  = ""
+    output += color
+    output += "#{Time.now.strftime("%H:%M:%S")} #{pad_process_name(name)} | "
+    output += Term::ANSIColor.reset
+    output += message.chomp
+    puts output
   end
 
   def print(message=nil)
@@ -134,11 +149,6 @@ private ######################################################################
     end
   end
 
-  def error(message)
-    puts "ERROR: #{message}"
-    exit 1
-  end
-
   def longest_process_name
     @longest_process_name ||= begin
       longest = procfile.process_names.map { |name| name.length }.sort.last
@@ -188,37 +198,31 @@ private ######################################################################
     COLORS[@current_color]
   end
 
-  module Env
-    attr_reader :environment
+  def read_environment_files(filenames)
+    environment = {}
 
-    def read_environment_files(filenames)
-      environment = {}
-
-      (filenames || "").split(",").map(&:strip).each do |filename|
-        error "No such file: #{filename}" unless File.exists?(filename)
-        environment.merge!(read_environment(filename))
-      end
-
-      environment.merge!(read_environment(".env")) unless filenames
-      environment
+    (filenames || "").split(",").map(&:strip).each do |filename|
+      error "No such file: #{filename}" unless File.exists?(filename)
+      environment.merge!(read_environment(filename))
     end
 
-    def read_environment(filename)
-      return {} unless File.exists?(filename)
-
-      File.read(filename).split("\n").inject({}) do |hash, line|
-        if line =~ /\A([A-Za-z_0-9]+)=(.*)\z/
-          hash[$1] = $2
-        end
-        hash
-      end
-    end
-
-    def apply_environment!
-      @environment.each { |k,v| ENV[k] = v }
-    end
+    environment.merge!(read_environment(".env")) unless filenames
+    environment
   end
 
-  include Env
-  extend  Env
+  def read_environment(filename)
+    return {} unless File.exists?(filename)
+
+    File.read(filename).split("\n").inject({}) do |hash, line|
+      if line =~ /\A([A-Za-z_0-9]+)=(.*)\z/
+        key, val = [$1, $2]
+        case val
+          when /\A'(.*)'\z/ then hash[key] = $1
+          when /\A"(.*)"\z/ then hash[key] = $1.gsub(/\\(.)/, '\1')
+          else hash[key] = val
+        end
+      end
+      hash
+    end
+  end
 end

lib/foreman/export.rb

@@ -1,9 +1,30 @@
 require "foreman"
+require "foreman/helpers"
 
 module Foreman::Export
+  extend Foreman::Helpers
+
   class Exception < ::Exception; end
+
+  def self.formatter(format)
+    begin
+      require "foreman/export/#{ format.tr('-', '_') }"
+      classy_format = classify(format)
+      formatter     = constantize("Foreman::Export::#{ classy_format }")
+    rescue NameError => ex
+      error "Unknown export format: #{format} (no class Foreman::Export::#{ classy_format })."
+    rescue LoadError => ex
+      error "Unknown export format: #{format} (unable to load file 'foreman/export/#{ format.tr('-', '_') }')."
+    end
+  end
+
+  def self.error(message)
+    raise Foreman::Export::Exception.new(message)
+  end
+
 end
 
+
 require "foreman/export/base"
 require "foreman/export/inittab"
 require "foreman/export/upstart"

lib/foreman/export/base.rb

@@ -3,10 +3,17 @@ require "foreman/utils"
 
 class Foreman::Export::Base
 
-  attr_reader :engine
+  attr_reader :location, :engine, :app, :log, :port, :user, :template, :concurrency
 
-  def initialize(engine)
-    @engine = engine
+  def initialize(location, engine, options={})
+    @location    = location
+    @engine      = engine
+    @app         = options[:app]
+    @log         = options[:log]
+    @port        = options[:port]
+    @user        = options[:user]
+    @template    = options[:template]
+    @concurrency = Foreman::Utils.parse_concurrency(options[:concurrency])
   end
 
   def export

lib/foreman/export/bluepill.rb

@@ -3,23 +3,21 @@ require "foreman/export"
 
 class Foreman::Export::Bluepill < Foreman::Export::Base
 
-  def export(location, options={})
+  def export
     error("Must specify a location") unless location
 
     FileUtils.mkdir_p location
 
-    app = options[:app] || File.basename(engine.directory)
-    user = options[:user] || app
-    log_root = options[:log] || "/var/log/#{app}"
-    template_root = options[:template]
+    app = self.app || File.basename(engine.directory)
+    user = self.user || app
+    log_root = self.log || "/var/log/#{app}"
+    template_root = self.template
 
     Dir["#{location}/#{app}.pill"].each do |file|
       say "cleaning up: #{file}"
       FileUtils.rm(file)
     end
 
-    concurrency = Foreman::Utils.parse_concurrency(options[:concurrency])
-
     master_template = export_template("bluepill", "master.pill.erb", template_root)
     master_config   = ERB.new(master_template).result(binding)
     write_file "#{location}/#{app}.pill", master_config

lib/foreman/export/inittab.rb

@@ -2,20 +2,18 @@ require "foreman/export"
 
 class Foreman::Export::Inittab < Foreman::Export::Base
 
-  def export(fname=nil, options={})
-    app = options[:app] || File.basename(engine.directory)
-    user = options[:user] || app
-    log_root = options[:log] || "/var/log/#{app}"
-
-    concurrency = Foreman::Utils.parse_concurrency(options[:concurrency])
+  def export
+    app = self.app || File.basename(engine.directory)
+    user = self.user || app
+    log_root = self.log || "/var/log/#{app}"
 
     inittab = []
     inittab << "# ----- foreman #{app} processes -----"
 
     engine.procfile.entries.inject(1) do |index, process|
-      1.upto(concurrency[process.name]) do |num|
+      1.upto(self.concurrency[process.name]) do |num|
         id = app.slice(0, 2).upcase + sprintf("%02d", index)
-        port = engine.port_for(process, num, options[:port])
+        port = engine.port_for(process, num, self.port)
         inittab << "#{id}:4:respawn:/bin/su - #{user} -c 'PORT=#{port} #{process.command} >> #{log_root}/#{process.name}-#{num}.log 2>&1'"
         index += 1
       end
@@ -26,12 +24,12 @@ class Foreman::Export::Inittab < Foreman::Export::Base
 
     inittab = inittab.join("\n") + "\n"
 
-    if fname
+    if location == "-"
+      puts inittab
+    else
       FileUtils.mkdir_p(log_root) rescue error "could not create #{log_root}"
       FileUtils.chown(user, nil, log_root) rescue error "could not chown #{log_root} to #{user}"
-      write_file(fname, inittab)
-    else
-      puts inittab
+      write_file(location, inittab)
     end
   end
 

lib/foreman/export/runit.rb

@@ -4,21 +4,19 @@ require "foreman/export"
 class Foreman::Export::Runit < Foreman::Export::Base
   ENV_VARIABLE_REGEX = /([a-zA-Z_]+[a-zA-Z0-9_]*)=(\S+)/
 
-  def export(location, options={})
+  def export
     error("Must specify a location") unless location
 
-    app = options[:app] || File.basename(engine.directory)
-    user = options[:user] || app
-    log_root = options[:log] || "/var/log/#{app}"
-    template_root = options[:template]
-
-    concurrency = Foreman::Utils.parse_concurrency(options[:concurrency])
+    app = self.app || File.basename(engine.directory)
+    user = self.user || app
+    log_root = self.log || "/var/log/#{app}"
+    template_root = self.template
 
     run_template = export_template('runit', 'run.erb', template_root)
     log_run_template = export_template('runit', 'log_run.erb', template_root)
 
     engine.procfile.entries.each do |process|
-      1.upto(concurrency[process.name]) do |num|
+      1.upto(self.concurrency[process.name]) do |num|
         process_directory     = "#{location}/#{app}-#{process.name}-#{num}"
         process_env_directory = "#{process_directory}/env"
         process_log_directory = "#{process_directory}/log"
@@ -31,7 +29,7 @@ class Foreman::Export::Runit < Foreman::Export::Base
         write_file "#{process_directory}/run", run
         FileUtils.chmod 0755, "#{process_directory}/run"
 
-        port = engine.port_for(process, num, options[:port])
+        port = engine.port_for(process, num, self.port)
         environment_variables = {'PORT' => port}.
             merge(engine.environment).
             merge(inline_variables(process.command))
@@ -51,7 +49,7 @@ class Foreman::Export::Runit < Foreman::Export::Base
   private
   def create_directory(location)
     say "creating: #{location}"
-    FileUtils.mkdir(location)
+    FileUtils.mkdir_p(location)
   end
 
   def inline_variables(command)

lib/foreman/export/upstart.rb

@@ -3,23 +3,21 @@ require "foreman/export"
 
 class Foreman::Export::Upstart < Foreman::Export::Base
 
-  def export(location, options={})
+  def export
     error("Must specify a location") unless location
 
     FileUtils.mkdir_p location
 
-    app = options[:app] || File.basename(engine.directory)
-    user = options[:user] || app
-    log_root = options[:log] || "/var/log/#{app}"
-    template_root = options[:template]
+    app = self.app || File.basename(engine.directory)
+    user = self.user || app
+    log_root = self.log || "/var/log/#{app}"
+    template_root = self.template
 
     Dir["#{location}/#{app}*.conf"].each do |file|
       say "cleaning up: #{file}"
       FileUtils.rm(file)
     end
 
-    concurrency = Foreman::Utils.parse_concurrency(options[:concurrency])
-
     master_template = export_template("upstart", "master.conf.erb", template_root)
     master_config   = ERB.new(master_template).result(binding)
     write_file "#{location}/#{app}.conf", master_config
@@ -27,13 +25,13 @@ class Foreman::Export::Upstart < Foreman::Export::Base
     process_template = export_template("upstart", "process.conf.erb", template_root)
 
     engine.procfile.entries.each do |process|
-      next if (conc = concurrency[process.name]) < 1
+      next if (conc = self.concurrency[process.name]) < 1
       process_master_template = export_template("upstart", "process_master.conf.erb", template_root)
       process_master_config   = ERB.new(process_master_template).result(binding)
       write_file "#{location}/#{app}-#{process.name}.conf", process_master_config
 
-      1.upto(concurrency[process.name]) do |num|
-        port = engine.port_for(process, num, options[:port])
+      1.upto(self.concurrency[process.name]) do |num|
+        port = engine.port_for(process, num, self.port)
         process_config = ERB.new(process_template).result(binding)
         write_file "#{location}/#{app}-#{process.name}-#{num}.conf", process_config
       end

lib/foreman/helpers.rb

@@ -0,0 +1,45 @@
+module Foreman::Helpers
+  # Copied whole sale from, https://github.com/defunkt/resque/
+
+  # Given a word with dashes, returns a camel cased version of it.
+  #
+  # classify('job-name') # => 'JobName'
+  def classify(dashed_word)
+    dashed_word.split('-').each { |part| part[0] = part[0].chr.upcase }.join
+  end  # Tries to find a constant with the name specified in the argument string:
+
+  #
+  # constantize("Module") # => Module
+  # constantize("Test::Unit") # => Test::Unit
+  #
+  # The name is assumed to be the one of a top-level constant, no matter
+  # whether it starts with "::" or not. No lexical context is taken into
+  # account:
+  #
+  # C = 'outside'
+  # module M
+  #   C = 'inside'
+  #   C # => 'inside'
+  #   constantize("C") # => 'outside', same as ::C
+  # end
+  #
+  # NameError is raised when the constant is unknown.
+  def constantize(camel_cased_word)
+    camel_cased_word = camel_cased_word.to_s
+
+    names = camel_cased_word.split('::')
+    names.shift if names.empty? || names.first.empty?
+
+    constant = Object
+    names.each do |name|
+      args = Module.method(:const_get).arity != 1 ? [false] : []
+
+      if constant.const_defined?(name, *args)
+        constant = constant.const_get(name)
+      else
+        constant = constant.const_missing(name)
+      end
+    end
+    constant
+  end
+end

lib/foreman/process.rb

@@ -24,6 +24,24 @@ class Foreman::Process
     "%s.%s" % [ entry.name, num ]
   end
 
+  def kill(signal)
+    pid && Process.kill(signal, pid)
+  rescue Errno::ESRCH
+    false
+  end
+
+  def detach
+    pid && Process.detach(pid)
+  end
+
+  def alive?
+    kill(0)
+  end
+
+  def dead?
+    !alive?
+  end
+
 private
 
   def fork_with_io(command, basedir)
@@ -45,7 +63,7 @@ private
         $stderr.reopen writer
         reader.close
         exec Foreman.runner, "-d", basedir, command
-     end
+      end
     end
     [ reader, pid ]
   end
@@ -69,12 +87,10 @@ private
   end
 
   def with_environment(environment)
-    old_env = ENV.each_pair.inject({}) { |h,(k,v)| h.update(k => v) }
-    environment.each { |k,v| ENV[k] = v }
-    ret = yield
-    ENV.clear
-    old_env.each { |k,v| ENV[k] = v}
-    ret
+    original = ENV.to_hash
+    ENV.update environment
+    yield
+  ensure
+    ENV.replace original
   end
-
 end

lib/foreman/version.rb

@@ -1,5 +1,5 @@
 module Foreman
 
-  VERSION = "0.37.0.pre3"
+  VERSION = "0.40.0"
 
 end

man/foreman.1

@@ -1,7 +1,7 @@
 .\" generated with Ronn/v0.7.3
 .\" http://github.com/rtomayko/ronn/tree/0.7.3
 .
-.TH "FOREMAN" "1" "January 2012" "Foreman 0.33.1" "Foreman Manual"
+.TH "FOREMAN" "1" "February 2012" "Foreman 0.39.0" "Foreman Manual"
 .
 .SH "NAME"
 \fBforeman\fR \- manage Procfile\-based applications
@@ -10,10 +10,13 @@
 \fBforeman start [process]\fR
 .
 .br
+\fBforeman run <command>\fR
+.
+.br
 \fBforeman export <format> [location]\fR
 .
 .SH "DESCRIPTION"
-\fBForeman\fR is a manager for Procfile\-based applications\. Its aim is to abstract away the details of the Procfile format, and allow you to either run your application directly or export it to some other process management format\.
+Foreman is a manager for Procfile\-based applications\. Its aim is to abstract away the details of the Procfile format, and allow you to either run your application directly or export it to some other process management format\.
 .
 .SH "RUNNING"
 \fBforeman start\fR is used to run your application directly from the command line\.
@@ -35,6 +38,9 @@ Specify the number of each process type to run\. The value passed in should be i
 \fB\-p\fR, \fB\-\-port\fR
 Specify which port to use as the base for this application\. Should be a multiple of 1000\.
 .
+.P
+\fBforeman run\fR is used to run one\-off commands using the same environment as your defined processes\.
+.
 .SH "EXPORTING"
 \fBforeman export\fR is used to export your application to another process management format\.
 .
@@ -61,10 +67,14 @@ Specify the directory to place process logs in\.
 Specify which port to use as the base for this application\. Should be a multiple of 1000\.
 .
 .TP
+\fB\-t\fR, \fB\-\-template\fR
+Specify an alternate template to use for creating export files\. See \fIhttps://github\.com/ddollar/foreman/tree/master/data/export\fR for examples\.
+.
+.TP
 \fB\-u\fR, \fB\-\-user\fR
 Specify the user the application should be run as\. Defaults to the app name
 .
-.SH "OPTIONS"
+.SH "GLOBAL OPTIONS"
 These options control all modes of foreman\'s operation\.
 .
 .TP

man/foreman.1.ronn

@@ -4,11 +4,12 @@ foreman(1) -- manage Procfile-based applications
 ## SYNOPSIS
 
 `foreman start [process]`<br>
+`foreman run <command>`<br>
 `foreman export <format> [location]`
 
 ## DESCRIPTION
 
-**Foreman** is a manager for Procfile-based applications. Its aim is to
+Foreman is a manager for Procfile-based applications. Its aim is to
 abstract away the details of the Procfile format, and allow you to either run
 your application directly or export it to some other process management
 format.
@@ -33,6 +34,9 @@ The following options control how the application is run:
     Specify which port to use as the base for this application. Should be
     a multiple of 1000.
 
+`foreman run` is used to run one-off commands using the same environment
+as your defined processes.
+
 ## EXPORTING
 
 `foreman export` is used to export your application to another process
@@ -58,11 +62,15 @@ The following options control how the application is run:
     Specify which port to use as the base for this application. Should be
     a multiple of 1000.
 
+  * `-t`, `--template`:
+    Specify an alternate template to use for creating export files.
+    See <https://github.com/ddollar/foreman/tree/master/data/export> for examples.
+
   * `-u`, `--user`:
     Specify the user the application should be run as. Defaults to the
     app name
 
-## OPTIONS
+## GLOBAL OPTIONS
 
 These options control all modes of foreman's operation.
 

spec/foreman/cli_spec.rb

@@ -1,8 +1,10 @@
 require "spec_helper"
 require "foreman/cli"
 
-describe "Foreman::CLI" do
+describe "Foreman::CLI", :fakefs do
   subject { Foreman::CLI.new }
+  let(:engine) { subject.send(:engine) }
+  let(:entries) { engine.procfile.entries.inject({}) { |h,e| h.update(e.name => e) } }
 
   describe "start" do
     describe "with a non-existent Procfile" do
@@ -22,15 +24,35 @@ describe "Foreman::CLI" do
         mock.instance_of(Foreman::Engine).start
         subject.start
       end
+
+      it "can run a single process" do
+        dont_allow(subject).error
+        stub(engine).watch_for_output
+        stub(engine).watch_for_termination
+        mock(entries["alpha"]).spawn(1, is_a(IO), engine.directory, {}, 5000) { [] }
+        mock(entries["bravo"]).spawn(0, is_a(IO), engine.directory, {}, 5100) { [] }
+        subject.start("alpha")
+      end
     end
   end
 
   describe "export" do
     describe "options" do
+      it "uses .foreman" do
+        write_procfile
+        File.open(".foreman", "w") { |f| f.puts "concurrency: alpha=2" }
+        mock_export = mock(Foreman::Export::Upstart)
+        mock(Foreman::Export::Upstart).new("/upstart", is_a(Foreman::Engine), { "concurrency" => "alpha=2" }) { mock_export }
+        mock_export.export
+        foreman %{ export upstart /upstart }
+      end
+
       it "respects --env" do
         write_procfile
         write_env("envfile")
-        mock.instance_of(Foreman::Export::Upstart).export("/upstart", { "env" => "envfile" })
+        mock_export = mock(Foreman::Export::Upstart)
+        mock(Foreman::Export::Upstart).new("/upstart", is_a(Foreman::Engine), { "env" => "envfile" }) { mock_export }
+        mock_export.export
         foreman %{ export upstart /upstart --env envfile }
       end
     end
@@ -47,10 +69,18 @@ describe "Foreman::CLI" do
     describe "with a Procfile" do
       before(:each) { write_procfile }
 
-      describe "with an invalid formatter" do
+      describe "with a formatter with a generic error" do
+        before do
+          mock(Foreman::Export).formatter("errorful") { Class.new(Foreman::Export::Base) do
+            def export
+              raise Foreman::Export::Exception.new("foo")
+            end
+          end }
+        end
+
         it "prints an error" do
-          mock_error(subject, "Unknown export format: invalidformatter.") do
-            subject.export("invalidformatter")
+          mock_error(subject, "foo") do
+            subject.export("errorful")
           end
         end
       end
@@ -60,7 +90,9 @@ describe "Foreman::CLI" do
 
         it "runs successfully" do
           dont_allow(subject).error
-          mock.instance_of(Foreman::Export::Upstart).export("/tmp/foo", {})
+          mock_export = mock(Foreman::Export::Upstart)
+          mock(Foreman::Export::Upstart).new("/tmp/foo", is_a(Foreman::Engine), {}) { mock_export }
+          mock_export.export
           subject.export("upstart", "/tmp/foo")
         end
       end
@@ -72,7 +104,7 @@ describe "Foreman::CLI" do
       before { write_procfile }
 
       it "displays the jobs" do
-        mock(subject).display("valid procfile detected (alpha, bravo)")
+        mock(subject).puts("valid procfile detected (alpha, bravo)")
         subject.check
       end
     end
@@ -88,48 +120,56 @@ describe "Foreman::CLI" do
         end
       end
     end
+
+    describe "without a Procfile" do
+      it "displays an error" do
+        mock_error(subject, "Procfile does not exist.") do
+          subject.check
+        end
+      end
+    end
   end
-  
+
   describe "run" do
     describe "with a valid Procfile" do
       before { write_procfile }
 
       describe "and a command" do
         let(:command) { ["ls", "-l"] }
-        
+
         before(:each) do
           stub(subject).exec
         end
-        
+
         it "should load the environment file" do
           write_env
           preserving_env do
             subject.run *command
             ENV["FOO"].should == "bar"
           end
-          
+
           ENV["FOO"].should be_nil
         end
-        
+
         it "should runute the command as a string" do
           mock(subject).exec(command.join(" "))
           subject.run *command
         end
       end
-      
+
       describe "and a non-existent command" do
         let(:command) { "iuhtngrglhulhdfg" }
-        
+
         it "should print an error" do
           mock_error(subject, "command not found: #{command}") do
             subject.run command
           end
         end
       end
-      
+
       describe "and a non-executable command" do
         let(:command) { __FILE__ }
-        
+
         it "should print an error" do
           mock_error(subject, "not executable: #{command}") do
             subject.run command

spec/foreman/engine_spec.rb

@@ -1,9 +1,16 @@
 require "spec_helper"
 require "foreman/engine"
 
-describe "Foreman::Engine" do
+describe "Foreman::Engine", :fakefs do
   subject { Foreman::Engine.new("Procfile", {}) }
 
+  before do
+    any_instance_of(Foreman::Engine) do |engine|
+      stub(engine).proctitle
+      stub(engine).termtitle
+    end
+  end
+
   describe "initialize" do
     describe "without an existing Procfile" do
       it "raises an error" do
@@ -46,14 +53,16 @@ describe "Foreman::Engine" do
     before(:each) do
       write_procfile
       stub(Process).fork
+      any_instance_of(Foreman::Engine) do |engine|
+        stub(engine).info
+        stub(engine).spawn_processes
+        stub(engine).watch_for_termination
+      end
     end
 
     it "should read if specified" do
       File.open("/tmp/env", "w") { |f| f.puts("FOO=baz") }
       engine = Foreman::Engine.new("Procfile", :env => "/tmp/env")
-      stub(engine).info
-      mock(engine).spawn_processes
-      mock(engine).watch_for_termination
       engine.environment.should == {"FOO"=>"baz"}
       engine.start
     end
@@ -62,13 +71,21 @@ describe "Foreman::Engine" do
       File.open("/tmp/env1", "w") { |f| f.puts("FOO=bar") }
       File.open("/tmp/env2", "w") { |f| f.puts("BAZ=qux") }
       engine = Foreman::Engine.new("Procfile", :env => "/tmp/env1,/tmp/env2")
-      stub(engine).info
-      mock(engine).spawn_processes
-      mock(engine).watch_for_termination
       engine.environment.should == { "FOO"=>"bar", "BAZ"=>"qux" }
       engine.start
     end
 
+    it "should handle quoted values" do
+      File.open("/tmp/env", "w") do |f|
+        f.puts 'FOO=bar'
+        f.puts 'BAZ="qux"'
+        f.puts "FRED='barney'"
+        f.puts 'OTHER="escaped\"quote"'
+      end
+      engine = Foreman::Engine.new("Procfile", :env => "/tmp/env")
+      engine.environment.should == { "FOO" => "bar", "BAZ" => "qux", "FRED" => "barney", "OTHER" => 'escaped"quote' }
+    end
+
     it "should fail if specified and doesnt exist" do
       mock.instance_of(Foreman::Engine).error("No such file: /tmp/env")
       engine = Foreman::Engine.new("Procfile", :env => "/tmp/env")
@@ -77,10 +94,27 @@ describe "Foreman::Engine" do
     it "should read .env if none specified" do
       File.open(".env", "w") { |f| f.puts("FOO=qoo") }
       engine = Foreman::Engine.new("Procfile")
-      mock(engine).spawn_processes
-      mock(engine).watch_for_termination
       engine.environment.should == {"FOO"=>"qoo"}
       engine.start
     end
   end
+
+  describe "utf8" do
+    before(:each) do
+      File.open("Procfile", "w") do |file|
+        file.puts "utf8: #{resource_path("bin/utf8")}"
+      end
+    end
+
+    it "should spawn" do
+      stub(subject).watch_for_output
+      stub(subject).watch_for_termination
+      subject.start
+      Process.waitall
+      mock(subject).info(/started with pid \d+/, "utf8.1", anything)
+      mock(subject).info("\xff\x03\n", "utf8.1", anything)
+      subject.send(:poll_readers)
+      subject.send(:poll_readers)
+    end
+  end
 end

spec/foreman/export/base_spec.rb

@@ -0,0 +1,22 @@
+require "spec_helper"
+require "foreman/export/base"
+
+describe "Foreman::Export::Base" do
+  let(:procfile) { FileUtils.mkdir_p("/tmp/app"); write_procfile("/tmp/app/Procfile") }
+  let(:location) { "/tmp/init" }
+  let(:engine)   { Foreman::Engine.new(procfile) }
+  let(:subject)  { Foreman::Export::Base.new(location, engine) }
+
+  it "has a say method for displaying info" do
+    mock(subject).puts("[foreman export] foo")
+    subject.send(:say, "foo")
+  end
+
+  it "export needs to be overridden" do
+    lambda { subject.export }.should raise_error("export method must be overridden")
+  end
+
+  it "raises errors as a Foreman::Export::Exception" do
+    lambda { subject.send(:error, "foo") }.should raise_error(Foreman::Export::Exception, "foo")
+  end
+end

spec/foreman/export/bluepill_spec.rb

@@ -3,22 +3,34 @@ require "foreman/engine"
 require "foreman/export/bluepill"
 require "tmpdir"
 
-describe Foreman::Export::Bluepill do
+describe Foreman::Export::Bluepill, :fakefs do
   let(:procfile) { FileUtils.mkdir_p("/tmp/app"); write_procfile("/tmp/app/Procfile") }
-  let(:engine) { Foreman::Engine.new(procfile) }
-  let(:bluepill) { Foreman::Export::Bluepill.new(engine) }
+  let(:engine)   { Foreman::Engine.new(procfile) }
+  let(:options)  { Hash.new }
+  let(:bluepill) { Foreman::Export::Bluepill.new("/tmp/init", engine, options) }
 
   before(:each) { load_export_templates_into_fakefs("bluepill") }
   before(:each) { stub(bluepill).say }
 
   it "exports to the filesystem" do
-    bluepill.export("/tmp/init")
+    bluepill.export
     normalize_space(File.read("/tmp/init/app.pill")).should == normalize_space(example_export_file("bluepill/app.pill"))
   end
 
-  it "exports to the filesystem with concurrency" do
-    bluepill.export("/tmp/init", :concurrency => "alpha=2")
-    
-    normalize_space(File.read("/tmp/init/app.pill")).should == normalize_space(example_export_file("bluepill/app-concurrency.pill"))
+  it "cleans up if exporting into an existing dir" do
+    mock(FileUtils).rm("/tmp/init/app.pill")
+
+    bluepill.export
+    bluepill.export
   end
-end
+
+  context  "with concurrency" do
+    let(:options) { Hash[:concurrency => "alpha=2"] }
+
+    it "exports to the filesystem with concurrency" do
+      bluepill.export
+      normalize_space(File.read("/tmp/init/app.pill")).should == normalize_space(example_export_file("bluepill/app-concurrency.pill"))
+    end
+  end
+
+end

spec/foreman/export/inittab_spec.rb

@@ -0,0 +1,40 @@
+require "spec_helper"
+require "foreman/engine"
+require "foreman/export/inittab"
+require "tmpdir"
+
+describe Foreman::Export::Inittab, :fakefs do
+  let(:location) { "/tmp/inittab" }
+  let(:procfile) { FileUtils.mkdir_p("/tmp/app"); write_procfile("/tmp/app/Procfile") }
+  let(:location) { "/tmp/inittab" }
+  let(:engine)   { Foreman::Engine.new(procfile) }
+  let(:options)  { Hash.new }
+  let(:inittab)  { Foreman::Export::Inittab.new(location, engine, options) }
+
+  before(:each) { load_export_templates_into_fakefs("inittab") }
+  before(:each) { stub(inittab).say }
+
+  it "exports to the filesystem" do
+    inittab.export
+    File.read("/tmp/inittab").should == example_export_file("inittab/inittab.default")
+  end
+
+  context "to stdout" do
+    let(:location) { "-" }
+
+    it "exports to stdout" do
+      mock(inittab).puts example_export_file("inittab/inittab.default")
+      inittab.export
+    end
+  end
+
+  context "with concurrency" do
+    let(:options) { Hash[:concurrency => "alpha=2"] }
+
+    it "exports to the filesystem with concurrency" do
+      inittab.export
+      File.read("/tmp/inittab").should == example_export_file("inittab/inittab.concurrency")
+    end
+  end
+
+end

spec/foreman/export/runit_spec.rb

@@ -3,34 +3,39 @@ require "foreman/engine"
 require "foreman/export/runit"
 require "tmpdir"
 
-describe Foreman::Export::Runit do
+describe Foreman::Export::Runit, :fakefs do
   let(:procfile) { FileUtils.mkdir_p("/tmp/app"); write_procfile("/tmp/app/Procfile", 'bar=baz') }
   let(:engine) { Foreman::Engine.new(procfile) }
-  let(:runit) { Foreman::Export::Runit.new(engine) }
-  
+  let(:runit) { Foreman::Export::Runit.new('/tmp/init', engine, :concurrency => 'alpha=2,bravo=1') }
+
   before(:each) { load_export_templates_into_fakefs("runit") }
   before(:each) { stub(runit).say }
   before(:each) { stub(FakeFS::FileUtils).chmod }
-  
+
   it "exports to the filesystem" do
     FileUtils.mkdir_p('/tmp/init')
-    runit.export('/tmp/init', :concurrency => "alpha=2,bravo=1")
-    
+
+    runit.export
+
     File.read("/tmp/init/app-alpha-1/run").should == example_export_file('runit/app-alpha-1-run')
-    File.read("/tmp/init/app-alpha-1/log/run").should == 
+    File.read("/tmp/init/app-alpha-1/log/run").should ==
         example_export_file('runit/app-alpha-1-log-run')
     File.read("/tmp/init/app-alpha-1/env/PORT").should == "5000\n"
     File.read("/tmp/init/app-alpha-1/env/BAR").should == "baz\n"
-    
+
     File.read("/tmp/init/app-alpha-2/run").should == example_export_file('runit/app-alpha-2-run')
-    File.read("/tmp/init/app-alpha-2/log/run").should == 
+    File.read("/tmp/init/app-alpha-2/log/run").should ==
         example_export_file('runit/app-alpha-2-log-run')
     File.read("/tmp/init/app-alpha-2/env/PORT").should == "5001\n"
     File.read("/tmp/init/app-alpha-2/env/BAR").should == "baz\n"
-    
+
     File.read("/tmp/init/app-bravo-1/run").should == example_export_file('runit/app-bravo-1-run')
-    File.read("/tmp/init/app-bravo-1/log/run").should == 
+    File.read("/tmp/init/app-bravo-1/log/run").should ==
         example_export_file('runit/app-bravo-1-log-run')
     File.read("/tmp/init/app-bravo-1/env/PORT").should == "5100\n"
   end
-end
+
+  it "creates a full path to the export directory" do
+    expect { runit.export }.to_not raise_error(Errno::ENOENT)
+  end
+end

spec/foreman/export/upstart_spec.rb

@@ -3,16 +3,17 @@ require "foreman/engine"
 require "foreman/export/upstart"
 require "tmpdir"
 
-describe Foreman::Export::Upstart do
+describe Foreman::Export::Upstart, :fakefs do
   let(:procfile) { FileUtils.mkdir_p("/tmp/app"); write_procfile("/tmp/app/Procfile") }
-  let(:engine) { Foreman::Engine.new(procfile) }
-  let(:upstart) { Foreman::Export::Upstart.new(engine) }
+  let(:engine)   { Foreman::Engine.new(procfile) }
+  let(:options)  { Hash.new }
+  let(:upstart)  { Foreman::Export::Upstart.new("/tmp/init", engine, options) }
 
   before(:each) { load_export_templates_into_fakefs("upstart") }
   before(:each) { stub(upstart).say }
 
   it "exports to the filesystem" do
-    upstart.export("/tmp/init")
+    upstart.export
 
     File.read("/tmp/init/app.conf").should         == example_export_file("upstart/app.conf")
     File.read("/tmp/init/app-alpha.conf").should   == example_export_file("upstart/app-alpha.conf")
@@ -21,18 +22,34 @@ describe Foreman::Export::Upstart do
     File.read("/tmp/init/app-bravo-1.conf").should == example_export_file("upstart/app-bravo-1.conf")
   end
 
-  it "exports to the filesystem with concurrency" do
-    upstart.export("/tmp/init", :concurrency => "alpha=2")
+  it "cleans up if exporting into an existing dir" do
+    mock(FileUtils).rm("/tmp/init/app.conf")
+    mock(FileUtils).rm("/tmp/init/app-alpha.conf")
+    mock(FileUtils).rm("/tmp/init/app-alpha-1.conf")
+    mock(FileUtils).rm("/tmp/init/app-bravo.conf")
+    mock(FileUtils).rm("/tmp/init/app-bravo-1.conf")
 
-    File.read("/tmp/init/app.conf").should         == example_export_file("upstart/app.conf")
-    File.read("/tmp/init/app-alpha.conf").should   == example_export_file("upstart/app-alpha.conf")
-    File.read("/tmp/init/app-alpha-1.conf").should == example_export_file("upstart/app-alpha-1.conf")
-    File.read("/tmp/init/app-alpha-2.conf").should == example_export_file("upstart/app-alpha-2.conf")
-    File.exists?("/tmp/init/app-bravo-1.conf").should == false
+    upstart.export
+    upstart.export
+  end
+
+  context "with concurrency" do
+    let(:options) { Hash[:concurrency => "alpha=2"] }
+
+    it "exports to the filesystem with concurrency" do
+      upstart.export
+
+      File.read("/tmp/init/app.conf").should            == example_export_file("upstart/app.conf")
+      File.read("/tmp/init/app-alpha.conf").should      == example_export_file("upstart/app-alpha.conf")
+      File.read("/tmp/init/app-alpha-1.conf").should    == example_export_file("upstart/app-alpha-1.conf")
+      File.read("/tmp/init/app-alpha-2.conf").should    == example_export_file("upstart/app-alpha-2.conf")
+      File.exists?("/tmp/init/app-bravo-1.conf").should == false
+    end
   end
 
   context "with alternate templates" do
     let(:template_root) { "/tmp/alternate" }
+    let(:upstart) { Foreman::Export::Upstart.new("/tmp/init", engine, :template => template_root) }
 
     before do
       FileUtils.mkdir_p template_root
@@ -40,7 +57,7 @@ describe Foreman::Export::Upstart do
     end
 
     it "can export with alternate template files" do
-      upstart.export("/tmp/init", :template => template_root)
+      upstart.export
 
       File.read("/tmp/init/app.conf").should == "alternate_template\n"
     end
@@ -61,7 +78,7 @@ describe Foreman::Export::Upstart do
     end
 
     it "can export with alternate template files" do
-      upstart.export("/tmp/init")
+      upstart.export
 
       File.read("/tmp/init/app.conf").should == "default_alternate_template\n"
     end

spec/foreman/export_spec.rb

@@ -1,2 +1,24 @@
 require "spec_helper"
 require "foreman/export"
+
+describe "Foreman::Export" do
+  subject { Foreman::Export }
+
+  describe "with a formatter that doesn't declare the appropriate class" do
+    it "prints an error" do
+      mock(subject).require("foreman/export/invalidformatter")
+      mock_export_error("Unknown export format: invalidformatter (no class Foreman::Export::Invalidformatter).") do
+        subject.formatter("invalidformatter") 
+      end
+    end
+  end
+
+  describe "with an invalid formatter" do
+
+    it "prints an error" do
+      mock_export_error("Unknown export format: invalidformatter (unable to load file 'foreman/export/invalidformatter').") do
+        subject.formatter("invalidformatter")
+      end
+    end
+  end
+end

spec/foreman/helpers_spec.rb

@@ -0,0 +1,26 @@
+require "spec_helper"
+require "foreman/helpers"
+
+describe "Foreman::Helpers" do
+  before do
+    module Foo
+      class Bar; end
+    end
+  end
+
+  after do
+    Object.send(:remove_const, :Foo)
+  end
+
+  subject { o = Object.new; o.extend(Foreman::Helpers); o }
+
+  it "should classify words" do
+    subject.classify("foo").should == "Foo"
+    subject.classify("foo-bar").should == "FooBar"
+  end
+
+  it "should constantize words" do
+    subject.constantize("Object").should == Object
+    subject.constantize("Foo::Bar").should == Foo::Bar
+  end
+end

spec/foreman/process_spec.rb

@@ -1,2 +1,131 @@
-require "spec_helper"
-require "foreman/process"
+require 'spec_helper'
+require 'foreman/process'
+require 'ostruct'
+require 'timeout'
+require 'tmpdir'
+
+describe Foreman::Process do
+  subject { described_class.new entry, number, port }
+
+  let(:number)  { 1 }
+  let(:port)    { 777 }
+  let(:command) { "script" }
+  let(:name)    { "foobar" }
+  let(:entry)   { OpenStruct.new :name => name, :command => command }
+
+  its(:entry) { entry }
+  its(:num)   { number }
+  its(:port)  { port }
+  its(:name)  { "#{name}.#{port}" }
+  its(:pid)   { nil }
+
+  describe '#run' do
+    let(:pipe)       { :pipe }
+    let(:basedir)    { Dir.mktmpdir }
+    let(:env)        {{ 'foo' => 'bar' }}
+    let(:init_delta) { 0.1 }
+
+    after { FileUtils.remove_entry_secure basedir }
+
+    def run(cmd=command)
+      entry.command = cmd
+      subject.run pipe, basedir, env
+      subject.detach && sleep(init_delta)
+    end
+
+    def run_file(executable, code)
+      file = File.open("#{basedir}/script", 'w') {|it| it << code }
+      run "#{executable} #{file.path}"
+      sleep 1
+    end
+
+    context 'options' do
+      it 'should set PORT for environment' do
+        mock(subject).run_process(basedir, command, pipe) do
+          ENV['PORT'].should == port.to_s
+        end
+        run
+      end
+
+      it 'should set custom variables for environment' do
+        mock(subject).run_process(basedir, command, pipe) do
+          ENV['foo'].should == 'bar'
+        end
+        run
+      end
+
+      it 'should restore environment afterwards' do
+        mock(subject).run_process(basedir, command, pipe)
+        run
+        ENV.should_not include('PORT', 'foo')
+      end
+    end
+
+    context 'process' do
+      around do |spec|
+        IO.pipe do |reader, writer|
+          @reader, @writer = reader, writer
+          spec.run
+        end
+      end
+
+      let(:pipe) { @writer }
+      let(:output) { @reader.read_nonblock 1024 }
+
+      it 'should not block' do
+        expect {
+          Timeout.timeout(2*init_delta) { run 'sleep 2' }
+        }.should_not raise_exception
+      end
+
+      it 'should be alive' do
+        run 'sleep 1'
+        subject.should be_alive
+      end
+
+      it 'should be dead' do
+        run 'exit'
+        subject.should be_dead
+      end
+
+      it 'should be killable' do
+        run 'sleep 1'
+        subject.kill 'TERM'
+        subject.should be_dead
+      end
+
+      it 'should send different signals' do
+        run_file 'ruby', <<-CODE
+          trap "TERM", "IGNORE"
+          loop { sleep 1 }
+        CODE
+        subject.should be_alive
+        subject.kill 'TERM'
+        subject.should be_alive
+        subject.kill 'KILL'
+        subject.should be_dead
+      end
+
+      it 'should redirect stdout' do
+        run 'echo hey'
+        output.should include('hey')
+      end
+
+      it 'should redirect stderr' do
+        run 'echo hey >2'
+        output.should include('hey')
+      end
+
+      it 'should handle variables' do
+        run 'echo $PORT'
+        output.should include('777')
+      end
+
+      it 'should handle arguments' do
+        pending
+        run %{ sh -c "trap '' TERM; sleep 10" }
+        subject.should be_alive
+      end
+    end
+  end
+end

spec/foreman_spec.rb

@@ -8,26 +8,9 @@ describe Foreman do
     it { should be_a String }
   end
 
-  describe "::load_env!(env_file)" do
-    before do
-      FakeFS.activate!
-    end
-
-    after do
-      FakeFS.deactivate!
-      ENV['FOO'] = nil
-    end
-
-    it "should load env_file into ENV" do
-      File.open("/tmp/env1", "w") { |f| f.puts("FOO=bar") }
-      Foreman.load_env!("/tmp/env1")
-      ENV['FOO'].should == 'bar'
-    end 
-
-    it "should assume env_file in ./.env" do
-      File.open("./.env", "w") { |f| f.puts("FOO=bar") }
-      Foreman.load_env!
-      ENV['FOO'].should == 'bar'
+  describe "runner" do
+    it "should exist" do
+      File.exists?(Foreman.runner).should == true
     end
   end
 end

spec/helper_spec.rb

@@ -3,16 +3,16 @@ require "spec_helper"
 describe "spec helpers" do
   describe "#preserving_env" do
     after { ENV.delete "FOO" }
-    
+
     it "should remove added environment vars" do
       preserving_env { ENV["FOO"] = "baz" }
       ENV["FOO"].should == nil
     end
-    
+
     it "should reset modified environment vars" do
       ENV["FOO"] = "bar"
       preserving_env { ENV["FOO"] = "baz"}
       ENV["FOO"].should == "bar"
     end
   end
-end
+end

spec/resources/bin/utf8

@@ -0,0 +1,2 @@
+#!/usr/bin/env ruby
+puts "\xff\x03"

spec/resources/export/inittab/inittab.concurrency

@@ -0,0 +1,4 @@
+# ----- foreman app processes -----
+AP01:4:respawn:/bin/su - app -c 'PORT=5000 ./alpha >> /var/log/app/alpha-1.log 2>&1'
+AP02:4:respawn:/bin/su - app -c 'PORT=5001 ./alpha >> /var/log/app/alpha-2.log 2>&1'
+# ----- end foreman app processes -----

spec/resources/export/inittab/inittab.default

@@ -0,0 +1,4 @@
+# ----- foreman app processes -----
+AP01:4:respawn:/bin/su - app -c 'PORT=5000 ./alpha >> /var/log/app/alpha-1.log 2>&1'
+AP02:4:respawn:/bin/su - app -c 'PORT=5100 ./bravo >> /var/log/app/bravo-1.log 2>&1'
+# ----- end foreman app processes -----

spec/spec_helper.rb

@@ -1,10 +1,20 @@
 require "rubygems"
+
+require "simplecov"
+SimpleCov.start do
+  add_filter "/spec/"
+end
+
 require "rspec"
 require "fakefs/safe"
 require "fakefs/spec_helpers"
 
 $:.unshift File.expand_path("../../lib", __FILE__)
 
+def mock_export_error(message)
+  lambda { yield }.should raise_error(Foreman::Export::Exception, message)
+end
+
 def mock_error(subject, message)
   mock_exit do
     mock(subject).puts("ERROR: #{message}")
@@ -37,9 +47,11 @@ def write_procfile(procfile="Procfile", alpha_env="")
   File.expand_path(procfile)
 end
 
-def write_env(env=".env")
+def write_env(env=".env", options={"FOO"=>"bar"})
   File.open(env, "w") do |file|
-    file.puts "FOO=bar"
+    options.each do |key, val|
+      file.puts "#{key}=#{val}"
+    end
   end
 end
 
@@ -56,9 +68,13 @@ def load_export_templates_into_fakefs(type)
   end
 end
 
+def resource_path(filename)
+  File.expand_path("../resources/#{filename}", __FILE__)
+end
+
 def example_export_file(filename)
   FakeFS.deactivate!
-  data = File.read(File.expand_path("../resources/export/#{filename}", __FILE__))
+  data = File.read(File.expand_path(resource_path("export/#{filename}"), __FILE__))
   FakeFS.activate!
   data
 end
@@ -76,10 +92,11 @@ end
 def normalize_space(s)
   s.gsub(/\n[\n\s]*/, "\n")
 end
-  
+
 RSpec.configure do |config|
+  config.treat_symbols_as_metadata_keys_with_true_values = true
   config.color_enabled = true
   config.order = 'rand'
-  config.include FakeFS::SpecHelpers
+  config.include FakeFS::SpecHelpers, :fakefs
   config.mock_with :rr
 end

tasks/dist.rake

@@ -0,0 +1,112 @@
+require "erb"
+require "fileutils"
+require "tmpdir"
+
+def assemble(source, target, perms=0644)
+  FileUtils.mkdir_p(File.dirname(target))
+  File.open(target, "w") do |f|
+    f.puts ERB.new(File.read(source)).result(binding)
+  end
+  File.chmod(perms, target)
+end
+
+def assemble_distribution(target_dir=Dir.pwd)
+  distribution_files.each do |source|
+    target = source.gsub(/^#{project_root}/, target_dir)
+    FileUtils.mkdir_p(File.dirname(target))
+    FileUtils.cp(source, target)
+  end
+end
+
+GEM_BLACKLIST = %w( bundler foreman )
+
+def assemble_gems(target_dir=Dir.pwd)
+  lines = %x{ cd #{project_root} && bundle show }.strip.split("\n")
+  raise "error running bundler" unless $?.success?
+
+  %x{ env BUNDLE_WITHOUT="development:test" bundle show }.split("\n").each do |line|
+    if line =~ /^  \* (.*?) \((.*?)\)/
+      next if GEM_BLACKLIST.include?($1)
+      puts "vendoring: #{$1}-#{$2}"
+      gem_dir = %x{ bundle show #{$1} }.strip
+      FileUtils.mkdir_p "#{target_dir}/vendor/gems"
+      %x{ cp -R "#{gem_dir}" "#{target_dir}/vendor/gems" }
+    end
+  end.compact
+end
+
+def beta?
+  Foreman::VERSION.to_s =~ /pre/
+end
+
+def clean(file)
+  rm file if File.exists?(file)
+end
+
+def distribution_files(type=nil)
+  require "foreman/distribution"
+  base_files = Foreman::Distribution.files
+  type_files = type ?
+    Dir[File.expand_path("../../dist/resources/#{type}/**/*", __FILE__)] : []
+  base_files.concat(type_files)
+end
+
+def mkchdir(dir)
+  FileUtils.mkdir_p(dir)
+  Dir.chdir(dir) do |dir|
+    yield(File.expand_path(dir))
+  end
+end
+
+def pkg(filename)
+  File.expand_path("../../pkg/#{filename}", __FILE__)
+end
+
+def project_root
+  File.expand_path("../..", __FILE__)
+end
+
+def resource(name)
+  File.expand_path("../../dist/resources/#{name}", __FILE__)
+end
+
+def s3_connect
+  return if @s3_connected
+
+  require "aws/s3"
+
+  unless ENV["DAVID_RELEASE_ACCESS"] && ENV["DAVID_RELEASE_SECRET"]
+    puts "please set DAVID_RELEASE_ACCESS and DAVID_RELEASE_SECRET in your environment"
+    exit 1
+  end
+
+  AWS::S3::Base.establish_connection!(
+    :access_key_id => ENV["DAVID_RELEASE_ACCESS"],
+    :secret_access_key => ENV["DAVID_RELEASE_SECRET"]
+  )
+
+  @s3_connected = true
+end
+
+def store(package_file, filename, bucket="assets.foreman.io")
+  s3_connect
+  puts "storing: #{filename}"
+  AWS::S3::S3Object.store(filename, File.open(package_file), bucket, :access => :public_read)
+end
+
+def tempdir
+  Dir.mktmpdir do |dir|
+    Dir.chdir(dir) do
+      yield(dir)
+    end
+  end
+end
+
+def version
+  require "foreman/version"
+  Foreman::VERSION
+end
+
+Dir[File.expand_path("../../dist/**/*.rake", __FILE__)].each do |rake|
+  import rake
+end

tasks/release.rake

@@ -0,0 +1,74 @@
+require "time"
+
+desc "Build the manual"
+task :man do
+  ENV['RONN_MANUAL']  = "Foreman Manual"
+  ENV['RONN_ORGANIZATION'] = "Foreman #{Foreman::VERSION}"
+  sh "ronn -w -s toc -r5 --markdown man/*.ronn"
+end
+
+desc "Commit the manual to git"
+task "man:commit" => :man do
+  sh "git add README.md"
+  sh "git commit -am 'update docs' || echo 'nothing to commit'"
+end
+
+desc "Generate the Github docs"
+task :pages => "man:commit" do
+  sh %{
+    cp man/foreman.1.html /tmp/foreman.1.html
+    git checkout gh-pages
+    rm ./index.html
+    cp /tmp/foreman.1.html ./index.html
+    git add -u index.html
+    git commit -m "saving man page to github docs"
+    git push origin -f gh-pages
+    git checkout master
+  }
+end
+
+desc "Generate an authors list"
+task :authors do
+  authors = %x{ git log --pretty=format:"%an" | sort -u }.split("\n")
+  readme = File.read("README.md")
+  readme.gsub!(/#### Patches contributed by\n([^\n]*)\n/m, "#### Patches contributed by\n#{authors.join(", ")}\n")
+  File.open("README.md", "w") { |f| f.print readme }
+end
+
+def latest_release
+  latest = File.read("Changelog.md").split("\n").first.split(" ")[1]
+end
+
+def newer_release
+  tags = %x{ git tag --contains v#{latest_release} }.split("\n").sort_by do |tag|
+    Gem::Version.new(tag[1..-1])
+  end
+  tags.reject { |tag| Gem::Version.new(tag[1..-1]).prerelease? }[1]
+end
+
+desc "Generate a Changelog"
+task :changelog do
+  while release = newer_release
+    entry = %x{ git show --format="%cd" #{release} | head -n 1 }
+    date = Time.parse(entry.chomp).strftime("%Y-%m-%d")
+
+    message  = "## #{release[1..-1]} (#{date})\n\n"
+    message += %x{ git log --format="* %s  [%an]" v#{latest_release}..#{release} }
+
+    changelog = File.read("Changelog.md")
+    changelog = message + "\n" + changelog
+
+    puts release
+
+    File.open("Changelog.md", "w") do |file|
+      file.print changelog
+    end
+  end
+end
+
+desc "Cut a release"
+task :release do
+  Rake::Task["authors"].invoke
+  Rake::Task["changelog"].invoke
+  Rake::Task["pages"].invoke
+end

tasks/rspec.rake

@@ -0,0 +1,8 @@
+require "rspec/core/rake_task"
+
+task :default => :spec
+
+desc "Run all specs"
+RSpec::Core::RakeTask.new(:spec) do |t|
+  t.pattern = 'spec/**/*_spec.rb'
+end