cucumber 0.1.16 → 0.2.0

data/lib/cucumber/parser/table.tt

@@ -0,0 +1,59 @@
+module Cucumber
+  module Parser
+    # TIP: When you hack on the grammar, just delete feature.rb in this directory.
+    # Also make sure you have uninstalled all cucumber gems (don't forget xxx-cucumber
+    # github gems).
+    #
+    # Treetop will then generate the parser in-memory. When you're happy, just generate
+    # the rb file with tt feature.tt
+    grammar Table
+
+      rule table
+        table_row+ {
+          def build
+            Ast::Table.new(raw)
+          end
+
+          def raw
+            elements.map{|e| e.build}
+          end
+        }
+      end
+
+      rule table_row
+        space* '|' cells:(cell '|')+ space* (eol+ / eof) {
+          def build
+            row = cells.elements.map do |elt| 
+              value = elt.cell.text_value.strip
+              value.empty? ? nil : value
+            end
+
+            class << row
+              attr_accessor :line
+            end
+            row.line = cells.line
+
+            row
+          end
+        }
+      end
+
+      rule cell
+        (!('|' / eol) .)*
+      end
+
+      rule space
+        [ \t]
+      end
+
+      rule eol
+        "\n" / ("\r" "\n"?)
+      end
+
+      rule eof
+        !.
+      end
+
+    end
+  end
+end

data/lib/cucumber/parser/treetop_ext.rb

@@ -0,0 +1,75 @@
+begin
+  require 'treetop'
+  require 'treetop/runtime'
+  require 'treetop/ruby_extensions'
+rescue LoadError
+  require "rubygems"
+  gem "treetop"
+  require 'treetop'
+  require 'treetop/runtime'
+  require 'treetop/ruby_extensions'
+end
+
+module Cucumber
+  module Parser
+    module TreetopExt
+      FILE_COLON_LINE_PATTERN = /^([\w\W]*?):([\d:]+)$/
+
+      # Parses a file and returns a Cucumber::Ast
+      def parse_file(file)
+        _, path, lines = *FILE_COLON_LINE_PATTERN.match(file)
+        if path
+          lines = lines.split(':').map { |line| line.to_i }
+        else
+          path = file
+          lines = []
+        end
+
+        loader = lambda { |io| parse_or_fail(io.read, path) }
+        feature = if path =~ /^http/
+          require 'open-uri'
+          open(path, &loader)
+        else
+          File.open(path, Cucumber.file_mode('r'), &loader) 
+        end
+        feature.lines = lines
+        feature
+      end
+
+      def parse_or_fail(s, file=nil, line_offset=0)
+        parse_tree = parse(s)
+        if parse_tree.nil?
+          raise Cucumber::Parser::SyntaxError.new(self, file, line_offset)
+        else
+          ast = parse_tree.build
+          ast.file = file
+          ast
+        end
+      end
+    end
+
+    class SyntaxError < StandardError
+      def initialize(parser, file, line_offset)
+        tf = parser.terminal_failures
+        expected = tf.size == 1 ? tf[0].expected_string.inspect : "one of #{tf.map{|f| f.expected_string.inspect}.uniq*', '}"
+        line = parser.failure_line + line_offset
+        message = "#{file}:#{line}:#{parser.failure_column}: Parse error, expected #{expected}."
+        super(message)
+      end
+    end
+  end
+end
+
+module Treetop
+  module Runtime
+    class SyntaxNode
+      def line
+        input.line_of(interval.first)
+      end
+    end
+    
+    class CompiledParser
+      include Cucumber::Parser::TreetopExt
+    end
+  end
+end

data/lib/cucumber/platform.rb

@@ -1,9 +1,11 @@
 # Detect the platform we're running on so we can tweak behaviour
 # in various places.
 require 'rbconfig'
+require 'yaml'
 
 module Cucumber
   LANGUAGE_FILE = File.expand_path(File.dirname(__FILE__) + '/languages.yml')
+  LANGUAGES     = YAML.load_file(LANGUAGE_FILE)
   BINARY        = File.expand_path(File.dirname(__FILE__) + '/../../bin/cucumber')
   JRUBY         = defined?(JRUBY_VERSION)
   IRONRUBY      = Config::CONFIG['sitedir'] =~ /IronRuby/
@@ -12,21 +14,4 @@ module Cucumber
   RAILS         = defined?(Rails)
   RUBY_BINARY   = File.join(Config::CONFIG['bindir'], Config::CONFIG['ruby_install_name'])
   RUBY_1_9      = RUBY_VERSION =~ /^1\.9/
