kosmas58-cucumber 0.1.16.5

data/lib/cucumber/languages.yml

@@ -0,0 +1,286 @@
+# http://www.ietf.org/rfc/rfc4646.txt
+# http://www.ietf.org/rfc/rfc4647.txt
+# Others:
+# 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":
+  feature: Feature
+  scenario: Scenario
+  scenario_outline: Scenario Outline
+  examples: Examples
+  more_examples: More Examples
+  given_scenario: GivenScenario
+  given: Given
+  when: When
+  then: Then
+  and: And
+  but: But
+# Please help us keeping the languages below uptodate. The parsers for a language
+# that is missing a keyword will expect the English word until the missing word(s)
+# are added.
+#
+# Please keep the grammars in alphabetical order from here and down.
+
+# Arabic
+"ar":
+  feature: خاصية
+  scenario: سيناريو
+  more_examples: امثلة اكثر
+  given_scenario: بفرض سيناريو معين
+  given: بفرض
+  when: متى
+  then: اذاً
+  and: و
+  but: لكن
+# Welsh
+"cy":
+  feature: Arwedd
+  scenario: Scenario
+  more_examples: Hychwaneg enghreifftiau
+  given_scenario: Anrhegedig scenario
+  given: anrhegedig a
+  when: Pryd
+  then: Yna
+  and: A
+  but: Ond
+# Danish
+"da":
+  feature: Egenskab
+  scenario: Scenarie
+  given_scenario: GivetScenarie
+  given: Givet
+  when: Når
+  then: Så
+  and: Og
+  but: Men
+# German
+"de":
+  feature: Funktionalität
+  scenario: Szenario
+  scenario_outline: Szenariogrundriss
+  examples: Beispiele
+  more_examples: Mehr Beispiele
+  given_scenario: Gegebenes Szenario
+  given: Gegeben sei
+  when: Wenn
+  then: Dann
+  and: Und
+  but: Aber
+# LOLCAT
+"en-lol":
+  feature: OH HAI
+  scenario: MISHUN
+  more_examples: MOAR EXAMPLZ
+  given_scenario: SRSLY
+  given: GIVN
+  when: WEN
+  then: DEN
+  and: AN
+  but: BUT
+# Texan
+"en-tx":
+  feature: Feature
+  scenario: Scenario
+  more_examples: More Examples
+  given_scenario: GivenScenario
+  given: Given y'all
+  when: When y'all
+  then: Then y'all
+  and: And y'all
+  but: But y'all
+# Spanish
+"es":
+  feature: Característica
+  scenario: Escenario
+  more_examples: Más ejemplos
+  given_scenario: DadoElEscenario
+  given: Dado
+  when: Cuando
+  then: Entonces
+  and: Y
+  but: Pero
+# Estonian
+"et":
+  feature: Omadus
+  scenario: Stsenaarium
+  given_scenario: EeldadesStsenaariumit
+  given: Eeldades
+  when: Kui
+  then: Siis
+  and: Ja
+  but: Kuid
+# Finnish
+"fi":
+  feature: Ominaisuus
+  scenario: Tapaus
+  scenario_outline: Tapausaihio
+  examples: Tapaukset
+  more_examples: Lisätapaukset
+  given_scenario: Oletetaan tapaus
+  given: Oletetaan
+  when: Kun
+  then: Niin
+  and: Ja
+  but: Mutta
+# French
+"fr":
+  feature: Fonctionnalité
+  scenario: Scénario
+  more_examples: Plus d'exemples
+  given_scenario: Soit le Scénario
+  given: Etant donné
+  when: Lorsque
+  then: Alors
+  and: Et
+  but: Mais
+# Malay
+"id":
+  feature: Fitur
+  scenario: Skenario
+  more_examples: Contoh Tambahan
+  given_scenario: DenganSkenario
+  given: Dengan
+  when: Ketika
+  then: Maka
+  and: Dan
+  but: Tapi
+# Italian
+"it":
+  feature: Funzionalità
+  scenario: Scenario
+  more_examples: Più esempi
+  given_scenario: DatoLoScenario
+  given: Dato
+  when: Quando
+  then: Allora
+  and: E
+  but: Ma
+# Japanese
+"ja":
+  feature: フィーチャ
+  scenario: シナリオ
+  more_examples: 他のサンプル
+  given_scenario: 前提シナリオ
+  given: 前提
+  when: もし
+  then: ならば
+  and: かつ
+  but: しかし
+# Lithuanian
+"lt":
+  feature: Sąvybė
+  scenario: Scenarijus
+  more_examples: Daugiau pavyzdžių
+  given_scenario: DuotasScenarijus
+  given: Duota
+  when: Kai
+  then: Tada
+  and: Ir
+  but: Bet
+# Dutch
+"nl":
+  feature: Functionaliteit
+  scenario: Scenario
+  more_examples: Meer voorbeelden
+  given_scenario: GegevenScenario
+  given: Gegeven
+  when: Als
+  then: Dan
+  and: En
+  but: Maar
+# Norwegian
+"no":
+  feature: Egenskap
+  scenario: Scenario
+  more_examples: Flere eksempler
+  given_scenario: GittScenario
+  given: Gitt
+  when: Når
+  then: Så
+  and: Og
+  but: Men
+# Polish
+"pl":
+  feature: Właściwość
+  scenario: Scenariusz
+  more_examples: WięcejPrzykładów
+  given_scenario: DanyScenariusz
+  given: Dane
+  when: Jeżeli
+  then: Wtedy
+  and: Oraz
+  but: Ale
+# Portuguese
+"pt":
+  feature: Característica
+  scenario: Cenário
+  given_scenario: DadoOCenário
+  given: Dado
+  when: Quando
+  then: Então
+  and: E
+  but: Mas
+# Romanian (without diacritics - the commonly used)
+"ro":
+  feature: Functionalitate
+  scenario: Scenariu
+  more_examples: Mai multe exemple
+  given_scenario: ScenariuDat
+  given: Daca
+  when: Cand
+  then: Atunci
+  and: Si
+  but: Dar
+# Romanian (with diacritics - not commonly used)
+"ro2":
+  feature: Funcționalitate
+  scenario: Scenariu
+  more_examples: Mai multe exemple
+  given_scenario: ScenariuDat
+  given: Dacă
+  when: Când
+  then: Atunci
+  and: Și
+  but: Dar
+# Russian
+"ru":
+  feature: Функционал
+  scenario: Сценарий
+  given_scenario: ДанныйСценарий
+  given: Сначала
+  when: Если
+  then: То
+  and: И
+  but: Но
+# Swedish
+"se":
+  feature: Egenskap
+  scenario: Scenario
+  given_scenario: GivetScenario
+  given: Givet
+  when: När
+  then: Så
+  and: Och
+  but: Men
+# Chinese simplified
+"zh-CN":
+  feature: 功能
+  scenario: 场景
+  given_scenario: 引用场景
+  given: 假如
+  when: 当
+  then: 那么
+  and: 而且
+  but: 但是
+# Korean
+"ko":
+  feature: 기능
+  scenario: 예
+  more_examples: 다른 예
+  given_scenario: 주어진 예
+  given: 조건
+  when: 만일
+  then: 그러면
+  and: 그리고
+  but: 하지만

