bts-cucumber 0.1.13.1

data/lib/cucumber/tree/features.rb

@@ -0,0 +1,21 @@
+module Cucumber
+  module Tree
+    class Features
+      def initialize
+        @features = []
+      end
+      
+      def length
+        @features.length
+      end
+
+      def <<(feature)
+        @features << feature
+      end
+
+      def accept(visitor)
+        @features.each{|feature| visitor.visit_feature(feature)}
+      end
+    end
+  end
+end

data/lib/cucumber/tree/given_scenario.rb

@@ -0,0 +1,13 @@
+module Cucumber
+  module Tree
+    class GivenScenario
+      def initialize(scenario, name, line)
+        @scenario, @name, @line = scenario, name, line
+      end
+      
+      def steps
+        @scenario.given_scenario_steps(@name)
+      end
+    end
+  end
+end

data/lib/cucumber/tree/scenario.rb

@@ -0,0 +1,175 @@
+module Cucumber
+  module Tree
+    class BaseScenario
+      attr_reader :feature
+
+      def file
+        @feature.file
+      end
+
+      def accept(visitor)
+        steps.each do |step|
+          if step.row?
+            visitor.visit_row_step(step)
+          else
+            visitor.visit_regular_step(step)
+          end
+        end
+      end
+
+      def at_line?(l)
+        line == l || steps.map{|s| s.line}.index(l)
+      end
+
+      def previous_step(step)
+        i = steps.index(step)
+        raise "Couldn't find #{step} among #{steps}" if i.nil?
+        steps[i-1]
+      end
+      
+      def pending?
+        steps.empty?
+      end
+      
+    end
+
+    class Scenario < BaseScenario
+      MIN_PADDING = 2
+      INDENT = 2
+
+      # If a table follows, the header will be stored here. Weird, but convenient.
+      attr_reader :table_header
+      attr_accessor :table_column_widths
+      attr_reader :name, :line
+
+      def initialize(feature, name, line, &proc)
+        require 'cucumber/core_ext/string'
+        @feature, @name, @line = feature, name, line
+        @steps_and_given_scenarios = []
+        instance_eval(&proc) if block_given?
+      end
+
+      def table_header=  header
+        @table_header = header
+        update_table_column_widths header
+      end
+
+      def steps
+        @steps ||= @steps_and_given_scenarios.map{|step| step.steps}.flatten
+      end
+
+      def given_scenario_steps(name)
+        sibling_named(name).steps
+      end
+
+      def sibling_named(name)
+        @feature.scenario_named(name)
+      end
+
+      def length
+        @length ||= Cucumber.language['scenario'].jlength + 2 + (@name.nil? ? 0 : @name.jlength)
+      end
+
+      def max_line_length
+        [length, max_step_length].max
+      end
+
+      def padding_length
+        padding = (max_line_length - length) + MIN_PADDING
+        padding += INDENT if length != max_line_length
+        padding
+      end
+
+      def step_padding_length(step)
+        padding = (max_line_length - step.length) + MIN_PADDING
+        padding -= INDENT if length == max_line_length
+        padding
+      end
+
+      def max_step_length
+        @max_step_length ||= (steps.map{|step| step.length}.max || 0)
+      end
+
+      def update_table_column_widths values
+        @table_column_widths ||= [0] * values.size
+        @table_column_widths = @table_column_widths.zip(values).map {|max, value| [max, value.size].max}
+      end
+
+      def row?
+        false
+      end
+
+      def create_step(keyword, name, line)
+        step = Step.new(self, keyword, name, line)
+        @steps_and_given_scenarios << step
+        step
+      end
+
+      def create_given_scenario(name, line)
+        given_scenario =  GivenScenario.new(self, name, line)
+        @steps_and_given_scenarios << given_scenario
+        given_scenario
+      end
+
+      def Given(name)
+        create_step('Given', name, *caller[0].split(':')[1].to_i)
+      end
+
+      def When(name)
+        create_step('When', name, *caller[0].split(':')[1].to_i)
+      end
+
+      def Then(name)
+        create_step('Then', name, *caller[0].split(':')[1].to_i)
+      end
+
+      def And(name)
+        create_step('And', name, *caller[0].split(':')[1].to_i)
+      end
+
+    end
+
+    class RowScenario < BaseScenario
+      attr_reader :line
+
+      def initialize(feature, template_scenario, values, line)
+        @feature, @template_scenario, @values, @line = feature, template_scenario, values, line
+        template_scenario.update_table_column_widths values
+      end
+
+      def row?
+        true
+      end
+
+      def name
+        @template_scenario.name
+      end
+
+      #We can only cache steps once the template scenarios steps have been bound in order to know what arity the steps have
+      def steps
+        if template_steps_bound?
+          @unbound_steps = nil
+          @bound_steps ||= build_steps
+        else
+          @unbound_steps ||= build_steps
+        end
+      end
+      
+      private
+      def build_steps
+        @template_scenario.steps.map do |template_step|
+          args = []
+          template_step.arity.times do
+            args << @values.shift
+          end
+          RowStep.new(self, template_step, args)
+        end
+      end
+      
+      def template_steps_bound?
+        @template_steps_bound ||= @template_scenario.steps.inject(0) { |arity_sum, step| arity_sum + step.arity } != 0
+      end
+      
+    end
+  end
+end

