cucumber 0.1.16 → 0.2.0

data/lib/cucumber/model.rb

@@ -1 +0,0 @@
-%w{table}.each{|f| require "cucumber/model/#{f}"}

data/lib/cucumber/model/table.rb

@@ -1,32 +0,0 @@
-module Cucumber
-  module Model
-    class Table
-      attr_accessor :raw
-      
-      # Creates a new table. The +raw+ argument should be an array
-      # of arrays
-      def initialize(raw)
-        @raw = raw
-      end
-      
-      # Turn the table into an array of Hash where each Hash
-      # has keys corresponding to the table header (first line)
-      # and the values are the individual row cells.
-      def hashes
-        header = @raw[0]
-        rows.map do |row|
-          h = {}
-          row.each_with_index do |v,n|
-            key = header[n]
-            h[key] = v
-          end
-          h
-        end
-      end
-      
-      def rows
-        @raw[1..-1]
-      end
-    end
-  end
-end

data/lib/cucumber/step_methods.rb

@@ -1,49 +0,0 @@
-require 'cucumber/step_mother'
-
-module Cucumber
-  # Defines "global" methods that may be used in *_steps.rb files.
-  module StepMethods
-    # Each scenario will execute in the context of what the supplied block returns.
-    def World(&proc)
-      executor.register_world_proc(&proc)
-    end
-
-    def Before(&proc)
-      executor.register_before_scenario_proc(&proc)
-    end
-    
-    def After(&proc)
-      executor.register_after_scenario_proc(&proc)
-    end
-
-    def AfterStep(&proc)
-      executor.register_after_step_proc(&proc)
-    end
-
-    def Given(key, &proc)
-      step_mother.register_step_proc(key, &proc)
-    end
-
-    def When(key, &proc)
-      step_mother.register_step_proc(key, &proc)
-    end
-
-    def Then(key, &proc)
-      step_mother.register_step_proc(key, &proc)
-    end
-    
-    # Simple workaround for old skool steps
-    def steps_for(*_)
-      STDERR.puts "WARNING: In Cucumber the steps_for method is obsolete"
-      yield
-    end
-    
-    def step_mother #:nodoc:
-      @step_mother ||= StepMother.new
-    end
-    
-    def executor
-      @executor ||= Executor.new(step_mother)
-    end
-  end
-end

data/lib/cucumber/tree.rb

@@ -1,16 +0,0 @@
-%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/tree/feature.rb

@@ -1,105 +0,0 @@
-module Cucumber
-  module Tree
-    class Feature
-      attr_reader :header
-      attr_reader :scenarios
-      MIN_PADDING = 2
-
-      attr_accessor :file
-
-      def initialize(header, &proc)
-        @header = header
-        @scenarios = []
-        instance_eval(&proc) if block_given?
-      end
-
-      def add_scenario(name, line, &proc)
-        scenario = Scenario.new(self, name, line, &proc)
-        @scenarios << scenario
-        scenario
-      end
-
-      def add_scenario_outline(name, line, &proc)
-        scenario = ScenarioOutline.new(self, name, line, &proc)
-        @scenarios << scenario
-        scenario
-      end
-
-      def add_row_scenario(template_scenario, values, line)
-        scenario = RowScenario.new(self, template_scenario, values, line)
-        @scenarios << scenario
-        scenario
-      end
-            
-      def add_row_scenario_outline(template_scenario, values, line)
-        scenario = RowScenarioOutline.new(self, template_scenario, values, line)
-        @scenarios << scenario
-        scenario
-      end
-
-      def scenario_named(name)
-        @scenarios.find {|s| s.name == name}
-      end
-
-      def padding_length
-        MIN_PADDING
-      end
-
-      def Scenario(name, &proc)
-        line = caller[0] =~ /:(\d+)$/ ? $1 : nil
-        add_scenario(name, line, &proc)
-      end
-
-      def ScenarioOutline(name, &proc)
-        line = caller[0] =~ /:(\d+)$/ ? $1 : nil
-        add_scenario_outline(name, line, &proc)
-      end
-
-      def Table(matrix = [], &proc)
-        table = Table.new(matrix)
-        proc.call(table)
-  
-        template_scenario = @scenarios.last
-        template_scenario.table_header = matrix[0]
-
-        matrix[1..-1].each do |row|
-          if template_scenario.outline?
-            add_row_scenario_outline(template_scenario, row, row.line)
-          else
-            add_row_scenario(template_scenario, row, row.line)
-          end
-        end
-      end
-
-      def accept(visitor)
-        visitor.visit_header(@header)
-        @scenarios.each do |scenario|
-          if scenario.outline? && !scenario.row?
-            visitor.visit_scenario_outline(scenario)
-          elsif scenario.row?
-            visitor.visit_row_scenario(scenario)
-          else
-            visitor.visit_regular_scenario(scenario)
-          end
-        end
-      end
-      
-      def last_line(scenario)
-        next_scenario = next_scenario(scenario) 
-        next_scenario ? next_scenario.line - 1 : lines
-      end
-      
-      protected
-      
-      def next_scenario(scenario)
-        index = @scenarios.index(scenario)
-        @scenarios[index + 1]
-      end
-      
-      def lines
-        @lines ||= File.readlines(file).size
-      end
-      
-    end
-  end
-end

data/lib/cucumber/tree/features.rb

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

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

@@ -1,240 +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.outline? && !step.row?
-            visitor.visit_step_outline(step)
-          elsif step.row?
-            visitor.visit_row_step(step)
-          else
-            visitor.visit_regular_step(step)
-          end
-        end
-      end
-
-      def at_line?(l)
-        (line..last_line).include?(l)
-      end
-      
-      def last_line
-        @last_line ||= @feature.last_line(self)
-      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
-      
-      def outline?
-        false
-      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 ScenarioOutline < Scenario
-      def outline?
-        true
-      end
-
-      def length
-        @length ||= Cucumber.language['scenario_outline'].jlength + 2 + (@name.nil? ? 0 : @name.jlength)
-      end
-      
-      def create_step(keyword, name, line)
-        step = StepOutline.new(self, keyword, name, line)
-        @steps_and_given_scenarios << step
-        step
-      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
-    
-    class RowScenarioOutline < RowScenario
-      def outline?
-        true
-      end
-
-      def steps
-        @processed_placeholders = []
-        @steps ||= @template_scenario.steps.map do |template_step|
-          build_row_step_outline(template_step)
-        end
-      end
-
-      private
-
-      def build_row_step_outline(template_step)
-        step_name = template_step.name
-        placeholder_values = []
-
-        @template_scenario.table_header.each_with_index do |column_name, column_number|
-
-          if step_name =~ placeholder_regexp(column_name)
-            step_name = step_name.gsub(placeholder_regexp(column_name), @values[column_number])
-            
-            unless @processed_placeholders.include?(column_name)
-              placeholder_values << @values[column_number]
-              @processed_placeholders << column_name
-            end
-          end
-
-        end
-        RowStepOutline.new(self, template_step, step_name, placeholder_values, @line)
-      end
-      
-      def placeholder_regexp(string)
-        /#{Regexp.escape("<#{string}>")}/
-      end
-    end
-    
-  end
-end