cucumber 0.1.10 → 0.2.0

data/lib/cucumber/parser/treetop_ext.rb

@@ -0,0 +1,75 @@
+begin
+  require 'treetop'
+  require 'treetop/runtime'
+  require 'treetop/ruby_extensions'
+rescue LoadError
+  require "rubygems"
+  gem "treetop"
+  require 'treetop'
+  require 'treetop/runtime'
+  require 'treetop/ruby_extensions'
+end
+
+module Cucumber
+  module Parser
+    module TreetopExt
+      FILE_COLON_LINE_PATTERN = /^([\w\W]*?):([\d:]+)$/
+
+      # Parses a file and returns a Cucumber::Ast
+      def parse_file(file)
+        _, path, lines = *FILE_COLON_LINE_PATTERN.match(file)
+        if path
+          lines = lines.split(':').map { |line| line.to_i }
+        else
+          path = file
+          lines = []
+        end
+
+        loader = lambda { |io| parse_or_fail(io.read, path) }
+        feature = if path =~ /^http/
+          require 'open-uri'
+          open(path, &loader)
+        else
+          File.open(path, Cucumber.file_mode('r'), &loader) 
+        end
+        feature.lines = lines
+        feature
+      end
+
+      def parse_or_fail(s, file=nil, line_offset=0)
+        parse_tree = parse(s)
+        if parse_tree.nil?
+          raise Cucumber::Parser::SyntaxError.new(self, file, line_offset)
+        else
+          ast = parse_tree.build
+          ast.file = file
+          ast
+        end
+      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*', '}"
+        line = parser.failure_line + line_offset
+        message = "#{file}:#{line}:#{parser.failure_column}: Parse error, expected #{expected}."
+        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
+    end
+  end
+end

data/lib/cucumber/parser.rb

@@ -0,0 +1,43 @@
+require 'erb'
+require 'cucumber/platform'
+require 'cucumber/ast'
+require 'cucumber/parser/treetop_ext'
+require 'cucumber/parser/table'
+
+module Cucumber
+  # Classes in this module parse feature files and translate the parse tree 
+  # (concrete syntax tree) into an abstract syntax tree (AST) using
+  # <a href="http://martinfowler.com/dslwip/EmbeddedTranslation.html">Embedded translation</a>.
+  #
+  # The AST is built by the various <tt>#build</tt> methods in the parse tree.
+  #
+  # The AST classes are defined in the Cucumber::Ast module.
+  module Parser
+    translator = Module.new do
+      def keywordz(key)
+        'Scenario'
+      end
+    end
+
+    def self.load_parser(keywords)
+      Loader.new(keywords)
+    end
+    
+    class Loader
+      def initialize(keywords)
+        @keywords = keywords
+        i18n_tt = File.expand_path(File.dirname(__FILE__) + '/parser/i18n.tt')
+        template = File.open(i18n_tt, Cucumber.file_mode('r')).read
+        erb = ERB.new(template)
+        grammar = erb.result(binding)
+        Treetop.load_from_string(grammar)
+        require 'cucumber/parser/feature'
+      end
+
+      def keywords(key)
+        values = @keywords[key].split('|')
+        values.map{|value| "'#{value}'"}.join(" / ")
+      end
+    end
+  end
+end

data/lib/cucumber/platform.rb

@@ -1,12 +1,17 @@
 # Detect the platform we're running on so we can tweak behaviour
 # in various places.
 require 'rbconfig'
+require 'yaml'
 
-$CUCUMBER_JRUBY       = defined?(JRUBY_VERSION)
-$CUCUMBER_IRONRUBY    = Config::CONFIG['sitedir'] =~ /IronRuby/
-$CUCUMBER_WINDOWS     = Config::CONFIG['host_os'] =~ /mswin|mingw/
-$CUCUMBER_WINDOWS_MRI = $CUCUMBER_WINDOWS && !$CUCUMBER_JRUBY && !$CUCUMBER_IRONRUBY
-
-if $CUCUMBER_IRONRUBY
-  ENV['GEM_PATH'] ||= "C:/ruby/lib/ruby/gems/1.8"
-end
+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/
+end

