cucumber 0.1.10 → 0.2.0

data/lib/cucumber/tree/scenario.rb

@@ -1,174 +0,0 @@
-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)
-        @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
-          @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

@@ -1,134 +0,0 @@
-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'"
-          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

@@ -1,26 +0,0 @@
-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

@@ -1,23 +0,0 @@
-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

@@ -1,18 +0,0 @@
-%w{features feature scenario step given_scenario table top_down_visitor}.each{|f| require "cucumber/tree/#{f}"}
-require 'cucumber/core_ext/proc'
-require 'cucumber/core_ext/string'
-
-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

@@ -1,206 +0,0 @@
-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