runnerbean 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 6db84c5833b28b6b42632acadeaa26ca0229359d
+  data.tar.gz: 3f99346b043a96c2c944a48000c59ef3aa1ddf1f
+SHA512:
+  metadata.gz: a8a3f81f604839a6828e1be2fdf7e162d2cf7d93b8aff0cef040d2e118acf40ff52e60e54c5ab65110c4dfd2fae0ec40213d7fd8c2e64c273fc37c5b72b70208
+  data.tar.gz: ea4f22990d4a4dc4a696d3d9f8c58e2f7274ae868e0e9f5bc2d4a0f5574e30bc1f446be494fab272ea4754682480f75c7edfc02439330b87ac99398adf38f7a6

data/.gitignore

@@ -0,0 +1,14 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+*.bundle
+*.so
+*.o
+*.a
+mkmf.log

data/.rspec

@@ -0,0 +1,2 @@
+--color
+--require spec_helper

data/.rubocop.yml

@@ -0,0 +1,7 @@
+Metrics/LineLength:
+  Description: 'Limit lines to 120 characters.'
+  Max: 120
+
+Style/Documentation:
+  Enabled: false
+

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in runnerbean.gemspec
+gemspec

data/Guardfile

@@ -0,0 +1,58 @@
+# A sample Guardfile
+# More info at https://github.com/guard/guard#readme
+
+## Uncomment and set this to only include directories you want to watch
+# directories %w(app lib config test spec features) \
+#  .select{|d| Dir.exists?(d) ? d : UI.warning("Directory #{d} does not exist")}
+
+## Note: if you are using the `directories` clause above and you are not
+## watching the project directory ('.'), then you will want to move
+## the Guardfile to a watched dir and symlink it back, e.g.
+#
+#  $ mkdir config
+#  $ mv Guardfile config/
+#  $ ln -s config/Guardfile .
+#
+# and, you'll have to watch "config/Guardfile" instead of "Guardfile"
+
+group :all_plugins, halt_on_fail: true do
+  guard :bundler do
+    require 'guard/bundler'
+    require 'guard/bundler/verify'
+    helper = Guard::Bundler::Verify.new
+
+    files = ['Gemfile']
+    files += Dir['*.gemspec'] if files.any? { |f| helper.uses_gemspec?(f) }
+
+    # Assume files are symlinked from somewhere
+    files.each { |file| watch(helper.real_path(file)) }
+  end
+
+  # Note: The cmd option is now required due to the increasing number of ways
+  #       rspec may be run, below are examples of the most common uses.
+  #  * bundler: 'bundle exec rspec'
+  #  * bundler binstubs: 'bin/rspec'
+  #  * spring: 'bin/rspec' (This will use spring if running and you have
+  #                          installed the spring binstubs per the docs)
+  #  * zeus: 'zeus rspec' (requires the server to be started separately)
+  #  * 'just' rspec: 'rspec'
+
+  guard :rspec, cmd: 'bundle exec rspec', all_on_start: true, all_after_pass: true do
+    require 'guard/rspec/dsl'
+    dsl = Guard::RSpec::Dsl.new(self)
+
+    # RSpec files
+    rspec = dsl.rspec
+    watch(rspec.spec_helper) { rspec.spec_dir }
+    watch(rspec.spec_support) { rspec.spec_dir }
+    watch(rspec.spec_files)
+
+    # Ruby files
+    watch(%r{^lib/(.+)\.rb$}) { |m| "spec/#{m[1]}_spec.rb" }
+  end
+
+  guard :rubocop do
+    watch(/.+\.rb$/)
+    watch(%r{(?:.+/)?\.rubocop\.yml$}) { |m| File.dirname(m[0]) }
+  end
+end

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2015 baob
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,31 @@
+# Runnerbean
+
+Automates starting and stopping processes for testing.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'runnerbean'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install runnerbean
+
+## Usage
+
+See examples folder for examples of use.
+
+## Contributing
+
+1. Fork it ( https://github.com/[my-github-username]/runnerbean/fork )
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create a new Pull Request

data/Rakefile

@@ -0,0 +1 @@
+require 'bundler/gem_tasks'

data/examples/front_and_back

@@ -0,0 +1,60 @@
+#!/usr/bin/env ruby
+
+APP_ROOT = File.expand_path('..', __dir__)
+$LOAD_PATH.unshift(File.join(APP_ROOT, 'lib'))
+
+require 'runnerbean'
+
+class Frontend
+  attr_accessor :log_file_prefix
+
+  def start_command
+    "echo 'This would be the Frontend start command'"
+  end
+
+  def sleep_after_start
+    1
+  end
+
+  def kill_command
+    "echo 'This would be the Frontend kill command'"
+  end
+
+  def sleep_after_kill
+    1
+  end
+end
+
+class Backend
+  attr_accessor :log_file_prefix
+
+  def start_command
+    "echo 'This would be the Backend start command'"
+  end
+
+  def sleep_after_start
+    1
+  end
+
+  def kill_command
+    "echo 'This would be the Backend kill command'"
+  end
+
+  def sleep_after_kill
+    1
+  end
+end
+
+runner = Runnerbean.runner('front_and_back')
+runner.add_process(frontend: Frontend.new,
+                   backend:  Backend.new)
+
+runner.start!(:frontend)
+puts 'Frontend only Tests would run here ...'
+runner.kill!(:frontend)
+
+puts "\n .... and .... \n\n"
+
+runner.start!(:frontend, :backend)
+puts 'combined Frontend and Backend Tests would run here ...'
+runner.kill!(:frontend, :backend)

data/examples/process_groups

@@ -0,0 +1,64 @@
+#!/usr/bin/env ruby
+
+APP_ROOT = File.expand_path('..', __dir__)
+$LOAD_PATH.unshift(File.join(APP_ROOT, 'lib'))
+
+require 'runnerbean'
+
+class Frontend
+  attr_accessor :log_file_prefix
+
+  def start_command
+    "echo 'This would be the Frontend start command'"
+  end
+
+  def sleep_after_start
+    1
+  end
+
+  def kill_command
+    "echo 'This would be the Frontend kill command'"
+  end
+
+  def sleep_after_kill
+    1
+  end
+end
+
+class Backend
+  attr_accessor :log_file_prefix
+
+  def start_command
+    "echo 'This would be the Backend start command'"
+  end
+
+  def sleep_after_start
+    1
+  end
+
+  def kill_command
+    "echo 'This would be the Backend kill command'"
+  end
+
+  def sleep_after_kill
+    1
+  end
+end
+
+runner = Runnerbean.runner
+runner.add_process(frontend: Frontend.new,
+                   backend:  Backend.new)
+
+smoke_test_group = runner.group(:frontend, :backend)
+smoke_test_group.name = ('smoke_test')
+backend = runner.group(:backend)
+
+backend.start!
+puts 'Backend only Tests would run here ...'
+backend.kill!
+
+puts "\n .... and .... \n\n"
+
+smoke_test_group.start!
+puts 'combined Frontend and Backend Tests would run here ...'
+smoke_test_group.kill!

data/examples/simple

@@ -0,0 +1,35 @@
+#!/usr/bin/env ruby
+
+APP_ROOT = File.expand_path('..', __dir__)
+$LOAD_PATH.unshift(File.join(APP_ROOT, 'lib'))
+
+require 'runnerbean'
+
+class MyTestProcess
+  attr_accessor :log_file_prefix
+
+  def start_command
+    "echo 'This would be the start command, logging to prefix of #{log_file_prefix}' &&" \
+    "echo '... with a following delay of #{sleep_after_start}'"
+  end
+
+  def sleep_after_start
+    7
+  end
+
+  def kill_command
+    "echo 'This would be the kill command, logging to prefix of #{log_file_prefix}' &&" \
+    "echo '... with a following delay of #{sleep_after_kill}'"
+  end
+
+  def sleep_after_kill
+    4
+  end
+end
+
+runner = Runnerbean.runner('simple')
+runner.add_process(my_process: MyTestProcess.new)
+
+runner.start!(:my_process)
+puts 'Tests would run here ...'
+runner.kill!(:my_process)

data/lib/runnerbean/process_group.rb

@@ -0,0 +1,62 @@
+module Runnerbean
+  class ProcessGroup
+    attr_reader :processes
+    attr_writer :name
+
+    def initialize(*processes)
+      @processes = processes
+    end
+
+    def kill!
+      generic_command(:kill)
+    end
+
+    def start!
+      generic_command(:start)
+    end
+
+    def name
+      @name ||= default_process_group_name
+    end
+
+    private
+
+    def default_process_group_name
+      return processes.map(&:name).join('_and_')
+    rescue
+      'default_process_group_name'
+    end
+
+    def generic_command(command)
+      request_log_files
+
+      commands = find_commands(command)
+      execute(*commands)
+
+      sleep_times = find_sleep_times(command)
+      sleep_for(*sleep_times)
+    end
+
+    def request_log_files
+      processes.each { |p| p.log_file_prefix = name }
+    end
+
+    def find_commands(command)
+      command_getter = "#{command}_command".to_sym
+      processes.map(&command_getter).compact
+    end
+
+    def execute(*commands)
+      commands.map { |k| Kernel.system(k) } unless commands.size == 0
+    end
+
+    def find_sleep_times(command)
+      sleep_getter = "sleep_after_#{command}".to_sym
+      processes.map(&sleep_getter).compact
+    end
+
+    def sleep_for(*sleep_times)
+      Kernel.sleep(sleep_times.max) unless sleep_times.size == 0
+    end
+  end
+end

data/lib/runnerbean/runner.rb

@@ -0,0 +1,56 @@
+require 'runnerbean/process_group'
+
+module Runnerbean
+  class Runner
+    attr_reader :name
+
+    def initialize(opts = {})
+      @name = opts[:name] || 'runner'
+    end
+
+    def add_process(opts)
+      opts.each do |key, value|
+        process_index[key] = value
+      end
+    end
+
+    def kill!(*process_names)
+      pg = process_group(*process_names)
+      pg.name = name
+      pg.kill!
+      pg # allows chaining
+    end
+
+    def start!(*process_names)
+      pg = process_group(*process_names)
+      pg.name = name
+      pg.start!
+      pg # allows chaining
+    end
+
+    def group(*process_names)
+      process_group(*process_names)
+    end
+
+    private
+
+    def process_group(*process_names)
+      processes = processes_from_names(*process_names)
+      ProcessGroup.new(*processes)
+    end
+
+    def processes_from_names(*process_names)
+      process_names.map { |pn| process_from_name(pn) }
+    end
+
+    def process_from_name(name)
+      process_index.fetch(name)
+    rescue KeyError => e
+      raise ProcessNotDefined, e.message
+    end
+
+    def process_index
+      @process_index ||= {}
+    end
+  end
+end

data/lib/runnerbean/version.rb

@@ -0,0 +1,3 @@
+module Runnerbean
+  VERSION = '0.0.1'
+end

data/lib/runnerbean.rb

@@ -0,0 +1,10 @@
+require 'runnerbean/version'
+require 'runnerbean/runner'
+
+module Runnerbean
+  def self.runner(name = 'runnerbean')
+    Runnerbean::Runner.new(name: name)
+  end
+
+  class ProcessNotDefined < Exception; end
+end

data/runnerbean.gemspec

@@ -0,0 +1,31 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'runnerbean/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'runnerbean'
+  spec.version       = Runnerbean::VERSION
+  spec.authors       = ['baob']
+  spec.email         = ['coder@onesandthrees.com']
+  spec.summary       = 'Automates starting and stopping processes for testing.'
+  # spec.description   = %q{TODO: Write a longer description. Optional.}
+  spec.homepage      = ''
+  spec.license       = 'MIT'
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ['lib']
+
+  spec.add_development_dependency 'bundler', '~> 1.7'
+  spec.add_development_dependency 'rake', '~> 10.0'
+  spec.add_development_dependency 'rspec'
+  spec.add_development_dependency 'guard'
+  spec.add_development_dependency 'guard-rspec'
+  spec.add_development_dependency 'terminal-notifier-guard'
+  spec.add_development_dependency 'rubocop'
+  spec.add_development_dependency 'guard-rubocop'
+  spec.add_development_dependency 'guard-bundler'
+  spec.add_development_dependency 'pry'
+end

data/spec/runnerbean/process_group_spec.rb

@@ -0,0 +1,122 @@
+require 'runnerbean'
+require 'runnerbean/process_group'
+
+module Runnerbean
+  RSpec.describe ProcessGroup do
+    let(:group) { described_class.new(*processes) }
+    let(:name) { 'default_process_group_name' }
+    let(:the_frontend_kill) { 'kill_that_frontend' }
+    let(:the_frontend_start) { 'start_that_frontend' }
+    let(:the_frontend) do
+      double('the frontend',
+             name: 'name_of_the_frontend',
+             kill_command: the_frontend_kill,
+             start_command: the_frontend_start,
+             sleep_after_start: 7,
+             sleep_after_kill: 2,
+             :'log_file_prefix=' => nil
+            )
+    end
+    let(:the_worker_kill) { 'kill_that_worker' }
+    let(:the_worker) do
+      double('the worker',
+             name: 'name_of_the_worker',
+             kill_command: the_worker_kill,
+             sleep_after_kill: 4,
+             :'log_file_prefix=' => nil
+            )
+    end
+    before { allow(Kernel).to receive(:system).with(anything) }
+    before { allow(Kernel).to receive(:sleep).with(anything) }
+
+    context 'with an incomplete process defined' do
+      let(:bad_process) do
+        class BadProcess; end
+        BadProcess
+      end
+      let(:processes) { [bad_process] }
+
+      describe '#start!' do
+        subject { group.start! }
+
+        it 'raises no method error' do
+          expect { subject }.to raise_error(NoMethodError)
+        end
+      end
+    end
+
+    context 'with a :frontend process injected' do
+      let(:processes) { [the_frontend] }
+
+      describe '#name' do
+        specify { expect(group.name).to eq(the_frontend.name) }
+      end
+
+      describe '#kill!' do
+        subject { group.kill! }
+
+        it 'runs shell command specified for frontend' do
+          expect(Kernel).to receive(:system).with(the_frontend_kill)
+          subject
+        end
+
+        it 'sleeps for specified time' do
+          expect(Kernel).to receive(:sleep).with(the_frontend.sleep_after_kill)
+          subject
+        end
+      end
+
+      describe '#start!' do
+        subject { group.start! }
+
+        it 'runs shell command specified for frontend' do
+          expect(Kernel).to receive(:system).with(the_frontend_start)
+          subject
+        end
+
+        it 'instructs process to log to logfile, prefixed with group name' do
+          expect(the_frontend).to receive(:log_file_prefix=).with(group.name)
+          subject
+        end
+
+        it 'sleeps for specified time' do
+          expect(Kernel).to receive(:sleep).with(the_frontend.sleep_after_start)
+          subject
+        end
+      end
+
+      context 'with a :worker process injected' do
+        let(:processes) { [the_frontend, the_worker] }
+
+        describe '#name' do
+          let(:expected_name) { [the_frontend.name, the_worker.name].join('_and_') }
+
+          specify { expect(group.name).to eq(expected_name) }
+        end
+
+        describe '#kill!' do
+          subject { group.kill! }
+
+          it 'runs shell command specified for worker' do
+            expect(Kernel).to receive(:system).with(the_worker_kill)
+            subject
+          end
+
+          it 'runs shell command specified for frontend' do
+            expect(Kernel).to receive(:system).with(the_frontend_kill)
+            subject
+          end
+        end
+
+        context 'and with the name overridden' do
+          describe '#name' do
+            let(:new_name) { 'override_name' }
+            before { group.name = new_name }
+
+            specify { expect(group.name).to eq(new_name) }
+          end
+        end
+      end # context 'with a :worker process injected' do
+    end # context 'with a :frontend process injected' do
+  end
+end

data/spec/runnerbean/runner_integration_spec.rb

@@ -0,0 +1,87 @@
+require 'runnerbean'
+require 'runnerbean/runner'
+
+module Runnerbean
+  RSpec.describe Runner do
+    let(:runner) { described_class.new(init_options) }
+    let(:init_options) { { name: name } }
+    let(:name) { 'a_name' }
+    let(:the_frontend_kill) { 'kill_that_frontend' }
+    let(:the_frontend_start) { 'start_that_frontend' }
+    let(:the_frontend) do
+      double('the frontend',
+             kill_command: the_frontend_kill,
+             start_command: the_frontend_start,
+             sleep_after_start: 7,
+             sleep_after_kill: 2,
+             :'log_file_prefix=' => nil
+            )
+    end
+    let(:the_worker_kill) { 'kill_that_worker' }
+    let(:the_worker) do
+      double('the worker',
+             kill_command: the_worker_kill,
+             sleep_after_kill: 4,
+             :'log_file_prefix=' => nil
+            )
+    end
+    before { allow(Kernel).to receive(:system).with(anything) }
+    before { allow(Kernel).to receive(:sleep).with(anything) }
+
+    describe 'integration with process groups' do
+      context 'with a :frontend process injected' do
+        before { runner.add_process(frontend: the_frontend) }
+
+        describe '#kill!(:frontend)' do
+          subject { runner.kill!(:frontend) }
+
+          it 'runs shell command specified for frontend' do
+            expect(Kernel).to receive(:system).with(the_frontend_kill)
+            subject
+          end
+        end
+
+        describe '#start!(:frontend)' do
+          subject { runner.start!(:frontend) }
+
+          it 'runs shell command specified for frontend' do
+            expect(Kernel).to receive(:system).with(the_frontend_start)
+            subject
+          end
+        end
+
+        context 'with a :worker process injected' do
+          before { runner.add_process(worker: the_worker) }
+
+          describe '#kill!(:worker)' do
+            subject { runner.kill!(:worker) }
+
+            it 'runs shell command specified for worker' do
+              expect(Kernel).to receive(:system).with(the_worker_kill)
+              subject
+            end
+
+            it 'does not runs shell command specified for frontend' do
+              expect(Kernel).to_not receive(:system).with(the_frontend_kill)
+              subject
+            end
+          end
+
+          describe '#kill!(:worker, :frontend)' do
+            subject { runner.kill!(:worker, :frontend) }
+
+            it 'runs shell command specified for worker' do
+              expect(Kernel).to receive(:system).with(the_worker_kill)
+              subject
+            end
+
+            it 'runs shell command specified for frontend' do
+              expect(Kernel).to receive(:system).with(the_frontend_kill)
+              subject
+            end
+          end
+        end # context 'with a :worker process injected' do
+      end # context 'with a :frontend process injected' do
+    end
+  end
+end

data/spec/runnerbean/runner_spec.rb

@@ -0,0 +1,90 @@
+require 'runnerbean'
+require 'runnerbean/runner'
+
+module Runnerbean
+  RSpec.describe Runner do
+    let(:runner) { described_class.new(init_options) }
+    let(:init_options) { { name: the_runner_name } }
+    let(:the_frontend) { double('the frontend') }
+    let(:the_worker) { double('the worker') }
+    let(:a_process_group) { double('a process group', :'name=' => nil) }
+
+    describe 'initalised with a name' do
+      let(:the_runner_name) { 'a_name' }
+
+      describe '#name' do
+        specify { expect(runner.name).to be(the_runner_name) }
+      end
+
+      context 'with a :frontend process injected' do
+        before { runner.add_process(frontend: the_frontend) }
+
+        context 'and with a :worker process injected' do
+          before { runner.add_process(worker: the_worker) }
+
+          describe '#group(:worker)' do
+            subject { runner.group(:worker) }
+
+            it 'returns process_group initialised with worker' do
+              expect(ProcessGroup).to receive(:new).with(the_worker).and_return(a_process_group)
+              expect(subject).to be(a_process_group)
+            end
+          end
+
+          describe '#group(:worker, :frontend)' do
+            subject { runner.group(:worker, :frontend) }
+
+            it 'returns process_group initialised with worker and frontend' do
+              expect(ProcessGroup).to receive(:new).with(the_worker, the_frontend).and_return(a_process_group)
+              expect(subject).to be(a_process_group)
+            end
+          end
+
+          describe '#start!(:frontend)' do
+            subject { runner.start!(:frontend) }
+            before do
+              allow(a_process_group).to receive(:start!)
+              allow(ProcessGroup).to receive(:new).with(the_frontend).and_return(a_process_group)
+            end
+
+            it 'returns process_group initialised with frontend' do
+              expect(ProcessGroup).to receive(:new).with(the_frontend).and_return(a_process_group)
+              expect(subject).to be(a_process_group)
+            end
+
+            it 'calls .start! on the process group' do
+              expect(a_process_group).to receive(:start!)
+              subject
+            end
+          end
+
+          describe '#kill!(:worker)' do
+            subject { runner.kill!(:worker) }
+            before do
+              allow(a_process_group).to receive(:kill!)
+              allow(ProcessGroup).to receive(:new).with(the_worker).and_return(a_process_group)
+            end
+
+            it 'returns process_group initialised with worker' do
+              expect(ProcessGroup).to receive(:new).with(the_worker).and_return(a_process_group)
+              expect(subject).to be(a_process_group)
+            end
+
+            it 'calls .kill! on the process group' do
+              expect(a_process_group).to receive(:kill!)
+              subject
+            end
+          end
+
+          describe '#start!(:backend)' do
+            subject { runner.start!(:backend) }
+
+            it 'raises not defined exception' do
+              expect { subject }.to raise_error(::Runnerbean::ProcessNotDefined)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/spec/runnerbean_spec.rb

@@ -0,0 +1,10 @@
+require 'runnerbean'
+require 'runnerbean/runner'
+
+RSpec.describe Runnerbean do
+  describe '.runner' do
+    subject { described_class.runner }
+
+    specify { expect(subject).to be_instance_of(Runnerbean::Runner) }
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,98 @@
+# This file was generated by the `rspec --init` command. Conventionally, all
+# specs live under a `spec` directory, which RSpec adds to the `$LOAD_PATH`.
+# The generated `.rspec` file contains `--require spec_helper` which will cause
+# this file to always be loaded, without a need to explicitly require it in any
+# files.
+#
+# Given that it is always loaded, you are encouraged to keep this file as
+# light-weight as possible. Requiring heavyweight dependencies from this file
+# will add to the boot time of your test suite on EVERY test run, even for an
+# individual file that may not need all of that loaded. Instead, consider making
+# a separate helper file that requires the additional dependencies and performs
+# the additional setup, and require it from the spec files that actually need
+# it.
+#
+# The `.rspec` file also contains a few flags that are not defaults but that
+# users commonly want.
+#
+
+APP_ROOT = File.expand_path('..', __dir__)
+$LOAD_PATH.unshift(File.join(APP_ROOT, 'lib'))
+
+# See http://rubydoc.info/gems/rspec-core/RSpec/Core/Configuration
+RSpec.configure do |config|
+  # rspec-expectations config goes here. You can use an alternate
+  # assertion/expectation library such as wrong or the stdlib/minitest
+  # assertions if you prefer.
+  config.expect_with :rspec do |expectations|
+    # This option will default to `true` in RSpec 4. It makes the `description`
+    # and `failure_message` of custom matchers include text for helper methods
+    # defined using `chain`, e.g.:
+    #     be_bigger_than(2).and_smaller_than(4).description
+    #     # => "be bigger than 2 and smaller than 4"
+    # ...rather than:
+    #     # => "be bigger than 2"
+    expectations.include_chain_clauses_in_custom_matcher_descriptions = true
+  end
+
+  # rspec-mocks config goes here. You can use an alternate test double
+  # library (such as bogus or mocha) by changing the `mock_with` option here.
+  config.mock_with :rspec do |mocks|
+    # Prevents you from mocking or stubbing a method that does not exist on
+    # a real object. This is generally recommended, and will default to
+    # `true` in RSpec 4.
+    mocks.verify_partial_doubles = true
+  end
+
+  # The settings below are suggested to provide a good initial experience
+  # with RSpec, but feel free to customize to your heart's content.
+  #   # These two settings work together to allow you to limit a spec run
+  #   # to individual examples or groups you care about by tagging them with
+  #   # `:focus` metadata. When nothing is tagged with `:focus`, all examples
+  #   # get run.
+  #   config.filter_run :focus
+  #   config.run_all_when_everything_filtered = true
+  #
+  #   # Allows RSpec to persist some state between runs in order to support
+  #   # the `--only-failures` and `--next-failure` CLI options. We recommend
+  #   # you configure your source control system to ignore this file.
+  #   config.example_status_persistence_file_path = "spec/examples.txt"
+  #
+  #   # Limits the available syntax to the non-monkey patched syntax that is
+  #   # recommended. For more details, see:
+  #   #   - http://myronmars.to/n/dev-blog/2012/06/rspecs-new-expectation-syntax
+  #   #   - http://www.teaisaweso.me/blog/2013/05/27/rspecs-new-message-expectation-syntax/
+  #   #   - http://myronmars.to/n/dev-blog/2014/05/notable-changes-in-rspec-3#new__config_option_to_disable_rspeccore_monkey_patching
+  config.disable_monkey_patching!
+  #
+  #   # This setting enables warnings. It's recommended, but in some cases may
+  #   # be too noisy due to issues in dependencies.
+  #   config.warnings = true
+  #
+  #   # Many RSpec users commonly either run the entire suite or an individual
+  #   # file, and it's useful to allow more verbose output when running an
+  #   # individual spec file.
+  if config.files_to_run.one?
+    # Use the documentation formatter for detailed output,
+    # unless a formatter has already been configured
+    # (e.g. via a command-line flag).
+    config.default_formatter = 'doc'
+  end
+  #
+  #   # Print the 10 slowest examples and example groups at the
+  #   # end of the spec run, to help surface which specs are running
+  #   # particularly slow.
+  #   config.profile_examples = 10
+  #
+  #   # Run specs in random order to surface order dependencies. If you find an
+  #   # order dependency and want to debug it, you can fix the order by providing
+  #   # the seed, which is printed after each run.
+  #   #     --seed 1234
+  config.order = :random
+  #
+  #   # Seed global randomization in this process using the `--seed` CLI option.
+  #   # Setting this allows you to use `--seed` to deterministically reproduce
+  #   # test failures related to randomization by passing the same `--seed` value
+  #   # as the one that triggered the failure.
+  Kernel.srand config.seed
+end

metadata

@@ -0,0 +1,210 @@
+--- !ruby/object:Gem::Specification
+name: runnerbean
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- baob
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-09-06 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.7'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.7'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: guard
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: guard-rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: terminal-notifier-guard
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rubocop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: guard-rubocop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: guard-bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: pry
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: 
+email:
+- coder@onesandthrees.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rspec"
+- ".rubocop.yml"
+- Gemfile
+- Guardfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- examples/front_and_back
+- examples/process_groups
+- examples/simple
+- lib/runnerbean.rb
+- lib/runnerbean/process_group.rb
+- lib/runnerbean/runner.rb
+- lib/runnerbean/version.rb
+- runnerbean.gemspec
+- spec/runnerbean/process_group_spec.rb
+- spec/runnerbean/runner_integration_spec.rb
+- spec/runnerbean/runner_spec.rb
+- spec/runnerbean_spec.rb
+- spec/spec_helper.rb
+homepage: ''
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.4.3
+signing_key: 
+specification_version: 4
+summary: Automates starting and stopping processes for testing.
+test_files:
+- spec/runnerbean/process_group_spec.rb
+- spec/runnerbean/runner_integration_spec.rb
+- spec/runnerbean/runner_spec.rb
+- spec/runnerbean_spec.rb
+- spec/spec_helper.rb