data/lib/cucumber/model/table.rb

@@ -0,0 +1,32 @@
+module Cucumber
+  module Model
+    class Table
+      attr_accessor :raw
+      
+      # Creates a new table. The +raw+ argument should be an array
+      # of arrays
+      def initialize(raw)
+        @raw = raw
+      end
+      
+      # Turn the table into an array of Hash where each Hash
+      # has keys corresponding to the table header (first line)
+      # and the values are the individual row cells.
+      def hashes
+        header = @raw[0]
+        rows.map do |row|
+          h = {}
+          row.each_with_index do |v,n|
+            key = header[n]
+            h[key] = v
+          end
+          h
+        end
+      end
+      
+      def rows
+        @raw[1..-1]
+      end
+    end
+  end
+end

data/lib/cucumber/model.rb

@@ -0,0 +1 @@
+%w{table}.each{|f| require "cucumber/model/#{f}"}

data/lib/cucumber/platform.rb

@@ -0,0 +1,32 @@
+# Detect the platform we're running on so we can tweak behaviour
+# in various places.
+require 'rbconfig'
+
+module Cucumber
+  LANGUAGE_FILE = File.expand_path(File.dirname(__FILE__) + '/languages.yml')
+  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/
+
+  class << self
+    attr_reader :language
+    
+    def load_language(lang)
+      @language = config[lang]
+    end
+    
+    def languages
+      config.keys.sort
+    end
+    
+    def config
+      require 'yaml'
+      @config ||= YAML.load_file(LANGUAGE_FILE)
+    end
+  end  
+end

