cuke_commander 1.0.0

data/.gitignore

@@ -0,0 +1,22 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+*.bundle
+*.so
+*.o
+*.a
+mkmf.log

data/.simplecov

@@ -0,0 +1,11 @@
+SimpleCov.start do
+
+  # Don't need to track test code
+  add_filter '/spec/'
+  add_filter '/features/'
+
+  #Ignore results that are older than 10 minutes
+  merge_timeout 600
+
+  SimpleCov.command_name 'cuke_commander'
+end

data/Gemfile

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

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2015 Grange Insurance
+
+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,50 @@
+# CukeCommander
+
+The cuke_commander gem provides an easy and programmatic way to build a command line for running Cucumber.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'cuke_commander'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install cuke_commander
+
+## Usage
+
+    require 'cuke_commander'
+
+    # Choose your Cucumber options
+    cucumber_options = {tags: ['@tag1', '@tag2,@tag3'],
+                        formatters: {json: 'json_output.txt',
+                                     pretty: ''},
+                        options: ['-r features']}
+
+    # Use the generator to create an appropriate Cucumber command line
+    clg = CukeCommander::CLGenerator.new
+    command_line = clg.generate_command_line(cucumber_options)
+
+    puts command_line
+    # This will produce something along the lines of
+    # cucumber -t @tag1 -t @tag2,@tag3 -f json -o json_output.txt -f pretty -r features
+
+    # Use the command line to kick off Cucumber
+    system(command_line)
+
+Simple!
+
+(see documentation for all implemented Cucumber options)
+
+## Contributing
+
+1. Fork it ( https://github.com/[my-github-username]/cuke_commander/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,45 @@
+require "bundler/gem_tasks"
+require 'cucumber/rake/task'
+require 'rspec/core/rake_task'
+
+
+def set_cucumber_options(options)
+  ENV['CUCUMBER_OPTS'] = options
+end
+
+def combine_options(set_1, set_2)
+  set_2 ? "#{set_1} #{set_2}" : set_1
+end
+
+
+namespace 'cuke_commander' do
+
+  task :clear_coverage do
+    puts 'Clearing old code coverage results...'
+
+    # Remove previous coverage results so that they don't get merged into the new results
+    code_coverage_directory = File.join(File.dirname(__FILE__), 'coverage')
+    FileUtils.remove_dir(code_coverage_directory, true) if File.exists?(code_coverage_directory)
+  end
+
+  desc 'Run all of the Cucumber features for the gem'
+  task :features, [:command_options] do |_t, args|
+    set_cucumber_options(combine_options('-t ~@wip -t ~@off', args[:command_options]))
+  end
+  Cucumber::Rake::Task.new(:features)
+
+  desc 'Run all of the RSpec specifications for the gem'
+  RSpec::Core::RakeTask.new(:specs, :command_options) do |t, args|
+    t.rspec_opts = "-t ~wip -t ~off "
+    t.rspec_opts << args[:command_options] if args[:command_options]
+  end
+
+  desc 'Test All The Things'
+  task :test_everything, [:command_options] => [:clear_coverage] do |_t, args|
+    Rake::Task['cuke_commander:specs'].invoke(args[:command_options])
+    Rake::Task['cuke_commander:features'].invoke(args[:command_options])
+  end
+
+end
+
+task :default => 'cuke_commander:test_everything'

data/cuke_commander.gemspec

@@ -0,0 +1,26 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'cuke_commander/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "cuke_commander"
+  spec.version       = CukeCommander::VERSION
+  spec.authors       = ["Eric Kessler", 'Donavan Stanley']
+  spec.email         = ["morrow748@gmail.com", 'stanleyd@grangeinsurance.com']
+  spec.description   = %q{Command Cucumber}
+  spec.summary       = %q{Provides an easy way to build a cucumber commandline.}
+  spec.homepage      = "https://github.com/grange-insurance/cuke_commander"
+  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.6"
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency 'cucumber'
+  spec.add_development_dependency 'rspec'
+  spec.add_development_dependency 'simplecov'
+end

data/features/command_line_format.feature

@@ -0,0 +1,179 @@
+Feature: Command line formatting
+
+  As a person who uses fancy cucumber command lines
+  I want to know command line formatting
+  So I can get the right command line
+
+
+  Background:
+    Given a command line generator
+
+  Scenario: Base format
+    When  I ask for a cucumber command line with no additional options
+    Then  I am given the following cucumber command line
+      | cucumber |
+
+  Scenario: Profile flag format
+    When  I ask for a cucumber command line with the following profiles
+      | profile_1 |
+    Then  I am given the following cucumber command line
+      | cucumber -p profile_1 |
+    When  I ask for a cucumber command line with the following profiles
+      | profile_2 |
+      | profile_3 |
+    Then  I am given the following cucumber command line
+      | cucumber -p profile_2 -p profile_3 |
+
+  Scenario: No-profile flag format
+    When  I ask for a cucumber command line with a no-profile flag
+    Then  I am given the following cucumber command line
+      | cucumber -P |
+
+  Scenario: Tag flag format
+    When  I ask for a cucumber command line with the following tags
+      | @tag_1 |
+    Then  I am given the following cucumber command line
+      | cucumber -t @tag_1 |
+    When  I ask for a cucumber command line with the following tags
+      | @tag_2       |
+      | @tag_3,@tag4 |
+    Then  I am given the following cucumber command line
+      | cucumber -t @tag_2 -t @tag_3,@tag4 |
+
+  Scenario: File-path flag format
+    When  I ask for a cucumber command line with the following file-paths
+      | features/common |
+    Then  I am given the following cucumber command line
+      | cucumber features/common |
+    When  I ask for a cucumber command line with the following file-paths
+      | features/some_dir       |
+      | features/some_other_dir |
+    Then  I am given the following cucumber command line
+      | cucumber features/some_dir features/some_other_dir |
+
+  Scenario: Exclude pattern flag format
+    When  I ask for a cucumber command line with the following exclude patterns
+      | pattern_1 |
+    Then  I am given the following cucumber command line
+      | cucumber -e pattern_1 |
+    When  I ask for a cucumber command line with the following exclude patterns
+      | pattern_2 |
+      | pattern_3 |
+    Then  I am given the following cucumber command line
+      | cucumber -e pattern_2 -e pattern_3 |
+
+  Scenario: No-source flag format
+    When  I ask for a cucumber command line with a no-source flag
+    Then  I am given the following cucumber command line
+      | cucumber -s |
+
+  Scenario: No-color flag format
+    When  I ask for a cucumber command line with a no-color flag
+    Then  I am given the following cucumber command line
+      | cucumber --no-color |
+
+  Scenario: Color flag format
+    When  I ask for a cucumber command line with a color flag
+    Then  I am given the following cucumber command line
+      | cucumber --color |
+
+  Scenario: Formatter flag format
+    When  I ask for a cucumber command line with the following formatters
+      | formatter | output_location |
+      | json      | STDOUT          |
+    Then  I am given the following cucumber command line
+      | cucumber -f json -o STDOUT |
+    When  I ask for a cucumber command line with the following formatters
+      | formatter | output_location |
+      | pretty    |                 |
+      | html      | output.html     |
+    Then  I am given the following cucumber command line
+      | cucumber -f pretty -f html -o output.html |
+
+  Scenario: Backtrace flag format
+    When  I ask for a cucumber command line with a backtrace flag
+    Then  I am given the following cucumber command line
+      | cucumber -b |
+
+  Scenario: Dry run flag format
+    When  I ask for a cucumber command line with a dry run flag
+    Then  I am given the following cucumber command line
+      | cucumber -d |
+
+  Scenario: Guess flag format
+    When  I ask for a cucumber command line with a guess flag
+    Then  I am given the following cucumber command line
+      | cucumber -g |
+
+  Scenario: WIP flag format
+    When  I ask for a cucumber command line with a wip flag
+    Then  I am given the following cucumber command line
+      | cucumber -w |
+
+  Scenario: Quiet flag format
+    When  I ask for a cucumber command line with a quiet flag
+    Then  I am given the following cucumber command line
+      | cucumber -q |
+
+  Scenario: Help flag format
+    When  I ask for a cucumber command line with a help flag
+    Then  I am given the following cucumber command line
+      | cucumber -h |
+
+  Scenario: Version flag format
+    When  I ask for a cucumber command line with a version flag
+    Then  I am given the following cucumber command line
+      | cucumber --version |
+
+  Scenario: Strict flag format
+    When  I ask for a cucumber command line with a strict flag
+    Then  I am given the following cucumber command line
+      | cucumber -S |
+
+  Scenario: Verbose flag format
+    When  I ask for a cucumber command line with a verbose flag
+    Then  I am given the following cucumber command line
+      | cucumber -v |
+
+  Scenario: Expand flag format
+    When  I ask for a cucumber command line with an expand flag
+    Then  I am given the following cucumber command line
+      | cucumber -x |
+
+  Scenario: Name flag format
+    When  I ask for a cucumber command line with the name patterns
+      | pattern_1 |
+    Then  I am given the following cucumber command line
+      | cucumber -n pattern_1 |
+    When  I ask for a cucumber command line with the name patterns
+      | pattern_2 |
+      | pattern_3 |
+    Then  I am given the following cucumber command line
+      | cucumber -n pattern_2 -n pattern_3 |
+
+  Scenario: Require flag format
+    When  I ask for a cucumber command line with the following required files
+      | features/foo.rb |
+    Then  I am given the following cucumber command line
+      | cucumber -r features/foo.rb |
+    When  I ask for a cucumber command line with the following required files
+      | features/bar.rb     |
+      | features/bar/baz.rb |
+    Then  I am given the following cucumber command line
+      | cucumber -r features/bar.rb -r features/bar/baz.rb |
+
+  Scenario: Additional options format
+
+  The additional options will be added to the end of the command line. This behavior allows for modifying
+  the generated command line due to Cucumber options that this gem has not implemented or to handle possible
+  extensions made to Cucumber by the user or, really, for any reason at all.
+
+    When  I ask for a cucumber command line with the following additional options
+      | --expand |
+    Then  I am given the following cucumber command line
+      | cucumber --expand |
+    When  I ask for a cucumber command line with the following additional options
+      | -d        |
+      | fooBAR!!! |
+    Then  I am given the following cucumber command line
+      | cucumber -d fooBAR!!! |

data/features/cucumber_options.feature

@@ -0,0 +1,46 @@
+Feature: Cucumber options
+
+  As a person who uses fancy cucumber command lines
+  I want to know about the available cucumber options
+  So that I can use them correctly
+
+
+  Scenario: Available Cucumber options
+    * The following Cucumber options are available for use:
+      | profiles   |
+      | tags       |
+      | file_paths |
+      | excludes   |
+      | no_source  |
+      | formatters |
+      | no_color   |
+      | color      |
+      | requires   |
+      | names      |
+      | dry_run    |
+      | backtrace  |
+      | strict     |
+      | verbose    |
+      | expand     |
+      | version    |
+      | help       |
+      | quiet      |
+      | wip        |
+      | guess      |
+      | no_profile |
+      | options    |
+
+  Scenario: Generator will accept known options
+    Given a command line generator
+    When  I ask for a cucumber command line with a valid option
+    Then  the generator will not error
+
+  Scenario: Unknown options trigger an error
+    Given a command line generator
+    When  I ask for a Cucumber command line with an invalid option
+    Then  the generator will error
+
+  Scenario: Invalid option values trigger an error
+    Given a command line generator
+    When  I ask for a Cucumber command line with an invalid option value
+    Then  the generator will error

data/features/generate_command_line.feature

@@ -0,0 +1,11 @@
+Feature: Command line generation
+
+  As a person who uses fancy cucumber command lines
+  I want to have them made for me
+  In order to not have to build it myself on the fly
+
+
+  Scenario: Can generate a command line
+    Given a command line generator
+    When  I ask for a cucumber command line
+    Then  I am given a cucumber command line

data/features/step_definitions/action_steps.rb

@@ -0,0 +1,156 @@
+When(/^I ask for a cucumber command line$/) do
+  @command_line = @commander.generate_command_line
+end
+
+When(/^I ask for a cucumber command line with no additional options$/) do
+  @command_line = @commander.generate_command_line
+end
+
+When(/^I ask for a cucumber command line with the following profiles$/) do |profiles|
+  options = {profiles: profiles.raw.flatten}
+  @command_line = @commander.generate_command_line(options)
+end
+
+When(/^I ask for a cucumber command line with a no\-profile flag$/) do
+  @options = {no_profile: true}
+  @command_line = @commander.generate_command_line(@options)
+end
+
+When(/^I ask for a cucumber command line with the following tags$/) do |tags|
+  @options = {tags: tags.raw.flatten}
+  @command_line = @commander.generate_command_line(@options)
+end
+
+When(/^I ask for a cucumber command line with the following file-paths$/) do |table|
+  @options = {file_paths: table.raw.flatten}
+  @command_line = @commander.generate_command_line(@options)
+end
+
+When(/^I ask for a cucumber command line with the following exclude patterns$/) do |table|
+  @options = {excludes: table.raw.flatten}
+  @command_line = @commander.generate_command_line(@options)
+end
+
+When(/^I ask for a cucumber command line with a no-source flag$/) do
+  @options = {no_source: true}
+  @command_line = @commander.generate_command_line(@options)
+end
+
+When(/^I ask for a cucumber command line with a no-color flag$/) do
+  @options = {no_color: true}
+  @command_line = @commander.generate_command_line(@options)
+end
+
+When(/^I ask for a cucumber command line with a color flag$/) do
+  @options = {color: true}
+  @command_line = @commander.generate_command_line(@options)
+end
+
+When(/^I ask for a cucumber command line with the following formatters$/) do |table|
+  table = table.raw
+  table.shift
+
+  @options = {formatters: Hash[table]}
+  @command_line = @commander.generate_command_line(@options)
+end
+
+When(/^I ask for a Cucumber command line with an invalid option value$/) do
+  options = {:tags => :bad_tag_value}
+
+  begin
+    @error_encountered = false
+    @commander.generate_command_line(options)
+  rescue ArgumentError => e
+    @error_message = e.message
+    @error_encountered = true
+  end
+end
+
+When(/^I ask for a Cucumber command line with an invalid option$/) do
+  options = {not_a_valid_option: 'some value'}
+
+  begin
+    @error_encountered = false
+    @commander.generate_command_line(options)
+  rescue ArgumentError => e
+    @error_message = e.message
+    @error_encountered = true
+  end
+end
+
+When(/^I ask for a cucumber command line with a valid option$/) do
+  options = {tags: 'foo'}
+
+  begin
+    @error_encountered = false
+    @commander.generate_command_line(options)
+  rescue ArgumentError => e
+    @error_message = e.message
+    @error_encountered = true
+  end
+end
+
+When(/I ask for a cucumber command line with the following additional options$/) do |options|
+  @options = {options: options.raw.flatten}
+  @command_line = @commander.generate_command_line(@options)
+end
+
+When(/^I ask for a cucumber command line with a backtrace flag$/) do
+  @options = {backtrace: true}
+  @command_line = @commander.generate_command_line(@options)
+end
+
+When(/^I ask for a cucumber command line with a dry run flag$/) do
+  @options = {dry_run: true}
+  @command_line = @commander.generate_command_line(@options)
+end
+
+When(/^I ask for a cucumber command line with a guess flag$/) do
+  @options = {guess: true}
+  @command_line = @commander.generate_command_line(@options)
+end
+
+When(/^I ask for a cucumber command line with a wip flag$/) do
+  @options = {wip: true}
+  @command_line = @commander.generate_command_line(@options)
+end
+
+When(/^I ask for a cucumber command line with a quiet flag$/) do
+  @options = {quiet: true}
+  @command_line = @commander.generate_command_line(@options)
+end
+
+When(/^I ask for a cucumber command line with a help flag$/) do
+  @options = {help: true}
+  @command_line = @commander.generate_command_line(@options)
+end
+
+When(/^I ask for a cucumber command line with a version flag$/) do
+  @options = {version: true}
+  @command_line = @commander.generate_command_line(@options)
+end
+
+When(/^I ask for a cucumber command line with a strict flag$/) do
+  @options = {strict: true}
+  @command_line = @commander.generate_command_line(@options)
+end
+
+When(/^I ask for a cucumber command line with a verbose flag$/) do
+  @options = {verbose: true}
+  @command_line = @commander.generate_command_line(@options)
+end
+
+When(/^I ask for a cucumber command line with an expand flag$/) do
+  @options = {expand: true}
+  @command_line = @commander.generate_command_line(@options)
+end
+
+When(/^I ask for a cucumber command line with the name patterns$/) do |names|
+  options = {names: names.raw.flatten}
+  @command_line = @commander.generate_command_line(options)
+end
+
+When(/^I ask for a cucumber command line with the following required files$/) do |requires|
+  options = {requires: requires.raw.flatten}
+  @command_line = @commander.generate_command_line(options)
+end

data/features/step_definitions/setup_steps.rb

@@ -0,0 +1,3 @@
+Given(/^a command line generator$/) do
+  @commander = CukeCommander::CLGenerator.new
+end

data/features/step_definitions/verification_steps.rb

@@ -0,0 +1,19 @@
+Then(/^I am given a cucumber command line$/) do
+  expect(@command_line).to include("cucumber")
+end
+
+Then(/^I am given the following cucumber command line$/) do |line|
+  expect(@command_line).to eq(line.raw.flatten.first)
+end
+
+Then(/^the generator (will|will not) error$/) do |will_or_will_not|
+  if will_or_will_not == 'will'
+    raise("Expected error, did not error") unless @error_encountered
+  else
+    raise("Expected no error, but got: #{@error_message}") if @error_encountered
+  end
+end
+
+And(/^The following Cucumber options are available for use:$/) do |valid_options|
+  expect(CukeCommander::CUKE_OPTIONS).to match_array(valid_options.raw.flatten)
+end

data/features/support/env.rb

@@ -0,0 +1,4 @@
+require 'simplecov'
+SimpleCov.command_name 'cuke_commander-cucumber'
+
+require 'cuke_commander'

data/lib/cuke_commander.rb

@@ -0,0 +1,10 @@
+require "cuke_commander/version"
+require "cuke_commander/cl_generator"
+
+
+# Top level module under which the gem code lives.
+module CukeCommander
+
+  # The Cucumber options that are currently supported by the gem.
+  CUKE_OPTIONS = %w{ profiles tags file_paths formatters excludes no_source no_color options backtrace color dry_run expand guess help names no_profile quiet requires strict verbose version wip}
+end

data/lib/cuke_commander/cl_generator.rb

@@ -0,0 +1,208 @@
+module CukeCommander
+
+  # The object responsible for generating Cucumber command lines.
+  class CLGenerator
+
+    # Generates a Cucumber command line.
+    #
+    # Most option values are either an Array or a boolean value. In the case of the former, a
+    # String can be used instead of an Array when only a single value is needed. Some option
+    # values come in pairs (e.g. formatters and their output locations). These option values
+    # are taken as a Hash where a key is the first part of the pair and the key's value is the
+    # second part.
+    #
+    # @param options [Hash] the Cucumber options that the command line should include.
+    def generate_command_line(options = {})
+      validate_options(options)
+      command_line = 'cucumber'
+
+      append_options(command_line, wrap_options(options[:profiles]), '-p')      if options[:profiles]
+      append_options(command_line, wrap_options(options[:names]), '-n')         if options[:names]
+      append_options(command_line, wrap_options(options[:tags]), '-t')          if options[:tags]
+      append_options(command_line, wrap_options(options[:file_paths]))          if options[:file_paths]
+      append_options(command_line, wrap_options(options[:excludes]), '-e')      if options[:excludes]
+      append_options(command_line, wrap_options(options[:requires]), '-r')      if options[:requires]
+      append_option(command_line, '-s')                                         if options[:no_source]
+
+      if options[:formatters]
+        options[:formatters].each do |format, output_location|
+          append_option(command_line, format, '-f')
+          append_option(command_line, output_location, '-o') unless output_location.to_s.empty?
+        end
+      end
+
+      append_option(command_line, '--no-color')                     if options[:no_color]
+      append_option(command_line, '--color')                        if options[:color]
+      append_option(command_line, '-b')                             if options[:backtrace]
+      append_option(command_line, '-d')                             if options[:dry_run]
+      append_option(command_line, '-P')                             if options[:no_profile]
+      append_option(command_line, '-g')                             if options[:guess]
+      append_option(command_line, '-w')                             if options[:wip]
+      append_option(command_line, '-q')                             if options[:quiet]
+      append_option(command_line, '-v')                             if options[:verbose]
+      append_option(command_line, '--version')                      if options[:version]
+      append_option(command_line, '-h')                             if options[:help]
+      append_option(command_line, '-x')                             if options[:expand]
+      append_option(command_line, '-S')                             if options[:strict]
+
+      append_options(command_line, wrap_options(options[:options])) if options[:options]
+
+      command_line
+    end
+
+
+    private
+
+
+    def validate_options(options)
+      raise(ArgumentError, "Argument must be a Hash, got: #{options.class}") unless options.is_a?(Hash)
+
+      options.each_key do |option|
+        raise(ArgumentError, "Option: #{option}, is not a cucumber option") unless CUKE_OPTIONS.include?(option.to_s)
+      end
+
+      raise_invalid_error('Profiles', 'a String or Array', options[:profiles])           unless valid_profiles?(options[:profiles])
+      raise_invalid_error('Tags', 'a String or Array', options[:tags])                   unless valid_tags?(options[:tags])
+      raise_invalid_error('File path', 'a String or Array', options[:file_paths])        unless valid_file_paths?(options[:file_paths])
+      raise_invalid_error('Formatters', 'a Hash', options[:formatters])                  unless valid_formatters?(options[:formatters])
+      raise_invalid_error('Excludes', 'a String or Array', options[:excludes])           unless valid_excludes?(options[:excludes])
+      raise_invalid_error('No-source', 'true or false', options[:no_source])             unless valid_no_source?(options[:no_source])
+      raise_invalid_error('No-color', 'true or false', options[:no_color])               unless valid_no_color?(options[:no_color])
+      raise_invalid_error('Color', 'true or false', options[:color])                     unless valid_color?(options[:color])
+      raise_invalid_error('Backtrace', 'true or false', options[:backtrace])             unless valid_backtrace?(options[:backtrace])
+      raise_invalid_error('Expand', 'true or false', options[:expand])                   unless valid_expand?(options[:expand])
+      raise_invalid_error('Guess', 'true or false', options[:guess])                     unless valid_guess?(options[:guess])
+      raise_invalid_error('Help', 'true or false', options[:help])                       unless valid_help?(options[:help])
+      raise_invalid_error('Dry run', 'true or false', options[:dry_run])                 unless valid_dry_run?(options[:dry_run])
+      raise_invalid_error('No profile', 'true or false', options[:no_profile])           unless valid_no_profile?(options[:no_profile])
+      raise_invalid_error('Quiet', 'true or false', options[:quiet])                     unless valid_quiet?(options[:quiet])
+      raise_invalid_error('Strict', 'true or false', options[:strict])                   unless valid_strict?(options[:strict])
+      raise_invalid_error('Verbose', 'true or false', options[:verbose])                 unless valid_verbose?(options[:verbose])
+      raise_invalid_error('Version', 'true or false', options[:version])                 unless valid_version?(options[:version])
+      raise_invalid_error('Wip', 'true or false', options[:wip])                         unless valid_wip?(options[:wip])
+      raise_invalid_error('Names', 'a String or Array', options[:names])                 unless valid_names?(options[:names])
+      raise_invalid_error('Requires', 'a String or Array', options[:requires])           unless valid_requires?(options[:requires])
+      raise_invalid_error('Options', 'a String or Array', options[:options])             unless valid_options?(options[:options])
+    end
+
+    def append_options(command, option_set, flag= nil)
+      option_set.each do |option|
+        append_option(command, option, flag)
+      end
+    end
+
+    def append_option(command, option, flag= nil)
+      command << " #{flag}" if flag
+      command << " #{option}"
+    end
+
+    def wrap_options(option_set)
+      option_set.is_a?(Array) ? option_set : [option_set]
+    end
+
+    def raise_invalid_error(option, valid_types, value_used)
+      raise(ArgumentError, "#{option} option must be #{valid_types}, got: #{value_used.class}")
+    end
+
+    def valid_profiles?(profiles)
+      valid_string_array_value?(profiles)
+    end
+
+    def valid_tags?(tags)
+      valid_string_array_value?(tags)
+    end
+
+    def valid_file_paths?(file_paths)
+      valid_string_array_value?(file_paths)
+    end
+
+    def valid_formatters?(formatters)
+      valid_hash_value?(formatters)
+    end
+
+    def valid_excludes?(excludes)
+      valid_string_array_value?(excludes)
+    end
+
+    def valid_no_source?(no_source)
+      valid_boolean_value?(no_source)
+    end
+
+    def valid_no_color?(no_color)
+      valid_boolean_value?(no_color)
+    end
+
+    def valid_color?(color)
+      valid_boolean_value?(color)
+    end
+
+    def valid_backtrace?(backtrace)
+      valid_boolean_value?(backtrace)
+    end
+
+    def valid_wip?(wip)
+      valid_boolean_value?(wip)
+    end
+
+    def valid_no_profile?(no_profile)
+      valid_boolean_value?(no_profile)
+    end
+
+    def valid_expand?(expand)
+      valid_boolean_value?(expand)
+    end
+
+    def valid_strict?(strict)
+      valid_boolean_value?(strict)
+    end
+
+    def valid_verbose?(verbose)
+      valid_boolean_value?(verbose)
+    end
+
+    def valid_version?(version)
+      valid_boolean_value?(version)
+    end
+
+    def valid_quiet?(quiet)
+      valid_boolean_value?(quiet)
+    end
+
+    def valid_guess?(guess)
+      valid_boolean_value?(guess)
+    end
+
+    def valid_help?(help)
+      valid_boolean_value?(help)
+    end
+
+    def valid_dry_run?(dry_run)
+      valid_boolean_value?(dry_run)
+    end
+
+    def valid_names?(names)
+      valid_string_array_value?(names)
+    end
+
+    def valid_requires?(requires)
+      valid_string_array_value?(requires)
+    end
+
+    def valid_options?(options)
+      valid_string_array_value?(options)
+    end
+
+    def valid_string_array_value?(value)
+      value.nil? || value.is_a?(Array) || value.is_a?(String)
+    end
+
+    def valid_boolean_value?(value)
+      value.nil? || (value == true) || (value == false)
+    end
+
+    def valid_hash_value?(value)
+      value.nil? || value.is_a?(Hash)
+    end
+
+  end
+end

data/lib/cuke_commander/version.rb

@@ -0,0 +1,5 @@
+module CukeCommander
+
+  # The current version for the gem.
+  VERSION = '1.0.0'
+end

data/spec/cl_generator_spec.rb

@@ -0,0 +1,249 @@
+require 'spec_helper'
+
+
+describe 'CLGenerator, Unit' do
+
+  let(:clazz) { CukeCommander::CLGenerator }
+  let(:generator) { clazz.new }
+
+
+  it 'is defined' do
+    expect(CukeCommander.const_defined?(:CLGenerator)).to be true
+  end
+
+  it 'can generate a command line' do
+    expect(generator).to respond_to(:generate_command_line)
+  end
+
+  it 'returns a string that represents a Cucumber command line' do
+    expect(generator.generate_command_line).to be_a String
+    expect(generator.generate_command_line).to match(/^cucumber ?/)
+  end
+
+  it 'can build a command line based on options' do
+    expect(generator.method(:generate_command_line).arity).to eq(-1)
+  end
+
+  describe 'option handling' do
+
+    all_options = {profiles: 'foo',
+                   tags: 'foo',
+                   file_paths: 'foo',
+                   formatters: {some_formatter: 'some_file.txt'},
+                   excludes: 'foo',
+                   no_source: true,
+                   no_color: true,
+                   options: 'foo',
+                   backtrace: true,
+                   color: true,
+                   dry_run: true,
+                   expand: true,
+                   guess: true,
+                   help: true,
+                   names: 'foo',
+                   no_profile: true,
+                   quiet: true,
+                   requires: 'foo',
+                   strict: true,
+                   verbose: true,
+                   version: true,
+                   wip: true
+    }
+
+    let(:test_options) { all_options.dup }
+    let(:bad_value) { 7 }
+
+    before(:all) do
+      # Not an actual test but here to make sure that the test data is
+      # updated when options are added or removed
+      expect(all_options.keys).to match_array(CukeCommander::CUKE_OPTIONS.collect { |option| option.to_sym })
+    end
+
+    it 'can handle generating a command line when no options are provided' do
+      expect { generator.generate_command_line }.to_not raise_exception
+    end
+
+    it 'can handle generating a command line when all options are provided' do
+      expect { generator.generate_command_line(all_options) }.to_not raise_exception
+    end
+
+    it 'only accepts cucumber options' do
+      options = {:not_a_cucumber_option => ['123', '345', '678']}
+      expect { generator.generate_command_line(options) }.to raise_exception
+    end
+
+    CukeCommander::CUKE_OPTIONS.each do |option|
+
+      it "can handle generating a command line when the '#{option}' option is provided" do
+        test_options.keep_if { |key, value| key == option }
+
+        expect { generator.generate_command_line }.to_not raise_exception
+      end
+
+      it "can handle generating a command line when the '#{option}' option is not provided" do
+        test_options.delete_if { |key, value| key == option }
+
+        expect { generator.generate_command_line }.to_not raise_exception
+      end
+
+      it "validates the '#{option}' option" do
+        test_options[option.to_sym] = bad_value
+
+        expect { generator.generate_command_line(test_options) }.to raise_error(ArgumentError, /must.*got.*#{bad_value.class}/)
+      end
+
+    end
+
+    it 'only accepts an options Hash as an argument' do
+      options = [1, 2, 3]
+
+      expect { generator.generate_command_line(options) }.to raise_error(ArgumentError, /must.*Hash.*got.*#{options.class}/)
+    end
+
+    it 'only accepts a string or array as a profile value' do
+      expect { generator.generate_command_line({profiles: 'foo'}) }.to_not raise_error
+      expect { generator.generate_command_line({profiles: ['foo', 'bar']}) }.to_not raise_error
+      expect { generator.generate_command_line({profiles: bad_value}) }.to raise_error(ArgumentError, /must.*String or Array.*got.*#{bad_value.class}/)
+    end
+
+    it 'only accepts a string or array as a tag value' do
+      expect { generator.generate_command_line({tags: 'foo'}) }.to_not raise_error
+      expect { generator.generate_command_line({tags: ['foo', 'bar']}) }.to_not raise_error
+      expect { generator.generate_command_line({tags: bad_value}) }.to raise_error(ArgumentError, /must.*String or Array.*got.*#{bad_value.class}/)
+    end
+
+    it 'only accepts a string or array as a file path value' do
+      expect { generator.generate_command_line({file_paths: 'foo'}) }.to_not raise_error
+      expect { generator.generate_command_line({file_paths: ['foo', 'bar']}) }.to_not raise_error
+      expect { generator.generate_command_line({file_paths: bad_value}) }.to raise_error(ArgumentError, /must.*String or Array.*got.*#{bad_value.class}/)
+    end
+
+    it 'only accepts a hash as a formatters value' do
+      expect { generator.generate_command_line({formatters: {}}) }.to_not raise_error
+      expect { generator.generate_command_line({formatters: bad_value}) }.to raise_error(ArgumentError, /must.*Hash.*got.*#{bad_value.class}/)
+    end
+
+    it 'only accepts a string or array as an excluded patterns value' do
+      expect { generator.generate_command_line({excludes: 'foo'}) }.to_not raise_error
+      expect { generator.generate_command_line({excludes: ['foo', 'bar']}) }.to_not raise_error
+      expect { generator.generate_command_line({excludes: bad_value}) }.to raise_error(ArgumentError, /must.*String or Array.*got.*#{bad_value.class}/)
+    end
+
+    it 'only accepts a boolean as a no-source value' do
+      expect { generator.generate_command_line({no_source: true}) }.to_not raise_error
+      expect { generator.generate_command_line({no_source: false}) }.to_not raise_error
+      expect { generator.generate_command_line({no_source: bad_value}) }.to raise_error(ArgumentError, /must.*true or false.*got.*#{bad_value.class}/)
+    end
+
+    it 'only accepts a boolean as a no-color value' do
+      expect { generator.generate_command_line({no_color: true}) }.to_not raise_error
+      expect { generator.generate_command_line({no_color: false}) }.to_not raise_error
+      expect { generator.generate_command_line({no_color: bad_value}) }.to raise_error(ArgumentError, /must.*true or false.*got.*#{bad_value.class}/)
+    end
+
+    it 'only accepts a boolean as a color value' do
+      expect { generator.generate_command_line({color: true}) }.to_not raise_error
+      expect { generator.generate_command_line({color: false}) }.to_not raise_error
+      expect { generator.generate_command_line({color: bad_value}) }.to raise_error(ArgumentError, /must.*true or false.*got.*#{bad_value.class}/)
+    end
+
+    it 'only accepts a boolean as a backtrace value' do
+      expect { generator.generate_command_line({backtrace: true}) }.to_not raise_error
+      expect { generator.generate_command_line({backtrace: false}) }.to_not raise_error
+      expect { generator.generate_command_line({backtrace: bad_value}) }.to raise_error(ArgumentError, /must.*true or false.*got.*#{bad_value.class}/)
+    end
+
+    it 'only accepts a boolean as a dry run value' do
+      expect { generator.generate_command_line({dry_run: true}) }.to_not raise_error
+      expect { generator.generate_command_line({dry_run: false}) }.to_not raise_error
+      expect { generator.generate_command_line({dry_run: bad_value}) }.to raise_error(ArgumentError, /must.*true or false.*got.*#{bad_value.class}/)
+    end
+
+    it 'only accepts a boolean as an expand value' do
+      expect { generator.generate_command_line({expand: true}) }.to_not raise_error
+      expect { generator.generate_command_line({expand: false}) }.to_not raise_error
+      expect { generator.generate_command_line({expand: bad_value}) }.to raise_error(ArgumentError, /must.*true or false.*got.*#{bad_value.class}/)
+    end
+
+    it 'only accepts a boolean as a guess value' do
+      expect { generator.generate_command_line({guess: true}) }.to_not raise_error
+      expect { generator.generate_command_line({guess: false}) }.to_not raise_error
+      expect { generator.generate_command_line({guess: bad_value}) }.to raise_error(ArgumentError, /must.*true or false.*got.*#{bad_value.class}/)
+    end
+
+    it 'only accepts a boolean as a help value' do
+      expect { generator.generate_command_line({help: true}) }.to_not raise_error
+      expect { generator.generate_command_line({help: false}) }.to_not raise_error
+      expect { generator.generate_command_line({help: bad_value}) }.to raise_error(ArgumentError, /must.*true or false.*got.*#{bad_value.class}/)
+    end
+
+    it 'only accepts a boolean as a quiet value' do
+      expect { generator.generate_command_line({quiet: true}) }.to_not raise_error
+      expect { generator.generate_command_line({quiet: false}) }.to_not raise_error
+      expect { generator.generate_command_line({quiet: bad_value}) }.to raise_error(ArgumentError, /must.*true or false.*got.*#{bad_value.class}/)
+    end
+
+    it 'only accepts a boolean as a strict value' do
+      expect { generator.generate_command_line({strict: true}) }.to_not raise_error
+      expect { generator.generate_command_line({strict: false}) }.to_not raise_error
+      expect { generator.generate_command_line({strict: bad_value}) }.to raise_error(ArgumentError, /must.*true or false.*got.*#{bad_value.class}/)
+    end
+
+    it 'only accepts a boolean as a verbose value' do
+      expect { generator.generate_command_line({verbose: true}) }.to_not raise_error
+      expect { generator.generate_command_line({verbose: false}) }.to_not raise_error
+      expect { generator.generate_command_line({verbose: bad_value}) }.to raise_error(ArgumentError, /must.*true or false.*got.*#{bad_value.class}/)
+    end
+
+    it 'only accepts a boolean as a version value' do
+      expect { generator.generate_command_line({version: true}) }.to_not raise_error
+      expect { generator.generate_command_line({version: false}) }.to_not raise_error
+      expect { generator.generate_command_line({version: bad_value}) }.to raise_error(ArgumentError, /must.*true or false.*got.*#{bad_value.class}/)
+    end
+
+    it 'only accepts a boolean as a wip value' do
+      expect { generator.generate_command_line({wip: true}) }.to_not raise_error
+      expect { generator.generate_command_line({wip: false}) }.to_not raise_error
+      expect { generator.generate_command_line({wip: bad_value}) }.to raise_error(ArgumentError, /must.*true or false.*got.*#{bad_value.class}/)
+    end
+
+    it 'only accepts a boolean as a no profile value' do
+      expect { generator.generate_command_line({no_profile: true}) }.to_not raise_error
+      expect { generator.generate_command_line({no_profile: false}) }.to_not raise_error
+      expect { generator.generate_command_line({no_profile: bad_value}) }.to raise_error(ArgumentError, /must.*true or false.*got.*#{bad_value.class}/)
+    end
+
+    it 'only accepts a string or array as a require value' do
+      expect { generator.generate_command_line({requires: 'foo'}) }.to_not raise_error
+      expect { generator.generate_command_line({requires: ['foo', 'bar']}) }.to_not raise_error
+      expect { generator.generate_command_line({requires: bad_value}) }.to raise_error(ArgumentError, /must.*String or Array.*got.*#{bad_value.class}/)
+    end
+
+    it 'only accepts a string or array as a name value' do
+      expect { generator.generate_command_line({names: 'foo'}) }.to_not raise_error
+      expect { generator.generate_command_line({names: ['foo', 'bar']}) }.to_not raise_error
+      expect { generator.generate_command_line({names: bad_value}) }.to raise_error(ArgumentError, /must.*String or Array.*got.*#{bad_value.class}/)
+    end
+
+    it 'only accepts a string or array as an options value' do
+      expect { generator.generate_command_line({options: 'foo'}) }.to_not raise_error
+      expect { generator.generate_command_line({options: ['foo', 'bar']}) }.to_not raise_error
+      expect { generator.generate_command_line({options: bad_value}) }.to raise_error(ArgumentError, /must.*String or Array.*got.*#{bad_value.class}/)
+    end
+  end
+
+  describe 'old bugs' do
+    # Was doing an existence check instead of a true/false check
+    it 'will not set no_source flag when value is false' do
+      options = {no_source: false}
+      expect(generator.generate_command_line(options)).to eq('cucumber')
+    end
+
+    # Was doing an existence check instead of a true/false check
+    it 'will not set no_color flag when value is false' do
+      options = {no_color: false}
+      expect(generator.generate_command_line(options)).to eq('cucumber')
+    end
+  end
+
+end

data/spec/cuke_commander_spec.rb

@@ -0,0 +1,17 @@
+require 'spec_helper'
+
+
+describe 'CukeCommander, Unit' do
+
+  let(:nodule) { CukeCommander }
+
+
+  it 'is defined' do
+    expect(Kernel.const_defined?(:CukeCommander)).to be true
+  end
+
+  it 'defines the available Cucumber options' do
+    expect(nodule.const_defined?(:CUKE_OPTIONS)).to be true
+  end
+
+end

data/spec/spec_helper.rb

@@ -0,0 +1,5 @@
+require 'simplecov'
+SimpleCov.command_name 'cuke_commander-rspec'
+
+
+require 'cuke_commander'

metadata

@@ -0,0 +1,164 @@
+--- !ruby/object:Gem::Specification
+name: cuke_commander
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+  prerelease: 
+platform: ruby
+authors:
+- Eric Kessler
+- Donavan Stanley
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-03-20 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.6'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.6'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: cucumber
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: simplecov
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Command Cucumber
+email:
+- morrow748@gmail.com
+- stanleyd@grangeinsurance.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- .simplecov
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- cuke_commander.gemspec
+- features/command_line_format.feature
+- features/cucumber_options.feature
+- features/generate_command_line.feature
+- features/step_definitions/action_steps.rb
+- features/step_definitions/setup_steps.rb
+- features/step_definitions/verification_steps.rb
+- features/support/env.rb
+- lib/cuke_commander.rb
+- lib/cuke_commander/cl_generator.rb
+- lib/cuke_commander/version.rb
+- spec/cl_generator_spec.rb
+- spec/cuke_commander_spec.rb
+- spec/spec_helper.rb
+homepage: https://github.com/grange-insurance/cuke_commander
+licenses:
+- MIT
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+      segments:
+      - 0
+      hash: 772110449
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+      segments:
+      - 0
+      hash: 772110449
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.24
+signing_key: 
+specification_version: 3
+summary: Provides an easy way to build a cucumber commandline.
+test_files:
+- features/command_line_format.feature
+- features/cucumber_options.feature
+- features/generate_command_line.feature
+- features/step_definitions/action_steps.rb
+- features/step_definitions/setup_steps.rb
+- features/step_definitions/verification_steps.rb
+- features/support/env.rb
+- spec/cl_generator_spec.rb
+- spec/cuke_commander_spec.rb
+- spec/spec_helper.rb