jwilger-cucumber 0.3.11.200906161550

data/lib/cucumber/ast/step_invocation.rb

@@ -0,0 +1,136 @@
+module Cucumber
+  module Ast
+    class StepInvocation
+      attr_writer :step_collection, :background
+      attr_reader :name, :matched_cells, :status, :reported_exception
+      attr_accessor :exception
+
+      def initialize(step, name, multiline_arg, matched_cells)
+        @step, @name, @multiline_arg, @matched_cells = step, name, multiline_arg, matched_cells
+        status!(:skipped)
+      end
+
+      def background?
+        @background
+      end
+
+      def skip_invoke!
+        @skip_invoke = true
+      end
+
+      def accept(visitor)
+        invoke(visitor.step_mother, visitor.options)
+        visit_step_result(visitor)
+      end
+
+      def visit_step_result(visitor)
+        visitor.visit_step_result(keyword, @step_match, @multiline_arg, @status, @reported_exception, source_indent, @background)
+      end
+
+      def invoke(step_mother, options)
+        find_step_match!(step_mother)
+        unless @skip_invoke || options[:dry_run] || @exception || @step_collection.exception
+          @skip_invoke = true
+          begin
+            step_mother.current_world.__cucumber_current_step = self if step_mother.current_world # Nil in Pure Java
+            @step_match.invoke(step_mother.current_world, @multiline_arg)
+            step_mother.after_step
+            status!(:passed)
+          rescue Pending => e
+            failed(options, e, false)
+            status!(:pending)
+          rescue Undefined => e
+            failed(options, e, false)
+            status!(:undefined)
+          rescue Exception => e
+            failed(options, e, false)
+            status!(:failed)
+          end
+        end
+      end
+
+      def find_step_match!(step_mother)
+        return if @step_match
+        begin
+          @step_match = step_mother.step_match(@name)
+        rescue Undefined => e
+          failed(step_mother.options, e, true)
+          status!(:undefined)
+          @step_match = NoStepMatch.new(@step, @name)
+        rescue Ambiguous => e
+          failed(step_mother.options, e, false)
+          status!(:failed)
+          @step_match = NoStepMatch.new(@step, @name)
+        end
+        step_mother.step_visited(self)
+      end
+
+      def failed(options, e, clear_backtrace)
+        e.set_backtrace([]) if clear_backtrace
+        e.backtrace << @step.backtrace_line unless @step.backtrace_line.nil?
+        @exception = e
+        if(options[:strict] || !(Undefined === e) || e.nested?)
+          @reported_exception = e
+        else
+          @reported_exception = nil
+        end
+      end
+
+      def status!(status)
+        @status = status
+        @matched_cells.each do |cell|
+          cell.status = status
+        end
+      end
+
+      def previous
+        @step_collection.previous_step(self)
+      end
+
+      def actual_keyword
+        repeat_keywords = [language.but_keywords, language.and_keywords].flatten
+        if repeat_keywords.index(@step.keyword) && previous
+          previous.actual_keyword
+        else
+          keyword
+        end
+      end
+
+      def source_indent
+        @step.feature_element.source_indent(text_length)
+      end
+
+      def text_length
+        @step.text_length(@name)
+      end
+
+      def keyword
+        @step.keyword
+      end
+
+      def multiline_arg
+        @step.multiline_arg
+      end
+
+      def file_colon_line
+        @step.file_colon_line
+      end
+
+      def dom_id
+        @step.dom_id
+      end
+
+      def backtrace_line
+        @step.backtrace_line
+      end
+
+      def language
+        @step.language
+      end
+
+      def to_sexp
+        [:step_invocation, @step.line, @step.keyword, @name, (@multiline_arg.nil? ? nil : @multiline_arg.to_sexp)].compact
+      end
+    end
+  end
+end

data/lib/cucumber/ast/table.rb

