aslakhellesoy-cucumber 0.1.4 → 0.1.5

data/lib/cucumber/languages.yml

@@ -1,31 +0,0 @@
-# http://en.wikipedia.org/wiki/IETF_language_tag
-# http://www.iana.org/assignments/language-subtag-registry
-# http://ftp.ics.uci.edu/pub/ietf/http/related/iso639.txt (Use this I think)
-"en":
-  scenario: Scenario
-  given_scenario: GivenScenario
-  given: Given
-  when: When
-  then: Then
-  and: And
-"no":
-  scenario: Scenario
-  given_scenario: GittScenario
-  given: Gitt
-  when: Når
-  then: Så
-  and: Og
-"fr":
-  scenario: Scenario
-  given_scenario: SoitScenario
-  given: Soit
-  when: Lorsque
-  then: Alors
-  and: Et
-"pt":
-  scenario: Escenario
-  given_scenario: DadoElEscenario
-  given: Dado
-  when: Cuando
-  then: Entonces
-  and: Y

data/lib/cucumber/rails/rspec.rb

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

data/lib/cucumber/rails/world.rb

@@ -1,71 +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 hvaing non-helpful responses returned.
-ActionController::Base.class_eval do
-  def perform_action
-    perform_action_without_rescue
-  end
-end
-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
-
-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 = true
-      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
-  end
-end
-
-World do
-  Cucumber::Rails::World.new
-end
-
-if defined?(ActiveRecord::Base)
-  Before do
-    if defined?(ActiveRecord::Base)
-      if ActiveRecord::Base.connection.respond_to?(:increment_open_transactions)
-        ActiveRecord::Base.connection.increment_open_transactions
-      else
-        ActiveRecord::Base.send :increment_open_transactions
-      end
-    end
-    ActiveRecord::Base.connection.begin_db_transaction
-    ActionMailer::Base.deliveries = [] if defined?(ActionMailer::Base)
-  end
-  
-  After do
-    if defined?(ActiveRecord::Base)
-      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

data/lib/cucumber/rake/task.rb

@@ -1,75 +0,0 @@
-module Cucumber
-  module Rake
-    # Defines a task for running features.
-    class Task
-      LIB    = File.expand_path(File.dirname(__FILE__) + '/../..')
-      BINARY = File.expand_path(File.dirname(__FILE__) + '/../../../bin/cucumber')
-
-      attr_accessor :libs
-      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")
-        @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?
-        define_tasks
-      end
-    
-      def define_tasks
-        desc @desc
-        task @task_name do
-          lib_args     = ['"%s"' % ([LIB] + libs).join(File::PATH_SEPARATOR)]
-          cucumber_bin = ['"%s"' % BINARY]
-          cuc_opts     = [(ENV['CUCUMBER_OPTS'] || cucumber_opts)]
-
-          step_files.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).flatten
-          else
-            args = (['-I'] + lib_args + cucumber_bin + cuc_opts + feature_files).flatten
-          end
-          ruby(args.join(" ")) # ruby(*args) is broken on Windows
-        end
-      end
-
-
-      def feature_files # :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 # :nodoc:
-        if ENV['STEPS']
-          FileList[ ENV['STEPS'] ]
-        else
-          result = []
-          result += step_list.to_a if step_list
-          result += FileList[step_pattern].to_a if step_pattern
-          FileList[result]
-        end
-      end
-    end
-  end
-end

data/lib/cucumber/step_methods.rb

@@ -1,41 +0,0 @@
-require 'cucumber/step_mother'
-
-module Cucumber
-  # Defines "global" methods that may be used in *_steps.rb files.
-  module StepMethods
-    # Each scenario will execute in the context of what the supplied block returns.
-    def World(&proc)
-      $executor.register_world_proc(&proc)
-    end
-
-    def Before(&proc)
-      $executor.register_before_proc(&proc)
-    end
-    
-    def After(&proc)
-      $executor.register_after_proc(&proc)
-    end
-
-    def Given(key, &proc)
-      step_mother.register_step_proc(key, &proc)
-    end
-
-    def When(key, &proc)
-      step_mother.register_step_proc(key, &proc)
-    end
-
-    def Then(key, &proc)
-      step_mother.register_step_proc(key, &proc)
-    end
-    
-    # Simple workaround for old skool steps
-    def steps_for(*_)
-      STDERR.puts "WARNING: In Cucumber the steps_for method is obsolete"
-      yield
-    end
-    
-    def step_mother #:nodoc:
-      @step_mother ||= StepMother.new
-    end
-  end
-end

data/lib/cucumber/step_mother.rb

