stefl-cucumber 0.10.1

data/lib/cucumber/rake/task.rb

@@ -0,0 +1,170 @@
+require 'cucumber/platform'
+
+module Cucumber
+  module Rake
+    # Defines a Rake task for running features.
+    #
+    # The simplest use of it goes something like:
+    #
+    #   Cucumber::Rake::Task.new
+    #
+    # This will define a task named <tt>cucumber</tt> described as 'Run Cucumber features'. 
+    # 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 = %w{--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
+      class InProcessCucumberRunner #:nodoc:
+        attr_reader :args
+        
+        def initialize(libs, cucumber_opts, feature_files)
+          raise "libs must be an Array when running in-process" unless Array === libs
+          libs.reverse.each{|lib| $LOAD_PATH.unshift(lib)}
+          @args = (
+            cucumber_opts + 
+            feature_files
+          ).flatten.compact
+        end
+        
+        def run
+          require 'cucumber/cli/main'
+          failure = Cucumber::Cli::Main.execute(args)
+          raise "Cucumber failed" if failure
+        end
+      end
+      
+      class ForkedCucumberRunner #:nodoc:
+        attr_reader :args
+        
+        def initialize(libs, cucumber_bin, cucumber_opts, feature_files)
+          @args = (
+            ['-I'] + load_path(libs) + 
+            quoted_binary(cucumber_bin) + 
+            cucumber_opts + 
+            feature_files
+          ).flatten
+        end
+
+        def load_path(libs)
+          ['"%s"' % libs.join(File::PATH_SEPARATOR)]
+        end
+
+        def quoted_binary(cucumber_bin)
+          ['"%s"' % cucumber_bin]
+        end
+
+        def runner
+          File.exist?("./Gemfile") && Gem.available?("bundler") ? ["bundle", "exec", RUBY] : [RUBY]
+        end
+
+        def run
+          sh((runner + args).join(" "))
+        end
+      end
+
+      class RCovCucumberRunner < ForkedCucumberRunner #:nodoc:
+        def initialize(libs, cucumber_bin, cucumber_opts, feature_files, rcov_opts)
+          @args = (
+            ['-I'] + load_path(libs) + 
+            ['-S', 'rcov'] + rcov_opts +
+            quoted_binary(cucumber_bin) + 
+            ['--'] + 
+            cucumber_opts + 
+            feature_files
+          ).flatten
+        end
+      end
+
+      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
+
+      # Extra options to pass to the cucumber binary. Can be overridden by the CUCUMBER_OPTS environment variable.
+      # It's recommended to pass an Array, but if it's a String it will be #split by ' '.
+      attr_accessor :cucumber_opts
+      def cucumber_opts=(opts) #:nodoc:
+        @cucumber_opts = String === opts ? opts.split(' ') : opts
+      end
+
+      # Run cucumber with RCov? Defaults to false. If you set this to
+      # true, +fork+ is implicit.
+      attr_accessor :rcov
+
+      # Extra options to pass to rcov.
+      # It's recommended to pass an Array, but if it's a String it will be #split by ' '.
+      attr_accessor :rcov_opts
+      def rcov_opts=(opts) #:nodoc:
+        @rcov_opts = String === opts ? opts.split(' ') : opts
+      end
+
+      # Whether or not to fork a new ruby interpreter. Defaults to true. You may gain
+      # some startup speed if you set it to false, but this may also cause issues with
+      # your load path and gems.
+      attr_accessor :fork
+
+      # 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.
+      attr_accessor :profile
+
+      # Define Cucumber Rake task
+      def initialize(task_name = "cucumber", desc = "Run Cucumber features")
+        @task_name, @desc = task_name, desc
+        @fork = true
+        @libs = ['lib']
+        @rcov_opts = %w{--rails --exclude osx\/objc,gems\/}
+
+        yield self if block_given?
+
+        @binary = binary.nil? ? Cucumber::BINARY : File.expand_path(binary)
+        @libs.insert(0, LIB) if binary == Cucumber::BINARY
+
+        define_task
+      end
+
+      def define_task #:nodoc:
+        desc @desc
+        task @task_name do
+          runner.run
+        end
+      end
+
+      def runner(task_args = nil) #:nodoc:
+        cucumber_opts = [(ENV['CUCUMBER_OPTS'] ? ENV['CUCUMBER_OPTS'].split(/\s+/) : nil) || cucumber_opts_with_profile]
+        if(@rcov)
+          RCovCucumberRunner.new(libs, binary, cucumber_opts, feature_files, rcov_opts)
+        elsif(@fork)
+          ForkedCucumberRunner.new(libs, binary, cucumber_opts, feature_files)
+        else
+          InProcessCucumberRunner.new(libs, cucumber_opts, feature_files)
+        end
+      end
+
+      def cucumber_opts_with_profile #:nodoc:
+        @profile ? [cucumber_opts, '--profile', @profile] : cucumber_opts
+      end
+
+      def feature_files #:nodoc:
+        make_command_line_safe(FileList[ ENV['FEATURE'] || [] ])
+      end
+
+      def make_command_line_safe(list)
+        list.map{|string| string.gsub(' ', '\ ')}
+      end
+    end
+  end
+end

