cellophane 0.1.0

data/features/step_definitions.feature

@@ -0,0 +1,47 @@
+Feature: Step Definitions
+
+@1
+Scenario: Requiring existing step definition
+
+Given a project directory with the following structure
+ | type      | path                                   |
+ | directory | features                               |
+ | directory | features/step_definitions              |
+ | file      | features/one.feature                   |
+ | file      | features/two.feature                   |
+ | file      | features/step_definitions/one_steps.rb |
+When Cellophane is called with "one"
+Then the command should include "features/one.feature"
+And the command should include "-r features/step_definitions/one_steps.rb"
+
+@2
+Scenario: Not requiring step definition that doesn't exist
+
+Given a project directory with the following structure
+ | type      | path                                   |
+ | directory | features                               |
+ | directory | features/step_definitions              |
+ | file      | features/one.feature                   |
+ | file      | features/two.feature                   |
+ | file      | features/step_definitions/one_steps.rb |
+When Cellophane is called with "two"
+Then the command should include "features/two.feature"
+And the command should not include "-r features/step_definitions/two_steps.rb"
+
+@3
+Scenario: Step definitions nested in feature subdirectories
+
+Given a project directory with the following structure
+ | type      | path                                         |
+ | directory | features                                     |
+ | directory | features/admin                               |
+ | directory | features/admin/step_definitions              |
+ | file      | features/admin/one.feature                   |
+ | file      | features/admin/two.feature                   |
+ | file      | features/admin/step_definitions/one_steps.rb |
+And a project options file with the following options
+ | option                                   |
+ | step_path: {nested_in: step_definitions} |
+When Cellophane is called with "admin/one"
+Then the command should include "features/admin/one.feature"
+And the command should include "-r features/admin/step_definitions/one_steps.rb"

data/features/support/cellophane_methods.rb

@@ -0,0 +1,29 @@
+module CellophaneMethods
+	def call_cellophane(args = [])
+		cellophane = Cellophane::Main.new(args)
+		@command = cellophane.command
+		@message = cellophane.message
+	end
+
+	def output_command
+		puts "\n\n#{@command}\n\n"
+	end
+
+	def output_message
+		puts "\n\n#{@message}\n\n"
+	end
+	
+	def save_initial_dir
+		@initial_dir = Dir.pwd
+	end
+	
+	def restore_initial_dir
+		Dir.chdir(@initial_dir)
+	end
+	
+	def ensure_project_dir_removed
+		FileUtils.remove_dir(@project_dir, true) if @project_dir && File.exist?(@project_dir)
+	end
+end
+
+World(CellophaneMethods)

data/features/support/cellophane_steps.rb

@@ -0,0 +1,43 @@
+Given /^I debug$/ do
+	require 'ruby-debug'
+	debugger
+	puts "\n\ndebugging\n\n"
+end
+
+Given /^Cellophane is called with "([^"]*)"$/ do |args|
+	call_cellophane(args.split(' '))
+end
+
+Given /^the (command|message) should include "([^"]+)"$/ do |what, expected|
+	(what == 'command' ? @command : @message).should =~ /#{expected}/
+end
+
+Given /^the (command|message) should not include "([^"]+)"$/ do |what, expected|
+	(what == 'command' ? @command : @message).should_not =~ /#{expected}/
+end
+
+Given /^a project directory with the following structure$/ do |structure|
+	@project_dir = './test_project'
+	# just in case the last run failed to exit cleanly, delete the test_project directory
+	# if it exists
+	FileUtils.remove_dir(@project_dir, true) if File.exist?(@project_dir)
+	FileUtils.mkdir(@project_dir)
+	Dir.chdir(@project_dir)
+	
+	structure.hashes.each do |entry|
+		if entry[:type] == 'directory'
+			FileUtils.mkdir_p(entry[:path])
+		else
+			File.open(entry[:path], 'w') {|f| f.write("# #{entry[:path]}") }
+		end
+	end
+end
+
+Given /^a project options file with the following options$/ do |lines|
+	options = lines.hashes.collect { |line| line[:option] }
+	
+	contents = options.join("\n")
+	
+	# already in the project dir
+	File.open(Cellophane::PROJECT_OPTIONS_FILE, 'w') { |f| f.write(contents) }
+end