@@ -1,38 +0,0 @@
-require 'cucumber/tree/top_down_visitor'
-require 'cucumber/core_ext/proc'
-
-module Cucumber
-  # A StepMother keeps track of step procs and assigns them
-  # to each step when visiting the tree.
-  class StepMother < Tree::TopDownVisitor
-    def initialize
-      @step_procs = {}
-    end
-
-    def register_step_proc(key, &proc)
-      regexp = case(key)
-      when String
-        Regexp.new("^#{key}$") # TODO: replace $variable with (.*)
-      when Regexp
-        key
-      else
-        raise "Step patterns must be Regexp or String, but was: #{key.inspect}"
-      end
-      proc.extend(CoreExt::CallIn)
-      proc.name = key.inspect
-      @step_procs[regexp] = proc
-    end
-    
-    def visit_step(step)
-      # Maybe we shouldn't attach the regexp etc to
-      # the step? Maybe steps pull them out as needed?
-      # Do we then have to attach ourself to the step instead?
-      # What would we gain from a pull design?
-      @step_procs.each do |regexp, proc|
-        if step.respond_to?(:name) && step.name =~ regexp
-          step.attach(regexp, proc, $~.captures)
-        end
-      end
-    end
-  end
-end

data/lib/cucumber/tree/feature.rb

@@ -1,45 +0,0 @@
-module Cucumber
-  module Tree
-    class Feature
-      attr_accessor :file
-      
-      def initialize(header, &proc)
-        @header = header
-        @scenarios = []
-        instance_eval(&proc) if block_given?
-      end
-
-      def add_scenario(name, &proc)
-        scenario = Scenario.new(self, name, &proc)
-        @scenarios << scenario
-        scenario
-      end
-      
-      def add_row_scenario(template_scenario, values, line)
-        scenario = RowScenario.new(self, template_scenario, values, line)
-        @scenarios << scenario
-        scenario
-      end
-
-      def Scenario(name, &proc)
-        add_scenario(name, &proc)
-      end
-      
-      def Table(matrix = [], &proc)
-        table = Table.new(matrix)
-        proc.call(table)
-        template_scenario = @scenarios.last
-        matrix[1..-1].each do |row|
-          @scenarios << RowScenario.new(self, template_scenario, row, row.line)
-        end
-      end
-
-      def accept(visitor)
-        visitor.visit_header(@header)
-        @scenarios.each do |scenario|
-          visitor.visit_scenario(scenario)
-        end
-      end
-    end
-  end
-end

data/lib/cucumber/tree/features.rb

@@ -1,21 +0,0 @@
-module Cucumber
-  module Tree
-    class Features
-      def initialize
-        @features = []
-      end
-      
-      def length
-        @features.length
-      end
-
-      def <<(feature)
-        @features << feature
-      end
-
-      def accept(visitor)
-        @features.each{|feature| visitor.visit_feature(feature)}
-      end
-    end
-  end
-end

data/lib/cucumber/tree/scenario.rb

@@ -1,85 +0,0 @@
-module Cucumber
-  module Tree
-    class BaseScenario
-      def file
-        @feature.file
-      end
-
-      def accept(visitor)
-        steps.each do |step|
-          visitor.visit_step(step)
-        end
-      end
-
-      def at_line?(l)
-        line == l || steps.map{|s| s.line}.index(l)
-      end
-      
-      def previous_step(step)
-        i = steps.index(step)
-        raise "Couldn't find #{step} among #{steps}" if i.nil?
-        steps[i-1]
-      end
-    end
-
-    class Scenario < BaseScenario
-      
-      # If a table follows, the header will be stored here. Weird, but convenient.
-      attr_accessor :table_header
-      
-      def initialize(feature, name, &proc)
-        @feature, @name = feature, name
-        @steps = []
-        instance_eval(&proc) if block_given?
-      end
-
-      def row?
-        false
-      end
-      
-      def add_step(keyword, name, line)
-        @steps << Step.new(self, keyword, name, line)
-      end
-
-      def Given(name)
-        add_step('Given', name, *caller[0].split(':')[1].to_i)
-      end
-
-      def When(name)
-        add_step('When', name, *caller[0].split(':')[1].to_i)
-      end
-
-      def Then(name)
-        add_step('Then', name, *caller[0].split(':')[1].to_i)
-      end
-
-      def And(name)
-        add_step('And', name, *caller[0].split(':')[1].to_i)
-      end
-
-      attr_reader :name, :steps, :line
-
-    end
-
-    class RowScenario < BaseScenario
-      attr_reader :line
-      
-      def initialize(feature, template_scenario, values, line)
-        @feature, @template_scenario, @values, @line = feature, template_scenario, values, line
-      end
-      
-      def row?
-        true
-      end
-
-      def steps
-        @steps ||= @template_scenario.steps.map do |template_step|
-          args = template_step.args.map do
-            @values.shift
-          end
-          RowStep.new(self, template_step.keyword, template_step.proc, args)
-        end
-      end
-    end
-  end
-end

data/lib/cucumber/tree/step.rb

