squirrel-cucumber 0.3.12

data/lib/cucumber/parser/table.tt

@@ -0,0 +1,71 @@
+module Cucumber
+  module Parser
+    # TIP: When you hack on the grammar, just delete feature.rb in this directory.
+    # Also make sure you have uninstalled all cucumber gems (don't forget xxx-cucumber
+    # github gems).
+    #
+    # Treetop will then generate the parser in-memory. When you're happy, just generate
+    # the rb file with tt feature.tt
+    grammar Table
+
+      rule table
+        table_row+ {
+          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(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
+              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,52 @@
+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
+    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
+    
+    module TreetopExt
+      def parse_or_fail(source, file=nil, filter=nil, line_offset=0)
+        parse_tree = parse(source)
+        if parse_tree.nil?
+          raise Cucumber::Parser::SyntaxError.new(self, file, line_offset)
+        else
+          ast = parse_tree.build(filter) # may return nil if it doesn't match filter.
+          ast.file = file unless ast.nil?
+          ast
+        end
+      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/platform.rb

@@ -0,0 +1,23 @@
+# Detect the platform we're running on so we can tweak behaviour
+# in various places.
+require 'rbconfig'
+require 'yaml'
+
+module Cucumber
+  # TODO: Move these constants and the file to Language. Update wiki
+  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')
+  LIBDIR        = File.expand_path(File.dirname(__FILE__) + '/../../lib')
+  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/
+  
+  def self.file_mode(m)
+    RUBY_1_9 ? "#{m}:UTF-8" : m
+  end
+end

data/lib/cucumber/rails/rspec.rb

@@ -0,0 +1,10 @@
+require 'cucumber/rails/world'
+require 'spec/expectations'
+require 'spec/rails/matchers'
+
+[Cucumber::Rails::World, ActionController::Integration::Session].each do |klass|
+  klass.class_eval do
+    include Spec::Matchers
+    include Spec::Rails::Matchers
+  end
+end

data/lib/cucumber/rails/world.rb

@@ -0,0 +1,99 @@
+# 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
+
+begin
+  require 'test/unit/testresult'
+rescue LoadError => e
+  e.message << "\nYou must gem install test-unit. For more info see https://rspec.lighthouseapp.com/projects/16211/tickets/292"
+  e.message << "\nAlso make sure you have rack 1.0.0 or higher."
+  raise e
+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
+
+      unless ::Rails.configuration.cache_classes
+        warn "WARNING: You have set Rails' config.cache_classes to false (most likely in config/environments/test.rb).  This setting is known to break Cucumber's use_transactional_fixtures method. Set config.cache_classes to true if you want to use transactional fixtures.  For more information see https://rspec.lighthouseapp.com/projects/16211/tickets/165."
+      end
+
+      World.use_transactional_fixtures = true
+      if defined?(ActiveRecord::Base)
+        $__cucumber_toplevel.Before do
+          @__cucumber_ar_connection = ActiveRecord::Base.connection
+          if @__cucumber_ar_connection.respond_to?(:increment_open_transactions)
+            @__cucumber_ar_connection.increment_open_transactions
+          else
+            ActiveRecord::Base.__send__(:increment_open_transactions)
+          end
+          @__cucumber_ar_connection.begin_db_transaction
+          ActionMailer::Base.deliveries = [] if defined?(ActionMailer::Base)
+        end
+        
+        $__cucumber_toplevel.After do
+          @__cucumber_ar_connection.rollback_db_transaction
+          if @__cucumber_ar_connection.respond_to?(:decrement_open_transactions)
+            @__cucumber_ar_connection.decrement_open_transactions
+          else
+            ActiveRecord::Base.__send__(:decrement_open_transactions)
+          end
+        end
+      end
+    end
+
+    def self.bypass_rescue
+      ActionController::Base.class_eval do
+        alias_method :rescue_action_without_bypass, :rescue_action
+
+        def rescue_action(exception)
+          raise exception
+        end
+      end
+
+      begin
+        ActionController::Failsafe.class_eval do
+          alias_method :failsafe_response_without_bypass, :failsafe_response
+        
+          def failsafe_response(exception)
+            raise exception
+          end
+        end
+      rescue NameError # Failsafe was introduced in Rails 2.3.2
+        ActionController::Dispatcher.class_eval do
+          def self.failsafe_response(output, status, exception = nil)
+            raise exception
+          end
+        end
+      end
+    end
+  end
+end
+
+World do
+  Cucumber::Rails::World.new
+end

data/lib/cucumber/rake/task.rb

@@ -0,0 +1,233 @@
+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 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 = %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 run
+          ruby(args.join(" ")) # ruby(*args) is broken on Windows
+        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:
+
+      # 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("\nWARNING: 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\n")
+          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
+      deprecate_accessor :step_list
+
+      # File pattern for finding step definitions. Defaults to 
+      # 'features/**/*.rb'.
+      deprecate_accessor :step_pattern
+
+      # Array of paths to specific features to run. 
+      deprecate_accessor :feature_list
+
+      # File pattern for finding features to run. Defaults to 
+      # '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.
+      # 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.
+      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
+      def profile=(profile) #:nodoc:
+        @profile = profile
+        unless feature_list
+          # TODO: remove once we completely remove these from the rake task.
+          @step_list = []
+          @feature_list = [] # Don't use accessor to avoid deprecation warning.
+        end
+      end
+
+      # Define Cucumber Rake task
+      def initialize(task_name = "features", desc = "Run Features with Cucumber")
+        @task_name, @desc = task_name, desc
+        @fork = true
+        @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 = 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(task_args), rcov_opts)
+        elsif(@fork)
+          ForkedCucumberRunner.new(libs, binary, cucumber_opts, feature_files(task_args))
+        else
+          InProcessCucumberRunner.new(libs, cucumber_opts, feature_files(task_args))
+        end
+      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'] ]
+        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 # :nodoc:
+        desc @desc
+        task @task_name, :feature_name do |t, args|
+          runner(args).run
+        end
+      end
+
+      def feature_files(task_arguments) # :nodoc:
+        FileList[File.join("features", "**", "#{task_arguments[:feature_name]}.feature")]
+      end
+
+    end
+
+  end
+end