aslakhellesoy-cucumber 0.1.16.4 → 0.1.16.5

data/lib/autotest/cucumber_mixin.rb

@@ -1,13 +1,13 @@
 require 'autotest'
 require 'tempfile'
-require File.dirname(__FILE__) + '/../cucumber/platform'
+require File.dirname(__FILE__) + '/../cucumber'
 
 module Autotest::CucumberMixin
   def self.included(receiver)
     receiver::ALL_HOOKS << [:run_features, :ran_features]
   end
   
-  attr_accessor :scenarios_to_run
+  attr_accessor :features_to_run
   
   def initialize
     super
@@ -45,7 +45,7 @@ module Autotest::CucumberMixin
   end
   
   def all_features_good
-    scenarios_to_run == []
+    features_to_run == ""
   end
   
   def get_to_green
@@ -62,13 +62,13 @@ module Autotest::CucumberMixin
   end
   
   def reset_features
-    self.scenarios_to_run = :all
+    self.features_to_run = :all
   end
     
   def run_features
     hook :run_features
-    Tempfile.open('autotest-cucumber') do |dirty_scenarios_file|
-      cmd = self.make_cucumber_cmd self.scenarios_to_run, dirty_scenarios_file.path
+    Tempfile.open('autotest-cucumber') do |dirty_features_file|
+      cmd = self.make_cucumber_cmd(self.features_to_run, dirty_features_file.path)
       return if cmd.empty?
       puts cmd unless $q
       old_sync = $stdout.sync
@@ -94,37 +94,30 @@ module Autotest::CucumberMixin
       ensure
         $stdout.sync = old_sync
       end
-      self.scenarios_to_run = dirty_scenarios_file.readlines.map { |l| l.chomp }
-      self.tainted = true unless self.scenarios_to_run == []
+      self.features_to_run = dirty_features_file.read
+      self.tainted = true unless self.features_to_run == []
     end
     hook :ran_features
   end
   
-  def make_cucumber_cmd(scenarios_to_run, dirty_scenarios_filename)
-    return '' if scenarios_to_run == []
+  def make_cucumber_cmd(features_to_run, dirty_features_filename)
+    return '' if features_to_run == ''
     
     profiles = YAML.load_file("cucumber.yml").keys rescue []
     
-    profile ||= "autotest-all" if profiles.include?("autotest-all") and scenarios_to_run == :all
+    profile ||= "autotest-all" if profiles.include?("autotest-all") and features_to_run == :all
     profile ||= "autotest"     if profiles.include?("autotest")
     profile ||= nil
     
     if profile
       args = ["--profile", profile]
     else
-      args = %w{features --format} << (scenarios_to_run == :all ? "progress" : "pretty")
+      args = %w{--format} << (features_to_run == :all ? "progress" : "pretty")
     end
-    args += %w{--format autotest --color --out} << dirty_scenarios_filename
+    args += %w{--color --format rerun --out} << dirty_features_filename
+    args << (features_to_run == :all ? "features" : features_to_run)
     args = args.join(' ')
-    
-    if scenarios_to_run == :all
-      scenario_args = nil
-    else
-      # We escape scenario names for the shell by wrapping them in $'...' and replacing
-      # every single quote with an escaped version, "\'".  We use a double backslash for
-      # Ruby, and we put it in a block or gsub interpolates the sequence "\'" as $'.
-      scenario_args = scenarios_to_run.map { |s| "-s $'#{s.gsub("'") {"\\'"} }'" }.join(' ')
-    end
-    return "#{Cucumber::RUBY_BINARY} #{Cucumber::BINARY} #{args} #{scenario_args}"
+
+    return "#{Cucumber::RUBY_BINARY} #{Cucumber::BINARY} #{args}"
   end
 end

data/lib/cucumber/ast/comment.rb

@@ -0,0 +1,26 @@
+module Cucumber
+  module Ast
+    # Holds the value of a comment parsed from a feature file:
+    #
+    #   # Lorem ipsum
+    #   # dolor sit amet
+    #
+    # This gets parsed into a Comment with value <tt>"# Lorem ipsum\n# dolor sit amet\n"</tt>
+    #
+    class Comment
+      def initialize(value)
+        @value = value
+      end
+
+      def accept(visitor)
+        @value.split("\n").each do |line|
+          visitor.visit_comment_line(line.strip)
+        end
+      end
+      
+      def to_sexp
+        (@value.nil? || @value == '') ? nil : [:comment, @value]
+      end
+    end
+  end
+end