data/features/support/env.rb

@@ -0,0 +1,17 @@
+$LOAD_PATH.unshift(File.dirname(__FILE__) + '/../../lib')
+require 'cellophane/main'
+require 'rspec/expectations'
+
+Before do
+	save_initial_dir
+	ensure_project_dir_removed
+end
+
+Before('@debug') do
+	require 'ruby-debug'
+end
+
+After do
+	restore_initial_dir
+	ensure_project_dir_removed
+end

data/features/tags.feature

@@ -0,0 +1,55 @@
+Feature: Tags
+
+@1
+Scenario: OR tag
+
+When Cellophane is called with "-t one,two"
+Then the command should include "-t @one,@two"
+
+@2
+Scenario: NOT tag
+
+When Cellophane is called with "-t one,~two"
+Then the command should include "-t @one -t ~@two"
+
+@3
+Scenario: AND tag
+
+When Cellophane is called with "-t one,+two"
+Then the command should include "-t @one -t @two"
+
+@4
+Scenario: Mixed tags in a logical order
+
+When Cellophane is called with "-t one,two,~three,+four"
+Then the command should include "-t @one,@two -t @four -t ~@three"
+
+@5
+Scenario: Mixed tags not in a logical order
+
+When Cellophane is called with "-t +four,one,~three,two"
+Then the command should include "-t @one,@two -t @four -t ~@three"
+
+@6
+Scenario: Numeric OR tag ranges
+
+When Cellophane is called with "-t 1-3"
+Then the command should include "-t @1,@2,@3"
+
+@7
+Scenario: Numeric NOT tag ranges
+
+When Cellophane is called with "-t ~1-3"
+Then the command should include "-t ~@1 -t ~@2 -t ~@3"
+
+@8
+Scenario: Numeric OR tag range with a NOT in the OR range
+
+When Cellophane is called with "-t 1-3,~2"
+Then the command should include "-t @1,@3"
+
+@9
+Scenario: Numeric OR tag range with a NOT out of the OR range
+
+When Cellophane is called with "-t 1-3,~slow"
+Then the command should include "-t @1,@2,@3 -t ~@slow"

data/lib/cellophane/main.rb

@@ -0,0 +1,82 @@
+require 'fileutils'
+require 'cellophane/parser'
+require 'cellophane/options'
+
+module Cellophane
+	
+	PROJECT_OPTIONS_FILE = '.cellophane.yaml'
+	
+	class Main
+		attr_reader :command, :message, :project_options_file
+		
+		def initialize(args = nil)
+			args ||= ARGV
+			@project_options_file = Cellophane::PROJECT_OPTIONS_FILE
+			@options = Cellophane::Options.parse(args)
+			
+			@message = 'Invalid regular expression provided.' and return if @options[:regexp] && @options[:pattern].nil?
+			
+			parser = Cellophane::Parser.new(@options)
+			@features = parser.features
+			
+			@message = 'No features matching PATTERN were found.' and return unless @features
+			
+			@tags = parser.tags
+			
+			@command = generate_command
+		end
+
+		def run
+			puts @message and return if @message
+			@options[:print] ? puts(@command) : system("#{@command}\n\n")
+		end
+		
+		private
+		
+		def generate_command
+			cuke_cmd = "cucumber #{@options[:cucumber]}"
+
+			features = []
+			steps = []
+
+			if @features.any?
+				@features.each do |file|
+					file_parts = split_feature(file)
+					features << construct_feature_file(file_parts[:path], file_parts[:name])
+					steps << construct_step_file(file_parts[:path], file_parts[:name])
+				end
+				
+			else
+				# if there are no features explicitly identified, then cucumber will run all. However,
+				# if we are using non-standard locations for features or step definitions, we must tell
+				# cucumber accordingly
+				features << @options[:feature_path] if @options[:non_standard_feature_path]
+				steps << @options[:step_path] if @options[:non_standard_step_path]
+			end
+
+			requires = (@options[:requires] + steps).compact.uniq
+			cuke_cmd += " -r #{requires.join(' -r ')}" if requires.any?
+			cuke_cmd += " #{features.join(' ')}" if features.any?
+			return "#{cuke_cmd} #{@tags}".gsub('  ', ' ')
+		end
+		
+		def construct_feature_file(path, file)
+			"#{@options[:feature_path]}/#{path}/#{file}.feature".gsub('//', '/')
+		end
+		
+		def construct_step_file(path, file)
+			step_path = @options[:step_path].is_a?(Hash) ? "#{@options[:feature_path]}/#{path}/#{@options[:step_path][:nested_in]}" : "#{@options[:step_path]}/#{path}"
+			step_file = "#{step_path}/#{file}_steps.rb".gsub('//', '/')
+			return File.exist?(step_file) ? step_file : nil
+		end
+		
+		def split_feature(file)
+			name = File.basename(file, '.feature')
+			# now get rid of the file_name and the feature_path
+			path = File.dirname(file).gsub(@options[:feature_path_regexp], '')
+			return {:path => path, :name => name}
+		end
+
+	end # class Main
+end # module Cellophane
+

