aslakhellesoy-cucumber 0.1.99.3 → 0.1.99.4

data/lib/cucumber/parser.rb

@@ -1,24 +0,0 @@
-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
-    def self.load_parser(keywords)
-      template = File.open(File.dirname(__FILE__) + "/parser/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
-  end
-end

data/lib/cucumber/platform.rb

@@ -1,18 +0,0 @@
-# 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

@@ -1,5 +0,0 @@
-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

@@ -1,73 +0,0 @@
-# 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

@@ -1,106 +0,0 @@
-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

@@ -1,87 +0,0 @@
-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

@@ -1,164 +0,0 @@
-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