cucumber 0.2.3 → 0.3.0

data/features/snippet.feature

@@ -0,0 +1,23 @@
+Feature: Snippets
+  In order to help speed up writing step definitions
+  As a feature editor
+  I want snippet suggestions for undefined step definitions
+
+  Scenario: Snippet for undefined step with a pystring
+    When I run cucumber features/undefined_multiline_args.feature:3 -n
+    Then the output should contain
+      """
+      Given /^a pystring$/ do |string|
+        # string is a Cucumber::Ast::PyString
+        pending
+      end
+      """
+  Scenario: Snippet for undefined step with a step table
+    When I run cucumber features/undefined_multiline_args.feature:9 -n
+    Then the output should contain
+      """
+      Given /^a table$/ do |table|
+        # table is a Cucumber::Ast::Table
+        pending
+      end
+      """

data/features/step_definitions/cucumber_steps.rb

@@ -1,30 +1,61 @@
-Given /^I am in (.*)$/ do |dir|
-  @dir = dir
+Given /^I am in (.*)$/ do |example_dir_relative_path|
+  @current_dir = examples_dir(example_dir_relative_path)
 end
 
-When /^I run cucumber (.*)$/ do |cmd|
-  @dir ||= 'self_test'
-  full_dir ||= File.expand_path(File.dirname(__FILE__) + "/../../examples/#{@dir}")
-  Dir.chdir(full_dir) do
-    @full_cmd = "#{Cucumber::RUBY_BINARY} #{Cucumber::BINARY} --no-color #{cmd}"
-    @out = `#{@full_cmd}`
-    @status = $?.exitstatus
+Given /^a standard Cucumber project directory structure$/ do
+  @current_dir = working_dir
+  in_current_dir do
+    FileUtils.mkdir_p 'features/support'
+    FileUtils.mkdir 'features/step_definitions'
   end
 end
 
-Then /^it should (fail|pass) with$/ do |success, output|
-  @out.should == output
+Given /^a file named "([^\"]*)" with:$/ do |file_name, file_content|
+  create_file(file_name, file_content)
+end
+
+Given /^the following profiles? (?:are|is) defined:$/ do |profiles|
+  create_file('cucumber.yml', profiles)
+end
+
+When /^I run cucumber (.*)$/ do |cucumber_opts|
+  run "#{Cucumber::RUBY_BINARY} #{Cucumber::BINARY} --no-color #{cucumber_opts}"
+end
+
+When /^I run rake (.*)$/ do |rake_opts|
+  run "rake #{rake_opts}"
+end
+
+Then /^it should (fail|pass)$/ do |success|
   if success == 'fail'
-    @status.should_not == 0
+    last_exit_status.should_not == 0
   else
-    @status.should == 0
+    last_exit_status.should == 0
   end
 end
 
-Then /^(.*) should contain$/ do |file, text|
+Then /^it should (fail|pass) with$/ do |success, output|
+  last_stdout.should == output
+  Then("it should #{success}")
+end
+
+Then /^the output should contain$/ do |text|
+  last_stdout.should include(text)
+end
+
+Then /^"(.*)" should contain$/ do |file, text|
   IO.read(file).should == text
 end
 
-Then /^(.*) should match$/ do |file, text|
+Then /^"(.*)" should match$/ do |file, text|
   IO.read(file).should =~ Regexp.new(text)
 end
+
+Then /^STDERR should match$/ do |text|
+  last_stderr.should =~ /#{text}/
+end
+
+Then /^"(.*)" should exist$/ do |file|
+  File.exists?(file).should be_true
+  FileUtils.rm(file)
+end

data/features/support/env.rb

@@ -1,8 +1,65 @@
 require 'rubygems'
+require 'tempfile'
 require 'spec/expectations'
 require 'fileutils'
+require 'forwardable'
 
