pezra-cucumber 0.3.94.1

data/lib/autotest/discover.rb

@@ -0,0 +1,9 @@
+Autotest.add_discovery do
+  if File.directory?('features')
+    if ENV['AUTOFEATURE'] =~ /true/i
+      "cucumber"
+    else
+      puts "(Not running features.  To run features in autotest, set AUTOFEATURE=true.)"
+    end
+  end
+end

data/lib/cucumber.rb

@@ -0,0 +1,11 @@
+$:.unshift(File.dirname(__FILE__)) unless
+  $:.include?(File.dirname(__FILE__)) || $:.include?(File.expand_path(File.dirname(__FILE__)))
+
+require 'yaml'
+require 'cucumber/platform'
+require 'cucumber/parser'
+require 'cucumber/version'
+require 'cucumber/step_mother'
+require 'cucumber/cli/main'
+require 'cucumber/broadcaster'
+require 'cucumber/core_ext/exception'

data/lib/cucumber/ast.rb

@@ -0,0 +1,29 @@
+require 'cucumber/ast/comment'
+require 'cucumber/ast/tags'
+require 'cucumber/ast/features'
+require 'cucumber/ast/feature'
+require 'cucumber/ast/background'
+require 'cucumber/ast/scenario'
+require 'cucumber/ast/scenario_outline'
+require 'cucumber/ast/step_invocation'
+require 'cucumber/ast/step_collection'
+require 'cucumber/ast/step'
+require 'cucumber/ast/table'
+require 'cucumber/ast/py_string'
+require 'cucumber/ast/outline_table'
+require 'cucumber/ast/examples'
+require 'cucumber/ast/visitor'
+
+module Cucumber
+  # Classes in this module represent the Abstract Syntax Tree (AST)
+  # that gets built when feature files are parsed.
+  #
+  # AST classes don't expose any internal data directly. This is
+  # in order to encourage a less coupled design in the classes
+  # that operate on the AST. The only public method is #accept.
+  #
+  # The AST can be traversed with a visitor. See Cucumber::Format::Pretty
+  # for an example.
+  module Ast
+  end
+end

data/lib/cucumber/ast/background.rb

@@ -0,0 +1,63 @@
+require 'cucumber/ast/feature_element'
+
+module Cucumber
+  module Ast
+    class Background
+      include FeatureElement
+      attr_reader :feature_elements
+
+      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)
+        @feature_elements = []
+      end
+
+      def step_collection(step_invocations)
+        unless(@first_collection_created)
+          @first_collection_created = true
+          @step_invocations.dup(step_invocations)
+        else
+          @steps.step_invocations(true).dup(step_invocations)
+        end
+      end
+
+      def accept(visitor)
+        return if $cucumber_interrupted
+        visitor.visit_comment(@comment) unless @comment.empty?
+        visitor.visit_background_name(@keyword, @name, file_colon_line(@line), source_indent(first_line_length))
+        visitor.step_mother.before(hook_context)
+        visitor.visit_steps(@step_invocations)
+        @failed = @step_invocations.detect{|step_invocation| step_invocation.exception}
+        visitor.step_mother.after(hook_context) if @failed || @feature_elements.empty?
+      end
+
+      def accept_hook?(hook)
+        if hook_context != self
+          hook_context.accept_hook?(hook)
+        else
+          # We have no scenarios, just ask our feature
+          @feature.accept_hook?(hook)
+        end
+      end
+
+      def failed?
+        @failed
+      end
+
+      def hook_context
+        @feature_elements.first || self
+      end
+
+      def to_sexp
+        sexp = [:background, @line, @keyword]
+        sexp += [@name] unless @name.empty?
+        comment = @comment.to_sexp
+        sexp += [comment] if comment
+        steps = @steps.to_sexp
+        sexp += steps if steps.any?
+        sexp
+      end
+    end
+  end
+end

data/lib/cucumber/ast/comment.rb

@@ -0,0 +1,31 @@
+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 empty?
+        @value.nil? || @value == ""
+      end
+
+      def accept(visitor)
+        return if $cucumber_interrupted
+        @value.strip.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,27 @@
+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)
+        return if $cucumber_interrupted
+        visitor.visit_examples_name(@keyword, @name)
+        visitor.visit_outline_table(@outline_table)
+      end
+
+      def skip_invoke!
+        @outline_table.skip_invoke!
+      end
+
+      def each_example_row(&proc)
+        @outline_table.cells_rows[1..-1].each(&proc)
+      end
+
+      def to_sexp
+        [:examples, @keyword, @name, @outline_table.to_sexp]
+      end
+    end
+  end
+end