data/lib/cucumber/ast/examples.rb

@@ -0,0 +1,22 @@
+module Cucumber
+  module Ast
+    class Examples
+      def initialize(line, keyword, name, outline_table)
+        @keyword, @name, @outline_table = keyword, name, outline_table
+      end
+
+      def accept(visitor)
+        visitor.visit_examples_name(@keyword, @name)
+        @outline_table.accept(visitor, nil)
+      end
+
+      def at_lines?(lines)
+        lines.empty? || lines.index(@line) || @outline_table.at_lines?(lines)
+      end
+
+      def to_sexp
+        [:examples, @keyword, @name, @outline_table.to_sexp]
+      end
+    end
+  end
+end

data/lib/cucumber/ast/feature.rb

@@ -0,0 +1,60 @@
+module Cucumber
+  module Ast
+    # Represents the root node of a parsed feature.
+    class Feature
+      attr_accessor :file
+      attr_writer :features, :lines
+
+      def initialize(comment, tags, name, feature_elements)
+        @comment, @tags, @name, @feature_elements = comment, tags, name, feature_elements
+        feature_elements.each{|feature_element| feature_element.feature = self}
+        @lines = []
+      end
+
+      def tagged_with?(tag_names, check_elements=true)
+        @tags.among?(tag_names) || 
+        (check_elements && @feature_elements.detect{|e| e.tagged_with?(tag_names)})
+      end
+      
+      def matches_scenario_names?(scenario_names)
+        @feature_elements.detect{|e| e.matches_scenario_names?(scenario_names)}
+      end
+
+      def accept(visitor)
+        visitor.current_feature_lines = @lines
+        visitor.visit_comment(@comment)
+        visitor.visit_tags(@tags)
+        visitor.visit_feature_name(@name)
+        @feature_elements.each do |feature_element|
+          visitor.visit_feature_element(feature_element) if @features.visit?(feature_element, @lines)
+        end
+      end
+
+      def scenario_executed(scenario)
+        @features.scenario_executed(scenario) if @features
+      end
+
+      def step_executed(step)
+        @features.step_executed(step) if @features
+      end
+
+      def backtrace_line(step_name, line)
+        "#{file_line(line)}:in `#{step_name}'"
+      end
+
+      def file_line(line)
+        "#{@file}:#{line}"
+      end
+
+      def to_sexp
+        sexp = [:feature, @name]
+        comment = @comment.to_sexp
+        sexp += [comment] if comment
+        tags = @tags.to_sexp
+        sexp += tags if tags.any?
+        sexp += @feature_elements.map{|e| e.to_sexp}
+        sexp
+      end
+    end
+  end
+end

data/lib/cucumber/ast/features.rb

@@ -0,0 +1,39 @@
+module Cucumber
+  module Ast
+    class Features
+      attr_reader :steps, :scenarios
+
+      def initialize(filter)
+        @filter = filter
+
+        @features = []
+        @scenarios = []
+        @steps = Hash.new{|steps, status| steps[status] = []}
+      end
+
+      def add_feature(feature)
+        feature.features = self
+        @features << feature
+      end
+
+      def visit?(node, lines)
+        @filter.matched?(node) &&
+        (lines.empty? ? true : node.at_lines?(lines))
+      end
+
+      def scenario_executed(scenario)
+        @scenarios << scenario
+      end
+      
+      def step_executed(step)
+        @steps[step.status] << step
+      end
+
+      def accept(visitor)
+        @features.each do |feature|
+          visitor.visit_feature(feature) if visit?(feature, [])
+        end
+      end
+    end
+  end
+end

data/lib/cucumber/ast/filter.rb

@@ -0,0 +1,22 @@
+module Cucumber
+  module Ast
+    class Filter
+      def initialize(options)
+        @options = options
+      end
+      
+      def matched?(node)
+        matched_by_tags?(node) &&
+        matched_by_scenario_names?(node)
+      end
+      
+      def matched_by_tags?(node)
+        @options[:tags].empty? || node.tagged_with?(@options[:tags])
+      end
+
+      def matched_by_scenario_names?(node)
+        @options[:scenario_names].empty? || node.matches_scenario_names?(@options[:scenario_names])
+      end
+    end
+  end
+end

