cucumber 0.1.10 → 0.2.0

data/lib/cucumber/step_mother.rb

@@ -1,95 +1,214 @@
-require 'cucumber/tree/top_down_visitor'
-require 'cucumber/core_ext/proc'
+require 'cucumber/step_definition'
+require 'cucumber/world'
+require 'cucumber/core_ext/instance_exec'
 
 module Cucumber
-  class Pending < StandardError
-  end
+  class Undefined < StandardError
+    attr_reader :step_name
+
+    def initialize(step_name)
+      super %{Undefined step: "#{step_name}"}
+      @step_name = step_name
+    end
+    
+    def nested!
+      @nested = true
+    end
 
-  class Duplicate < StandardError
+    def nested?
+      @nested
+    end
   end
 
-  class Multiple < StandardError
+  # Raised when a StepDefinition's block invokes World#pending
+  class Pending < StandardError
   end
 
-  class MissingProc < StandardError
-    def message
-      "Step definitions must always have a proc"
+  # Raised when a step matches 2 or more StepDefinition
+  class Ambiguous < StandardError
+    def initialize(step_name, step_definitions)
+      message = "Ambiguous match of \"#{step_name}\":\n\n"
+      message << step_definitions.map{|sd| sd.backtrace_line}.join("\n")
+      message << "\n\n"
+      super(message)
     end
   end
 
-  class StepMother
-    PENDING = lambda do |*_| 
-      raise Pending
+  # Raised when 2 or more StepDefinition have the same Regexp
+  class Redundant < StandardError
+    def initialize(step_def_1, step_def_2)
+      message = "Multiple step definitions have the same Regexp:\n\n"
+      message << step_def_1.backtrace_line << "\n"
+      message << step_def_2.backtrace_line << "\n\n"
+      super(message)
     end
-    PENDING.extend(CoreExt::CallIn)
-    PENDING.name = "PENDING"
+  end
 
-    def initialize
-      @step_procs = Hash.new(PENDING)
+  # This is the main interface for registering step definitions, which is done
+  # from <tt>*_steps.rb</tt> files. This module is included right at the top-level
+  # so #register_step_definition (and more interestingly - its aliases) are
+  # available from the top-level.
+  module StepMother
+    class << self
+      def alias_adverb(adverb)
+        adverb = adverb.gsub(/\s/, '')
+        alias_method adverb, :register_step_definition
+      end
     end
 
-    def register_step_proc(key, &proc)
-      raise MissingProc if proc.nil?
-      regexp = case(key)
-      when String
-        # Replace the $foo and $bar style parameters
-        pattern = key.gsub(/\$\w+/, '(.*)')
-        Regexp.new("^#{pattern}$")
-      when Regexp
-        key
+    attr_writer :snippet_generator, :options, :visitor
+
+    def step_visited(step)
+      steps << step unless steps.index(step)
+    end
+    
+    def steps(status = nil)
+      @steps ||= []
+      if(status)
+        @steps.select{|step| step.status == status}
       else
-        raise "Step patterns must be Regexp or String, but was: #{key.inspect}"
+        @steps
       end
-      proc.extend(CoreExt::CallIn)
-      proc.name = key.inspect
-
-      if @step_procs.has_key?(regexp)
-        first_proc = @step_procs[regexp]
-        message = %{Duplicate step definitions:
+    end
 
-#{first_proc.to_backtrace_line}
-#{proc.to_backtrace_line}
+    def scenarios
+      @scenarios ||= []
+    end
 
-}
-        raise Duplicate.new(message)
+    # Registers a new StepDefinition. This method is aliased
+    # to <tt>Given</tt>, <tt>When</tt> and <tt>Then</tt>.
+    #
+    # See Cucumber#alias_steps for details on how to
+    # create your own aliases.
+    #
+    # The +&proc+ gets executed in the context of a <tt>world</tt>
+    # object, which is defined by #World. A new <tt>world</tt>
+    # object is created for each scenario and is shared across
+    # step definitions within that scenario.
+    def register_step_definition(regexp, &proc)
+      step_definition = StepDefinition.new(regexp, &proc)
+      step_definitions.each do |already|
+        raise Redundant.new(already, step_definition) if already.match(regexp)
       end
+      step_definitions << step_definition
+      step_definition
+    end
 