data/lib/cucumber/tree/step.rb

@@ -0,0 +1,142 @@
+module Cucumber
+  module Tree
+    class BaseStep
+      attr_reader :scenario
+      attr_accessor :error
+
+      def self.new_id!
+        @next_id ||= -1
+        @next_id += 1
+      end
+
+      attr_reader :error
+
+      def file
+        @scenario.file
+      end
+
+      def steps
+        self
+      end
+      
+      def length
+        keyword.jlength + 1 + name.jlength
+      end
+
+      if defined?(JRUBY_VERSION)
+        PENDING_ADJUSTMENT = 2
+        REGULAR_ADJUSTMENT = 1
+      else
+        PENDING_ADJUSTMENT = 3
+        REGULAR_ADJUSTMENT = 2
+      end
+
+      def execute_in(world, regexp, args, proc)
+        strip_pos = nil
+        begin
+          proc.call_in(world, *args)
+        rescue ArityMismatchError => e
+          e.backtrace[0] = proc.to_backtrace_line
+          strip_pos = e.backtrace.index("#{__FILE__}:#{__LINE__ - 3}:in `execute_in'")
+          format_error(strip_pos, proc, e)
+        rescue => e
+          method_line = "#{__FILE__}:#{__LINE__ - 6}:in `execute_in'"
+
+          # IronRuby returns nil for backtrace...
+          if e.backtrace.nil?
+            def e.backtrace
+              @cucumber_backtrace ||= []
+            end
+          end
+
+          method_line_pos = e.backtrace.index(method_line)
+          if method_line_pos
+            strip_pos = method_line_pos - (Pending === e ? PENDING_ADJUSTMENT : REGULAR_ADJUSTMENT) 
+          else
+            # This happens with rails, because they screw up the backtrace
+            # before we get here (injecting erb stacktrace and such)
+          end
+          format_error(strip_pos, proc, e)
+        end
+      end
+
+      def format_error(strip_pos, proc, e)
+        @error = e
+        # Remove lines underneath the plain text step
+        e.backtrace[strip_pos..-1] = nil unless strip_pos.nil?
+        e.backtrace.flatten
+        # Replace the step line with something more readable
+        e.backtrace.replace(e.backtrace.map{|l| l.gsub(/`#{proc.meth}'/, "`#{keyword} #{proc.name}'")})
+        if row?
+          e.backtrace << "#{file}:#{line}:in `#{proc.name}'"
+        else
+          e.backtrace << "#{file}:#{line}:in `#{keyword} #{name}'"
+        end
+        raise e
+      end
+
+      def id
+        @id ||= self.class.new_id!
+      end
+      
+      def actual_keyword
+        keyword == Cucumber.language['and'] ? previous_step.actual_keyword : keyword
+      end
+      
+      def previous_step
+        @scenario.previous_step(self)
+      end
+      
+      def padding_length
+        @scenario.step_padding_length(self)
+      end
+    end
+    
+    class Step < BaseStep
+      attr_reader :keyword, :name, :line
+      attr_accessor :arity, :extra_args
+
+      def row?
+        false
+      end
+
+      def initialize(scenario, keyword, name, line)
+        @scenario, @keyword, @name, @line = scenario, keyword, name, line
+        @extra_args = []
+        @arity = 0
+      end
+
+      def regexp_args_proc(step_mother)
+        regexp, args, proc = step_mother.regexp_args_proc(name)
+        @arity = args.length
+        [regexp, (args + extra_args), proc]
+      end
+
+      def format(regexp, format=nil, &proc)
+        regexp.nil? ? name : name.gzub(regexp, format, &proc)
+      end
+    end
+
+    class RowStep < BaseStep
+      attr_reader :keyword
+
+      def initialize(scenario, step, args)
+        @scenario, @step, @args = scenario, step, args
+      end
+      
+      def regexp_args_proc(step_mother)
+        regexp, _, proc = @step.regexp_args_proc(step_mother)
+        [regexp, @args, proc]
+      end
+      
+      def row?
+        true
+      end
+
+      def line
+        @scenario.line
+      end
+    end
+
+  end
+end

data/lib/cucumber/tree/table.rb

@@ -0,0 +1,26 @@
+module Cucumber
+  module Tree
+    class Table
+      def initialize(rows)
+        @rows = rows
+      end
+      
+      def |(cell)
+        @row ||= []
+        if cell == self
+          line = *caller[0].split(':')[1].to_i
+          @row.instance_eval %{
+            def line
+              #{line}
+            end
+          }
+          @rows << @row
+          @row = nil
+        else
+          @row << cell.to_s
+        end
+        self
+      end
+    end
+  end
+end

data/lib/cucumber/tree/top_down_visitor.rb

@@ -0,0 +1,23 @@
+module Cucumber
+  module Tree
+    class TopDownVisitor
+      def visit_features(features)
+        features.accept(self)
+      end
+
+      def visit_feature(feature)
+        feature.accept(self)
+      end
+
+      def visit_header(header)
+      end
+
+      def visit_scenario(scenario)
+        scenario.accept(self)
+      end
+
+      def visit_step(step)
+      end
+    end
+  end
+end

data/lib/cucumber/tree.rb

@@ -0,0 +1,16 @@
+%w{features feature scenario step given_scenario table top_down_visitor}.each{|f| require "cucumber/tree/#{f}"}
+
+module Cucumber
+  module Tree
+    def Feature(header, &proc)
+      feature = Feature.new("Feature: " + header, &proc)
+      feature.file, _, _ = *caller[0].split(':')
+      features << feature
+      feature
+    end
+
+    def features #:nodoc:
+      @features ||= Tree::Features.new
+    end
+  end
+end

data/lib/cucumber/treetop_parser/feature.treetop.erb

@@ -0,0 +1,206 @@
+module Cucumber
+# :stopdoc:
+module TreetopParser
+grammar Feature
+  rule root
+    space? header scenario_sequence space? {
+      def compile
+        feature = Tree::Feature.new(header.text_value.strip)
+        scenario_sequence.compile(feature)
+        feature
+      end
+    }
+  end
+  
+  rule header
+    (!(scenario_keyword / comment_to_eol) .)+
+  end
+  
+  rule scenario_sequence
+    head:scenario? tail:(space scenario_or_table)* {
+      def compile(feature)
+        ([head] + tail).each do |scenario_or_table|
+          scenario_or_table.compile(feature) if scenario_or_table.respond_to?(:compile)
+        end
+      end
+      
+      def tail
+        super.elements.map { |elt| elt.scenario_or_table }
+      end
+    }
+  end
+
+  rule scenario
+    scenario_keyword space? name:line_to_eol steps:(space step_sequence)? {
+      def compile(feature)
+        line = input.line_of(interval.first)
+        scenario = feature.add_scenario(name.text_value.strip, line)
+        steps.step_sequence.compile(scenario) if steps.respond_to?(:step_sequence)
+        # TODO - GET RID OF THIS last_scenario NASTINESS
+        # Use a better datastructure, like a linked list...
+        Feature.last_scenario = scenario
+      end
+    }
+  end
+  
+  rule scenario_or_table
+    scenario / more_examples
+  end
+  
+  rule more_examples
+    more_examples_keyword table {
+      def compile(f)
+        table.compile(f)
+      end
+    }
+  end
+  
+  rule table
+    space head:table_line body:(blank* eol space? table_line)* {
+      def compile(feature)
+        Feature.last_scenario.table_header = head.cell_values
+        body.each do |table_line|
+          feature.add_row_scenario(Feature.last_scenario, table_line.cell_values, table_line.line)
+        end
+      end
+      
+      def matrix
+        ([head] + body).map do |table_line|
+          table_line.cell_values # We're losing the line - we'll get it back when we make our own class
+        end
+      end
+      
+      def to_arg
+        Model::Table.new(matrix)
+      end
+      
+      def body
+        super.elements.map { |elt| elt.table_line }
+      end
+    }
+  end
+  
+  rule table_line
+    separator cells:(blank* cell_value blank* separator)+ {
+      def cell_values
+        cells.elements.map { |elt| elt.cell_value.text_value.strip }
+      end
+
+      def line
+        input.line_of(interval.first)
+      end
+    }
+  end
+
+  rule cell_value
+    (!(separator / eol) .)*
+  end
+
+  rule step_sequence
+    head:step tail:(space step)* {
+      def compile(scenario)
+        ([head] + tail).each do |step|
+          step.compile(scenario)
+        end
+      end
+      
+      def tail
+        super.elements.map { |elt| elt.step }
+      end
+    }
+  end
+
+  rule step
+    given_scenario / plain_step
+  end
+  
+  rule given_scenario
+    given_scenario_keyword space? name:line_to_eol {
+      def compile(scenario)
+        line = input.line_of(interval.first)
+        scenario.create_given_scenario(name.text_value.strip, line)
+      end
+    }
+  end
+
+  rule plain_step
+    step_keyword space? name:line_to_eol multi:multiline_arg? {
+      def compile(scenario)
+        line = input.line_of(interval.first)
+        step = scenario.create_step(step_keyword.text_value, name.text_value.strip, line)
+
+        if multi.respond_to?(:to_arg)
+          step.extra_args << multi.to_arg
+        end
+      end
+    }
+  end
+  
+  rule multiline_arg
+    table / multiline_string
+  end
+  
+  rule multiline_string
+    eol indent:space triple_quote string:(!triple_quote .)* triple_quote {
+      def to_arg
+        indent_length = indent.text_value.length
+        significant_lines = string.text_value.split("\n")[1..-2]
+        significant_lines.map do |l| 
+          l[indent_length..-1]
+        end.join("\n")
+      end
+    }
+  end
+
+  rule triple_quote
+    '"""'
+  end
+
+  rule separator
+    '|'
+  end
+
+  rule space
+    (white / comment_to_eol)+
+  end
+
+  rule line_to_eol
+    (!eol .)*
+  end
+
+  rule comment_to_eol
+    '#' line_to_eol
+  end
+
+  rule white
+    blank / eol
+  end
+  
+  rule blank
+    [ \t]
+  end
+  
+  rule eol
+    ("\r" "\n"?) / "\n"
+  end
+  
+  rule step_keyword
+    "<%= words['given'] %>" / "<%= words['when'] %>" / "<%= words['then'] %>" / "<%= words['and'] %>" / "<%= words['but'] %>"
+  end
+  
+  rule scenario_keyword
+    "<%= words['scenario'] %>" ":"?
+  end
+  
+  rule more_examples_keyword
+    "<%= words['more_examples'] %>" ":"?
+  end
+  
+  rule given_scenario_keyword
+    "<%= words['given_scenario'] %>" ":"?
+  end
+
+end
+
+end
+end