cucumber 0.1.6

data/lib/cucumber/step_methods.rb

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

data/lib/cucumber/step_mother.rb

@@ -0,0 +1,82 @@
+require 'cucumber/tree/top_down_visitor'
+require 'cucumber/core_ext/proc'
+
+module Cucumber
+  class Pending < StandardError
+  end
+
+  class Duplicate < StandardError
+  end
+
+  class Multiple < StandardError
+  end
+
+  class StepMother
+    PENDING = lambda do |*_| 
+      raise Pending
+    end
+    PENDING.extend(CoreExt::CallIn)
+    PENDING.name = "PENDING"
+
+    def initialize
+      @step_procs = Hash.new(PENDING)
+    end
+
+    def register_step_proc(key, &proc)
+      regexp = case(key)
+      when String
+        # Replace the $foo and $bar style parameters
+        pattern = key.gsub(/\$\w+/, '(.*)')
+        Regexp.new("^#{pattern}$")
+      when Regexp
+        key
+      else
+        raise "Step patterns must be Regexp or String, but was: #{key.inspect}"
+      end
+      proc.extend(CoreExt::CallIn)
+      proc.name = key.inspect
+
+      if @step_procs.has_key?(regexp)
+        first_proc = @step_procs[regexp]
+        message = %{Duplicate step definitions:
+
+#{first_proc.backtrace_line}
+#{proc.backtrace_line}
+
+}
+        raise Duplicate.new(message)
+      end
+
+      @step_procs[regexp] = proc
+    end
+
+    def regexp_args_proc(step_name)
+      candidates = @step_procs.map do |regexp, proc|
+        if step_name =~ regexp
+          [regexp, $~.captures, proc]
+        end
+      end.compact
+      
+      case(candidates.length)
+      when 0
+        [nil, [], PENDING]
+      when 1
+        candidates[0]
+      else
+        message = %{Multiple step definitions match #{step_name.inspect}:
+
+#{candidates.map{|regexp, args, proc| proc.backtrace_line}.join("\n")}
+
+}
+        raise Multiple.new(message)
+      end
+     end
+    
+    def proc_for(regexp)
+      @step_procs[regexp]
+    end
+    
+    def execute(step)
+    end
+  end
+end

data/lib/cucumber/tree.rb

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

@@ -0,0 +1,53 @@
+module Cucumber
+  module Tree
+    class Feature
+      attr_accessor :file
+      
+      def initialize(header, &proc)
+        @header = header
+        @scenarios = []
+        instance_eval(&proc) if block_given?
+      end
+
+      def add_scenario(name, &proc)
+        scenario = Scenario.new(self, name, &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 scenario_named(name)
+        @scenarios.find {|s| s.name == name}
+      end
+
+      def Scenario(name, &proc)
+        add_scenario(name, &proc)
+      end
+      
+      def Table(matrix = [], &proc)
+        table = Table.new(matrix)
+        proc.call(table)
+        template_scenario = @scenarios.last
+        matrix[1..-1].each do |row|
+          @scenarios << RowScenario.new(self, template_scenario, row, row.line)
+        end
+      end
+
+      def accept(visitor)
+        visitor.visit_header(@header)
+        @scenarios.each do |scenario|
+          if scenario.row?
+            visitor.visit_row_scenario(scenario)
+          else
+            visitor.visit_regular_scenario(scenario)
+          end
+        end
+      end
+    end
+  end
+end

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,110 @@
+module Cucumber
+  module Tree
+    class BaseScenario
+      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
+    end
+
+    class Scenario < BaseScenario
+      
+      # If a table follows, the header will be stored here. Weird, but convenient.
+      attr_accessor :table_header
+      
+      def initialize(feature, name, &proc)
+        @feature, @name = feature, name
+        @steps_and_given_scenarios = []
+        instance_eval(&proc) if block_given?
+      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 row?
+        false
+      end
+      
+      def add_step(keyword, name, line)
+        @steps_and_given_scenarios << Step.new(self, keyword, name, line)
+      end
+      
+      def add_given_scenario(name, line)
+        @steps_and_given_scenarios << GivenScenario.new(self, name, line)
+      end
+
+      def Given(name)
+        add_step('Given', name, *caller[0].split(':')[1].to_i)
+      end
+
+      def When(name)
+        add_step('When', name, *caller[0].split(':')[1].to_i)
+      end
+
+      def Then(name)
+        add_step('Then', name, *caller[0].split(':')[1].to_i)
+      end
+
+      def And(name)
+        add_step('And', name, *caller[0].split(':')[1].to_i)
+      end
+
+      attr_reader :name, :line
+
+    end
+
+    class RowScenario < BaseScenario
+      attr_reader :line
+      
+      def initialize(feature, template_scenario, values, line)
+        @feature, @template_scenario, @values, @line = feature, template_scenario, values, line
+      end
+      
+      def row?
+        true
+      end
+      
+      def name
+        @template_scenario.name
+      end
+
+      def steps
+        @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
+    end
+  end
+end

data/lib/cucumber/tree/step.rb

@@ -0,0 +1,123 @@
+module Cucumber
+  module Tree
+    class BaseStep
+      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
+
+      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.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 stactrace 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
+    end
+    
+    class Step < BaseStep
+      attr_reader :keyword, :name, :line
+      attr_accessor :arity
+
+      def row?
+        false
+      end
+
+      def initialize(scenario, keyword, name, line)
+        @scenario, @keyword, @name, @line = scenario, keyword, name, line
+      end
+
+      def regexp_args_proc(step_mother)
+        regexp, args, proc = step_mother.regexp_args_proc(name)
+        @arity = args.length
+        [regexp, 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