step_master 0.0.1

data/History.txt

@@ -0,0 +1,3 @@
+=== 0.0.1 2009-10-14
+
+* Initial release

data/Manifest.txt

@@ -0,0 +1,12 @@
+History.txt
+Manifest.txt
+PostInstall.txt
+README.rdoc
+Rakefile
+lib/step_master.rb
+lib/step_master/matcher.rb
+lib/step_master/possible.rb
+lib/step_master/step_item.rb
+lib/step_master/step_variable.rb
+spec/spec_helper.rb
+spec/step_helper/matcher_spec.rb

data/PostInstall.txt

@@ -0,0 +1 @@
+For more information on step_master, see http://github.com/clearwavebuild/step_master

data/README.rdoc

@@ -0,0 +1,53 @@
+= StepMaster
+
+http://github.com/clearwavebuild/step_master
+
+== DESCRIPTION:
+
+Provide a simple and easy way to find and auto-complete gherkin steps, when writing cucumber features
+
+== FEATURES/PROBLEMS:
+
+none
+
+== SYNOPSIS:
+
+	require 'step_master'
+
+	matcher = StepMaster::Matcher.new			
+	matcher << "Given /^I like pie$/ do"
+	matcher << "Given /^I like cake$/ do"
+	
+	matcher.complete("Given I like") #=> ["pie", "cake"]
+	
+
+== REQUIREMENTS:
+
+none
+
+== INSTALL:
+
+	sudo gem install clearwavebuild-step_master -s http://gems.github.com
+
+== LICENSE:
+
+Copyright (c) 2009 Clearwave Inc
+
+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/Rakefile

@@ -0,0 +1,26 @@
+require 'rubygems'
+gem 'hoe', '>= 2.1.0'
+require 'hoe'
+require 'fileutils'
+require './lib/step_master'
+
+Hoe.plugin :newgem
+# Hoe.plugin :website
+# Hoe.plugin :cucumberfeatures
+
+# Generate all the Rake tasks
+# Run 'rake -T' to see list of generated tasks (from gem root directory)
+$hoe = Hoe.spec 'step_master' do
+  self.developer 'Jim Holmes', '32bitkid@gmail.com'
+  self.post_install_message = 'PostInstall.txt' # TODO remove if post-install message not required
+  self.rubyforge_name       = self.name # TODO this is default value
+  # self.extra_deps         = [['activesupport','>= 2.0.2']]
+
+end
+
+require 'newgem/tasks'
+Dir['tasks/**/*.rake'].each { |t| load t }
+
+# TODO - want other tests/tasks run by default? Add them to the list
+# remove_task :default
+# task :default => [:spec, :features]

data/lib/step_master/matcher.rb