data/lib/cucumber/ast/outline_table.rb

@@ -0,0 +1,49 @@
+module Cucumber
+  module Ast
+    class OutlineTable < Table
+      def initialize(raw, scenario_outline)
+        super(raw)
+        @scenario_outline = scenario_outline
+        @cells_class = ExampleCells
+      end
+
+      def accept(visitor, status)
+        rows.each_with_index do |row, n|
+          should_visit = n == 0 || 
+            row.at_lines?(visitor.current_feature_lines) ||
+            @scenario_outline.at_header_or_step_lines?(visitor.current_feature_lines)
+
+          if should_visit
+            visitor.visit_table_row(row, status)
+          end
+        end
+        nil
+      end
+
+      def execute_row(cells, visitor, &proc)
+        @scenario_outline.execute_row(cells, visitor, &proc)
+      end
+
+      class ExampleCells < Cells
+        def accept(visitor, status)
+          if header?
+            @cells.each do |cell|
+              visitor.visit_table_cell(cell, :thead)
+            end
+            nil
+          else
+            exception = @table.execute_row(self, visitor) do |cell, status|
+              visitor.visit_table_cell(cell, status)
+            end
+          end
+        end
+
+        private
+
+        def header?
+          index == 0
+        end
+      end
+    end
+  end
+end

data/lib/cucumber/ast/py_string.rb

@@ -0,0 +1,52 @@
+module Cucumber
+  module Ast
+    # Represents an inline argument in a step. Example:
+    #
+    #   Given the message
+    #     """
+    #     I like
+    #     Cucumber sandwich
+    #     """
+    #
+    # The text between the pair of <tt>"""</tt> is stored inside a PyString,
+    # which is yielded to the StepDefinition block as the last argument.
+    #
+    # The StepDefinition can then access the String via the #to_s method. In the
+    # example above, that would return: <tt>"I like\nCucumber sandwich"</tt>
+    #
+    # Note how the indentation from the source is stripped away.
+    #
+    class PyString
+      def initialize(start_line, end_line, string, quotes_indent)
+        @start_line, @end_line = start_line, end_line
+        @string, @quotes_indent = string, quotes_indent
+      end
+
+      def to_s
+        @string.indent(-@quotes_indent)
+      end
+
+      def at_lines?(lines)
+        lines.detect{|l| l >= @start_line && l <= @end_line}
+      end
+
+      def accept(visitor, status)
+        visitor.visit_py_string(to_s, status)
+      end
+      
+      def arguments_replaced(arguments) #:nodoc:
+        string = @string
+        arguments.each do |name, value|
+          string = string.gsub(name, value)
+        end
+        PyString.new(@start_line, @end_line, string, @quotes_indent)
+      end
+      
+      # For testing only
+      def to_sexp #:nodoc:
+        [:py_string, to_s]
+      end
+                
+    end
+  end
+end

data/lib/cucumber/ast/scenario.rb