-After do
-  FileUtils.rm_rf 'examples/self_test/tmp'
-  FileUtils.mkdir 'examples/self_test/tmp'
-end
+class CucumberWorld
+  extend Forwardable
+  def_delegators CucumberWorld, :examples_dir, :self_test_dir, :working_dir, :cucumber_lib_dir
+
+  def self.examples_dir(subdir=nil)
+    @examples_dir ||= File.expand_path(File.join(File.dirname(__FILE__), '../../examples'))
+    subdir ? File.join(@examples_dir, subdir) : @examples_dir
+  end
+
+  def self.self_test_dir
+    @self_test_dir ||= examples_dir('self_test')
+  end
+
+  def self.working_dir
+    @working_dir ||= examples_dir('self_test/tmp')
+  end
+
+  def cucumber_lib_dir
+    @cucumber_lib_dir ||= File.expand_path(File.join(File.dirname(__FILE__), '../../lib'))
+  end
+
+  def initialize
+    @current_dir = self_test_dir
+  end
+
+  private
+  attr_reader :last_exit_status, :last_stdout, :last_stderr
+
+  def create_file(file_name, file_content)
+    file_content.gsub!("CUCUMBER_LIB", "'#{cucumber_lib_dir}'") # Some files, such as Rakefiles need to use the lib dir
+    in_current_dir do
+      File.open(file_name, 'w') { |f| f << file_content }
+    end
+  end
+
+  def in_current_dir(&block)
+    Dir.chdir(@current_dir, &block)
+  end
+
+  def run(command)
+    stderr_file = Tempfile.new('cucumber')
+    stderr_file.close
+    in_current_dir do
+      @last_stdout = `#{command} 2> #{stderr_file.path}`
+      @last_exit_status = $?.exitstatus
+    end
+    @last_stderr = IO.read(stderr_file.path)
+  end
+
+end
+
+World do
+  CucumberWorld.new
+end
+
+Before do
+  FileUtils.rm_rf CucumberWorld.working_dir
+  FileUtils.mkdir CucumberWorld.working_dir
+end

data/features/usage.feature

@@ -19,6 +19,7 @@ Feature: Cucumber command line
       /^call step "(.*)"$/                                              # features/step_definitions/sample_steps.rb:23
        Given call step "a step definition that calls an undefined step" # features/call_undefined_step_from_step_def.feature:7
       /^'(.+)' cukes$/   # features/step_definitions/sample_steps.rb:27
+       Given '10' cukes  # features/background/background_with_name.feature:4
        And '10' cukes    # features/background/failing_background.feature:5
        Given '10' cukes  # features/background/passing_background.feature:4
        Given '10' cukes  # features/background/scenario_outline_passing_background.feature:4
@@ -72,6 +73,7 @@ Feature: Cucumber command line
        Given '2' cukes   # features/tons_of_cukes.feature:51
        Given '2' cukes   # features/tons_of_cukes.feature:52
       /^I should have '(.+)' cukes$/      # features/step_definitions/sample_steps.rb:31
+       Then I should have '10' cukes      # features/background/background_with_name.feature:7
        Then I should have '10' cukes      # features/background/failing_background.feature:8
        Then I should have '10' cukes      # features/background/failing_background.feature:11
        Then I should have '10' cukes      # features/background/passing_background.feature:7
@@ -103,6 +105,9 @@ Feature: Cucumber command line
        Given failing expectation # features/failing_expectation.feature:4
       /^failing$/    # features/step_definitions/sample_steps.rb:8
        Given failing # features/sample.feature:16