data/lib/cucumber/rb_support/rb_dsl.rb

@@ -0,0 +1,112 @@
+module Cucumber
+  module RbSupport
+    # This module defines the methods you can use to define pure Ruby
+    # Step Definitions and Hooks. This module is mixed into the toplevel
+    # object.
+    module RbDsl
+      class << self
+        attr_writer :rb_language
+        
+        def alias_adverb(adverb)
+          alias_method adverb, :register_rb_step_definition
+        end
+
+        def build_rb_world_factory(world_modules, proc)
+          @rb_language.build_rb_world_factory(world_modules, proc)
+        end
+
+        def register_rb_hook(phase, tag_names, proc)
+          @rb_language.register_rb_hook(phase, tag_names, proc)
+        end
+
+        def register_rb_transform(regexp, proc)
+          @rb_language.register_rb_transform(regexp, proc)          
+        end
+
+        def register_rb_step_definition(regexp, proc)
+          @rb_language.register_rb_step_definition(regexp, proc)
+        end
+      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+. Examples:
+      #
+      #    World do
+      #      MyClass.new
+      #    end
+      #
+      #    World(MyModule)
+      #
+      def World(*world_modules, &proc)
+        RbDsl.build_rb_world_factory(world_modules, proc)
+      end
+
+      # Registers a proc that will run before each Scenario. You can register as many
+      # as you want (typically from ruby scripts under <tt>support/hooks.rb</tt>).
+      def Before(*tag_expressions, &proc)
+        RbDsl.register_rb_hook('before', tag_expressions, proc)
+      end
+
+      # Registers a proc that will run after each Scenario. You can register as many
+      # as you want (typically from ruby scripts under <tt>support/hooks.rb</tt>).
+      def After(*tag_expressions, &proc)
+        RbDsl.register_rb_hook('after', tag_expressions, proc)
+      end
+
+      # Registers a proc that will be wrapped around each scenario. The proc
+      # should accept two arguments: two arguments: the scenario and a "block"
+      # argument (but passed as a regular argument, since blocks cannot accept
+      # blocks in 1.8), on which it should call the .call method. You can register
+      # as many  as you want (typically from ruby scripts under <tt>support/hooks.rb</tt>).
+      def Around(*tag_expressions, &proc)
+        RbDsl.register_rb_hook('around', tag_expressions, proc)
+      end
+
+      # Registers a proc that will run after each Step. You can register as 
+      # as you want (typically from ruby scripts under <tt>support/hooks.rb</tt>).
+      def AfterStep(*tag_expressions, &proc)
+        RbDsl.register_rb_hook('after_step', tag_expressions, proc)
+      end
+
+      # Registers a proc that will be called with a step definition argument if it 
+      # matches the pattern passed as the first argument to Transform. Alternatively, if
+      # the pattern contains captures then they will be yielded as arguments to the
+      # provided proc. The return value of the proc is consequently yielded to the
+      # step definition.
+      def Transform(regexp, &proc)
+        RbDsl.register_rb_transform(regexp, proc)
+      end
+      
+      # Registers a proc that will run after Cucumber is configured. You can register as 
+      # as you want (typically from ruby scripts under <tt>support/hooks.rb</tt>).
+      # TODO: Deprecate this
+      def AfterConfiguration(&proc)
+        RbDsl.register_rb_hook('after_configuration', [], proc)
+      end      
+
+      # Registers a new Ruby StepDefinition. This method is aliased
+      # to <tt>Given</tt>, <tt>When</tt> and <tt>Then</tt>, and
+      # also to the i18n translations whenever a feature of a
+      # new language is loaded.
+      #
+      # 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_rb_step_definition(regexp, &proc)
+        RbDsl.register_rb_step_definition(regexp, proc)
+      end
+    end
+  end
+end
+
+extend(Cucumber::RbSupport::RbDsl)

data/lib/cucumber/rb_support/rb_hook.rb

@@ -0,0 +1,18 @@
+module Cucumber
+  module RbSupport
+    # Wrapper for Before, After and AfterStep hooks
+    class RbHook
+      attr_reader :tag_expressions
+
+      def initialize(rb_language, tag_expressions, proc)
+        @rb_language = rb_language
+        @tag_expressions = tag_expressions
+        @proc = proc
+      end
+
+      def invoke(location, argument, &block)
+        @rb_language.current_world.cucumber_instance_exec(false, location, *[argument, block].compact, &@proc)
+      end
+    end
+  end
+end

data/lib/cucumber/rb_support/rb_language.rb