@@ -1,141 +0,0 @@
-module Cucumber
-  module Tree
-    class BaseStep
-      def self.new_id!
-        @next_id ||= -1
-        @next_id += 1
-      end
-
-      attr_reader :error
-      attr_accessor :args
-
-      def file
-        @scenario.file
-      end
-
-      def regexp
-        @regexp || //
-      end
-
-      PENDING = lambda do |*_| 
-        raise Pending
-      end
-      PENDING.extend(CoreExt::CallIn)
-      PENDING.name = "PENDING"
-
-      def proc
-        @proc || PENDING
-      end
-
-      def attach(regexp, proc, args)
-        if @regexp
-          raise <<-EOM
-  "#{name}" matches several step definitions:
-
-  #{@proc.backtrace_line}
-  #{proc.backtrace_line}
-
-  Please give your steps unambiguous names
-          EOM
-        end
-        @regexp, @proc, @args = regexp, proc, args
-      end
-
-      if defined?(JRUBY_VERSION)
-        PENDING_ADJUSTMENT = 2
-        REGULAR_ADJUSTMENT = 1
-      else
-        PENDING_ADJUSTMENT = 3
-        REGULAR_ADJUSTMENT = 2
-      end
-
-      def execute_in(world)
-        strip_pos = nil
-        begin
-          proc.call_in(world, *@args)
-        rescue ArgCountError => e
-          e.backtrace[0] = @proc.backtrace_line
-          strip_pos = e.backtrace.index("#{__FILE__}:#{__LINE__ - 3}:in `execute_in'")
-          format_error(strip_pos, e)
-        rescue => e
-          method_line = "#{__FILE__}:#{__LINE__ - 6}:in `execute_in'"
-          method_line_pos = e.backtrace.index(method_line)
-          if method_line_pos
-            strip_pos = method_line_pos - (Pending === e ? PENDING_ADJUSTMENT : REGULAR_ADJUSTMENT) 
-          else
-            # This happens with rails, because they screw up the backtrace
-            # before we get here (injecting erb stactrace and such)
-          end
-          format_error(strip_pos, e)
-        end
-      end
-
-      def format_error(strip_pos, e)
-        @error = e
-        # Remove lines underneath the plain text step
-        e.backtrace[strip_pos..-1] = nil unless strip_pos.nil?
-        e.backtrace.flatten
-        # Replace the step line with something more readable
-        e.backtrace.replace(e.backtrace.map{|l| l.gsub(/`#{proc.meth}'/, "`#{keyword} #{proc.name}'")})
-        if row?
-          e.backtrace << "#{file}:#{line}:in `#{proc.name}'"
-        else
-          e.backtrace << "#{file}:#{line}:in `#{keyword} #{name}'"
-        end
-        raise e
-      end
-
-      def id
-        @id ||= self.class.new_id!
-      end
-      
-      def actual_keyword
-        keyword == Cucumber.language['and'] ? previous_step.actual_keyword : keyword
-      end
-      
-      def previous_step
-        @scenario.previous_step(self)
-      end
-    end
-    
-    class Step < BaseStep
-      attr_accessor :error
-
-      def row?
-        false
-      end
-
-      def initialize(scenario, keyword, name, line)
-        @scenario, @keyword, @name, @line = scenario, keyword, name, line
-        @args = []
-      end
-
-      def gzub(format=nil, &proc)
-        name.gzub(regexp, format, &proc)
-      end
-
-      attr_reader :keyword, :name, :line
-    end
-
-    class RowStep < BaseStep
-      attr_reader :keyword
-
-      def initialize(scenario, keyword, proc, args)
-        @scenario, @keyword, @proc, @args = scenario, keyword, proc, args
-      end
-
-      def gzub(format=nil, &proc)
-        raise "WWW"
-      end
-
-      def row?
-        true
-      end
-
-      def line
-        @scenario.line
-      end
-    end
-
-  end
-end

data/lib/cucumber/tree/table.rb

@@ -1,26 +0,0 @@
-module Cucumber
-  module Tree
-    class Table
-      def initialize(rows)
-        @rows = rows
-      end
-      
-      def |(cell)
-        @row ||= []
-        if cell == self
-          l = *caller[0].split(':')[1].to_i
-          @row.instance_eval %{
-            def line
-              #{l}
-            end
-          }
-          @rows << @row
-          @row = nil
-        else
-          @row << cell.to_s
-        end
-        self
-      end
-    end
-  end
-end

data/lib/cucumber/tree/top_down_visitor.rb

@@ -1,23 +0,0 @@
-module Cucumber
-  module Tree
-    class TopDownVisitor
-      def visit_features(features)
-        features.accept(self)
-      end
-
-      def visit_feature(feature)
-        feature.accept(self)
-      end
-
-      def visit_header(header)
-      end
-
-      def visit_scenario(scenario)
-        scenario.accept(self)
-      end
-
-      def visit_step(step)
-      end
-    end
-  end
-end

data/lib/cucumber/tree.rb

@@ -1,18 +0,0 @@
-%w{features feature scenario step table top_down_visitor}.each{|f| require "cucumber/tree/#{f}"}
-require 'cucumber/core_ext/proc'
-require 'cucumber/core_ext/string'
-
-module Cucumber
-  module Tree
-    def Feature(header, &proc)
-      feature = Feature.new("Feature: " + header, &proc)
-      feature.file, _, _ = *caller[0].split(':')
-      features << feature
-      feature
-    end
-
-    def features #:nodoc:
-      @features ||= Tree::Features.new
-    end
-  end
-end