cucumber 0.2.3 → 0.3.0

data/lib/cucumber/parser/table.tt

@@ -10,18 +10,30 @@ module Cucumber
 
       rule table
         table_row+ {
-          def build
+          def at_line?(line)
+            elements.detect{|table_row| table_row.at_line?(line)}
+          end
+
+          def build(filter=nil)
             Ast::Table.new(raw)
           end
 
-          def raw
-            elements.map{|e| e.build}
+          def raw(filter=nil, scenario_outline=nil)
+            elements.map do |table_row|
+              if(filter.nil? || table_row == elements[0] || filter.at_line?(table_row) || (scenario_outline && filter.outline_at_line?(scenario_outline)))
+                table_row.build
+              end
+            end.compact
           end
         }
       end
 
       rule table_row
         space* '|' cells:(cell '|')+ space* (eol+ / eof) {
+          def at_line?(line)
+            cells.line == line
+          end
+
           def build
             row = cells.elements.map do |elt| 
               value = elt.cell.text_value.strip

data/lib/cucumber/parser/treetop_ext.rb

@@ -12,37 +12,76 @@ end
 
 module Cucumber
   module Parser
-    module TreetopExt
+    class Filter
+      def initialize(lines, options)
+        @lines = lines
+        @include_tags = options[:include_tags] || []
+        @exclude_tags = options[:exclude_tags] || []
+        @names        = options[:scenario_names] || []
+      end
+
+      def accept?(syntax_node)
+        at_line?(syntax_node) &&
+        matches_tags?(syntax_node) &&
+        matches_names?(syntax_node)
+      end
+
+      def at_line?(syntax_node)
+        @lines.nil? || @lines.empty? || @lines.detect{|line| syntax_node.at_line?(line)}
+      end
+
+      def outline_at_line?(syntax_node)
+         @lines.nil? || @lines.empty? || @lines.detect{|line| syntax_node.outline_at_line?(line)}
+      end
+
+      def matches_tags?(syntax_node)
+        !excluded_by_tags?(syntax_node) &&
+        included_by_tags?(syntax_node)
+      end
+
+      def included_by_tags?(syntax_node)
+        @include_tags.empty? || syntax_node.has_tags?(@include_tags)
+      end
+
+      def excluded_by_tags?(syntax_node)
+        @exclude_tags.any? && syntax_node.has_tags?(@exclude_tags)
+      end
+      
+      def matches_names?(syntax_node)
+        @names.nil? || @names.empty? || @names.detect{|name| syntax_node.matches_name?(name)}
+      end
+    end
+
+    module TreetopExt      
       FILE_COLON_LINE_PATTERN = /^([\w\W]*?):([\d:]+)$/
 
       # Parses a file and returns a Cucumber::Ast
-      def parse_file(file)
+      def parse_file(file, options)
         _, path, lines = *FILE_COLON_LINE_PATTERN.match(file)
         if path
           lines = lines.split(':').map { |line| line.to_i }
         else
           path = file
-          lines = []
         end
+        filter = Filter.new(lines, options)
 
-        loader = lambda { |io| parse_or_fail(io.read, path) }
+        loader = lambda { |io| parse_or_fail(io.read, filter, 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)
+      def parse_or_fail(string, filter=nil, file=nil, line_offset=0)
+        parse_tree = parse(string)
         if parse_tree.nil?
           raise Cucumber::Parser::SyntaxError.new(self, file, line_offset)
         else
-          ast = parse_tree.build
-          ast.file = file
+          ast = parse_tree.build(filter) # may return nil if it doesn't match filter.
+          ast.file = file unless ast.nil?
           ast
         end
       end

data/lib/cucumber/rake/task.rb

@@ -27,26 +27,45 @@ module Cucumber
     class Task
       LIB    = File.expand_path(File.dirname(__FILE__) + '/../..') # :nodoc:
 
+      # TODO: remove depreated accessors for 0.4.0
+      def self.deprecate_accessor(attribute) # :nodoc:
+        attr_reader attribute
+        class_eval <<-EOF, __FILE__, __LINE__ + 1
+          def #{attribute}=(value)
+            @#{attribute} = value
+            warn("Cucumber::Rake::Task##{attribute} is deprecated and will be removed in 0.4.0.  Please use profiles for complex settings: http://wiki.github.com/aslakhellesoy/cucumber/using-rake#profiles")
+          end
+        EOF
+      end
+
       # 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
+      deprecate_accessor :step_list
       # File pattern for finding step definitions. Defaults to 
       # 'features/**/*.rb'.
-      attr_accessor :step_pattern
+      deprecate_accessor :step_pattern
       # Array of paths to specific features to run. 
-      attr_accessor :feature_list
+      deprecate_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
+      # 'features/**/*.feature'. Can be overridden by the FEATURE environment variable.
+      deprecate_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 what profile to be used.  When used with cucumber_opts it is simply appended to it. Will be ignored when CUCUMBER_OPTS is used.
+      def profile=(profile)
+        @profile = profile
+        unless feature_list
+          @feature_list = [] # Don't use accessor to avoid deprecation warning.
+        end
+      end
+      attr_reader :profile
 
       # Define a Rake
       def initialize(task_name = "features", desc = "Run Features with Cucumber")
@@ -75,7 +94,7 @@ module Cucumber
       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)]