@@ -0,0 +1,91 @@
+module Cucumber
+  module Ast
+    class Scenario
+      attr_writer :feature
+      
+      def initialize(comment, tags, line, keyword, name, steps)
+        @comment, @tags, @line, @keyword, @name = comment, tags, line, keyword, name
+        steps.each {|step| step.scenario = self}
+        @steps = steps
+      end
+
+      def tagged_with?(tag_names)
+        @tags.among?(tag_names) || @feature.tagged_with?(tag_names, false)
+      end
+
+      def matches_scenario_names?(scenario_names)
+        scenario_names.detect{|name| @name == name}
+      end
+
+      def accept(visitor)
+        visitor.visit_comment(@comment)
+        visitor.visit_tags(@tags)
+        visitor.visit_scenario_name(@keyword, @name, file_line(@line), source_indent(text_length))
+        visitor.world(self) do |world|
+          previous = :passed
+          @steps.each do |step|
+            step.previous = previous
+            step.world    = world
+            visitor.visit_step(step)
+            previous = step.status
+          end
+        end
+        @feature.scenario_executed(self) if @feature && !@executed
+        @executed = true
+      end
+
+      def source_indent(text_length)
+        max_line_length - text_length
+      end
+
+      def max_line_length
+        lengths = (@steps + [self]).map{|e| e.text_length}
+        lengths.max
+      end
+
+      def text_length
+        @keyword.jlength + @name.jlength
+      end
+
+      def at_lines?(lines)
+        at_header_or_step_lines?(lines)
+      end
+
+      def at_header_or_step_lines?(lines)
+        lines.empty? || lines.index(@line) || @steps.detect {|step| step.at_lines?(lines)} || @tags.at_lines?(lines)
+      end
+
+      def undefined?
+        @steps.empty?
+      end
+
+      def step_executed(step)
+        @feature.step_executed(step) if @feature
+      end
+
+      def backtrace_line(name = "#{@keyword} #{@name}", line = @line)
+        @feature.backtrace_line(name, line) if @feature
+      end
+
+      def file_line(line = @line)
+        @feature.file_line(line) if @feature
+      end
+
+      def previous_step(step)
+        i = @steps.index(step)
+        @steps[i-1]
+      end
+
+      def to_sexp
+        sexp = [:scenario, @line, @keyword, @name]
+        comment = @comment.to_sexp
+        sexp += [comment] if comment
+        tags = @tags.to_sexp
+        sexp += tags if tags.any?
+        steps = @steps.map{|step| step.to_sexp}
+        sexp += steps if steps.any?
+        sexp
+      end
+    end
+  end
+end

data/lib/cucumber/ast/scenario_outline.rb

@@ -0,0 +1,83 @@
+module Cucumber
+  module Ast
+    class ScenarioOutline < Scenario
+      # The +example_sections+ argument must be an Array where each element is another array representing
+      # an Examples section. This array has 3 elements:
+      #
+      # * Examples keyword
+      # * Examples section name
+      # * Raw matrix
+      def initialize(comment, tags, line, keyword, name, steps, example_sections)
+        super(comment, tags, line, keyword, name, steps)
+        steps.each {|step| step.status = :outline}
+
+        @examples_array = example_sections.map do |example_section|
+          examples_line       = example_section[0]
+          examples_keyword    = example_section[1]
+          examples_name       = example_section[2]
+          examples_matrix     = example_section[3]
+
+          examples_table = OutlineTable.new(examples_matrix, self)
+          Examples.new(examples_line, examples_keyword, examples_name, examples_table)
+        end
+      end
+
+      def at_lines?(lines)
+        super || @examples_array.detect { |examples| examples.at_lines?(lines) }
+      end
+
+      def accept(visitor)
+        visitor.visit_comment(@comment)
+        visitor.visit_tags(@tags)
+        visitor.visit_scenario_name(@keyword, @name, file_line(@line), source_indent(text_length))
+        @steps.each do |step|
+          visitor.visit_step(step)
+        end
+        @examples_array.each do |examples|
+          visitor.visit_examples(examples)
+        end
+      end
+
+      def execute_row(cells, visitor, &proc)
+        exception = nil
+        visitor.world(self) do |world|
+          previous_status = :passed
+          argument_hash = cells.to_hash
+          cell_index = 0
+          @steps.each do |step|
+            executed_step, previous_status, matched_args = 
+              step.execute_with_arguments(argument_hash, world, previous_status, visitor, cells[0].line)
+            # There might be steps that don't have any arguments
+            # If there are no matched args, we'll still iterate once
+            matched_args = [nil] if matched_args.empty?
+
+            matched_args.each do
+              cell = cells[cell_index]
+              if cell
+                proc.call(cell, previous_status)
+                cell_index += 1
+              end
+            end
+            exception ||= executed_step.exception
+          end
+        end
+        @feature.scenario_executed(self) if @feature
+        exception
+      end
+
+      def pending? ; false ; end
+
+      def to_sexp
+        sexp = [:scenario_outline, @keyword, @name]
+        comment = @comment.to_sexp
+        sexp += [comment] if comment
+        tags = @tags.to_sexp
+        sexp += tags if tags.any?
+        steps = @steps.map{|step| step.to_sexp}
+        sexp += steps if steps.any?
+        sexp += @examples_array.map{|e| e.to_sexp}
+        sexp
+      end
+    end
+  end
+end

