casecumber 1.0.2.1

data/lib/autotest/cucumber_rails.rb

@@ -0,0 +1,6 @@
+require 'autotest/rails'
+require 'autotest/cucumber_mixin'
+
+class Autotest::CucumberRails < Autotest::Rails
+  include CucumberMixin
+end

data/lib/autotest/cucumber_rails_rspec.rb

@@ -0,0 +1,6 @@
+require 'autotest/cucumber_mixin'
+require 'autotest/rails_rspec'
+
+class Autotest::CucumberRailsRspec < Autotest::RailsRspec
+  include CucumberMixin
+end

data/lib/autotest/cucumber_rails_rspec2.rb

@@ -0,0 +1,6 @@
+require 'autotest/cucumber_mixin'
+require 'autotest/rails_rspec2'
+
+class Autotest::CucumberRailsRspec2 < Autotest::RailsRspec2
+  include CucumberMixin
+end

data/lib/autotest/cucumber_rspec.rb

@@ -0,0 +1,6 @@
+require 'autotest/cucumber_mixin'
+require 'autotest/rspec'
+
+class Autotest::CucumberRspec < Autotest::Rspec
+  include CucumberMixin
+end

data/lib/autotest/cucumber_rspec2.rb

@@ -0,0 +1,6 @@
+require 'autotest/cucumber_mixin'
+require 'autotest/rspec2'
+
+class Autotest::CucumberRspec2 < Autotest::Rspec2
+  include CucumberMixin
+end

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,27 @@
+$:.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/step_mother'
+require 'cucumber/cli/main'
+require 'cucumber/broadcaster'
+require 'cucumber/step_definitions'
+
+module Cucumber
+  class << self
+    attr_accessor :wants_to_quit
+    
+    def logger
+      return @log if @log
+      @log = Logger.new(STDOUT)
+      @log.level = Logger::INFO
+      @log
+    end
+    
+    def logger=(logger)
+      @log = logger
+    end
+  end
+end

data/lib/cucumber/ast.rb

@@ -0,0 +1,30 @@
+require 'cucumber/ast/comment'
+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/tags'
+require 'cucumber/ast/doc_string'
+require 'cucumber/ast/outline_table'
+require 'cucumber/ast/examples'
+require 'cucumber/ast/visitor'
+require 'cucumber/ast/tree_walker'
+
+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,101 @@
+require 'cucumber/ast/feature_element'
+require 'cucumber/ast/names'
+
+module Cucumber
+  module Ast
+    class Background #:nodoc:
+      include FeatureElement
+      include Names
+      attr_reader :feature_elements
+
+      def initialize(comment, line, keyword, title, description, raw_steps)
+        @comment, @line, @keyword, @title, @description, @raw_steps = comment, line, keyword, title, description, raw_steps
+        @feature_elements = []
+      end
+
+      def init
+        return if @steps
+        attach_steps(@raw_steps)
+        @steps = StepCollection.new(@raw_steps)
+        @step_invocations = @steps.step_invocations(true)
+      end
+
+      def step_collection(step_invocations)
+        init
+        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.wants_to_quit
+        init
+        visitor.visit_comment(@comment) unless @comment.empty?
+        visitor.visit_background_name(@keyword, name, file_colon_line(@line), source_indent(first_line_length))
+        with_visitor(hook_context, visitor) do
+          visitor.step_mother.before(hook_context)
+          skip_invoke! if failed?
+          visitor.visit_steps(@step_invocations)
+          @failed = @step_invocations.detect{|step_invocation| step_invocation.exception || step_invocation.status != :passed }
+          visitor.step_mother.after(hook_context) if @failed || @feature_elements.empty?
+        end
+      end
+      
+      def with_visitor(scenario, visitor)
+        @current_visitor = visitor
+        init
+        if self != scenario && scenario.respond_to?(:with_visitor)
+          scenario.with_visitor(visitor) do
+            yield
+          end
+        else
+          yield
+        end
+      end
+      
+      def accept_hook?(hook)
+        init
+        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 skip_invoke!
+        @step_invocations.each{|step_invocation| step_invocation.skip_invoke!}
+      end
+
+      def failed?
+        @failed
+      end
+
+      def hook_context
+        @feature_elements.first || self
+      end
+
+      def to_sexp
+        init
+        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
+
+      def fail!(exception)
+        @failed = true
+        @exception = exception
+        @current_visitor.visit_exception(@exception, :failed)        
+      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 #:nodoc:
+      def initialize(value)
+        @value = value
+      end
+
+      def empty?
+        @value.nil? || @value == ""
+      end
+
+      def accept(visitor)
+        return if Cucumber.wants_to_quit
+        @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/doc_string.rb