@@ -0,0 +1,195 @@
+require 'cucumber/core_ext/instance_exec'
+require 'cucumber/rb_support/rb_dsl'
+require 'cucumber/rb_support/rb_world'
+require 'cucumber/rb_support/rb_step_definition'
+require 'cucumber/rb_support/rb_hook'
+require 'cucumber/rb_support/rb_transform'
+
+module Cucumber
+  module RbSupport
+    # Raised if a World block returns Nil.
+    class NilWorld < StandardError
+      def initialize
+        super("World procs should never return nil")
+      end
+    end
+
+    # Raised if there are 2 or more World blocks.
+    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 Cucumber::RbSupport::RbDsl#World RDoc\n"
+        message << "or http://wiki.github.com/aslakhellesoy/cucumber/a-whole-new-world.\n\n"
+        super(message)
+      end
+    end
+
+    # The Ruby implementation of the programming language API.
+    class RbLanguage
+      include LanguageSupport::LanguageMethods
+      attr_reader :current_world,
+                  :step_definitions
+
+      Gherkin::I18n.code_keywords.each do |adverb|
+        RbDsl.alias_adverb(adverb)
+        RbWorld.alias_adverb(adverb)
+      end
+
+      def initialize(step_mother)
+        @step_mother = step_mother
+        @step_definitions = []
+        RbDsl.rb_language = self
+        @world_proc = @world_modules = nil
+        enable_rspec_expectations_if_available
+      end
+
+      def enable_rspec_expectations_if_available
+        begin
+          # RSpec >=2.0
+          require 'rspec/expectations'
+          @rspec_matchers = ::RSpec::Matchers
+        rescue LoadError => try_rspec_1_2_4_or_higher
+          begin
+            require 'spec/expectations'
+            require 'spec/runner/differs/default'
+            require 'ostruct'
+            options = OpenStruct.new(:diff_format => :unified, :context_lines => 3)
+            Spec::Expectations.differ = Spec::Expectations::Differs::Default.new(options)
+            @rspec_matchers = ::Spec::Matchers
+          rescue LoadError => give_up
+            @rspec_matchers = Module.new{}
+          end
+        end
+      end
+
+      # Gets called for each file under features (or whatever is overridden
+      # with --require).
+      def step_definitions_for(rb_file) # Looks Unused - Delete?
+        begin
+          require rb_file # This will cause self.add_step_definition and self.add_hook to be called from RbDsl
+          step_definitions
+        rescue LoadError => e
+          e.message << "\nFailed to load #{code_file}"
+          raise e
+        ensure
+          @step_definitions = nil
+        end
+      end
+      
+      def step_matches(name_to_match, name_to_format)
+        @step_definitions.map do |step_definition|
+          if(arguments = step_definition.arguments_from(name_to_match))
+            StepMatch.new(step_definition, name_to_match, name_to_format, arguments)
+          else
+            nil
+          end
+        end.compact
+      end
+
+      ARGUMENT_PATTERNS = ['"([^"]*)"', '(\d+)']
+
+      def snippet_text(code_keyword, step_name, multiline_arg_class)
+        snippet_pattern = Regexp.escape(step_name).gsub('\ ', ' ').gsub('/', '\/')
+        arg_count = 0
+        ARGUMENT_PATTERNS.each do |pattern|
+          snippet_pattern = snippet_pattern.gsub(Regexp.new(pattern), pattern)
+          arg_count += snippet_pattern.scan(pattern).length
+        end
+
+        block_args = (0...arg_count).map {|n| "arg#{n+1}"}
+        block_args << multiline_arg_class.default_arg_name unless multiline_arg_class.nil?
+        block_arg_string = block_args.empty? ? "" : " |#{block_args.join(", ")}|"
+        multiline_class_comment = ""
+        if(multiline_arg_class == Ast::Table)
+          multiline_class_comment = "# #{multiline_arg_class.default_arg_name} is a #{multiline_arg_class.to_s}\n  "
+        end
+
+        "#{code_keyword} /^#{snippet_pattern}$/ do#{block_arg_string}\n  #{multiline_class_comment}pending # express the regexp above with the code you wish you had\nend"
+      end
+
+      def begin_rb_scenario(scenario)
+        create_world
+        extend_world
+        connect_world(scenario)
+      end
+
+      def register_rb_hook(phase, tag_expressions, proc)
+        add_hook(phase, RbHook.new(self, tag_expressions, proc))
+      end
+
+      def register_rb_transform(regexp, proc)
+        add_transform(RbTransform.new(self, regexp, proc))
+      end
+
+      def register_rb_step_definition(regexp, proc)
+        step_definition = RbStepDefinition.new(self, regexp, proc)
+        @step_definitions << step_definition
+        step_definition
+      end
+
+      def build_rb_world_factory(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 load_code_file(code_file)
+        load File.expand_path(code_file) # This will cause self.add_step_definition, self.add_hook, and self.add_transform to be called from RbDsl
+      end
+      
+      protected
+
+      def begin_scenario(scenario)
+        begin_rb_scenario(scenario)
+      end
+      
+      def end_scenario
+        @current_world = nil
+      end
+
+      private
+
+      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(RbWorld)
+        @current_world.extend(@rspec_matchers)
+        (@world_modules || []).each do |mod|
+          @current_world.extend(mod)
+        end
+      end
+
+      def connect_world(scenario)
+        @current_world.__cucumber_step_mother = @step_mother
+        @current_world.__natural_language = scenario.language
+      end
+
+      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
+    end
+  end
+end