+        cuc_opts     = [(ENV['CUCUMBER_OPTS'] || cucumber_opts_with_profile)]
 
         step_files(task_args).each do |step_file|
           cuc_opts << '--require'
@@ -92,6 +111,10 @@ module Cucumber
         args
       end
 
+      def cucumber_opts_with_profile # :nodoc:
+        @profile ? "#{cucumber_opts} --profile #{@profile}" : cucumber_opts
+      end
+
       def feature_files(task_args = nil) # :nodoc:
         if ENV['FEATURE']
           FileList[ ENV['FEATURE'] ]

data/lib/cucumber/step_definition.rb

@@ -59,7 +59,7 @@ module Cucumber
     PARAM_PATTERN = /"([^\"]*)"/
     ESCAPED_PARAM_PATTERN = '"([^\\"]*)"'
     
-    def self.snippet_text(step_keyword, step_name)
+    def self.snippet_text(step_keyword, step_name, multiline_arg_class = nil)
       escaped = Regexp.escape(step_name).gsub('\ ', ' ').gsub('/', '\/')
       escaped = escaped.gsub(PARAM_PATTERN, ESCAPED_PARAM_PATTERN)
 
@@ -68,9 +68,11 @@ module Cucumber
         n += 1
         "arg#{n}"
       end
+      block_args << multiline_arg_class.default_arg_name unless multiline_arg_class.nil?
       block_arg_string = block_args.empty? ? "" : " |#{block_args.join(", ")}|"
+      multiline_class_string = multiline_arg_class ? "# #{multiline_arg_class.default_arg_name} is a #{multiline_arg_class.to_s}\n  " : ""
 
-      "#{step_keyword} /^#{escaped}$/ do#{block_arg_string}\n  pending\nend"
+      "#{step_keyword} /^#{escaped}$/ do#{block_arg_string}\n  #{multiline_class_string}pending\nend"
     end
 
     class MissingProc < StandardError

data/lib/cucumber/step_mother.rb

@@ -45,11 +45,43 @@ module Cucumber
     end
   end
 
+  class NilWorld < StandardError
+    def initialize
+      super("World procs should never return nil")
+    end
+  end
+
+  class MultipleWorld < StandardError
+    def initialize(first_proc, second_proc)
+      message = "You can only pass a proc to #World once, but it's happening\n"
+      message << "in 2 places:\n\n"
+      message << first_proc.backtrace_line('World') << "\n"
+      message << second_proc.backtrace_line('World') << "\n\n"
+      message << "Use Ruby modules instead to extend your worlds. See the #World RDoc.\n\n"
+      super(message)
+    end
+  end
+
   # 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
+    class Hook
+      def initialize(tag_names, proc)
+        @tag_names = tag_names.map{|tag| Ast::Tags.strip_prefix(tag)}
+        @proc = proc
+      end
+
+      def matches_tag_names?(tag_names)
+        @tag_names.empty? || (@tag_names & tag_names).any?
+      end
+
+      def execute_in(world, scenario, location)
+        world.cucumber_instance_exec(false, location, scenario, &@proc)
+      end
+    end
+
     class << self
       def alias_adverb(adverb)
         adverb = adverb.gsub(/\s/, '')
@@ -97,18 +129,68 @@ module Cucumber
 
     # 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
+    def Before(*tag_names, &proc)
+      register_hook(:before, tag_names, proc)
     end
 