@@ -0,0 +1,334 @@
+module Cucumber
+  module Ast
+    # Holds the data of a table parsed from a feature file:
+    #
+    #   | a | b |
+    #   | c | d |
+    #
+    # This gets parsed into a Table holding the values <tt>[['a', 'b'], ['c', 'd']]</tt>
+    #
+    class Table      
+      NULL_CONVERSIONS = Hash.new(lambda{ |cell_value| cell_value }).freeze
+
+      attr_accessor :file
+
+      def self.default_arg_name
+        "table"
+      end
+
+      def initialize(raw, conversions = NULL_CONVERSIONS.dup)
+        # Verify that it's square
+        raw.transpose
+        @raw = raw
+        @cells_class = Cells
+        @cell_class = Cell
+        @conversion_procs = conversions
+      end
+
+      # Creates a copy of this table, inheriting the column mappings.
+      def dup
+        self.class.new(@raw.dup, @conversion_procs.dup)
+      end
+
+      # Returns a new, transposed table. Example:
+      #
+      # | a | 7 | 4 |
+      # | b | 9 | 2 |
+      #
+      # Gets converted into the following:
+      #
+      # | a | b |
+      # | 7 | 9 |
+      # | 4 | 2 |
+      #
+      def transpose
+        self.class.new(@raw.transpose, @conversion_procs.dup)
+      end
+
+      # Converts this table into an Array of Hash where the keys of each
+      # Hash are the headers in the table. For example, a Table built from
+      # the following plain text:
+      #
+      #   | a | b | sum |
+      #   | 2 | 3 | 5   |
+      #   | 7 | 9 | 16  |
+      #
+      # Gets converted into the following:
+      #
+      #   [{'a' => '2', 'b' => '3', 'sum' => '5'}, {'a' => '7', 'b' => '9', 'sum' => '16'}]
+      #
+      # Use #map_column! to specify how values in a column are converted.
+      #
+      def hashes
+        @hashes ||= cells_rows[1..-1].map do |row|
+          row.to_hash
+        end.freeze
+      end
+      
+      # Converts this table into a Hash where the first column is
+      # used as keys and the second column is used as values
+      #
+      #   | a | 2 |
+      #   | b | 3 |
+      #
+      # Gets converted into the following:
+      #
+      #   {'a' => '2', 'b' => '3'}
+      #
+      # The table must be exactly two columns wide 
+      #
+      def rows_hash
+        verify_table_width(2)
+        @rows_hash = self.transpose.hashes[0]
+      end
+
+      # Gets the raw data of this table. For example, a Table built from
+      # the following plain text:
+      #
+      #   | a | b |
+      #   | c | d |
+      #
+      # Get converted into the following:
+      #
+      #   [['a', 'b], ['c', 'd']]
+      #
+      def raw
+        @raw
+      end
+
+      # Same as #raw, but skips the first (header) row
+      def rows
+        @raw[1..-1]
+      end
+
+      def each_cells_row(&proc)
+        cells_rows.each(&proc)
+      end
+
+      def accept(visitor)
+        cells_rows.each do |row|
+          visitor.visit_table_row(row)
+        end
+        nil
+      end
+
+      # For testing only
+      def to_sexp #:nodoc:
+        [:table, *cells_rows.map{|row| row.to_sexp}]
+      end
+
+      # Returns a new Table where the headers are redefined. This makes it
+      # possible to use prettier header names in the features. Example:
+      #
+      #   | Phone Number | Address |
+      #   | 123456       | xyz     |
+      #   | 345678       | abc     |
+      #
+      # A StepDefinition receiving this table can then map the columns:
+      #
+      #   mapped_table = table.map_columns('Phone Number' => :phone, 'Address' => :address)
+      #   hashes = mapped_table.hashes
+      #   # => [{:phone => '123456', :address => 'xyz'}, {:phone => '345678', :address => 'abc'}]
+      #
+      def map_headers(mappings)
+        table = self.dup
+        table.map_headers!(mappings)
+        table
+      end
+
+      # Change how #hashes converts column values. The +column_name+ argument identifies the column
+      # and +conversion_proc+ performs the conversion for each cell in that column. If +strict+ is 
+      # true, an error will be raised if the column named +column_name+ is not found. If +strict+ 
+      # is false, no error will be raised. Example:
+      #
+      #   Given /^an expense report for (.*) with the following posts:$/ do |table|
+      #     posts_table.map_column!('amount') { |a| a.to_i }
+      #     posts_table.hashes.each do |post|
+      #       # post['amount'] is a Fixnum, rather than a String
+      #     end
+      #   end
+      #
+      def map_column!(column_name, strict=true, &conversion_proc)
+        verify_column(column_name) if strict
+        @conversion_procs[column_name] = conversion_proc
+      end
+
+      def to_hash(cells) #:nodoc:
+        hash = Hash.new do |hash, key|
+          hash[key.to_s] if key.is_a?(Symbol)
+        end
+        @raw[0].each_with_index do |column_name, column_index|
+          value = @conversion_procs[column_name].call(cells.value(column_index))
+          hash[column_name] = value
+        end
+        hash
+      end
+
+      def index(cells) #:nodoc:
+        cells_rows.index(cells)
+      end
+
+      def verify_column(column_name)
+        raise %{The column named "#{column_name}" does not exist} unless @raw[0].include?(column_name)
+      end
+      
+      def verify_table_width(width)
+        raise %{The table must have exactly #{width} columns} unless @raw[0].size == width
+      end
+
+      def arguments_replaced(arguments) #:nodoc:
+        raw_with_replaced_args = raw.map do |row|
+          row.map do |cell|
+            cell_with_replaced_args = cell
+            arguments.each do |name, value|
+              if cell_with_replaced_args && cell_with_replaced_args.include?(name)
+                cell_with_replaced_args = value ? cell_with_replaced_args.gsub(name, value) : nil
+              end
+            end
+            cell_with_replaced_args
+          end
+        end
+        Table.new(raw_with_replaced_args)
+      end
+
+      def has_text?(text)
+        raw.flatten.compact.detect{|cell_value| cell_value.index(text)}
+      end
+
+      def cells_rows
+        @rows ||= cell_matrix.map do |cell_row|
+          @cells_class.new(self, cell_row)
+        end.freeze
+      end
+
+      def headers
+        @raw.first
+      end
+
+      def header_cell(col)
+        cells_rows[0][col]
+      end
+
+      protected
+
+      def map_headers!(mappings)
+        headers = @raw[0]
+        mappings.each_pair do |pre, post|
+          headers[headers.index(pre)] = post
+          if @conversion_procs.has_key?(pre)
+            @conversion_procs[post] = @conversion_procs.delete(pre)
+          end
+        end
+      end
+
+      private
+
+      def col_width(col)
+        columns[col].__send__(:width)
+      end
+
+      def columns
+        @columns ||= cell_matrix.transpose.map do |cell_row|
+          @cells_class.new(self, cell_row)
+        end.freeze
+      end
+
+      def cell_matrix
+        row = -1
+        @cell_matrix ||= @raw.map do |raw_row|
+          line = raw_row.line rescue -1
+          row += 1
+          col = -1
+          raw_row.map do |raw_cell|
+            col += 1
+            @cell_class.new(raw_cell, self, row, col, line)
+          end
+        end.freeze
+      end
+
+      # Represents a row of cells or columns of cells
+      class Cells
+        include Enumerable
+        attr_reader :exception
+
+        def initialize(table, cells)
+          @table, @cells = table, cells
+        end
+
+        def accept(visitor)
+          each do |cell|
+            visitor.visit_table_cell(cell)
+          end
+          nil
+        end
+
+        # For testing only
+        def to_sexp #:nodoc:
+          [:row, line, *@cells.map{|cell| cell.to_sexp}]
+        end
+
+        def to_hash #:nodoc:
+          @to_hash ||= @table.to_hash(self).freeze
+        end
+
+        def value(n) #:nodoc:
+          self[n].value
+        end
+
+        def [](n)
+          @cells[n]
+        end
+
+        def line
+          @cells[0].line
+        end
+
+        def dom_id
+          "row_#{line}"
+        end
+
+        private
+
+        def index
+          @table.index(self)
+        end
+
+        def width
+          map{|cell| cell.value ? cell.value.to_s.jlength : 0}.max
+        end
+
+        def each(&proc)
+          @cells.each(&proc)
+        end
+      end
+
+      class Cell
+        attr_reader :value, :line
+        attr_writer :status
+
+        def initialize(value, table, row, col, line)
+          @value, @table, @row, @col, @line = value, table, row, col, line
+        end
+
+        def accept(visitor)
+          visitor.visit_table_cell_value(@value, col_width, @status)
+        end
+
+        def header_cell
+          @table.header_cell(@col)
+        end
+
+        # For testing only
+        def to_sexp #:nodoc:
+          [:cell, @value]
+        end
+
+        private
+
+        def col_width
+          @col_width ||= @table.__send__(:col_width, @col).freeze
+        end
+      end
+    end
+  end
+end

data/lib/cucumber/ast/tags.rb

@@ -0,0 +1,33 @@
+module Cucumber
+  module Ast
+    # Holds the names of tags parsed from a feature file:
+    #
+    #   @invoice @release_2
+    #
+    # This gets stored internally as <tt>["invoice", "release_2"]</tt>
+    #
+    class Tags
+      def self.strip_prefix(tag_name)
+        tag_name =~ /^@(.*)/ ? $1 : tag_name
+      end
+    
+      def initialize(line, tag_names)
+        @line, @tag_names = line, tag_names
+      end
+
+      def accept(visitor)
+        @tag_names.each do |tag_name|
+          visitor.visit_tag_name(tag_name)
+        end
+      end
+
+      def accept_hook?(hook)
+        hook.matches_tag_names?(@tag_names)
+      end
+
+      def to_sexp
+        @tag_names.map{|tag_name| [:tag, tag_name]}
+      end
+    end
+  end
+end

data/lib/cucumber/ast/visitor.rb

@@ -0,0 +1,116 @@
+module Cucumber
+  module Ast
+    # A dumb visitor that implements the whole Visitor API and just walks the tree.
+    class Visitor
+      attr_accessor :options
+      attr_reader :step_mother
+
+      def initialize(step_mother)
+        @options = {}
+        @step_mother = step_mother
+      end
+
+      def matches_scenario_names?(node)
+        scenario_name_regexps = options[:name_regexps] || []
+        scenario_name_regexps.empty? || node.matches_scenario_names?(scenario_name_regexps)
+      end
+
+      def visit_features(features)
+        features.accept(self)
+      end
+
+      def visit_feature(feature)
+        feature.accept(self)
+      end
+
+      def visit_comment(comment)
+        comment.accept(self)
+      end
+
+      def visit_comment_line(comment_line)
+      end
+
+      def visit_tags(tags)
+        tags.accept(self)
+      end
+
+      def visit_tag_name(tag_name)
+      end
+
+      def visit_feature_name(name)
+      end
+
+      # +feature_element+ is either Scenario or ScenarioOutline
+      def visit_feature_element(feature_element)
+        feature_element.accept(self)
+      end
+
+      def visit_background(background)
+        background.accept(self)
+      end
+
+      def visit_background_name(keyword, name, file_colon_line, source_indent)
+      end
+
+      def visit_examples_array(examples_array)
+        examples_array.accept(self)
+      end
+
+      def visit_examples(examples)
+        examples.accept(self)
+      end
+
+      def visit_examples_name(keyword, name)
+      end
+
+      def visit_outline_table(outline_table)
+        outline_table.accept(self)
+      end
+
+      def visit_scenario_name(keyword, name, file_colon_line, source_indent)
+      end
+
+      def visit_steps(steps)
+        steps.accept(self)
+      end
+
+      def visit_step(step)
+        step.accept(self)
+      end
+
+      def visit_step_result(keyword, step_match, multiline_arg, status, exception, source_indent, background)
+        visit_step_name(keyword, step_match, status, source_indent, background)
+        visit_multiline_arg(multiline_arg) if multiline_arg
+        visit_exception(exception, status) if exception
+      end
+
+      def visit_step_name(keyword, step_match, status, source_indent, background) #:nodoc:
+      end
+
+      def visit_multiline_arg(multiline_arg) #:nodoc:
+        multiline_arg.accept(self)
+      end
+
+      def visit_exception(exception, status) #:nodoc:
+      end
+
+      def visit_py_string(string)
+      end
+
+      def visit_table_row(table_row)
+        table_row.accept(self)
+      end
+
+      def visit_table_cell(table_cell)
+        table_cell.accept(self)
+      end
+
+      def visit_table_cell_value(value, width, status)
+      end
+
+      def announce(announcement)
+      end
+
+    end
+  end
+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/broadcaster.rb

@@ -0,0 +1,13 @@
+module Cucumber
+  class Broadcaster
+    def initialize(receivers = [])
+      @receivers = receivers
+    end
+
+    def method_missing(method_name, *args)
+      @receivers.map do |receiver|
+        receiver.__send__(method_name, *args)
+      end
+    end
+  end
+end