data/lib/cucumber/rails/rspec.rb

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

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

@@ -0,0 +1,112 @@
+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
+      attr_accessor :language
+
+      # 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?
+        
+        if language
+          @feature_pattern = "features/#{language}/*.feature"
+          @step_pattern    = "features/#{language}/step_definitions/*.rb"
+        else
+          @feature_pattern = "features/**/*.feature" if feature_pattern.nil? && feature_list.nil?
+          @step_pattern    = "features/**/*.rb"      if step_pattern.nil? && step_list.nil?
+        end
+   
+        @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_methods.rb

@@ -0,0 +1,49 @@
+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_scenario_proc(&proc)
+    end
+    
+    def After(&proc)
+      executor.register_after_scenario_proc(&proc)
+    end
+
+    def AfterStep(&proc)
+      executor.register_after_step_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
+    
+    def executor
+      @executor ||= Executor.new(step_mother)
+    end
+  end
+end

data/lib/cucumber/step_mother.rb

@@ -0,0 +1,98 @@
+require 'cucumber/tree/top_down_visitor'
+
+module Cucumber
+  class Pending < StandardError
+  end
+
+  class ForcedPending < Pending
+  end
+
+  class Duplicate < StandardError
+  end
+
+  class Multiple < StandardError
+  end
+
+  class MissingProc < StandardError
+    def message
+      "Step definitions must always have a proc"
+    end
+  end
+
+  class StepMother
+    PENDING = lambda do |*_| 
+      raise Pending
+    end
+    require 'cucumber/core_ext/proc'
+    PENDING.extend(CoreExt::CallIn)
+    PENDING.name = "PENDING"
+
+    def initialize
+      @step_procs = Hash.new(PENDING)
+    end
+
+    def register_step_proc(key, &proc)
+      raise MissingProc if proc.nil?
+      regexp = case(key)
+      when String
+        # Replace the $foo and $bar style parameters
+        pattern = key.gsub(/\$\w+/, '(.*)')
+        Regexp.new("^#{pattern}$")
+      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
+
+      if @step_procs.has_key?(regexp)
+        first_proc = @step_procs[regexp]
+        message = %{Duplicate step definitions:
+
+#{first_proc.to_backtrace_line}
+#{proc.to_backtrace_line}
+
+}
+        raise Duplicate.new(message)
+      end
+
+      @step_procs[regexp] = proc
+    end
+
+    def regexp_args_proc(step_name)
+      candidates = @step_procs.map do |regexp, proc|
+        if step_name =~ regexp
+          [regexp, $~.captures, proc]
+        end
+      end.compact
+      
+      case(candidates.length)
+      when 0
+        [nil, [], PENDING]
+      when 1
+        candidates[0]
+      else
+        message = %{Multiple step definitions match #{step_name.inspect}:
+
+#{candidates.map{|regexp, args, proc| proc.to_backtrace_line}.join("\n")}
+
+}
+        raise Multiple.new(message)
+      end
+     end
+    
+    def proc_for(regexp)
+      @step_procs[regexp]
+    end
+    
+    def has_step_definition?(step_name)
+      _, _, proc = regexp_args_proc(step_name)
+      proc != PENDING
+    end
+    
+    # TODO - move execute here?
+    def execute(step)
+    end
+  end
+end