aslakhellesoy-cucumber 0.0.1

data/lib/cucumber/parser/top_down_visitor.rb

@@ -0,0 +1,26 @@
+module Cucumber
+  module Parser
+    class TopDownVisitor
+      def visit_stories(stories)
+        stories.accept(self)
+      end
+
+      def visit_story(story)
+        story.accept(self)
+      end
+
+      def visit_header(header)
+      end
+
+      def visit_narrative(narrative)
+      end
+
+      def visit_scenario(scenario)
+        scenario.accept(self)
+      end
+
+      def visit_step(step)
+      end
+    end
+  end
+end

data/lib/cucumber/rails/world.rb

@@ -0,0 +1,69 @@
+# Based on code from Brian Takita, Yurii Rashkovskii and Ben Mabey
+# Adapted by Aslak Hellesøy
+
+if defined?(ActiveRecord::Base)
+  require 'test_help' 
+else
+  require 'action_controller/test_process'
+  require 'action_controller/integration'
+end
+require 'test/unit/testresult'
+require 'spec'
+require 'spec/rails'
+
+# These allow exceptions to come through as opposed to being caught and hvaing non-helpful responses returned.
+ActionController::Base.class_eval do
+  def perform_action
+    perform_action_without_rescue
+  end
+end
+Dispatcher.class_eval do
+  def self.failsafe_response(output, status, exception = nil)
+    raise exception
+  end
+end
+
+# So that Test::Unit doesn't launch at the end - makes it think it has already been run.
+Test::Unit.run = true
+
+# Hack to stop RSpec from dumping the summary
+Spec::Runner::Options.class_eval do
+  def examples_should_be_run?
+    false
+  end
+end
+
+ActionController::Integration::Session.send(:include, Spec::Matchers)
+ActionController::Integration::Session.send(:include, Spec::Rails::Matchers)
+
+module Cucumber
+  module Rails
+    class World < ActionController::IntegrationTest
+      if defined?(ActiveRecord::Base)
+        self.use_transactional_fixtures = true
+      else
+        def self.fixture_table_names; []; end # Workaround for projects that don't use ActiveRecord
+      end
+
+      def initialize #:nodoc:
+        @_result = Test::Unit::TestResult.new
+      end
+    end
+  end
+end
+
+World do
+  Cucumber::Rails::World.new
+end
+
+if defined?(ActiveRecord::Base)
+  Before do
+    ActiveRecord::Base.send :increment_open_transactions
+    ActiveRecord::Base.connection.begin_db_transaction
+  end
+  
+  After do
+    ActiveRecord::Base.connection.rollback_db_transaction
+    ActiveRecord::Base.send :decrement_open_transactions
+  end
+end

data/lib/cucumber/rake/task.rb

@@ -0,0 +1,74 @@
+module Cucumber
+  module Rake
+    # Defines a task for running stories.
+    # TODO: Base on http://github.com/dchelimsky/rspec/tree/master/lib/spec/rake/spectask.rb
+    class Task
+      LIB    = File.expand_path(File.dirname(__FILE__) + '/../..')
+      BINARY = File.expand_path(File.dirname(__FILE__) + '/../../../bin/cucumber')
+
+      attr_accessor :libs
+      attr_accessor :step_list
+      attr_accessor :step_pattern
+      attr_accessor :story_list
+      attr_accessor :story_pattern
+      attr_accessor :cucumber_opts
+      
+      # Define a task
+      def initialize(stories_path = "stories")
+        @stories_path = stories_path
+        @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?
+        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)
+
+            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
+          end
+        end
+      end
+
+
+      def story_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
+          FileList[result]
+        end
+      end
+
+      def step_files # :nodoc:
+        if ENV['STEPS']
+          FileList[ ENV['STEPS'] ]
+        else
+          result = []
+          result += step_list.to_a if step_list
+          result += FileList[step_pattern].to_a if step_pattern
+          FileList[result]
+        end
+      end
+    end
+  end
+end

data/lib/cucumber/ruby_tree.rb

@@ -0,0 +1,14 @@
+require 'cucumber/ruby_tree/nodes'
+
+module Cucumber
+  # Classes in this module implement the pure ruby stories in Cucumber.
+  module RubyTree
+    def Story(header, narrative, &proc)
+      stories << RubyStory.new(header, narrative, &proc)
+    end
+
+    def stories #:nodoc:
+      @stories ||= Tree::Stories.new
+    end
+  end
+end

data/lib/cucumber/ruby_tree/nodes.rb

@@ -0,0 +1,68 @@
+require 'cucumber/tree'
+
+module Cucumber
+  module RubyTree
+    class RubyStory
+      include Tree::Story
+
+      def initialize(header, narrative, &proc)
+        @header, @narrative = header, narrative
+        @scenarios = []
+        instance_eval(&proc)
+      end
+
+      def Scenario(name, &proc)
+        @scenarios << RubyScenario.new(name, &proc)
+      end
+
+    protected
+
+      attr_reader :header, :narrative, :scenarios
+
+    end
+
+    class RubyScenario
+      include Tree::Scenario
+
+      def initialize(name, &proc)
+        @name = name
+        @steps = []
+        @line = *caller[2].split(':')[1].to_i
+        instance_eval(&proc)
+      end
+
+      def Given(name)
+        @steps << RubyStep.new('Given', name)
+      end
+
+      def When(name)
+        @steps << RubyStep.new('When', name)
+      end
+
+      def Then(name)
+        @steps << RubyStep.new('Then', name)
+      end
+
+      def And(name)
+        @steps << RubyStep.new('And', name)
+      end
+
+      attr_reader :name, :steps, :line
+
+    end
+
+    class RubyStep
+      include Tree::Step
+      attr_accessor :error
+    
+      def initialize(keyword, name)
+        @keyword, @name = keyword, name
+        @file, @line, _ = *caller[2].split(':')
+      end
+
+      attr_reader :keyword, :name, :file, :line
+
+    end
+  end
+end
+

data/lib/cucumber/step_methods.rb

@@ -0,0 +1,39 @@
+require 'cucumber/step_mother'
+
+module Cucumber
+  module StepMethods  
+    def World(&proc)
+      $executor.register_world_proc(&proc)
+    end
+
+    def Before(&proc)
+      $executor.register_before_proc(&proc)
+    end
+    
+    def After(&proc)
+      $executor.register_after_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,38 @@
+require 'cucumber/parser/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
+    def initialize
+      @step_procs = {}
+    end
+
+    def register_step_proc(key, &proc)
+      regexp = case(key)
+      when String
+        Regexp.new("^#{key}$") # TODO: replace $variable with (.*)
+      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
+      @step_procs[regexp] = proc
+    end
+    
+    def visit_step(step)
+      # Maybe we shouldn't attach the regexp etc to
+      # the step? Maybe steps pull them out as needed?
+      # 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
+          step.attach(regexp, proc, $~.captures)
+        end
+      end
+    end
+  end
+end

data/lib/cucumber/tree.rb

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