data/lib/cucumber/rails/rspec.rb

@@ -1,12 +1,8 @@
-require 'spec'
-require 'spec/rails'
+require 'cucumber/rails/world'
+require 'spec/expectations'
+require 'spec/rails/matchers'
 
-# Hack to stop RSpec from dumping the summary
-Spec::Runner::Options.class_eval do
-  def examples_should_be_run?
-    false
-  end
+Cucumber::Rails::World.class_eval do
+  include Spec::Matchers
+  include Spec::Rails::Matchers
 end
-
-ActionController::Integration::Session.send(:include, Spec::Matchers)
-ActionController::Integration::Session.send(:include, Spec::Rails::Matchers)

data/lib/cucumber/rails/world.rb

@@ -11,11 +11,11 @@ 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
-    perform_action_without_rescue
+  def rescue_action(exception)
+    raise exception
   end
 end
-Dispatcher.class_eval do
+ActionController::Dispatcher.class_eval do
   def self.failsafe_response(output, status, exception = nil)
     raise exception
   end
@@ -24,7 +24,7 @@ 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=)
 
-$main = self
+$cucumber_toplevel = self
 
 module Cucumber #:nodoc:
   module Rails
@@ -44,22 +44,22 @@ module Cucumber #:nodoc:
     def self.use_transactional_fixtures
       World.use_transactional_fixtures = true
       if defined?(ActiveRecord::Base)
-        $main.Before do
+        $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
+            ActiveRecord::Base.__send__(:increment_open_transactions)
           end
           ActiveRecord::Base.connection.begin_db_transaction
           ActionMailer::Base.deliveries = [] if defined?(ActionMailer::Base)
         end
         
-        $main.After do
+        $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
+            ActiveRecord::Base.__send__(:decrement_open_transactions)
           end
         end
       end

data/lib/cucumber/rake/task.rb

@@ -1,42 +1,79 @@
+require 'cucumber/platform'
+
 module Cucumber
   module Rake
-    # Defines a task for running features.
+    # Defines a Rake task for running features.
+    #
+    # The simplest use of it goes something like:
+    #
+    #   Cucumber::Rake::Task.new
+    #
+    # This will create a task named 'features' described as 'Run Features with 
+    # Cucumber'. It will use steps from 'features/**/*.rb' and features in 'features/**/*.feature'.
+    #
+    # To further configure the task, you can pass a block:
+    #
+    #   Cucumber::Rake::Task.new do |t|
+    #     t.cucumber_opts = "--format progress"
+    #   end
+    #
+    # This task can also be configured to be run with RCov:
+    #
+    #   Cucumber::Rake::Task.new do |t|
+    #     t.rcov = true
+    #   end
+    # 
+    # See the attributes for additional configuration possibilities.
     class Task
-      LIB    = File.expand_path(File.dirname(__FILE__) + '/../..')
+      LIB    = File.expand_path(File.dirname(__FILE__) + '/../..') # :nodoc:
 
+      # Directories to add to the Ruby $LOAD_PATH
       attr_accessor :libs
+      # Name of the cucumber binary to use for running features. Defaults to Cucumber::BINARY
       attr_accessor :binary
+      # Array of paths to specific step definition files to use
       attr_accessor :step_list
+      # File pattern for finding step definitions. Defaults to 
+      # 'features/**/*.rb'.
       attr_accessor :step_pattern
+      # Array of paths to specific features to run. 
       attr_accessor :feature_list
+      # File pattern for finding features to run. Defaults to 
+      # 'features/**/*.feature'. Can be overriden by the FEATURE environment variable.
       attr_accessor :feature_pattern
