aslakhellesoy-cucumber 0.1.99.4 → 0.1.99.5

data/lib/cucumber/parser/table.tt

@@ -0,0 +1,53 @@
+module Cucumber
+  module Parser
+    grammar Table
+
+      rule table
+        table_row+ {
+          def build
+            Ast::Table.new(raw)
+          end
+
+          def raw
+            elements.map{|e| e.build}
+          end
+        }
+      end
+
+      rule table_row
+        space* '|' cells:(cell '|')+ space* (eol+ / eof) {
+          def build
+            row = cells.elements.map do |elt| 
+              value = elt.cell.text_value.strip
+              value.empty? ? nil : value
+            end
+
+            class << row
+              attr_accessor :line
+            end
+            row.line = cells.line
+
+            row
+          end
+        }
+      end
+
+      rule cell
+        (!('|' / eol) .)*
+      end
+
+      rule space
+        [ \t]
+      end
+
+      rule eol
+        "\n" / ("\r" "\n"?)
+      end
+
+      rule eof
+        !.
+      end
+
+    end
+  end
+end

data/lib/cucumber/parser/treetop_ext.rb

@@ -0,0 +1,67 @@
+require 'treetop'
+require 'treetop/runtime'
+require 'treetop/ruby_extensions'
+
+module Cucumber
+  module Parser
+    module TreetopExt
+      FILE_LINE_PATTERN = /^([\w\W]*?):([\d:]+)$/
+
+      # Parses a file and returns a Cucumber::Ast
+      def parse_file(file)
+        _, path, lines = *FILE_LINE_PATTERN.match(file)
+        if path
+          lines = lines.split(':').map { |line| line.to_i }
+        else
+          path = file
+          lines = []
+        end
+
+        feature = File.open(path, Cucumber.file_mode('r')) do |io|
+          parse_or_fail(io.read, path)
+        end
+        feature.lines = lines
+        feature
+      end
+    end
+
+    class SyntaxError < StandardError
+      def initialize(parser, file, line_offset)
+        tf = parser.terminal_failures
+        expected = tf.size == 1 ? tf[0].expected_string.inspect : "one of #{tf.map{|f| f.expected_string.inspect}.uniq*', '}"
+        after = parser.input[parser.index...parser.failure_index]
+        found = parser.input[parser.failure_index..parser.failure_index]
+        
+        line = parser.failure_line + line_offset
+        message = "#{file}:#{line}:#{parser.failure_column}: " +
+          "Parse error, expected #{expected}. After #{after.inspect}. Found: #{found.inspect}"
+        super(message)
+      end
+    end
+  end
+end
+
+module Treetop
+  module Runtime
+    class SyntaxNode
+      def line
+        input.line_of(interval.first)
+      end
+    end
+    
+    class CompiledParser
+      include Cucumber::Parser::TreetopExt
+      
+      def parse_or_fail(s, file=nil, line=0)
+        parse_tree = parse(s)
+        if parse_tree.nil?
+          raise Cucumber::Parser::SyntaxError.new(self, file, line)
+        else
+          ast = parse_tree.build
+          ast.file = file
+          ast
+        end
+      end
+    end
+  end
+end

data/lib/cucumber/platform.rb

@@ -0,0 +1,18 @@
+# Detect the platform we're running on so we can tweak behaviour
+# in various places.
+require 'rbconfig'
+require 'yaml'
+
+module Cucumber
+  LANGUAGE_FILE = File.expand_path(File.dirname(__FILE__) + '/languages.yml')
+  LANGUAGES     = YAML.load_file(LANGUAGE_FILE)
+  BINARY        = File.expand_path(File.dirname(__FILE__) + '/../../bin/cucumber')
+  JRUBY         = defined?(JRUBY_VERSION)
+  IRONRUBY      = Config::CONFIG['sitedir'] =~ /IronRuby/
+  WINDOWS       = Config::CONFIG['host_os'] =~ /mswin|mingw/
+  WINDOWS_MRI   = WINDOWS && !JRUBY && !IRONRUBY
+  RAILS         = defined?(Rails)
+  RUBY_BINARY   = File.join(Config::CONFIG['bindir'], Config::CONFIG['ruby_install_name'])
+  RUBY_1_9      = RUBY_VERSION =~ /^1\.9/
+  EXCEPTION_STATUS = Hash.new(:failed)
+end

data/lib/cucumber/rails/rspec.rb

@@ -0,0 +1,5 @@
+require 'spec/expectations'
+require 'spec/rails/matchers'
+
+ActionController::Integration::Session.send(:include, Spec::Matchers)
+ActionController::Integration::Session.send(:include, Spec::Rails::Matchers)