data/lib/cucumber/ast/step.rb

@@ -0,0 +1,130 @@
+require 'cucumber/step_definition'
+require 'cucumber/core_ext/string'
+
+module Cucumber
+  module Ast
+    class Step
+      attr_reader :keyword, :name
+      attr_writer :world, :previous, :options
+      attr_accessor :status, :scenario, :exception
+
+      def initialize(line, keyword, name, *multiline_args)
+        @line, @keyword, @name, @multiline_args = line, keyword, name, multiline_args
+      end
+
+      def execute_with_arguments(argument_hash, world, previous, visitor, row_line)
+        delimited_arguments = delimit_argument_names(argument_hash)
+        name                = replace_name_arguments(delimited_arguments)
+        multiline_args      = replace_multiline_args_arguments(delimited_arguments)
+
+        execute_twin(world, previous, visitor, row_line, name, *multiline_args)
+      end
+
+      def accept(visitor)
+        execute(visitor)
+        visitor.visit_step_name(@keyword, @name, @status, @step_definition, source_indent)
+        @multiline_args.each do |multiline_arg|
+          visitor.visit_multiline_arg(multiline_arg, @status)
+        end
+        @exception
+      end
+
+      def to_sexp
+        [:step, @line, @keyword, @name, *@multiline_args.map{|arg| arg.to_sexp}]
+      end
+
+      def at_lines?(lines)
+        lines.empty? || lines.index(@line) || @multiline_args.detect{|a| a.at_lines?(lines)}
+      end
+
+      def source_indent
+        @scenario.source_indent(text_length)
+      end
+
+      def text_length
+        @keyword.jlength + @name.jlength + 2 # Add 2 because steps get indented 2 more than scenarios
+      end
+
+      def backtrace_line
+        @backtrace_line ||= @scenario.backtrace_line("#{@keyword} #{@name}", @line) unless @scenario.nil?
+      end
+
+      def file_line
+        @file_line ||= @scenario.file_line(@line) unless @scenario.nil?
+      end
+
+      def actual_keyword
+        if [Cucumber.keyword_hash['and'], Cucumber.keyword_hash['but']].index(@keyword) && previous_step
+          previous_step.actual_keyword
+        else
+          @keyword
+        end
+      end
+
+      protected
+
+      def previous_step
+        @scenario.previous_step(self)
+      end
+
+      private
+
+      def execute(visitor)
+        matched_args = []
+        if @status.nil?
+          begin
+            @step_definition = visitor.step_definition(@name)
+            matched_args = @step_definition.matched_args(@name)
+            if @previous == :passed && !visitor.options[:dry_run]
+              @world.__cucumber_current_step = self
+              @step_definition.execute(@name, @world, *(matched_args + @multiline_args))
+              @status = :passed
+            else
+              @status = :skipped
+            end
+          rescue StepMother::Undefined
+            @status = :undefined
+          rescue StepMother::Pending
+            @status = :pending
+          rescue Exception => exception
+            @status = :failed
+            @exception = exception
+            @exception.backtrace << backtrace_line unless backtrace_line.nil?
+          end
+          @scenario.step_executed(self) if @scenario
+        end
+        [self, @status, matched_args]
+      end
+
+      def execute_twin(world, previous, visitor, line, name, *multiline_args)
+        # We'll create a new step and execute that
+        step = Step.new(line, @keyword, name, *multiline_args)
+        step.scenario = @scenario
+        step.world    = world
+        step.previous = previous
+        step.__send__(:execute, visitor)
+      end
+
+      ARGUMENT_START = '<'
+      ARGUMENT_END   = '>'
+
+      def delimit_argument_names(argument_hash)
+        argument_hash.inject({}) { |h,(k,v)| h["#{ARGUMENT_START}#{k}#{ARGUMENT_END}"] = v; h }
+      end
+
+      def replace_name_arguments(argument_hash)
+        name_with_arguments_replaced = @name
+        argument_hash.each do |name, value|
+          name_with_arguments_replaced = name_with_arguments_replaced.gsub(name, value)
+        end
+        name_with_arguments_replaced
+      end
+
+      def replace_multiline_args_arguments(arguments)
+        @multiline_args.map do |arg|
+          arg.arguments_replaced(arguments)
+        end
+      end
+    end
+  end
+end