-      @step_procs[regexp] = proc
-    end
-
-    def regexp_args_proc(step_name)
-      candidates = @step_procs.map do |regexp, proc|
-        if step_name =~ regexp
-          [regexp, $~.captures, proc]
-        end
-      end.compact
-      
-      case(candidates.length)
-      when 0
-        [nil, [], PENDING]
-      when 1
-        candidates[0]
-      else
-        message = %{Multiple step definitions match #{step_name.inspect}:
+    # Registers a Before proc. You can call this method as many times as you
+    # want (typically from ruby scripts under <tt>support</tt>).
+    def Before(&proc)
+      (@before_procs ||= []) << proc
+    end
+
+    def After(&proc)
+      (@after_procs ||= []) << proc
+    end
+
+    # Registers a World proc. You can call this method as many times as you
+    # want (typically from ruby scripts under <tt>support</tt>).
+    def World(&proc)
+      (@world_procs ||= []) << proc
+    end
+
+    def current_world
+      @current_world
+    end
 
-#{candidates.map{|regexp, args, proc| proc.to_backtrace_line}.join("\n")}
+    def step_match(step_name, formatted_step_name=nil)
+      matches = step_definitions.map { |d| d.step_match(step_name, formatted_step_name) }.compact
+      raise Undefined.new(step_name) if matches.empty?
+      matches = best_matches(step_name, matches) if matches.size > 1 && options[:guess]
+      raise Ambiguous.new(step_name, matches) if matches.size > 1
+      matches[0]
+    end
 
-}
-        raise Multiple.new(message)
+    def best_matches(step_name, step_matches)
+      max_arg_length = step_matches.map {|step_match| step_match.args.length }.max
+      top_groups     = step_matches.select {|step_match| step_match.args.length == max_arg_length }
+
+      if top_groups.length > 1
+        shortest_capture_length = top_groups.map {|step_match| step_match.args.inject(0) {|sum, c| sum + c.length } }.min
+        top_groups.select {|step_match| step_match.args.inject(0) {|sum, c| sum + c.length } == shortest_capture_length }
+      else
+        top_groups
       end
-     end
-    
-    def proc_for(regexp)
-      @step_procs[regexp]
     end
     
-    def has_step_definition?(step_name)
-      _, _, proc = regexp_args_proc(step_name)
-      proc != PENDING
+    def step_definitions
+      @step_definitions ||= []
+    end
+
+    def snippet_text(step_keyword, step_name)
+      @snippet_generator.snippet_text(step_keyword, step_name)
     end
     
-    # TODO - move execute here?
-    def execute(step)
+    def print_step_definitions(out)
+      step_definitions.each do |step_definition|
+        indent = max_step_definition_length - step_definition.text_length
+        out.puts(step_definition.to_s(indent))
+      end
+    end
+
+    def before_and_after(scenario, skip=false)
+      unless current_world || skip
+        new_world!
+        execute_before(scenario)
+      end
+      if block_given?
+        yield
+        execute_after(scenario) unless skip
+        nil_world!
+        scenario_visited(scenario)
+      end
+    end
+
+    private
+
+    def max_step_definition_length
+      @max_step_definition_length ||= step_definitions.map{|step_definition| step_definition.text_length}.max
+    end
+
+    def options
+      @options || {}
+    end
+
+    # Creates a new world instance
+    def new_world!
+      @current_world = Object.new
+      (@world_procs ||= []).each do |proc|
+        @current_world = proc.call(@current_world)
+      end
+
+      @current_world.extend(World)
+      @current_world.__cucumber_step_mother = self
+      @current_world.__cucumber_visitor = @visitor
+
+      @current_world.extend(::Spec::Matchers) if defined?(::Spec::Matchers)
+      @current_world
+    end
+
+    def nil_world!
+      @current_world = nil
+    end
+
+    def execute_before(scenario)
+      (@before_procs ||= []).each do |proc|
+        @current_world.cucumber_instance_exec(false, 'Before', scenario, &proc)
+      end
+    end
+
+    def execute_after(scenario)
+      (@after_procs ||= []).each do |proc|
+        @current_world.cucumber_instance_exec(false, 'After', scenario, &proc)
+      end
+    end
+
+    def scenario_visited(scenario)
+      scenarios << scenario unless scenarios.index(scenario)
+    end
+
+    def options
+      @options || {}
     end
   end
 end

data/lib/cucumber/version.rb

@@ -1,9 +1,10 @@
 module Cucumber #:nodoc:
   class VERSION #:nodoc:
     MAJOR = 0
-    MINOR = 1
-    TINY  = 10
+    MINOR = 2
+    TINY  = 0
+    PATCH = nil # Set to nil for official release
 
-    STRING = [MAJOR, MINOR, TINY].join('.')
+    STRING = [MAJOR, MINOR, TINY, PATCH].compact.join('.')
   end
 end