data/lib/cellophane/options.rb

@@ -0,0 +1,145 @@
+require 'optparse'
+require 'yaml'
+
+module Cellophane
+	class Options
+		def self.parse(args)
+			default_options = self.get_options(:default)
+			project_options = self.get_options(:project)
+			merged_options = default_options.merge(project_options)
+			
+			option_parser = OptionParser.new do |opts|
+				# Set a banner, displayed at the top of the help screen.
+				# TODO add example usage including ~feature, patterns, and ~tag
+				opts.banner = "Usage: cellophane [options] PATTERN"
+
+				opts.on('-r', '--regexp', 'PATTERN is a regular expression. Default is false.') do
+					merged_options[:regexp] = true
+				end
+				
+				opts.on('-t', '--tags TAGS', 'Tags to include/exclude.') do |tags|
+					merged_options[:tags] = tags
+				end
+
+				opts.on('-c', '--cucumber OPTIONS', 'Options to pass to cucumber.') do |cucumber|
+					merged_options[:cucumber] = cucumber
+				end
+	
+				opts.on('-p', '--print', 'Echo the command instead of calling cucumber.') do
+					merged_options[:print] = true
+				end
+
+				opts.on('-d', '--debug', 'Require ruby-debug.') do
+					require 'rubygems'
+					require 'ruby-debug'
+				end
+
+				# This displays the help screen, all programs are assumed to have this option.
+				opts.on( '-h', '--help', 'Display this screen.' ) do
+					puts opts
+					exit(0)
+				end
+			end
+
+			option_parser.parse!(args)
+			
+			# get the pattern from the command line (no switch)
+			merged_options[:pattern] = args.first if args.any?
+
+			return self.normalize_options(merged_options)
+		end # self.parse
+		
+		private
+		
+		def self.get_options(type = :default)
+			if type == :project
+				project_options = {}
+				
+				# load is used here due to require not requiring a file if
+				# it has already been required. This is mainly for testing
+				# purposes (multiple features needing to have different
+				# options for validation), but it shouldn't make a difference
+				# for run time.
+				#load project_options_file if File.exist?(project_options_file)
+				
+				if File.exist?(Cellophane::PROJECT_OPTIONS_FILE)
+					yaml_options = YAML.load_file(Cellophane::PROJECT_OPTIONS_FILE)
+					
+					['cucumber', 'feature_path', 'feature_path_regexp', 'step_path', 'requires'].each do |key|
+						project_options[key.to_sym] = yaml_options[key] if yaml_options.has_key?(key)
+					end
+				end
+				
+				project_options
+			else
+				{
+					:pattern => nil,
+					:regexp => false,
+					:print => false,
+					:cucumber => nil,
+					:tags => nil,
+					:feature_path => 'features',
+					:feature_path_regexp => nil,
+					:step_path => 'features/step_definitions',
+					:requires => []
+				}
+			end
+		end # get_options
+		
+		def self.normalize_options(options)
+			defaults = self.get_options(:default)
+
+			# ran into freezing problems in Ruby 1.9.2 otherwise
+			tmp_options = options.dup
+			
+			# normalize the paths for features and steps
+			# had originally used the gsub! and sub!, but hit freezing problems with Ruby 1.9.2
+			
+			# globs don't work with backslashes (if on windows)
+			tmp_options[:feature_path] = tmp_options[:feature_path].gsub(/\\/, '/')
+			# strip trailing slash
+			tmp_options[:feature_path] = tmp_options[:feature_path].sub(/\/$/, '')
+
+			if tmp_options[:step_path].is_a?(Hash)
+				# if the step path is configured in YAML, it will be a string key, not a symbol
+				key = tmp_options[:step_path].has_key?('nested_in') ? 'nested_in' : :nested_in
+				if tmp_options[:step_path].has_key?(key)
+					tmp_options[:step_path][:nested_in] = tmp_options[:step_path][key].gsub(/\\/, '/')
+					tmp_options[:step_path][:nested_in] = tmp_options[:step_path][key].sub(/\/$/, '')
+				end
+			else
+				tmp_options[:step_path] = tmp_options[:step_path].gsub(/\\/, '/')
+				tmp_options[:step_path] = tmp_options[:step_path].sub(/\/$/, '')
+			end
+			
+			# need to know this later
+			tmp_options[:non_standard_feature_path] = tmp_options[:feature_path] != defaults[:feature_path]
+			tmp_options[:non_standard_step_path] = tmp_options[:step_path] != defaults[:step_path]
+			
+			# make a regexp out of the features path if there isn't one already. we need to escape slashes so the
+			# regexp can be made
+			tmp_options[:feature_path_regexp] = Regexp.new(tmp_options[:feature_path].gsub('/', '\/')) unless tmp_options[:feature_path_regexp]
+			
+			# just in case someone sets necessary values to nil, let's go back to defaults
+			tmp_options[:regexp] ||= defaults[:regexp]
+			tmp_options[:feature_path] ||= defaults[:feature_path]
+			tmp_options[:step_path] ||= defaults[:step_path]
+			tmp_options[:requires] ||= defaults[:requires]
+			
+			# do what needs to be done on the pattern
+			unless tmp_options[:pattern].nil?
+				tmp_options[:pattern] = tmp_options[:pattern].strip
+				tmp_options[:pattern] = nil unless tmp_options[:pattern] && !tmp_options[:pattern].empty?
+			
+				begin
+					tmp_options[:pattern] = Regexp.new(tmp_options[:pattern]) if tmp_options[:regexp]
+				rescue
+					# if the regexp fails for some reason
+					tmp_options[:pattern] = nil
+				end
+			end
+			
+			return tmp_options
+		end # normalize_options
+	end # class Options
+end

