cucumber 0.1.16 → 0.2.0

data/lib/cucumber.rb

@@ -1,19 +1,63 @@
 $:.unshift(File.dirname(__FILE__)) unless
   $:.include?(File.dirname(__FILE__)) || $:.include?(File.expand_path(File.dirname(__FILE__)))
 
+require 'yaml'
 require 'cucumber/platform'
-require 'rubygems'
-require 'treetop/runtime'
-require 'treetop/ruby_extensions'
+require 'cucumber/parser'
 require 'cucumber/version'
-require 'cucumber/step_methods'
-require 'cucumber/tree'
-require 'cucumber/model'
-require 'cucumber/executor'
 require 'cucumber/step_mother'
-require 'cucumber/formatters'
-require 'cucumber/treetop_parser/feature_parser'
-require 'cucumber/cli'
+require 'cucumber/cli/main'
 require 'cucumber/broadcaster'
-require 'cucumber/world'
 require 'cucumber/core_ext/exception'
+
+module Cucumber
+  KEYWORD_KEYS = %w{name native encoding feature background scenario scenario_outline examples given when then but}
+  
+  class << self
+    attr_reader :lang
+    
+    def load_language(lang) #:nodoc:
+      return if @lang
+      @lang = lang
+      alias_step_definitions(lang)
+      Parser.load_parser(keyword_hash)
+    end
+
+    def language_incomplete?(lang=@lang)
+      KEYWORD_KEYS.detect{|key| keyword_hash(lang)[key].nil?}
+    end
+
+    # File mode that accounts for Ruby platform and current language
+    def file_mode(m)
+      Cucumber::RUBY_1_9 ? "#{m}:#{keyword_hash['encoding']}" : m
+    end
+
+    # Returns a Hash of the currently active
+    # language, or for a specific language if +lang+ is
+    # specified.
+    def keyword_hash(lang=@lang)
+      LANGUAGES[lang]
+    end
+    
+    def alias_step_definitions(lang) #:nodoc:
+      keywords = %w{given when then and but}.map{|keyword| keyword_hash(lang)[keyword]}
+      alias_steps(keywords)
+    end
+    
+    # Sets up additional method aliases for Given, When and Then.
+    # This does *not* affect how feature files are parsed. If you
+    # want to create aliases in the parser, you have to do this in
+    # languages.yml. For example:
+    #
+    # and: And|With
+    def alias_steps(keywords)
+      keywords.each do |adverb|
+        StepMother.alias_adverb(adverb)
+        World.alias_adverb(adverb)
+      end
+    end
+  end  
+
+  # Make sure we always have English aliases
+  alias_step_definitions('en')
+end

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,50 @@
+require 'cucumber/ast/feature_element'
+
+module Cucumber
+  module Ast
+    class Background
+      include FeatureElement
+      attr_writer :feature
+
+      def initialize(comment, line, keyword, steps)
+        @comment, @line, @keyword, @steps = comment, line, keyword, StepCollection.new(steps)
+        attach_steps(steps)
+        @step_invocations = @steps.step_invocations(true)
+      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)
+        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_steps(@step_invocations)
+        @failed = @step_invocations.detect{|step_invocation| step_invocation.exception}
+      end
+
+      def failed?
+        @failed
+      end
+
+      def text_length
+        @keyword.jlength
+      end
+
+      def to_sexp
+        sexp = [:background, @line, @keyword]
+        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,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,38 @@
+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)
+        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
+    end
+  end
+end

data/lib/cucumber/ast/feature.rb

@@ -0,0 +1,62 @@
+module Cucumber
+  module Ast
+    # Represents the root node of a parsed feature.
+    class Feature
+      attr_accessor :file
+      attr_writer :features, :lines
+
+      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
+        end
+      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)
+        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]
+        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 to_sexp
+        sexp = [:feature, @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,46 @@
+module Cucumber
+  module FeatureElement
+    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
+      @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
+
+    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
+
+    # TODO: Remove when we use StepCollection everywhere
+    def previous_step(step)
+      i = @steps.index(step) || -1
+      @steps[i-1]
+    end
+    
+  end
+end

data/lib/cucumber/ast/features.rb

@@ -0,0 +1,20 @@
+module Cucumber
+  module Ast
+    class Features
+      def initialize
+        @features = []
+      end
+
+      def add_feature(feature)
+        feature.features = self
+        @features << feature
+      end
+
+      def accept(visitor)
+        @features.each do |feature|
+          visitor.visit_feature(feature) if feature.descend?(visitor)
+        end
+      end
+    end
+  end
+end

data/lib/cucumber/ast/outline_table.rb

@@ -0,0 +1,81 @@
+module Cucumber
+  module Ast
+    class OutlineTable < Table
+      def initialize(raw, scenario_outline)
+        super(raw)
+        @scenario_outline = scenario_outline
+        @cells_class = ExampleCells
+        
+        cells_rows.each do |cells|
+          cells.create_step_invocations!(scenario_outline)
+        end
+      end
+
+      def accept(visitor)
+        cells_rows.each_with_index do |row, n|
+          if n == 0 || matches?(visitor, row)
+            visitor.visit_table_row(row)
+          end
+        end
+        nil
+      end
+
+      def descend?(visitor)
+        cells_rows.detect{|cells_row| cells_row.descend?(visitor)}
+      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|
+          cells.skip_invoke!
+        end
+      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!
+          end
+        end
+
+        def accept(visitor)
+          if header?
+            @cells.each do |cell|
+              cell.status = :skipped
+              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.exception
+              end
+
+              @cells.each do |cell|
+                visitor.visit_table_cell(cell)
+              end
+            end
+          end
+        end
+
+        private
+
+        def header?
+          index == 0
+        end
+      end
+    end
+  end
+end

data/lib/cucumber/ast/py_string.rb

@@ -0,0 +1,58 @@
+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.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)
+      end
+      
+      def arguments_replaced(arguments) #:nodoc:
+        string = @string
+        arguments.each do |name, value|
+          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