@@ -0,0 +1,80 @@
+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 DocString,
+    # 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 DocString #:nodoc:
+      class Builder
+        attr_reader :string
+
+        def initialize
+          @string = ''
+        end
+
+        def doc_string(string, line_number)
+          @string = string
+        end
+
+        def eof
+        end
+      end
+
+      attr_accessor :file
+
+      def self.default_arg_name
+        "string"
+      end
+
+      def self.parse(text)
+        builder = Builder.new
+        lexer = Gherkin::I18nLexer.new(builder)
+        lexer.scan(text)
+        new(builder.string)
+      end
+
+      def initialize(string)
+        @string = string
+      end
+
+      def to_step_definition_arg
+        @string
+      end
+
+      def accept(visitor)
+        return if Cucumber.wants_to_quit
+        visitor.visit_doc_string(@string)
+      end
+      
+      def arguments_replaced(arguments) #:nodoc:
+        string = @string
+        arguments.each do |name, value|
+          value ||= ''
+          string = string.gsub(name, value)
+        end
+        DocString.new(string)
+      end
+
+      def has_text?(text)
+        @string.index(text)
+      end
+
+      # For testing only
+      def to_sexp #:nodoc:
+        [:doc_string, to_step_definition_arg]
+      end
+    end
+  end
+end

data/lib/cucumber/ast/examples.rb

@@ -0,0 +1,46 @@
+require 'cucumber/ast/names'
+
+module Cucumber
+  module Ast
+    class Examples #:nodoc:
+      include Names
+      attr_writer :outline_table
+      
+      def initialize(comment, line, keyword, title, description, outline_table)
+        @comment, @keyword, @title, @description, @outline_table = comment, keyword, title, description, outline_table
+      end
+
+      attr_reader :gherkin_statement
+      def gherkin_statement(statement=nil)
+        @gherkin_statement ||= statement
+      end
+
+      def accept(visitor)
+        return if Cucumber.wants_to_quit
+        visitor.visit_comment(@comment) unless @comment.empty?
+        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 failed?
+        @outline_table.cells_rows[1..-1].select{|row| row.failed?}.any?
+      end
+
+      def to_sexp
+        sexp = [:examples, @keyword, name]
+        comment = @comment.to_sexp
+        sexp += [comment] if comment
+        sexp += [@outline_table.to_sexp]
+        sexp
+      end
+    end
+  end
+end

data/lib/cucumber/ast/feature.rb

@@ -0,0 +1,106 @@
+require 'cucumber/ast/names'
+
+module Cucumber
+  module Ast
+    # Represents the root node of a parsed feature.
+    class Feature #:nodoc:
+      include Names
+      
+      attr_accessor :language
+      attr_writer :features, :background
+      attr_reader :file
+
+      def initialize(background, comment, tags, keyword, title, description, feature_elements)
+        @background, @comment, @tags, @keyword, @title, @description, @feature_elements = background, comment, tags, keyword, title, description, feature_elements
+      end
+
+      attr_reader :gherkin_statement
+      def gherkin_statement(statement=nil)
+        @gherkin_statement ||= statement
+      end
+
+      def init
+        @background.feature = self if @background
+        @background.init if @background
+        @feature_elements.each do |feature_element|
+          feature_element.init
+          feature_element.feature = self
+        end
+      end
+
+      def add_feature_element(feature_element)
+        @feature_elements << feature_element
+      end
+
+      def accept(visitor)
+        return if Cucumber.wants_to_quit
+        init
+        visitor.visit_comment(@comment) unless @comment.empty?
+        visitor.visit_tags(@tags)
+        visitor.visit_feature_name(@keyword, indented_name)
+        visitor.visit_background(@background) if @background
+        @feature_elements.each do |feature_element|
+          visitor.visit_feature_element(feature_element)
+        end
+      end
+
+      def indented_name
+        indent = ""
+        name.split("\n").map do |l|
+          s = "#{indent}#{l}"
+          indent = "  "
+          s
+        end.join("\n")
+      end
+
+      def source_tag_names
+        @tags.tag_names
+      end
+
+      def accept_hook?(hook)
+        @tags.accept_hook?(hook)
+      end
+
+      def next_feature_element(feature_element, &proc)
+        init
+        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=(file)
+        file = file.gsub(/\//, '\\') if Cucumber::WINDOWS && file && !ENV['CUCUMBER_FORWARD_SLASH_PATHS']
+        @file = file
+      end
+      
+      def file_colon_line(line)
+        "#{@file}:#{line}"
+      end
+
+      def short_name
+        first_line = name.split(/\n/)[0]
+        if first_line =~ /#{language.keywords('feature')}:(.*)/
+          $1.strip
+        else
+          first_line
+        end
+      end
+
+      def to_sexp
+        init
+        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