aslakhellesoy-cucumber 0.0.1 → 0.1.1

data/lib/cucumber/rake/task.rb

@@ -1,6 +1,6 @@
 module Cucumber
   module Rake
-    # Defines a task for running stories.
+    # Defines a task for running features.
     # TODO: Base on http://github.com/dchelimsky/rspec/tree/master/lib/spec/rake/spectask.rb
     class Task
       LIB    = File.expand_path(File.dirname(__FILE__) + '/../..')
@@ -9,52 +9,50 @@ module Cucumber
       attr_accessor :libs
       attr_accessor :step_list
       attr_accessor :step_pattern
-      attr_accessor :story_list
-      attr_accessor :story_pattern
+      attr_accessor :feature_list
+      attr_accessor :feature_pattern
       attr_accessor :cucumber_opts
       
       # Define a task
-      def initialize(stories_path = "stories")
-        @stories_path = stories_path
+      def initialize(task_name = "features", desc = "Run Features")
+        @task_name, @desc = task_name, desc
         @libs = [LIB]
 
         yield self if block_given?
 
-        @story_pattern = "#{@stories_path}/**/*.story" if story_pattern.nil? && story_list.nil?
-        @step_pattern =  "#{@stories_path}/**/*.rb"    if step_pattern.nil? && step_list.nil?
+        @feature_pattern = "features/**/*.feature" if feature_pattern.nil? && feature_list.nil?
+        @step_pattern =  "features/**/*.rb"    if step_pattern.nil? && step_list.nil?
         define_tasks
       end
     
       def define_tasks
-        namespace :cucumber do
-          desc "Run Cucumber Stories under #{@stories_path}"
-          task @stories_path do
-            args = []
-            args << '-I'
-            args << '"%s"' % libs.join(File::PATH_SEPARATOR)
-            args << '"%s"' % BINARY
-            args << (ENV['CUCUMBER_OPTS'] || cucumber_opts)
+        desc @desc
+        task @task_name do
+          args = []
+          args << '-I'
+          args << '"%s"' % libs.join(File::PATH_SEPARATOR)
+          args << '"%s"' % BINARY
+          args << (ENV['CUCUMBER_OPTS'] || cucumber_opts)
 
-            step_files.each do |step_file|
-              args << '--require'
-              args << step_file
-            end
-            args << story_files
-            args.flatten!
-            args.compact!
-            ruby(args.join(" ")) # ruby(*args) is broken on Windows
+          step_files.each do |step_file|
+            args << '--require'
+            args << step_file
           end
+          args << feature_files
+          args.flatten!
+          args.compact!
+          ruby(args.join(" ")) # ruby(*args) is broken on Windows
         end
       end
 
 
-      def story_files # :nodoc:
+      def feature_files # :nodoc:
         if ENV['STORY']
           FileList[ ENV['STORY'] ]
         else
           result = []
-          result += story_list.to_a if story_list
-          result += FileList[story_pattern].to_a if story_pattern
+          result += feature_list.to_a if feature_list
+          result += FileList[feature_pattern].to_a if feature_pattern
           FileList[result]
         end
       end

data/lib/cucumber/step_mother.rb

@@ -1,10 +1,10 @@
-require 'cucumber/parser/top_down_visitor'
+require 'cucumber/tree/top_down_visitor'
 require 'cucumber/core_ext/proc'
 
 module Cucumber
   # A StepMother keeps track of step procs and assigns them
   # to each step when visiting the tree.
-  class StepMother < Parser::TopDownVisitor
+  class StepMother < Tree::TopDownVisitor
     def initialize
       @step_procs = {}
     end
@@ -29,7 +29,7 @@ module Cucumber
       # Do we then have to attach ourself to the step instead?
       # What would we gain from a pull design?
       @step_procs.each do |regexp, proc|
-        if step.name =~ regexp
+        if step.respond_to?(:name) && step.name =~ regexp
           step.attach(regexp, proc, $~.captures)
         end
       end

data/lib/cucumber/tree.rb

@@ -1,127 +1,18 @@
+%w{features feature scenario step table top_down_visitor}.each{|f| require "cucumber/tree/#{f}"}
 require 'cucumber/core_ext/proc'
 require 'cucumber/core_ext/string'
 
 module Cucumber
   module Tree
-    class Stories
-      def initialize
-        @stories = []
-      end
-      
-      def length
-        @stories.length
-      end
-
-      def <<(story)
-        @stories << story
-      end
-
-      def accept(visitor)
-        @stories.each{|story| visitor.visit_story(story)}
-      end
+    def Feature(header, &proc)
+      feature = Feature.new("Feature: " + header, &proc)
+      feature.file, _, _ = *caller[0].split(':')
+      features << feature
+      feature
     end
 