data/lib/cellophane/parser.rb

@@ -0,0 +1,137 @@
+module Cellophane
+	class Parser
+		def initialize(options)
+			@options = options
+		end
+		
+		def features
+			# if no pattern is specified, let cucumber run 'em all
+			return [] if @options[:pattern].nil?
+			collected_features = @options[:regexp] ? collect_features_by_regexp : collect_features_by_glob
+			return collected_features.any? ? collected_features : nil
+		end # features
+
+		def tags
+			tags = {
+				:or => [],
+				:and => [],
+				:not => []
+			}
+
+			return '' if @options[:tags].nil?
+
+			@options[:tags].split(',').each do |t|
+				# if tags are numeric, let's support ranges !!!
+				if t =~ /^(~)?([0-9]+)-([0-9]+)$/
+					x = $2.to_i
+					y = $3.to_i
+					exclude = $1
+				
+					# in case the user put them in the wrong order ... doh!
+					if x > y
+						z = x.dup
+						x = y.dup
+						y = z.dup
+					end
+				
+					(x..y).each do |i|
+						if exclude
+							tags[:not] << "#{i}"
+						else
+							tags[:or] << "#{i}"
+						end
+					end
+				else
+					if t =~ /^~(.+)/
+						tags[:not] << $1
+					elsif t =~ /^\+(.+)/
+						tags[:and] << $1
+					else
+						tags[:or] << t
+					end
+				end
+			end # each
+
+			[:and, :or, :not].each { |type| tags[type].uniq! }
+			
+			# if there are AND/OR tags, remove any NOT tags so we avoid
+			# duplicating the tag when passing to cucumber...so instead of
+			# cucumber -t @1,@2,@3 -t ~@2
+			# we'd like to see
+			# cucumber -t @1,@3
+
+			intersection = tags[:or] & tags[:not]
+			tags[:or] -= intersection
+			tags[:not] -= intersection
+
+			intersection = tags[:and] & tags[:not]
+			tags[:and] -= intersection
+			tags[:not] -= intersection
+
+			# now add @ and ~ as appropriate
+			tags[:or].each_with_index { |tag, i| tags[:or][i] = "@#{tag}" }
+			tags[:and].each_with_index { |tag, i| tags[:and][i] = "@#{tag}" }
+			tags[:not].each_with_index { |tag, i| tags[:not][i] = "~@#{tag}" }
+
+			tags_fragment = ''
+			tags_fragment += "-t #{tags[:or].join(',')} " if tags[:or].any?
+			tags_fragment += "-t #{tags[:and].join(' -t ')} " if tags[:and].any?
+			tags_fragment += "-t #{tags[:not].join(' -t ')}" if tags[:not].any?
+	
+			# if the user passes in tags with @ already in it
+			tags_fragment.gsub('@@', '@')
+		end # def self.parse_tags
+		
+		private
+
+		def collect_features_by_regexp
+			features = []
+
+			# start by globbing all feature files
+			Dir.glob("#{@options[:feature_path]}/**/*.feature").each do |feature_file|
+				# keep the ones that match the regexp
+				features << feature_file if @options[:pattern].match(feature_file)
+			end
+			
+			features.uniq
+		end # collect_features_by_regexp
+		
+		def collect_features_by_glob
+			only = []
+			except = []
+			features_to_include = []
+			features_to_exclude = []
+			pattern = @options[:pattern].dup
+
+			# want to run certain ones and/or exclude certain ones
+			pattern.split(',').each do |f|
+				if f[0].chr == '~'
+					except << f[1..f.length]
+				else
+					only << f
+				end
+			end
+
+			# if we have an exception, we want to get all features by default
+			pattern = '**/*' if except.any?
+			# unless we specifically say we want only certain ones
+			pattern = nil if only.any?
+
+			if only.any?
+				only.each do |f|
+					features_to_include += Dir.glob("#{@options[:feature_path]}/#{f}.feature")
+				end
+			else
+				features_to_include += Dir.glob("#{@options[:feature_path]}/#{pattern}.feature")
+			end
+
+			if except.any?
+				except.each do |f|
+					features_to_exclude = Dir.glob("#{@options[:feature_path]}/#{f}.feature")
+				end
+			end
+	
+			(features_to_include - features_to_exclude).uniq
+		end # collect_features_by_glob
+	end # class Parser
+end # module Cellophane