data/lib/cucumber/world.rb

@@ -0,0 +1,53 @@
+module Cucumber
+  # All steps are run in the context of an object that extends this module
+  module World
+    class << self
+      def alias_adverb(adverb)
+        alias_method adverb, :__cucumber_invoke
+      end
+    end
+    
+    attr_writer :__cucumber_step_mother, :__cucumber_visitor, :__cucumber_current_step
+
+    # Call a step from within a step definition
+    def __cucumber_invoke(name, multiline_argument=nil) #:nodoc:
+      begin
+        step_match = @__cucumber_step_mother.step_match(name)
+        step_match.invoke(self, multiline_argument)
+      rescue Exception => e
+        e.nested! if Undefined === e
+        @__cucumber_current_step.exception = e
+        raise e
+      end
+    end
+    
+    def table(text, file=nil, line_offset=0)
+      @table_parser ||= Parser::TableParser.new
+      @table_parser.parse_or_fail(text.strip, file, line_offset)
+    end
+
+    # Output +announcement+ alongside the formatted output.
+    # This is an alternative to using Kernel#puts - it will display
+    # nicer, and in all outputs (in case you use several formatters)
+    #
+    # Beware that the output will be printed *before* the corresponding
+    # step. This is because the step itself will not be printed until
+    # after it has run, so it can be coloured according to its status.
+    def announce(announcement)
+      @__cucumber_visitor.announce(announcement)
+    end
+
+    def pending(message = "TODO")
+      if block_given?
+        begin
+          yield
+        rescue Exception => e
+          raise Pending.new(message)
+        end
+        raise Pending.new("Expected pending '#{message}' to fail. No Error was raised. No longer pending?")
+      else
+        raise Pending.new(message)
+      end
+    end
+  end
+end

data/lib/cucumber.rb

@@ -1,39 +1,63 @@
 $:.unshift(File.dirname(__FILE__)) unless
   $:.include?(File.dirname(__FILE__)) || $:.include?(File.expand_path(File.dirname(__FILE__)))
 
-require 'jcode'
+require 'yaml'
 require 'cucumber/platform'
-require 'rubygems'
-require 'treetop/runtime'
-require 'treetop/ruby_extensions'
+require 'cucumber/parser'
 require 'cucumber/version'
-require 'cucumber/step_methods'
-require 'cucumber/tree'
-require 'cucumber/model'
-require 'cucumber/executor'
 require 'cucumber/step_mother'
-require 'cucumber/formatters'
-require 'cucumber/treetop_parser/feature_parser'
-require 'cucumber/cli'
+require 'cucumber/cli/main'
 require 'cucumber/broadcaster'
+require 'cucumber/core_ext/exception'
 
 module Cucumber
-  LANGUAGE_FILE = File.expand_path(File.dirname(__FILE__) + '/cucumber/languages.yml')
-
+  KEYWORD_KEYS = %w{name native encoding feature background scenario scenario_outline examples given when then but}
+  
   class << self
-    attr_reader :language
+    attr_reader :lang
     
-    def load_language(lang)
-      @language = config[lang]
+    def load_language(lang) #:nodoc:
+      return if @lang
+      @lang = lang
+      alias_step_definitions(lang)
+      Parser.load_parser(keyword_hash)
+    end
+
+    def language_incomplete?(lang=@lang)
+      KEYWORD_KEYS.detect{|key| keyword_hash(lang)[key].nil?}
+    end
+
+    # File mode that accounts for Ruby platform and current language
+    def file_mode(m)
+      Cucumber::RUBY_1_9 ? "#{m}:#{keyword_hash['encoding']}" : m
+    end
+
+    # Returns a Hash of the currently active
+    # language, or for a specific language if +lang+ is
+    # specified.
+    def keyword_hash(lang=@lang)
+      LANGUAGES[lang]
     end
     
-    def languages
-      config.keys.sort
+    def alias_step_definitions(lang) #:nodoc:
+      keywords = %w{given when then and but}.map{|keyword| keyword_hash(lang)[keyword]}
+      alias_steps(keywords)
     end
     
-    def config
-      require 'yaml'
-      @config ||= YAML.load_file(LANGUAGE_FILE)
+    # Sets up additional method aliases for Given, When and Then.
+    # This does *not* affect how feature files are parsed. If you
+    # want to create aliases in the parser, you have to do this in
+    # languages.yml. For example:
+    #
+    # and: And|With
+    def alias_steps(keywords)
+      keywords.each do |adverb|
+        StepMother.alias_adverb(adverb)
+        World.alias_adverb(adverb)
+      end
     end
   end  