-
-  class << self
-    attr_reader :language
-    
-    def load_language(lang)
-      @language = config[lang]
-    end
-    
-    def languages
-      config.keys.sort
-    end
-    
-    def config
-      require 'yaml'
-      @config ||= YAML.load_file(LANGUAGE_FILE)
-    end
-  end  
 end

data/lib/cucumber/rails/rspec.rb

@@ -1,12 +1,8 @@
+require 'cucumber/rails/world'
 require 'spec/expectations'
-require 'spec/rails'
+require 'spec/rails/matchers'
 
-# Hack to stop RSpec from dumping the summary
-Spec::Runner::Options.class_eval do
-  def examples_should_be_run?
-    false
-  end
+Cucumber::Rails::World.class_eval do
+  include Spec::Matchers
+  include Spec::Rails::Matchers
 end
-
-ActionController::Integration::Session.send(:include, Spec::Matchers)
-ActionController::Integration::Session.send(:include, Spec::Rails::Matchers)

data/lib/cucumber/rails/world.rb

@@ -11,8 +11,8 @@ require 'test/unit/testresult'
 
 # These allow exceptions to come through as opposed to being caught and having non-helpful responses returned.
 ActionController::Base.class_eval do
-  def perform_action_with_rescue
-    perform_action_without_rescue
+  def rescue_action(exception)
+    raise exception
   end
 end
 ActionController::Dispatcher.class_eval do

data/lib/cucumber/rake/task.rb

@@ -2,24 +2,56 @@ require 'cucumber/platform'
 
 module Cucumber
   module Rake
-    # Defines a task for running features.
+    # Defines a Rake task for running features.
+    #
+    # The simplest use of it goes something like:
+    #
+    #   Cucumber::Rake::Task.new
+    #
+    # This will create a task named 'features' described as 'Run Features with 
+    # Cucumber'. It will use steps from 'features/**/*.rb' and features in 'features/**/*.feature'.
+    #
+    # To further configure the task, you can pass a block:
+    #
+    #   Cucumber::Rake::Task.new do |t|
+    #     t.cucumber_opts = "--format progress"
+    #   end
+    #
+    # This task can also be configured to be run with RCov:
+    #
+    #   Cucumber::Rake::Task.new do |t|
+    #     t.rcov = true
+    #   end
+    # 
+    # See the attributes for additional configuration possibilities.
     class Task
-      LIB    = File.expand_path(File.dirname(__FILE__) + '/../..')
+      LIB    = File.expand_path(File.dirname(__FILE__) + '/../..') # :nodoc:
 
+      # Directories to add to the Ruby $LOAD_PATH
       attr_accessor :libs
+      # Name of the cucumber binary to use for running features. Defaults to Cucumber::BINARY
       attr_accessor :binary
+      # Array of paths to specific step definition files to use
       attr_accessor :step_list
+      # File pattern for finding step definitions. Defaults to 
+      # 'features/**/*.rb'.
       attr_accessor :step_pattern
+      # Array of paths to specific features to run. 
       attr_accessor :feature_list
+      # File pattern for finding features to run. Defaults to 
+      # 'features/**/*.feature'. Can be overriden by the FEATURE environment variable.
       attr_accessor :feature_pattern
+      # Extra options to pass to the cucumber binary. Can be overridden by the CUCUMBER_OPTS environment variable.
       attr_accessor :cucumber_opts
+      # Run cucumber with RCov?
       attr_accessor :rcov
+      # Extra options to pass to rcov
       attr_accessor :rcov_opts
 
-      # Define a task
+      # Define a Rake
       def initialize(task_name = "features", desc = "Run Features with Cucumber")
         @task_name, @desc = task_name, desc
-        @libs = []
+        @libs = ['lib']
         @rcov_opts = %w{--rails --exclude osx\/objc,gems\/}
 
         yield self if block_given?
@@ -33,14 +65,14 @@ module Cucumber
         define_task
       end
 
-      def define_task
+      def define_task # :nodoc:
         desc @desc
         task @task_name do
           ruby(arguments_for_ruby_execution.join(" ")) # ruby(*args) is broken on Windows
         end
       end
 
-      def arguments_for_ruby_execution(task_args = nil)
+      def arguments_for_ruby_execution(task_args = nil) # :nodoc:
         lib_args     = ['"%s"' % libs.join(File::PATH_SEPARATOR)]
         cucumber_bin = ['"%s"' % binary]
         cuc_opts     = [(ENV['CUCUMBER_OPTS'] || cucumber_opts)]
@@ -89,7 +121,7 @@ module Cucumber
         super(task_name, desc)
       end
 
-      def define_task
+      def define_task # :nodoc:
         desc @desc
         task @task_name, :feature_name do |t, args|
           ruby(arguments_for_ruby_execution(args).join(" ")) # ruby(*args) is broken on Windows

data/lib/cucumber/step_definition.rb