data/lib/cucumber/ast/feature.rb

@@ -0,0 +1,81 @@
+module Cucumber
+  module Ast
+    # Represents the root node of a parsed feature.
+    class Feature
+      attr_accessor :file, :language
+      attr_writer :features
+      attr_reader :name
+
+      def initialize(background, comment, tags, name, feature_elements)
+        @background, @comment, @tags, @name, @feature_elements = background, comment, tags, name.strip, feature_elements
+
+        background.feature = self if background
+        @feature_elements.each do |feature_element|
+          feature_element.feature = self
+        end
+      end
+
+      def accept(visitor)
+        return if $cucumber_interrupted
+        visitor.visit_comment(@comment) unless @comment.empty?
+        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)
+        end
+      end
+
+      def accept_hook?(hook)
+        @tags.accept_hook?(hook)
+      end
+
+      def next_feature_element(feature_element, &proc)
+        index = @feature_elements.index(feature_element)
+        next_one = @feature_elements[index+1]
+        proc.call(next_one) if next_one
+      end
+
+      def backtrace_line(step_name, line)
+        "#{file_colon_line(line)}:in `#{step_name}'"
+      end
+
+      def file_colon_line(line)
+        "#{@file}:#{line}"
+      end
+
+      def tag_count(tag)
+        if @tags.respond_to?(:count)
+          @tags.count(tag) # 1.9
+        else
+          @tags.select{|t| t == tag}.length  # 1.8
+        end
+      end
+
+      def feature_and_children_tag_count(tag)
+        children_tag_count = @feature_elements.inject(0){|count, feature_element| count += feature_element.tag_count(tag)}
+        children_tag_count + tag_count(tag)
+      end
+
+      def short_name
+        first_line = name.split(/\n/)[0]
+        if first_line =~ /#{language.keywords('feature', true)}:(.*)/
+          $1.strip
+        else
+          first_line
+        end
+      end
+
+      def to_sexp
+        sexp = [:feature, @file, @name]
+        comment = @comment.to_sexp
+        sexp += [comment] if comment
+        tags = @tags.to_sexp
+        sexp += tags if tags.any?
+        sexp += [@background.to_sexp] if @background
+        sexp += @feature_elements.map{|fe| fe.to_sexp}
+        sexp
+      end
+    end
+  end
+end

data/lib/cucumber/ast/feature_element.rb

@@ -0,0 +1,61 @@
+require 'enumerator'
+
+module Cucumber
+  module FeatureElement
+    attr_writer :feature
+
+    def attach_steps(steps)
+      steps.each {|step| step.feature_element = self}
+    end
+
+    def file_colon_line(line = @line)
+      @feature.file_colon_line(line) if @feature
+    end
+
+    def text_length
+      name_line_lengths.max
+    end
+
+    def first_line_length
+      name_line_lengths[0]
+    end
+
+    def name_line_lengths
+      if @name.empty?
+        [@keyword.jlength]
+      else
+        @name.split("\n").enum_for(:each_with_index).map do |line, line_number|
+          line_number == 0 ? @keyword.jlength + line.jlength : line.jlength + Ast::Step::INDENT - 1 # We -1 as names which are not keyword lines are missing a space between keyword and name
+        end
+      end
+    end
+
+    def matches_scenario_names?(scenario_name_regexps)
+      scenario_name_regexps.detect{|name| name =~ @name}
+    end
+
+    def backtrace_line(name = "#{@keyword} #{@name}", line = @line)
+      @feature.backtrace_line(name, line) if @feature
+    end
+
+    def source_indent(text_length)
+      max_line_length - text_length
+    end
+
+    def max_line_length
+      @steps.max_line_length(self)
+    end
+
+    def accept_hook?(hook)
+      @tags.accept_hook?(hook) || @feature.accept_hook?(hook)
+    end
+
+    def tag_count(tag)
+      @feature.tag_count(tag) == 0 ? @tags.count(tag) : @feature.tag_count(tag)
+    end
+
+    def language
+      @feature.language
+    end
+   end
+end

data/lib/cucumber/ast/features.rb