+
+  # Make sure we always have English aliases
+  alias_step_definitions('en')
 end

data/rails_generators/cucumber/cucumber_generator.rb

@@ -4,13 +4,17 @@ require 'rbconfig'
 class CucumberGenerator < Rails::Generator::Base
   DEFAULT_SHEBANG = File.join(Config::CONFIG['bindir'],
                               Config::CONFIG['ruby_install_name'])
+
+  attr_accessor :framework
+
   def manifest
     record do |m|
       m.directory 'features/step_definitions'
-      m.file      'webrat_steps.rb', 'features/step_definitions/webrat_steps.rb'
+      m.template  'webrat_steps.rb', 'features/step_definitions/webrat_steps.rb'
 
       m.directory 'features/support'
-      m.file      'env.rb',           'features/support/env.rb'
+      m.template  'env.rb',           'features/support/env.rb'
+      m.file      'paths.rb',         'features/support/paths.rb'
 
       m.directory 'lib/tasks'
       m.file      'cucumber.rake',    'lib/tasks/cucumber.rake'
@@ -21,10 +25,26 @@ class CucumberGenerator < Rails::Generator::Base
     end
   end
 
+  def framework
+    options[:framework] || :rspec
+  end
+
 protected
 
   def banner
     "Usage: #{$0} cucumber"
   end
 
-end
+  def add_options!(opt)
+    opt.separator ''
+    opt.separator 'Options:'
+    opt.on('--rspec', 'Setup cucumber for use with RSpec (default)') do |value|
+      options[:framework] = :rspec
+    end
+
+    opt.on('--testunit', 'Setup cucumber for use with test/unit') do |value|
+      options[:framework] = :testunit
+    end
+  end
+
+end

data/rails_generators/cucumber/templates/cucumber

@@ -1,7 +1,8 @@
 #!/usr/bin/env ruby
 begin
   load File.expand_path(File.dirname(__FILE__) + "/../vendor/plugins/cucumber/bin/cucumber")
-rescue LoadError
+rescue LoadError => e
+  raise unless e.to_s =~ /cucumber/  
   require "rubygems"
   load File.join(Gem.bindir, "cucumber")
 end

data/rails_generators/cucumber/templates/cucumber.rake

@@ -1,7 +1,15 @@
-$:.unshift(RAILS_ROOT + '/vendor/plugins/cucumber/lib')
-require 'cucumber/rake/task'
+$LOAD_PATH.unshift(RAILS_ROOT + '/vendor/plugins/cucumber/lib') if File.directory?(RAILS_ROOT + '/vendor/plugins/cucumber/lib')
 
-Cucumber::Rake::Task.new(:features) do |t|
-  t.cucumber_opts = "--format pretty"
+begin
+  require 'cucumber/rake/task'
+
+  Cucumber::Rake::Task.new(:features) do |t|
+    t.cucumber_opts = "--format pretty"
+  end
+  task :features => 'db:test:prepare'
+rescue LoadError
+  desc 'Cucumber rake task not available'
+  task :features do
+    abort 'Cucumber rake task is not available. Be sure to install cucumber as a gem or plugin'
+  end
 end
-task :features => 'db:test:prepare'

data/rails_generators/cucumber/templates/env.rb

@@ -1,8 +1,17 @@
 # Sets up the Rails environment for Cucumber
-ENV["RAILS_ENV"] = "test"
+ENV["RAILS_ENV"] ||= "test"
 require File.expand_path(File.dirname(__FILE__) + '/../../config/environment')
 require 'cucumber/rails/world'
+require 'cucumber/formatters/unicode' # Comment out this line if you don't want Cucumber Unicode support
 Cucumber::Rails.use_transactional_fixtures
 
-# Comment out the next line if you're not using RSpec's matchers (should / should_not) in your steps.
+require 'webrat'
+
+Webrat.configure do |config|
+  config.mode = :rails
+end
+<% if framework == :rspec -%>
+
 require 'cucumber/rails/rspec'
+require 'webrat/core/matchers'
+<% end -%>

data/rails_generators/cucumber/templates/paths.rb

@@ -0,0 +1,19 @@
+module NavigationHelpers
+  def path_to(page_name)
+    case page_name
+    
+    when /the homepage/
+      root_path
+    
+    # Add more page name => path mappings here
+    
+    else
+      raise "Can't find mapping from \"#{page_name}\" to a path."
+    end
+  end
+end
+
+World do |world|
+  world.extend NavigationHelpers
+  world
+end