aslakhellesoy-cucumber 0.1.16.4 → 0.1.16.5

data/lib/cucumber/ast/table.rb

@@ -0,0 +1,214 @@
+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
+      attr_accessor :file
+
+      def initialize(raw)
+        # Verify that it's square
+        raw.transpose
+        @raw = raw
+        @cells_class = Cells
+        @cell_class = Cell
+      end
+
+      def at_lines?(lines)
+        rows.detect { |row| row.at_lines?(lines) }
+      end
+
+      def accept(visitor, status)
+        rows.each do |row|
+          visitor.visit_table_row(row, status)
+        end
+        nil
+      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'}]
+      #
+      def hashes
+        @hashes ||= rows[1..-1].map do |row|
+          row.to_hash
+        end
+      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
+
+      # For testing only
+      def to_sexp #:nodoc:
+        [:table, *rows.map{|row| row.to_sexp}]
+      end
+
+      def to_hash(cells) #:nodoc:
+        hash = {}
+        @raw[0].each_with_index do |key, n|
+          hash[key] = cells.value(n)
+        end
+        hash
+      end
+
+      def index(cells) #:nodoc:
+        rows.index(cells)
+      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|
+              cell_with_replaced_args = cell_with_replaced_args.gsub(name, value)
+            end
+            cell_with_replaced_args
+          end
+        end
+
+        Table.new(raw_with_replaced_args)
+      end
+
+      def at_lines?(lines)
+        rows.detect{|row| row.at_lines?(lines)}
+      end
+
+      private
+
+      def col_width(col)
+        columns[col].__send__(:width)
+      end
+
+      def rows
+        @rows ||= cell_matrix.map do |cell_row|
+          @cells_class.new(self, cell_row)
+        end
+      end
+
+      def columns
+        @columns ||= cell_matrix.transpose.map do |cell_row|
+          @cells_class.new(self, cell_row)
+        end
+      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
+      end
+
+      # Represents a row of cells or columns of cells
+      class Cells
+        include Enumerable
+
+        def initialize(table, cells)
+          @table, @cells = table, cells
+        end
+
+        def accept(visitor, status)
+          each do |cell|
+            visitor.visit_table_cell(cell, status)
+          end
+          nil
+        end
+
+        # For testing only
+        def to_sexp #:nodoc:
+          [:row, *@cells.map{|cell| cell.to_sexp}]
+        end
+
+        def to_hash #:nodoc:
+          @to_hash ||= @table.to_hash(self)
+        end
+
+        def value(n) #:nodoc:
+          self[n].value
+        end
+
+        def [](n)
+          @cells[n]
+        end
+
+        def line
+          @cells[0].line
+        end
+
+        def at_lines?(lines)
+          lines.empty? || lines.index(line)
+        end
+
+        private
+
+        def index
+          @table.index(self)
+        end
+
+        def width
+          map{|cell| cell.value ? cell.value.jlength : 0}.max
+        end
+
+        def each(&proc)
+          @cells.each(&proc)
+        end
+      end
+
+      class Cell
+        attr_reader :value, :line
+
+        def initialize(value, table, row, col, line)
+          @value, @table, @row, @col, @line = value, table, row, col, line
+        end
+
+        def accept(visitor, status)
+          visitor.visit_table_cell_value(@value, col_width, status)
+        end
+
+        # For testing only
+        def to_sexp #:nodoc:
+          [:cell, @value]
+        end
+
+        private
+
+        def col_width
+          @col_width ||= @table.__send__(:col_width, @col)
+        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 initialize(line, tag_names)
+        @line, @tag_names = line, tag_names
+      end
+
+      def among?(tag_names)
+        (@tag_names & tag_names).any?
+      end
+
+      def at_lines?(lines)
+        lines.empty? || lines.index(@line)
+      end
+
+      def accept(visitor)
+        @tag_names.each do |tag_name|
+          visitor.visit_tag_name(tag_name)
+        end
+      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,93 @@
+module Cucumber
+  module Ast
+    # A dumb visitor that implements the whole Visitor API and just walks the tree.
+    class Visitor
+      attr_accessor :options
+
+      def initialize(step_mother)
+        @step_mother = step_mother
+      end
+
+      def world(scenario, &proc)
+        @step_mother.world(scenario, &proc)
+      end
+
+      def step_definition(step_name)
+        @step_mother.step_definition(step_name)
+      end
+
+      def current_feature_lines=(lines)
+        @current_feature_lines = lines
+      end
+
+      def current_feature_lines
+        @current_feature_lines || []
+      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_examples(examples)
+        examples.accept(self)
+      end
+
+      def visit_examples_name(keyword, name)
+      end
+
+      def visit_scenario_name(keyword, name, file_line, source_indent)
+      end
+
+      def visit_step(step)
+        step.accept(self)
+      end
+
+      def visit_step_name(keyword, step_name, status, step_definition, source_indent)
+      end
+
+      def visit_multiline_arg(multiline_arg, status)
+        multiline_arg.accept(self, status)
+      end
+
+      def visit_py_string(string, status)
+      end
+
+      def visit_table_row(table_row, status)
+        table_row.accept(self, status)
+      end
+
+      def visit_table_cell(table_cell, status)
+        table_cell.accept(self, status)
+      end
+
+      def visit_table_cell_value(value, width, status)
+      end
+    end
+  end
+end

data/lib/cucumber/ast.rb

@@ -0,0 +1,27 @@
+require 'cucumber/ast/comment'
+require 'cucumber/ast/tags'
+require 'cucumber/ast/features'
+require 'cucumber/ast/feature'
+require 'cucumber/ast/scenario'
+require 'cucumber/ast/scenario_outline'
+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'
+require 'cucumber/ast/filter'
+
+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

@@ -5,14 +5,9 @@ module Cucumber
       @receivers = receivers
     end
 
-    def register(receiver)
-      @receivers << receiver
-    end
-
     def method_missing(method_name, *args)
       @receivers.each  do |receiver|
-        r = (receiver == STDOUT) ? Kernel : receiver # Needed to make colors work on Windows
-        r.__send__(method_name, *args) if receiver.respond_to?(method_name)
+        receiver.__send__(method_name, *args)
       end
     end