@@ -0,0 +1,103 @@
+require 'cucumber/step_match'
+require 'cucumber/core_ext/string'
+require 'cucumber/core_ext/proc'
+
+module Cucumber
+  # A Step Definition holds a Regexp and a Proc, and is created
+  # by calling <tt>Given</tt>, <tt>When</tt> or <tt>Then</tt>
+  # in the <tt>step_definitions</tt> ruby files - for example:
+  #
+  #   Given /I have (\d+) cucumbers in my belly/ do
+  #     # some code here
+  #   end
+  #
+  class StepDefinition
+    def self.snippet_text(step_keyword, step_name)
+      escaped = Regexp.escape(step_name).gsub('\ ', ' ').gsub('/', '\/')
+      "#{step_keyword} /^#{escaped}$/ do\n  pending\nend"
+    end
+
+    class MissingProc < StandardError
+      def message
+        "Step definitions must always have a proc"
+      end
+    end
+
+    attr_reader :regexp
+
+    def initialize(pattern, &proc)
+      raise MissingProc if proc.nil?
+      if String === pattern
+        p = pattern.gsub(/\$\w+/, '(.*)') # Replace $var with (.*)
+        pattern = Regexp.new("^#{p}$") 
+      end
+      @regexp, @proc = pattern, proc
+    end
+
+    def step_match(name_to_match, name_to_report)
+      if(match = name_to_match.match(@regexp))
+        StepMatch.new(self, name_to_match, name_to_report, match.captures)
+      else
+        nil
+      end
+    end
+
+    def invoke(world, args, step_name)
+      args = args.map{|arg| Ast::PyString === arg ? arg.to_s : arg}
+      begin
+        world.cucumber_instance_exec(true, @regexp.inspect, *args, &@proc)
+      rescue Cucumber::ArityMismatchError => e
+        e.backtrace.unshift(self.backtrace_line)
+        raise e
+      end
+    end
+
+    #:stopdoc:
+
+    def match(step_name)
+      case step_name
+      when String then @regexp.match(step_name)
+      when Regexp then @regexp == step_name
+      end
+    end
+
+    # Formats the matched arguments of the associated Step. This method
+    # is usually called from visitors, which render output.
+    #
+    # The +format+ either be a String or a Proc.
+    #
+    # If it is a String it should be a format string according to
+    # <tt>Kernel#sprinf</tt>, for example:
+    #
+    #   '<span class="param">%s</span></tt>'
+    #
+    # If it is a Proc, it should take one argument and return the formatted
+    # argument, for example:
+    #
+    #   lambda { |param| "[#{param}]" }
+    #
+    def format_args(step_name, format)
+      step_name.gzub(@regexp, format)
+    end
+
+    def matched_args(step_name)
+      step_name.match(@regexp).captures
+    end
+
+    def backtrace_line
+      "#{file_colon_line}:in `#{@regexp.inspect}'"
+    end
+
+    def file_colon_line
+      @proc.file_colon_line
+    end
+
+    def text_length
+      @regexp.inspect.jlength
+    end
+
+    def to_s(indent = 0)
+      @regexp.inspect + (' # ').indent(indent) + file_colon_line
+    end
+  end
+end

data/lib/cucumber/step_match.rb

@@ -0,0 +1,49 @@
+module Cucumber
+  class StepMatch
+    attr_reader :step_definition
+    attr_reader :args
+    
+    def initialize(step_definition, step_name, formatted_step_name, args)
+      @step_definition, @step_name, @formatted_step_name, @args = step_definition, step_name, formatted_step_name, args
+    end
+    
+    def invoke(world, multiline_arg)
+      all_args = @args.dup
+      all_args << multiline_arg if multiline_arg
+      @step_definition.invoke(world, all_args, @step_name)
+    end
+
+    def format_args(format)
+      @formatted_step_name || @step_definition.format_args(@step_name, format)
+    end
+    
+    def file_colon_line
+      @step_definition.file_colon_line
+    end
+
+    def backtrace_line
+      @step_definition.backtrace_line
+    end
+  end
+  
+  class NoStepMatch
+    attr_reader :step_definition
+
+    def initialize(step)
+      @step = step
+    end
+    
+    def format_args(format)
+      @step.name
+    end
+
+    def file_colon_line
+      raise "No file:line for #{@step}" unless @step.file_colon_line
+      @step.file_colon_line
+    end
+
+    def backtrace_line
+      @step.backtrace_line
+    end
+  end
+end

data/lib/cucumber/step_mother.rb

@@ -1,98 +1,214 @@
-require 'cucumber/tree/top_down_visitor'
+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
 
-  class ForcedPending < Pending
-  end
+    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
-    require 'cucumber/core_ext/proc'
-    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