+      # Extra options to pass to the cucumber binary. Can be overridden by the CUCUMBER_OPTS environment variable.
       attr_accessor :cucumber_opts
+      # Run cucumber with RCov?
       attr_accessor :rcov
+      # Extra options to pass to rcov
       attr_accessor :rcov_opts
 
-      # Define a task
+      # Define a Rake
       def initialize(task_name = "features", desc = "Run Features with Cucumber")
         @task_name, @desc = task_name, desc
-        @libs = []
+        @libs = ['lib']
         @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        ||= File.expand_path(File.dirname(__FILE__) + '/../../../bin/cucumber')
+
+        @binary = binary.nil? ? Cucumber::BINARY : File.expand_path(binary)
+        @libs.insert(0, LIB) if binary == Cucumber::BINARY
+
         define_task
       end
 
-      def define_task
+      def define_task # :nodoc:
         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"' % ([LIB] + libs).join(File::PATH_SEPARATOR)]
+      def arguments_for_ruby_execution(task_args = nil) # :nodoc:
+        lib_args     = ['"%s"' % libs.join(File::PATH_SEPARATOR)]
         cucumber_bin = ['"%s"' % binary]
         cuc_opts     = [(ENV['CUCUMBER_OPTS'] || cucumber_opts)]
 
@@ -84,7 +121,7 @@ module Cucumber
         super(task_name, desc)
       end
 
-      def define_task
+      def define_task # :nodoc:
         desc @desc
         task @task_name, :feature_name do |t, args|
           ruby(arguments_for_ruby_execution(args).join(" ")) # ruby(*args) is broken on Windows

data/lib/cucumber/step_definition.rb

@@ -0,0 +1,103 @@
+require 'cucumber/step_match'
+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+/, '(.*)') # Replace $var with (.*)
+        pattern = Regexp.new("^#{p}$") 
+      end
+      @regexp, @proc = pattern, proc
+    end
+
+    def step_match(name_to_match, name_to_report)
+      if(match = name_to_match.match(@regexp))
+        StepMatch.new(self, name_to_match, name_to_report, match.captures)
+      else
+        nil
+      end
+    end
+
+    def invoke(world, args, step_name)
+      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.backtrace_line)
+        raise e
+      end
+    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 backtrace_line
+      "#{file_colon_line}:in `#{@regexp.inspect}'"
+    end
+
+    def file_colon_line
+      @proc.file_colon_line
+    end
+
+    def text_length
+      @regexp.inspect.jlength
+    end
+
+    def to_s(indent = 0)
+      @regexp.inspect + (' # ').indent(indent) + file_colon_line
+    end
+  end
+end

data/lib/cucumber/step_match.rb

@@ -0,0 +1,49 @@
+module Cucumber
+  class StepMatch
+    attr_reader :step_definition
+    attr_reader :args
+    
+    def initialize(step_definition, step_name, formatted_step_name, args)
+      @step_definition, @step_name, @formatted_step_name, @args = step_definition, step_name, formatted_step_name, args
+    end
+    
+    def invoke(world, multiline_arg)
+      all_args = @args.dup
+      all_args << multiline_arg if multiline_arg
+      @step_definition.invoke(world, all_args, @step_name)
+    end
+
+    def format_args(format)
+      @formatted_step_name || @step_definition.format_args(@step_name, format)
+    end
+    
+    def file_colon_line
+      @step_definition.file_colon_line
+    end
+
+    def backtrace_line
+      @step_definition.backtrace_line
+    end
+  end
+  
+  class NoStepMatch
+    attr_reader :step_definition
+
+    def initialize(step)
+      @step = step
+    end
+    
+    def format_args(format)
+      @step.name
+    end
+
+    def file_colon_line
+      raise "No file:line for #{@step}" unless @step.file_colon_line
+      @step.file_colon_line
+    end
+
+    def backtrace_line
+      @step.backtrace_line
+    end
+  end
+end