data/spec/cellophane_spec.rb

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

data/spec/spec_helper.rb

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

metadata

@@ -0,0 +1,87 @@
+--- !ruby/object:Gem::Specification 
+name: cellophane
+version: !ruby/object:Gem::Version 
+  prerelease: false
+  segments: 
+  - 0
+  - 1
+  - 0
+  version: 0.1.0
+platform: ruby
+authors: 
+- Phillip Koebbe
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-01-09 00:00:00 -06:00
+default_executable: cellophane
+dependencies: []
+
+description: Cellophane is a thin wrapper around Cucumber, making it easier to be creative when running features.
+email: phillip@livingdoor.net
+executables: 
+- cellophane
+extensions: []
+
+extra_rdoc_files: 
+- LICENSE.txt
+- README.textile
+files: 
+- .cellophane.yaml
+- .cellophane.yaml.sample
+- .document
+- LICENSE.txt
+- README.textile
+- Rakefile
+- VERSION
+- bin/cellophane
+- features/feature_paths.feature
+- features/glob_pattern.feature
+- features/project_options.feature
+- features/regular_expression_pattern.feature
+- features/step_definitions.feature
+- features/support/cellophane_methods.rb
+- features/support/cellophane_steps.rb
+- features/support/env.rb
+- features/tags.feature
+- lib/cellophane/main.rb
+- lib/cellophane/options.rb
+- lib/cellophane/parser.rb
+- spec/cellophane_spec.rb
+- spec/spec_helper.rb
+has_rdoc: true
+homepage: http://github.com/phillipkoebbe/cellophane
+licenses: 
+- MIT
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: A thin wrapper around Cucumber.
+test_files: 
+- spec/cellophane_spec.rb
+- spec/spec_helper.rb