-    module Story
-      def accept(visitor)
-        visitor.visit_header(header)
-        visitor.visit_narrative(narrative)
-        scenarios.each do |scenario|
-          visitor.visit_scenario(scenario)
-        end
-      end
-    end
-
-    module Scenario
-      def accept(visitor)
-        steps.each do |step|
-          visitor.visit_step(step)
-        end
-      end
-
-      def at_line?(l)
-        line == l || steps.map{|s| s.line}.index(l)
-      end
-    end
-
-    module Step
-      def self.included(base)
-        base.class_eval do
-          def self.new_id!
-            @next_id ||= -1
-            @next_id += 1
-          end
-        end
-      end
-
-      attr_reader :error
-
-      def regexp
-        @regexp || //
-      end
-
-      PENDING = lambda do |*_| 
-        raise Pending
-      end
-      PENDING.extend(CoreExt::CallIn)
-      PENDING.name = "PENDING"
-
-      def proc
-        @proc || PENDING
-      end
-
-      def attach(regexp, proc, args)
-        if @regexp
-          raise <<-EOM
-  "#{name}" matches several step definitions:
-
-  #{@proc.backtrace_line}
-  #{proc.backtrace_line}
-
-  Please give your steps unambiguous names
-          EOM
-        end
-        @regexp, @proc, @args = regexp, proc, args
-      end
-
-      def execute_in(world)
-        strip_pos = nil
-        begin
-          proc.call_in(world, *@args)
-        rescue ArgCountError => e
-          e.backtrace[0] = @proc.backtrace_line
-          strip_pos = e.backtrace.index("#{__FILE__}:#{__LINE__-3}:in `execute_in'")
-          format_error(strip_pos, 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 ? 3 : 2) 
-          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, e)
-        end
-      end
-
-      def format_error(strip_pos, 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}'")})
-        e.backtrace << "#{file}:#{line}:in `#{keyword} #{name}'"
-        raise e
-      end
-
-      def gzub(format=nil, &proc)
-        name.gzub(regexp, format, &proc)
-      end
-
-      def id
-        @id ||= self.class.new_id!
-      end
+    def features #:nodoc:
+      @features ||= Tree::Features.new
     end
   end
 end

data/lib/cucumber/tree/feature.rb

@@ -0,0 +1,45 @@
+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(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|
+          visitor.visit_scenario(scenario)
+        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/scenario.rb

@@ -0,0 +1,79 @@
+module Cucumber
+  module Tree
+    class BaseScenario
+      def file
+        @feature.file
+      end
+
+      def accept(visitor)
+        steps.each do |step|
+          visitor.visit_step(step)
+        end
+      end
+
+      def at_line?(l)
+        line == l || steps.map{|s| s.line}.index(l)
+      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 = []
+        instance_eval(&proc) if block_given?
+      end
+
+      def row?
+        false
+      end
+      
+      def add_step(keyword, name, line)
+        @steps << Step.new(self, keyword, 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, :steps, :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 steps
+        @steps ||= @template_scenario.steps.map do |template_step|
+          args = template_step.args.map do
+            @values.shift
+          end
+          RowStep.new(self, template_step.keyword, template_step.proc, args)
+        end
+      end
+    end
+  end
+end

data/lib/cucumber/tree/step.rb

@@ -0,0 +1,133 @@
+module Cucumber
+  module Tree
+    class BaseStep
+      def self.new_id!
+        @next_id ||= -1
+        @next_id += 1
+      end
+
+      attr_reader :error
+      attr_accessor :args
+
+      def file
+        @scenario.file
+      end
+
+      def regexp
+        @regexp || //
+      end
+
+      PENDING = lambda do |*_| 
+        raise Pending
+      end
+      PENDING.extend(CoreExt::CallIn)
+      PENDING.name = "PENDING"
+
+      def proc
+        @proc || PENDING
+      end
+
+      def attach(regexp, proc, args)
+        if @regexp
+          raise <<-EOM
+  "#{name}" matches several step definitions:
+
+  #{@proc.backtrace_line}
+  #{proc.backtrace_line}
+
+  Please give your steps unambiguous names
+          EOM
+        end
+        @regexp, @proc, @args = regexp, proc, args
+      end
+
+      if defined?(JRUBY_VERSION)
+        PENDING_ADJUSTMENT = 2
+        REGULAR_ADJUSTMENT = 1
+      else
+        PENDING_ADJUSTMENT = 3
+        REGULAR_ADJUSTMENT = 2
+      end
+
+      def execute_in(world)
+        strip_pos = nil
+        begin
+          proc.call_in(world, *@args)
+        rescue ArgCountError => e
+          e.backtrace[0] = @proc.backtrace_line
+          strip_pos = e.backtrace.index("#{__FILE__}:#{__LINE__ - 3}:in `execute_in'")
+          format_error(strip_pos, 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, e)
+        end
+      end
+
+      def format_error(strip_pos, 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
+    end
+    
+    class Step < BaseStep
+      attr_accessor :error
+
+      def row?
+        false
+      end
+
+      def initialize(scenario, keyword, name, line)
+        @scenario, @keyword, @name, @line = scenario, keyword, name, line
+        @args = []
+      end
+
+      def gzub(format=nil, &proc)
+        name.gzub(regexp, format, &proc)
+      end
+
+      attr_reader :keyword, :name, :line
+    end
+
+    class RowStep < BaseStep
+      attr_reader :keyword
+
+      def initialize(scenario, keyword, proc, args)
+        @scenario, @keyword, @proc, @args = scenario, keyword, proc, args
+      end
+
+      def gzub(format=nil, &proc)
+        raise "WWW"
+      end
+
+      def row?
+        true
+      end
+
+      def line
+        @scenario.line
+      end
+    end
+
+  end
+end