-    def After(&proc)
-      (@after_procs ||= []).unshift(proc)
+    def After(*tag_names, &proc)
+      register_hook(:after, tag_names, 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
+    def register_hook(phase, tags, proc)
+      hook = Hook.new(tags, proc)
+      hooks[phase] << hook
+      hook
+    end
+
+    def hooks
+      @hooks ||= Hash.new {|hash, phase| hash[phase] = []}
+    end
+
+    def hooks_for(phase, scenario)
+      hooks[phase].select{|hook| scenario.accept_hook?(hook)}
+    end
+
+    # Registers any number of +world_modules+ (Ruby Modules) and/or a Proc.
+    # The +proc+ will be executed once before each scenario to create an
+    # Object that the scenario's steps will run within. Any +world_modules+
+    # will be mixed into this Object (via Object#extend).
+    #
+    # This method is typically called from one or more Ruby scripts under 
+    # <tt>features/support</tt>. You can call this method as many times as you 
+    # like (to register more modules), but if you try to register more than 
+    # one Proc you will get an error.
+    #
+    # Cucumber will not yield anything to the +proc+ (like it used to do before v0.3).
+    #
+    # In earlier versions of Cucumber (before 0.3) you could not register
+    # any +world_modules+. Instead you would register several Proc objects (by 
+    # calling the method several times). The result of each +proc+ would be yielded 
+    # to the next +proc+. Example:
+    #
+    #   World do |world| # NOT SUPPORTED FROM 0.3
+    #     MyClass.new
+    #   end
+    #
+    #   World do |world| # NOT SUPPORTED FROM 0.3
+    #     world.extend(MyModule)
+    #   end
+    #
+    # From Cucumber 0.3 the recommended way to do this is:
+    #
+    #    World do
+    #      MyClass.new
+    #    end
+    #
+    #    World(MyModule)
+    #
+    def World(*world_modules, &proc)
+      if(proc)
+        raise MultipleWorld.new(@world_proc, proc) if @world_proc
+        @world_proc = proc
+      end
+      @world_modules ||= []
+      @world_modules += world_modules
     end
 
     def current_world
@@ -139,21 +221,27 @@ module Cucumber
       @step_definitions ||= []
     end
 
-    def snippet_text(step_keyword, step_name)
-      @snippet_generator.snippet_text(step_keyword, step_name)
+    def snippet_text(step_keyword, step_name, multiline_arg_class)
+      @snippet_generator.snippet_text(step_keyword, step_name, multiline_arg_class)
     end
 
     def before_and_after(scenario, skip=false)
-      unless current_world || skip
+      before(scenario) unless skip
+      yield
+      after(scenario) unless skip
+      scenario_visited(scenario)
+    end
+    
+    def before(scenario)
+      unless current_world
         new_world!
         execute_before(scenario)
       end
-      if block_given?
-        yield
-        execute_after(scenario) unless skip
-        nil_world!
-        scenario_visited(scenario)
-      end
+    end
+    
+    def after(scenario)
+      execute_after(scenario)
+      nil_world!
     end
 
     private
@@ -168,17 +256,46 @@ module Cucumber
 
     # Creates a new world instance
     def new_world!
-      @current_world = Object.new
-      (@world_procs ||= []).each do |proc|
-        @current_world = proc.call(@current_world)
+      create_world!
+      extend_world
+      connect_world
+      @current_world
+    end
+
+    def create_world!
+      if(@world_proc)
+        @current_world = @world_proc.call
+        check_nil(@current_world, @world_proc)
+      else
+        @current_world = Object.new
       end
+    end
 
+    def extend_world
       @current_world.extend(World)
+      @current_world.extend(::Spec::Matchers) if defined?(::Spec::Matchers)
+      (@world_modules || []).each do |mod|
+        @current_world.extend(mod)
+      end
+    end
+
+    def connect_world
       @current_world.__cucumber_step_mother = self
       @current_world.__cucumber_visitor = @visitor
+    end
 
-      @current_world.extend(::Spec::Matchers) if defined?(::Spec::Matchers)
-      @current_world
+    def check_nil(o, proc)
+      if o.nil?
+        begin
+          raise NilWorld.new
+        rescue NilWorld => e
+          e.backtrace.clear
+          e.backtrace.push(proc.backtrace_line("World"))
+          raise e
+        end
+      else
+        o
+      end
     end
 
     def nil_world!
@@ -186,14 +303,14 @@ module Cucumber
     end
 
     def execute_before(scenario)
-      (@before_procs ||= []).each do |proc|
-        @current_world.cucumber_instance_exec(false, 'Before', scenario, &proc)
+      hooks_for(:before, scenario).each do |hook|
+        hook.execute_in(@current_world, scenario, 'Before')
       end
     end
 
     def execute_after(scenario)
-      (@after_procs ||= []).each do |proc|
-        @current_world.cucumber_instance_exec(false, 'After', scenario, &proc)
+      hooks_for(:after, scenario).each do |hook|
+        hook.execute_in(@current_world, scenario, 'After')
       end
     end
 

data/lib/cucumber/version.rb

@@ -1,8 +1,8 @@
 module Cucumber #:nodoc:
   class VERSION #:nodoc:
     MAJOR = 0
-    MINOR = 2
-    TINY  = 3
+    MINOR = 3
+    TINY  = 0
     PATCH = nil # Set to nil for official release
 
     STRING = [MAJOR, MINOR, TINY, PATCH].compact.join('.')