data/lib/cucumber/rails/world.rb

@@ -0,0 +1,73 @@
+# 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'
+
+# These allow exceptions to come through as opposed to being caught and having non-helpful responses returned.
+ActionController::Base.class_eval do
+  def perform_action_with_rescue
+    perform_action_without_rescue
+  end
+end
+ActionController::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 if Test::Unit.respond_to?(:run=)
+
+$cucumber_toplevel = self
+
+module Cucumber #:nodoc:
+  module Rails
+    # All scenarios will execute in the context of a new instance of World.
+    class World < ActionController::IntegrationTest
+      if defined?(ActiveRecord::Base)
+        self.use_transactional_fixtures = false
+      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
+
+    def self.use_transactional_fixtures
+      World.use_transactional_fixtures = true
+      if defined?(ActiveRecord::Base)
+        $cucumber_toplevel.Before do
+          if ActiveRecord::Base.connection.respond_to?(:increment_open_transactions)
+            ActiveRecord::Base.connection.increment_open_transactions
+          else
+            ActiveRecord::Base.__send__(:increment_open_transactions)
+          end
+          ActiveRecord::Base.connection.begin_db_transaction
+          ActionMailer::Base.deliveries = [] if defined?(ActionMailer::Base)
+        end
+        
+        $cucumber_toplevel.After do
+          ActiveRecord::Base.connection.rollback_db_transaction
+          if ActiveRecord::Base.connection.respond_to?(:decrement_open_transactions)
+            ActiveRecord::Base.connection.decrement_open_transactions
+          else
+            ActiveRecord::Base.__send__(:decrement_open_transactions)
+          end
+        end
+      end
+    end
+
+  end
+end
+
+World do
+  Cucumber::Rails::World.new
+end

data/lib/cucumber/rake/task.rb

@@ -0,0 +1,106 @@
+require 'cucumber/platform'
+
+module Cucumber
+  module Rake
+    # Defines a task for running features.
+    class Task
+      LIB    = File.expand_path(File.dirname(__FILE__) + '/../..')
+
+      attr_accessor :libs
+      attr_accessor :binary
+      attr_accessor :step_list
+      attr_accessor :step_pattern
+      attr_accessor :feature_list
+      attr_accessor :feature_pattern
+      attr_accessor :cucumber_opts
+      attr_accessor :rcov
+      attr_accessor :rcov_opts
+
+      # Define a task
+      def initialize(task_name = "features", desc = "Run Features with Cucumber")
+        @task_name, @desc = task_name, desc
+        @libs = []
+        @rcov_opts = %w{--rails --exclude osx\/objc,gems\/}
+
+        yield self if block_given?
+
+        @feature_pattern = "features/**/*.feature" if feature_pattern.nil? && feature_list.nil?
+        @step_pattern    = "features/**/*.rb"      if step_pattern.nil? && step_list.nil?
+
+        @binary = binary.nil? ? Cucumber::BINARY : File.expand_path(binary)
+        @libs.insert(0, LIB) if binary == Cucumber::BINARY
+
+        define_task
+      end
+
+      def define_task
+        desc @desc
+        task @task_name do
+          ruby(arguments_for_ruby_execution.join(" ")) # ruby(*args) is broken on Windows
+        end
+      end
+
+      def arguments_for_ruby_execution(task_args = nil)
+        lib_args     = ['"%s"' % libs.join(File::PATH_SEPARATOR)]
+        cucumber_bin = ['"%s"' % binary]
+        cuc_opts     = [(ENV['CUCUMBER_OPTS'] || cucumber_opts)]
+
+        step_files(task_args).each do |step_file|
+          cuc_opts << '--require'
+          cuc_opts << step_file
+        end
+
+        if rcov
+          args = (['-I'] + lib_args + ['-S', 'rcov'] + rcov_opts +
+            cucumber_bin + ['--'] + cuc_opts + feature_files(task_args)).flatten
+        else
+          args = (['-I'] + lib_args + cucumber_bin + cuc_opts + feature_files(task_args)).flatten
+        end
+
+        args
+      end
+
+      def feature_files(task_args = nil) # :nodoc:
+        if ENV['FEATURE']
+          FileList[ ENV['FEATURE'] ]
+        else
+          result = []
+          result += feature_list.to_a if feature_list
+          result += FileList[feature_pattern].to_a if feature_pattern
+          FileList[result]
+        end
+      end
+
+      def step_files(task_args = nil) # :nodoc:
+        if ENV['STEPS']
+          FileList[ ENV['STEPS'] ]
+        else
+          result = []
+          result += Array(step_list) if step_list
+          result += Array(FileList[step_pattern]) if step_pattern
+          FileList[result]
+        end
+      end
+    end
+
+    class FeatureTask < Task
+
+      def initialize(task_name = "feature", desc = "Run a specified feature with Cucumber.  #{task_name}[feature_name]")
+        super(task_name, desc)
+      end
+
+      def define_task
+        desc @desc
+        task @task_name, :feature_name do |t, args|
+          ruby(arguments_for_ruby_execution(args).join(" ")) # ruby(*args) is broken on Windows
+        end
+      end
+
+      def feature_files(task_arguments) # :nodoc:
+        FileList[File.join("features", "**", "#{task_arguments[:feature_name]}.feature")]
+      end
+
+    end
+
+  end
+end