@@ -0,0 +1,40 @@
+module Cucumber
+  module Ast
+    class Features
+      include Enumerable
+
+      attr_reader :duration
+
+      def initialize
+        @features = []
+      end
+
+      def [](index)
+        @features[index]
+      end
+
+      def each(&proc)
+        @features.each(&proc)
+      end
+
+      def add_feature(feature)
+        feature.features = self
+        @features << feature
+      end
+
+      def accept(visitor)
+        return if $cucumber_interrupted
+        start = Time.now
+        self.each do |feature|
+          visitor.visit_feature(feature)
+        end
+        @duration = Time.now - start
+      end
+
+      def tag_count(tag)
+        @features.inject(0){|count, feature| count += feature.feature_and_children_tag_count(tag)}
+      end
+
+    end
+  end
+end

data/lib/cucumber/ast/outline_table.rb

@@ -0,0 +1,146 @@
+module Cucumber
+  module Ast
+    class OutlineTable < Table
+      def initialize(raw, scenario_outline)
+        super(raw)
+        @scenario_outline = scenario_outline
+        @cells_class = ExampleRow
+        create_step_invocations_for_example_rows!(scenario_outline)
+      end
+
+      def accept(visitor)
+        return if $cucumber_interrupted
+        cells_rows.each_with_index do |row, n|
+          if(visitor.options[:expand])
+            row.accept(visitor)
+          else
+            visitor.visit_table_row(row)
+          end
+        end
+        nil
+      end
+
+      def accept_hook?(hook)
+        @scenario_outline.accept_hook?(hook)
+      end
+
+      def skip_invoke!
+        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
+
+      def visit_scenario_name(visitor, row)
+        @scenario_outline.visit_scenario_name(visitor, row)
+      end
+
+      class ExampleRow < Cells
+        attr_reader :scenario_outline # https://rspec.lighthouseapp.com/projects/16211/tickets/342
+
+        def create_step_invocations!(scenario_outline)
+          @scenario_outline = scenario_outline
+          @step_invocations = scenario_outline.step_invocations(self)
+        end
+        
+        def skip_invoke!
+          @step_invocations.each do |step_invocation|
+            step_invocation.skip_invoke!
+          end
+        end
+
+        def accept(visitor)
+          return if $cucumber_interrupted
+          visitor.options[:expand] ? accept_expand(visitor) : accept_plain(visitor)
+        end
+
+        def accept_plain(visitor)
+          if header?
+            @cells.each do |cell|
+              cell.status = :skipped_param
+              visitor.visit_table_cell(cell)
+            end
+          else
+            visitor.step_mother.before_and_after(self) do
+              @step_invocations.each do |step_invocation|
+                step_invocation.invoke(visitor.step_mother, visitor.options)
+                @exception ||= step_invocation.reported_exception
+              end
+
+              @cells.each do |cell|
+                visitor.visit_table_cell(cell)
+              end
+              
+              visitor.visit_exception(@scenario_exception, :failed) if @scenario_exception
+            end
+          end
+        end
+
+        def accept_expand(visitor)
+          if header?
+          else
+            visitor.step_mother.before_and_after(self) do
+              @table.visit_scenario_name(visitor, self)
+              @step_invocations.each do |step_invocation|
+                step_invocation.invoke(visitor.step_mother, visitor.options)
+                @exception ||= step_invocation.reported_exception
+                step_invocation.visit_step_result(visitor)
+              end
+            end
+          end
+        end
+
+        def accept_hook?(hook)
+          @table.accept_hook?(hook)
+        end
+        
+        def exception
+          @exception || @scenario_exception
+        end
+        
+        def fail!(exception)
+          @scenario_exception = exception
+        end
+        
+        # Returns true if one or more steps failed
+        def failed?
+          @step_invocations.failed? || !!@scenario_exception
+        end
+
+        # Returns true if all steps passed
+        def passed?
+          !failed?
+        end
+
+        # Returns the status
+        def status
+          return :failed if @scenario_exception
+          @step_invocations.status
+        end
+
+        def backtrace_line
+          @scenario_outline.backtrace_line(name, line)
+        end
+
+        def name
+          "| #{@cells.collect{|c| c.value }.join(' | ')} |"
+        end
+
+        private
+
+        def header?
+          index == 0
+        end
+      end
+    end
+  end
+end