@@ -0,0 +1,126 @@
+#!/usr/bin/env ruby
+
+require 'step_master/step_item'
+require 'step_master/step_variable'
+require 'step_master/possible'
+
+# Provide a simple and easy way to find and auto-complete gherkin steps,
+# when writing cucumber features
+# See StepMaster for usage details.
+module StepMaster
+
+	# This class collects raw steps as strings.
+	# 
+  # The complete method returns a list of all possible
+	# steps that start with a given string (taking into
+	# account captures and imbedded regexps).
+	# 
+	# The is_match? method lets you check if a string exactly
+	# matches to a step definition
+	#
+	class Matcher
+		
+		STEP_REGEX = /^\s*(Given|Then|When)\s*\(?\s*\/\^?(.*)\/(\w*)\s*\)?\s*(?:do|\{)\s*(\|[^\|]+\|)?/.freeze
+		ARG_NAMES_REGEX = /\|(.*)\|/
+		ARG_TEXT_REGEX = /\(.*?[^\\]\)\??/
+		NON_CAPTURE_REGEX = /\(\?\:/
+		CHUNK_REGEX = /\S+|\s\??/
+		
+		attr_reader :match_table
+		
+		def initialize
+			@match_table = Possible.new
+		end
+		
+		# Insert a Ruby Step definition into the Match Table
+		#
+		# ==== Examples
+		#	  matcher << "Given /^this is a step$/ do"
+		#
+		def <<(value)
+			raise "#{value.inspect} is not a step" unless value =~ STEP_REGEX
+			
+			full_line = $&
+			step_type = $1
+			regex = $2.chomp("$")
+			regex_options = $3
+			args = $4
+			
+			arg_names = (args =~ ARG_NAMES_REGEX) ? $1.split(/\s*,\s*/) : []
+			arg_regexs = regex.chomp("$").scan(ARG_TEXT_REGEX)
+			
+			arg_objects = arg_regexs.collect do |x|
+				is_non_capture = (x =~ NON_CAPTURE_REGEX) != nil
+				StepVariable.new(x, regex_options, (is_non_capture) ? nil : arg_names.shift)
+			end
+			
+			
+			elements = if arg_regexs.length > 0
+				regex.split(Regexp.union(arg_regexs.collect { |x|
+					Regexp.new(Regexp.escape(x))
+				})).collect { |x|
+					x.scan(CHUNK_REGEX).collect { |i| StepItem.new(i, regex_options) }
+				}.zip(arg_objects).flatten.compact.unshift(StepItem.new(" ", regex_options)).unshift(StepItem.new(step_type, regex_options))
+			else
+				regex.scan(CHUNK_REGEX).unshift(" ").unshift(step_type).collect { |i| StepItem.new(i, regex_options) }
+			end
+						
+			elements.inject(@match_table) { |parent, i| parent[i] ||= Possible.new }.terminal!(full_line)			
+		end
+		
+		# Returns all possible outcomes of a string.
+		#
+		# ==== Parameters
+		# * +string+ - The string to try to auto complete
+		# * +options+ - :easy => true will replace captures with the variable names in the step definition
+		#
+		# ==== Examples
+		#   matcher.complete("Given this")
+		#   matcher.complete("Given this", :easy => true)
+		#
+		def complete(string, options = {})
+			possible_strings find_possible(string), options
+		end
+		
+		# Returns true if the string matches exactly to a step definition
+		#
+		# ==== Examples
+		#   matcher << "Given /^this$/ do"
+		#   matcher.is_match?("Given this") #=> true
+		#   matcher.is_match?("Given that") #=> false
+		#
+		def is_match?(string)
+			find_possible(string).any?{ |x| x.terminal? }
+		end
+		
+private
+		def find_possible(input, against = @match_table)
+			return against.keys.collect do |x|
+				if input =~ x.to_regexp
+					new_input = $'
+					unless new_input.empty?
+						find_possible new_input, against[x]
+					else
+						against[x]
+					end
+				end
+			end.flatten.compact
+		end
+		
+		def possible_strings(possible, options={}, so_far = [], collection = [])
+			if possible.is_a?(Array)
+				possible.each { |a| possible_strings(a, options, so_far, collection) }
+			else
+				possible.each do |k,v|
+					str = k.to_s(options)
+
+					here = (so_far + [str])
+					
+					collection << here.join("") if v.terminal?
+					possible_strings(v, options, here, collection)
+				end
+			end
+			collection
+		end
+	end
+end

data/lib/step_master/possible.rb

@@ -0,0 +1,21 @@
+module StepMaster
+	class Possible < ::Hash
+		EMPTY = Possible.new		
+		
+		def terminal!(result)
+			@terminal = result.freeze
+		end
+		
+		def terminal?
+			!@terminal.nil?
+		end
+		
+		def result
+			@terminal
+		end
+		
+		def inspect
+			super << ((terminal? )? "["+result+"]" : "")
+		end
+	end
+end

data/lib/step_master/step_item.rb

@@ -0,0 +1,31 @@
+module StepMaster
+	class StepItem
+		attr_reader :text, :options
+		
+		def initialize(text, opts)
+			@text = text.freeze
+			@options = 0
+			@options |= (opts.match(/i/) ? Regexp::IGNORECASE : 0)
+		end
+		
+		def to_regexp
+			@regex = Regexp.new("^" << text, options).freeze
+		end
+		
+		def to_s(options = {})
+			text
+		end
+		
+		def inspect
+			text.inspect
+		end		
+		
+		def eql?(o)
+			o.is_a?(StepItem) && self.text.eql?(o.text)
+		end
+		
+		def hash
+			text.hash
+		end		
+	end
+end

data/lib/step_master/step_variable.rb

@@ -0,0 +1,27 @@
+require 'step_master/step_item'
+
+module StepMaster
+	class StepVariable < StepItem
+		ARG_TEXT_REGEX = /\(.*?[^\\]\)/
+		
+		attr_reader :name
+		
+		def initialize(text, options, name)
+			super(text, options)
+			@name = name.freeze
+			
+			raise "#{@text.inspect} is not a variable!" unless @text =~ ARG_TEXT_REGEX
+			@easy = @name.nil? ? @text : $` + "<" + @name + ">" + $'
+				
+			@easy.freeze
+		end	
+		
+		def to_s(options = {})
+			options[:easy] ? @easy  : super()
+		end
+		
+		def inspect
+			"#{text.inspect}:#{name.inspect}"
+		end
+	end
+end

data/lib/step_master.rb

@@ -0,0 +1,8 @@
+$:.unshift(File.dirname(__FILE__)) unless
+  $:.include?(File.dirname(__FILE__)) || $:.include?(File.expand_path(File.dirname(__FILE__)))
+
+require 'step_master/matcher'
+
+module StepMaster
+  VERSION = '0.0.1'
+end

data/spec/spec_helper.rb

@@ -0,0 +1,5 @@
+$LOAD_PATH << File.join(File.dirname(__FILE__), "..", "lib")
+
+require 'rubygems'
+require 'spec'
+require 'step_master'

data/spec/step_helper/matcher_spec.rb

@@ -0,0 +1,276 @@
+require File.join(File.dirname(__FILE__), "..", "spec_helper")
+
+module StepMaster
+	
+	VALID_STEP = "Given /^nothing$/ do"
+	
+	describe Matcher do
+		before(:each) do
+			@matcher = Matcher.new			
+		end
+		
+		describe "#<<" do
+			it "accepts a string" do
+				@matcher << VALID_STEP
+			end
+			
+			it "not throw an exception when it recieves a valid step" do
+				lambda {
+					@matcher << VALID_STEP
+				}.should_not raise_error(Exception)
+			end		
+			
+			it "should not like a step it can't parse" do
+				lambda {
+					@matcher << "This is not a step"
+				}.should raise_error(%q["This is not a step" is not a step])
+			end
+		end
+		
+		describe "#is_match?" do
+			
+			describe "with a terminal and longer step" do
+				before :each do
+					@matcher << "Given /^I want pie$/ do"
+					@matcher << "Given /^I want pie in the morning$/ do"
+				end
+							
+				it "should match to 'I want pie'" do
+					@matcher.is_match?("Given I want pie").should be_true
+				end
+				
+				it "should not match to 'I want pie in" do
+					@matcher.is_match?("Given I want pie in").should be_false
+				end
+
+				it "should match to 'I want pie in the morning" do
+					@matcher.is_match?("Given I want pie in the morning").should be_true
+				end			
+			end
+			
+			describe "with a simple regex variable" do
+				before :each do
+					@matcher << 'Given /^I want (\w{3})$/ do |something|'
+				end	
+				
+				it "should match \"Given I want pie\"" do
+					@matcher.is_match?("Given I want pie").should be_true
+				end					
+				
+				it "should not match \"Given I want !@@\"" do
+					@matcher.is_match?("Given I want !@@").should be_false
+				end	
+			end
+			
+			describe "with regex with quotes around it" do
+				before :each do
+					@matcher << 'Given /^I want "([^\"]*)"$/ do |something|'
+				end	
+				
+				it "should match \"Given I want \"pie\"\"" do
+					@matcher.is_match?("Given I want \"pie\"").should be_true
+				end
+				
+				it "should match \"Given I want \"123\"\"" do
+					@matcher.is_match?("Given I want \"!@@\"").should be_true
+				end			
+			end				
+		end
+		
+		
+		describe "#complete" do
+			it "accepts a string" do
+				@matcher.complete("Given")
+			end
+			
+			it "should be able to match a simple step" do
+				@matcher << VALID_STEP
+				@matcher.complete("Given").should include(" nothing")
+			end
+			
+			describe "with two simple steps given" do
+				before(:each) do 
+					@matcher << "Given /^this$/ do"
+					@matcher << "Given /^that$/ do"					
+				end
+				
+				it "should return 2 results when search for 'Given'" do
+					@matcher.complete("Given").should have(2).results
+				end
+				
+				it "should return 'this' when search for 'Given'" do
+					@matcher.complete("Given").should include(" this")
+				end
+				
+				it "should return 'that' when search for 'Given'" do
+					@matcher.complete("Given").should include(" that")
+				end
+				
+				it "should return no results when search for 'Given this'" do
+					@matcher.complete("Given this").should have(0).results
+				end
+			end
+			
+			describe "with some simple branching steps" do
+				before(:each) do
+					@matcher << "Given /^I want pie$/ do"
+					@matcher << "Given /^I want cake$/ do"		
+					@matcher << "Given /^I can swim$/ do"		
+				end
+				
+				it "should return 3 results when search for 'Given'" do
+					@matcher.complete("Given").should have(3).results
+				end
+				
+				it "should include 'I want pie' when searched for 'Given'" do
+					@matcher.complete("Given").should include(" I want pie")
+				end
+				
+				it "should include 'I want cake' when searched for 'Given'" do
+					@matcher.complete("Given").should include(" I want cake")
+				end				
+				
+				it "should include 'I can swim' when searched for 'Given'" do
+					@matcher.complete("Given").should include(" I can swim")
+				end
+				
+				it "should return 2 results when search for 'Given I want'" do
+					@matcher.complete("Given I want").should have(2).results
+				end
+				
+				it "should include 'pie' when searched for 'Given'" do
+					@matcher.complete("Given I want").should include(" pie")
+				end
+				
+				it "should include 'cake' when searched for 'Given'" do
+					@matcher.complete("Given I want").should include(" cake")
+				end						
+				
+				it "should return 1 result when search for 'Given I can'" do
+					@matcher.complete("Given I can").should have(1).results
+				end												
+				
+				it "should include 'swim' when searched for 'Given'" do
+					@matcher.complete("Given I can").should include(" swim")
+				end				
+			end
+			
+			describe "with a terminal and longer step" do
+				before :each do
+					@matcher << "Given /^I want pie$/ do"
+					@matcher << "Given /^I want pie in the morning$/ do"
+				end
+				
+				it "should include 2 results when I search for 'Given'" do
+					@matcher.complete('Given').should have(2).results
+				end
+				
+				it "should include 'I want pie'" do
+					@matcher.complete("Given").should include(" I want pie")
+				end
+				
+				it "should include 'I want pie in the morning'" do
+					@matcher.complete("Given").should include(" I want pie in the morning")
+				end
+			end
+			
+			describe "with a simple regex variable" do
+				before :each do
+					@matcher << 'Given /^I want (\w{3})$/ do |something|'
+				end	
+				
+				it "should auto complete" do
+					@matcher.complete("Given").should have(1).result
+				end
+				
+				it "should complete with variables names " do
+					m = @matcher.complete("Given", :easy => true)
+					m.should have(1).result
+					m.should include(" I want <something>")
+				end				
+			end
+			
+			describe "with regex with quotes around it" do
+				before :each do
+					@matcher << 'Given /^I want "([^\"]*)"$/ do |something|'
+				end	
+				
+				it "should auto complete" do
+					@matcher.complete("Given").should have(1).result
+				end
+				
+				it "should complete with variables names " do
+					m = @matcher.complete("Given", :easy => true)
+					m.should have(1).result
+					m.should include(" I want \"<something>\"")
+				end				
+			end
+
+			describe "with more complex capture that could include spaces" do
+				before :each do
+					@matcher << 'Given /^I want "([^\"]*)" for dinner$/ do |something|'
+				end	
+				
+				it "should handle more than one word inside quotes" do
+					@matcher.complete("Given I want \"steak and potatoes\"").should have(1).result
+				end
+			end
+			
+			describe "with multiple arguments" do
+				before :each do
+					@matcher << 'Given /^I want "([^\"]*)" in the "([^\"]*)"$/ do |food, time_of_day|'
+				end		
+				
+				it "should complete with variables names " do
+					m = @matcher.complete("Given", :easy => true)
+					m.should have(1).result
+					m.should include(" I want \"<food>\" in the \"<time_of_day>\"")
+				end		 
+			end
+			
+			describe "with non captures" do
+				
+				it "should correctly match one variables name" do
+					@matcher << %q[Given /^I want "(?:[^\"]*)" in the "([^\"]*)"$/ do |time_of_day|]
+					m = @matcher.complete("Given", :easy => true)
+					m.should have(1).result
+					m.should include(%q[ I want "(?:[^\"]*)" in the "<time_of_day>"])
+				end		 
+				
+				it "should correctly match two variables name" do
+					@matcher << %q[Given /^I (\w{4}) "(?:[^\"]*)" in the "([^\"]*)"$/ do |type, time_of_day|]
+					m = @matcher.complete("Given", :easy => true)
+					m.should have(1).result
+					m.should include(%q[ I <type> "(?:[^\"]*)" in the "<time_of_day>"])
+				end		 
+				
+			end	
+
+			describe "with an optional space" do
+				before :each do
+					@matcher << %q~Given /^(?:a )?provider ?location (?:named |called )?"([^\"]*)" exists$/i do |name|~
+				end
+				
+				it "should correctly auto-complete" do 
+					@matcher.complete("Given provider location").should have(1).result
+					@matcher.complete("Given a provider location").should have(1).result
+					@matcher.complete("Given providerlocation").should have(1).result
+				end
+			end
+			
+			describe "with an case insensitive switch" do
+				before :each do
+					@matcher << %q~Given /^(?:a )?provider ?location (?:named |called )?"([^\"]*)" exists$/i do |name|~
+				end
+				
+				it "should correctly auto-complete" do 
+					@matcher.complete("Given provider location").should have(1).result
+					@matcher.complete("Given a Provider Location").should have(1).result
+					@matcher.complete("Given ProviderLocation").should have(1).result
+				end
+			end			
+			
+			
+		end		
+	end
+end

data/test/test_helper.rb

@@ -0,0 +1,3 @@
+require 'stringio'
+require 'test/unit'
+require File.dirname(__FILE__) + '/../lib/step_master'

data/test/test_step_master.rb

@@ -0,0 +1,11 @@
+require File.dirname(__FILE__) + '/test_helper.rb'
+
+class TestStepMaster < Test::Unit::TestCase
+
+  def setup
+  end
+  
+  def test_truth
+    assert true
+  end
+end

metadata

@@ -0,0 +1,80 @@
+--- !ruby/object:Gem::Specification 
+name: step_master
+version: !ruby/object:Gem::Version 
+  version: 0.0.1
+platform: ruby
+authors: 
+- Jim Holmes
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-10-14 00:00:00 -04:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: hoe
+  type: :development
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 2.3.3
+    version: 
+description: Provide a simple and easy way to find and auto-complete gherkin steps, when writing cucumber features
+email: 
+- 32bitkid@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- History.txt
+- Manifest.txt
+- PostInstall.txt
+files: 
+- History.txt
+- Manifest.txt
+- PostInstall.txt
+- README.rdoc
+- Rakefile
+- lib/step_master.rb
+- lib/step_master/matcher.rb
+- lib/step_master/possible.rb
+- lib/step_master/step_item.rb
+- lib/step_master/step_variable.rb
+- spec/spec_helper.rb
+- spec/step_helper/matcher_spec.rb
+has_rdoc: true
+homepage: http://github.com/clearwavebuild/step_master
+licenses: []
+
+post_install_message: PostInstall.txt
+rdoc_options: 
+- --main
+- README.rdoc
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: step_master
+rubygems_version: 1.3.5
+signing_key: 
+specification_version: 3
+summary: Provide a simple and easy way to find and auto-complete gherkin steps, when writing cucumber features
+test_files: 
+- test/test_step_master.rb
+- test/test_helper.rb