+      (::) UNUSED (::)
+      /^unused$/          # features/step_definitions/sample_steps.rb:66
+      /^another unused$/  # features/step_definitions/sample_steps.rb:69
 
       """
 

data/gem_tasks/deployment.rake

@@ -5,7 +5,7 @@ end
 
 namespace :manifest do
   desc 'Recreate Manifest.txt to include ALL files'
-  task :refresh do
+  task :refresh => :clobber do
     `rake check_manifest | patch -p0 > Manifest.txt`
   end
 end

data/lib/cucumber/ast/background.rb

@@ -6,8 +6,8 @@ module Cucumber
       include FeatureElement
       attr_writer :feature
 
-      def initialize(comment, line, keyword, steps)
-        @comment, @line, @keyword, @steps = comment, line, keyword, StepCollection.new(steps)
+      def initialize(comment, line, keyword, name, steps)
+        @comment, @line, @keyword, @name, @steps = comment, line, keyword, name, StepCollection.new(steps)
         attach_steps(steps)
         @step_invocations = @steps.step_invocations(true)
       end
@@ -23,10 +23,20 @@ module Cucumber
 
       def accept(visitor)
         visitor.visit_comment(@comment)
-        visitor.visit_background_name(@keyword, "", file_colon_line(@line), source_indent(text_length))
-        visitor.step_mother.before_and_after(self)
+        visitor.visit_background_name(@keyword, @name, file_colon_line(@line), source_indent(text_length))
+        visitor.step_mother.before(self)
         visitor.visit_steps(@step_invocations)
         @failed = @step_invocations.detect{|step_invocation| step_invocation.exception}
+        visitor.step_mother.after(self) if @failed
+      end
+
+      def accept_hook?(hook)
+        # TODO: When background is involved - no tag based hook filtering is occurring with
+        # the current implementation. All hooks will be executed. This is because of the line
+        #   visitor.step_mother.before(self)
+        # in the #accept method above. Instead, we should really be passing the first scenario
+        # here. We currently don't have access to that, so a refactoring is in order to make that happen.
+        true
       end
 
       def failed?

data/lib/cucumber/ast/examples.rb

@@ -10,26 +10,14 @@ module Cucumber
         visitor.visit_outline_table(@outline_table)
       end
 
-      def descend?(visitor)
-        @outline_table.descend?(visitor)
-      end
-
       def skip_invoke!
         @outline_table.skip_invoke!
       end
 
-      def matches_scenario_names?(scenario_names)
-        scenario_names.detect{|name| name == @name}
-      end
-
       def each_example_row(&proc)
         @outline_table.cells_rows[1..-1].each(&proc)
       end
 
-      def matches_lines?(lines)
-        lines.index(@line) || @outline_table.matches_lines?(lines)
-      end
-
       def to_sexp
         [:examples, @keyword, @name, @outline_table.to_sexp]
       end

data/lib/cucumber/ast/feature.rb

@@ -3,11 +3,10 @@ module Cucumber
     # Represents the root node of a parsed feature.
     class Feature
       attr_accessor :file
-      attr_writer :features, :lines
+      attr_writer :features
 
       def initialize(background, comment, tags, name, feature_elements)
         @background, @comment, @tags, @name, @feature_elements = background, comment, tags, name, feature_elements
-        @lines = []
 
         @feature_elements.each do |feature_element|
           feature_element.feature = self
@@ -15,24 +14,15 @@ module Cucumber
       end
 
       def accept(visitor)
-        visitor.current_feature_lines = @lines
         visitor.visit_comment(@comment)
         visitor.visit_tags(@tags)
         visitor.visit_feature_name(@name)
         visitor.visit_background(@background) if @background
         @feature_elements.each do |feature_element|
-          visitor.visit_feature_element(feature_element) if feature_element.descend?(visitor)
+          visitor.visit_feature_element(feature_element)
         end
       end
 
-      def descend?(visitor)
-        @feature_elements.detect{ |feature_element| feature_element.descend?(visitor) }
-      end
-
-      def has_tags?(tags)
-        @tags.has_tags?(tags)
-      end
-
       def next_feature_element(feature_element, &proc)
         index = @feature_elements.index(feature_element)
         next_one = @feature_elements[index+1]

data/lib/cucumber/ast/feature_element.rb

@@ -12,14 +12,6 @@ module Cucumber
       @keyword.jlength + @name.jlength
     end
 
-    def matches_lines?(lines)
-      lines.index(@line) || @steps.matches_lines?(lines) || @tags.matches_lines?(lines)
-    end
-
-    def has_tags?(tags)
-      @tags.has_tags?(tags) || @feature.has_tags?(tags)
-    end
-
     def matches_scenario_names?(scenario_names)
       scenario_names.detect{|name| name == @name}
     end
@@ -36,6 +28,10 @@ module Cucumber
       @steps.max_line_length(self)
     end
 
+    def accept_hook?(hook)
+      @tags.accept_hook?(hook)
+    end
+
     # TODO: Remove when we use StepCollection everywhere
     def previous_step(step)
       i = @steps.index(step) || -1

data/lib/cucumber/ast/features.rb

@@ -18,7 +18,7 @@ module Cucumber
 
       def accept(visitor)
         @features.each do |feature|
-          visitor.visit_feature(feature) if feature.descend?(visitor)
+          visitor.visit_feature(feature)
         end
       end
     end

data/lib/cucumber/ast/outline_table.rb

@@ -5,45 +5,41 @@ module Cucumber
         super(raw)
         @scenario_outline = scenario_outline
         @cells_class = ExampleCells
-        
-        cells_rows.each do |cells|
-          cells.create_step_invocations!(scenario_outline)
-        end
+        create_step_invocations_for_example_rows!(scenario_outline)
       end
 
       def accept(visitor)
         cells_rows.each_with_index do |row, n|
-          if n == 0 || matches?(visitor, row)
-            visitor.visit_table_row(row)
-          end
+          visitor.visit_table_row(row)
         end
         nil
       end
 
-      def descend?(visitor)
-        cells_rows.detect{|cells_row| cells_row.descend?(visitor)}
+      def accept_hook?(hook)
+        @scenario_outline.accept_hook?(hook)
       end
-      
-      def matches?(visitor, cells)
-        @scenario_outline.matches_tags_and_name?(visitor) &&
-        (visitor.matches_lines?(cells) || visitor.matches_lines?(@scenario_outline))
-      end
-      
+
       def skip_invoke!
-        cells_rows.each do |cells|
+        example_rows.each do |cells|
           cells.skip_invoke!
         end
       end
 
+      def create_step_invocations_for_example_rows!(scenario_outline)
+        example_rows.each do |cells|
+          cells.create_step_invocations!(scenario_outline)
+        end
+      end
+      
+      def example_rows
+        cells_rows[1..-1]
+      end
+
       class ExampleCells < Cells
         def create_step_invocations!(scenario_outline)
           @step_invocations = scenario_outline.step_invocations(self)
         end
         
-        def descend?(visitor)
-          @table.matches?(visitor, self)
-        end
-
         def skip_invoke!
           @step_invocations.each do |step_invocation|
             step_invocation.skip_invoke!
@@ -70,6 +66,10 @@ module Cucumber
           end
         end
 
+        def accept_hook?(hook)
+          @table.accept_hook?(hook)
+        end
+
         private
 
         def header?

data/lib/cucumber/ast/py_string.rb

@@ -17,26 +17,22 @@ module Cucumber
     # Note how the indentation from the source is stripped away.
     #
     class PyString
+
+      def self.default_arg_name
+        "string"
+      end
+
       def initialize(start_line, end_line, string, quotes_indent)
         @start_line, @end_line = start_line, end_line
         @string, @quotes_indent = string.gsub(/\\"/, '"'), quotes_indent
-        @status = :passed
-      end
-
-      def status=(status)
-        @status = status
       end
 
       def to_s
         @string.indent(-@quotes_indent)
       end
 
-      def matches_lines?(lines)
-        lines.detect{|l| l >= @start_line && l <= @end_line}
-      end
-
       def accept(visitor)
-        visitor.visit_py_string(to_s, @status)
+        visitor.visit_py_string(to_s)
       end
       
       def arguments_replaced(arguments) #:nodoc:
@@ -52,7 +48,6 @@ module Cucumber
       def to_sexp #:nodoc:
         [:py_string, to_s]
       end
-    
     end
   end
 end