data/lib/cucumber/step_definition.rb

@@ -0,0 +1,87 @@
+require 'cucumber/core_ext/string'
+require 'cucumber/core_ext/proc'
+
+module Cucumber
+  # A Step Definition holds a Regexp and a Proc, and is created
+  # by calling <tt>Given</tt>, <tt>When</tt> or <tt>Then</tt>
+  # in the <tt>step_definitions</tt> ruby files - for example:
+  #
+  #   Given /I have (\d+) cucumbers in my belly/ do
+  #     # some code here
+  #   end
+  #
+  class StepDefinition
+    def self.snippet_text(step_keyword, step_name)
+      escaped = Regexp.escape(step_name).gsub('\ ', ' ').gsub('/', '\/')
+      "#{step_keyword} /^#{escaped}$/ do\n  pending\nend"
+    end
+
+    class MissingProc < StandardError
+      def message
+        "Step definitions must always have a proc"
+      end
+    end
+
+    attr_reader :regexp
+
+    def initialize(pattern, &proc)
+      raise MissingProc if proc.nil?
+      if String === pattern
+        p = pattern.gsub(/\$\w+/, '(.*)')
+        pattern = Regexp.new("^#{p}$") 
+      end
+      @regexp, @proc = pattern, proc
+    end
+
+    #:stopdoc:
+
+    def match(step_name)
+      case step_name
+      when String then @regexp.match(step_name)
+      when Regexp then @regexp == step_name
+      end
+    end
+
+    # Formats the matched arguments of the associated Step. This method
+    # is usually called from visitors, which render output.
+    #
+    # The +format+ either be a String or a Proc.
+    #
+    # If it is a String it should be a format string according to
+    # <tt>Kernel#sprinf</tt>, for example:
+    #
+    #   '<span class="param">%s</span></tt>'
+    #
+    # If it is a Proc, it should take one argument and return the formatted
+    # argument, for example:
+    #
+    #   lambda { |param| "[#{param}]" }
+    #
+    def format_args(step_name, format)
+      step_name.gzub(@regexp, format)
+    end
+
+    def matched_args(step_name)
+      step_name.match(@regexp).captures
+    end
+
+    def execute(step_name, world, *args)
+      args = args.map{|arg| Ast::PyString === arg ? arg.to_s : arg}
+      begin
+        world.cucumber_instance_exec(true, @regexp.inspect, *args, &@proc)
+      rescue Cucumber::ArityMismatchError => e
+        e.backtrace.unshift(self.to_backtrace_line)
+        raise e
+      end
+    end
+
+    def to_backtrace_line
+      "#{file_colon_line}:in `#{@regexp.inspect}'"
+    end
+
+    def file_colon_line
+      @proc.file_colon_line
+    end
+
+  end
+end

data/lib/cucumber/step_mother.rb

@@ -0,0 +1,164 @@
+require 'cucumber/step_definition'
+require 'cucumber/core_ext/instance_exec'
+
+module Cucumber
+  # This is the main interface for registering step definitions, which is done
+  # from <tt>*_steps.rb</tt> files. This module is included right at the top-level
+  # so #register_step_definition (and more interestingly - its aliases) are
+  # available from the top-level.
+  module StepMother
+    attr_writer :snippet_generator
+
+    class Undefined < StandardError
+      attr_reader :step_name
+
+      def initialize(step_name)
+        super %{Undefined step: "#{step_name}"}
+        @step_name = step_name
+      end
+      Cucumber::EXCEPTION_STATUS[self] = :undefined
+    end
+
+    class Pending < StandardError
+      Cucumber::EXCEPTION_STATUS[self] = :pending
+    end
+
+    # Raised when a step matches 2 or more StepDefinition
+    class Ambiguous < StandardError
+      def initialize(step_name, step_definitions)
+        message = "Ambiguous match of \"#{step_name}\":\n\n"
+        message << step_definitions.map{|sd| sd.to_backtrace_line}.join("\n")
+        message << "\n\n"
+        super(message)
+      end
+    end
+
+    # Raised when 2 or more StepDefinition have the same Regexp
+    class Redundant < StandardError
+      def initialize(step_def_1, step_def_2)
+        message = "Multiple step definitions have the same Regexp:\n\n"
+        message << step_def_1.to_backtrace_line << "\n"
+        message << step_def_2.to_backtrace_line << "\n\n"
+        super(message)
+      end
+    end
+
+    # Registers a new StepDefinition. This method is aliased
+    # to <tt>Given</tt>, <tt>When</tt> and <tt>Then</tt>.
+    #
+    # See Cucumber#alias_steps for details on how to
+    # create your own aliases.
+    #
+    # The +&proc+ gets executed in the context of a <tt>world</tt>
+    # object, which is defined by #World. A new <tt>world</tt>
+    # object is created for each scenario and is shared across
+    # step definitions within that scenario.
+    def register_step_definition(regexp, &proc)
+      step_definition = StepDefinition.new(regexp, &proc)
+      step_definitions.each do |already|
+        raise Redundant.new(already, step_definition) if already.match(regexp)
+      end
+      step_definitions << step_definition
+      step_definition
+    end
+
+    def world(scenario, &proc)
+      world = new_world
+      begin
+        (@before_procs ||= []).each do |proc|
+          world.cucumber_instance_exec(false, 'Before', scenario, &proc)
+        end
+        yield world
+      ensure
+        (@after_procs ||= []).each do |proc|
+          world.cucumber_instance_exec(false, 'After', scenario, &proc)
+        end
+      end
+    end
+
+    # Registers a Before proc. You can call this method as many times as you
+    # want (typically from ruby scripts under <tt>support</tt>).
+    def Before(&proc)
+      (@before_procs ||= []) << proc
+    end
+
+    def After(&proc)
+      (@after_procs ||= []) << proc
+    end
+
+    # Registers a World proc. You can call this method as many times as you
+    # want (typically from ruby scripts under <tt>support</tt>).
+    def World(&proc)
+      (@world_procs ||= []) << proc
+    end
+
+    # Creates a new world instance
+    def new_world #:nodoc:
+      world = Object.new
+      (@world_procs ||= []).each do |proc|
+        world = proc.call(world)
+      end
+
+      world.extend(WorldMethods)
+      world.__cucumber_step_mother = self
+
+      world.extend(::Spec::Matchers) if defined?(::Spec::Matchers)
+      world
+    end
+
+    # Looks up the StepDefinition that matches +step_name+
+    def step_definition(step_name) #:nodoc:
+      found = step_definitions.select do |step_definition|
+        step_definition.match(step_name)
+      end
+      raise Undefined.new(step_name) if found.empty?
+      raise Ambiguous.new(step_name, found) if found.size > 1
+      found[0]
+    end
+
+    def step_definitions
+      @step_definitions ||= []
+    end
+
+    def snippet_text(step_keyword, step_name)
+      @snippet_generator.snippet_text(step_keyword, step_name)
+    end
+
+    module WorldMethods #:nodoc:
+      attr_writer :__cucumber_step_mother, :__cucumber_current_step
+
+      # Call a step from within a step definition
+      def __cucumber_invoke(name, *multiline_arguments)
+        begin
+          # TODO: Very similar to code in Step. Refactor. Get back StepInvocation?
+          # Make more similar to JBehave?
+          step_definition = @__cucumber_step_mother.step_definition(name)
+          matched_args = step_definition.matched_args(name)
+          args = (matched_args + multiline_arguments)
+          step_definition.execute(name, self, *args)
+        rescue Exception => e
+          @__cucumber_current_step.exception = e
+          raise e
+        end
+      end
+      
+      def table(text, file=nil, line=0)
+        @table_parser ||= Parser::TableParser.new
+        @table_parser.parse_or_fail(text.strip, file, line)
+      end
+
+      def pending(message = "TODO")
+        if block_given?
+          begin
+            yield
+          rescue Exception => e
+            raise Pending.new(message)
+          end
+          raise Pending.new("Expected pending '#{message}' to fail. No Error was raised. No longer pending?")
+        else
+          raise Pending.new(message)
+        end
+      end
+    end
+  end
+end