kosmas58-cucumber 0.1.99.21 → 0.1.99.22

data/lib/cucumber/parser/treetop_ext.rb

@@ -1,75 +0,0 @@
-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
-    module TreetopExt
-      FILE_LINE_PATTERN = /^([\w\W]*?):([\d:]+)$/
-
-      # Parses a file and returns a Cucumber::Ast
-      def parse_file(file)
-        _, path, lines = *FILE_LINE_PATTERN.match(file)
-        if path
-          lines = lines.split(':').map { |line| line.to_i }
-        else
-          path = file
-          lines = []
-        end
-
-        loader = lambda { |io| parse_or_fail(io.read, path) }
-        feature = if path =~ /^http/
-          require 'open-uri'
-          open(path, &loader)
-        else
-          File.open(path, Cucumber.file_mode('r'), &loader) 
-        end
-        feature.lines = lines
-        feature
-      end
-    end
-
-    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
-  end
-end
-
-module Treetop
-  module Runtime
-    class SyntaxNode
-      def line
-        input.line_of(interval.first)
-      end
-    end
-    
-    class CompiledParser
-      include Cucumber::Parser::TreetopExt
-      
-      def parse_or_fail(s, file=nil, line=0)
-        parse_tree = parse(s)
-        if parse_tree.nil?
-          raise Cucumber::Parser::SyntaxError.new(self, file, line)
-        else
-          ast = parse_tree.build
-          ast.file = file
-          ast
-        end
-      end
-    end
-  end
-end

data/lib/cucumber/parser.rb

@@ -1,43 +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
-    translator = Module.new do
-      def keywordz(key)
-        'Scenario'
-      end
-    end
-
-    def self.load_parser(keywords)
-      Loader.new(keywords)
-    end
-    
-    class Loader
-      def initialize(keywords)
-        @keywords = keywords
-        i18n_tt = File.expand_path(File.dirname(__FILE__) + '/parser/i18n.tt')
-        template = File.open(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
-
-      def keywords(key)
-        values = @keywords[key].split('|')
-        values.map{|value| "'#{value}'"}.join(" / ")
-      end
-    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,8 +0,0 @@
-require 'cucumber/rails/world'
-require 'spec/expectations'
-require 'spec/rails/matchers'
-
-Cucumber::Rails::World.class_eval do
-  include Spec::Matchers
-  include Spec::Rails::Matchers
-end

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,111 +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
-      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_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,183 +0,0 @@
-require 'cucumber/step_definition'
-require 'cucumber/core_ext/instance_exec'
-
-module Cucumber
-  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
-
-  # 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
-    attr_writer :options
-    
-    # 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, prior_world = nil, &proc)
-      world = prior_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?
-      found = best_matches(step_name, found) if found.size > 1 && options[:guess]
-      raise Ambiguous.new(step_name, found) if found.size > 1
-      found[0]
-    end
-
-    def best_matches(step_name, step_definitions)
-      top_group_score = step_definitions.map {|s| s.match(step_name).captures.length }.sort.last
-      top_groups = step_definitions.select {|s| s.match(step_name).captures.length == top_group_score }
-      if top_groups.size > 1
-        shortest_capture_length = top_groups.map {|s| s.match(step_name).captures.inject(0) {|sum, c| sum + c.length } }.sort.first
-        top_groups.select {|s| s.match(step_name).captures.inject(0) {|sum, c| sum + c.length } == shortest_capture_length }
-      else
-        top_groups
-      end
-    end
-    
-    def step_definitions
-      @step_definitions ||= []
-    end
-
-    def snippet_text(step_keyword, step_name)
-      @snippet_generator.snippet_text(step_keyword, step_name)
-    end
-
-    private
-    
-    def options
-      @options || {}
-    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

data/lib/cucumber/version.rb

@@ -1,10 +0,0 @@
-module Cucumber #:nodoc:
-  class VERSION #:nodoc:
-    MAJOR = 0
-    MINOR = 1
-    TINY  = 99
-    PATCH = 21 # Set to nil for official release
-
-    STRING = [MAJOR, MINOR, TINY, PATCH].compact.join('.')
-  end
-end

data/lib/cucumber.rb

@@ -1,71 +0,0 @@
-$:.unshift(File.dirname(__FILE__)) unless
-  $:.include?(File.dirname(__FILE__)) || $:.include?(File.expand_path(File.dirname(__FILE__)))
-
-require 'yaml'
-require 'cucumber/platform'
-require 'cucumber/parser'
-require 'cucumber/version'
-require 'cucumber/step_mother'
-require 'cucumber/cli/main'
-require 'cucumber/broadcaster'
-require 'cucumber/core_ext/exception'
-
-module Cucumber
-  KEYWORD_KEYS = %w{name native encoding feature background scenario scenario_outline examples given when then but}
-  
-  class << self
-    attr_reader :lang
-    
-    def load_language(lang) #:nodoc:
-      return if @lang
-      @lang = lang
-      alias_step_definitions(lang)
-      Parser.load_parser(keyword_hash)
-    end
-
-    def language_incomplete?(lang=@lang)
-      KEYWORD_KEYS.detect{|key| keyword_hash(lang)[key].nil?}
-    end
-
-    # File mode that accounts for Ruby platform and current language
-    def file_mode(m)
-      Cucumber::RUBY_1_9 ? "#{m}:#{keyword_hash['encoding']}" : m
-    end
-
-    # Returns a Hash of the currently active
-    # language, or for a specific language if +lang+ is
-    # specified.
-    def keyword_hash(lang=@lang)
-      LANGUAGES[lang]
-    end
-    
-    def alias_step_definitions(lang) #:nodoc:
-      keywords = %w{given when then and but}.map{|keyword| keyword_hash(lang)[keyword]}
-      alias_steps(keywords)
-    end
-    
-    # Sets up additional aliases for Given, When and Then.
-    # Try adding the following to your <tt>support/env.rb</tt>:
-    #
-    #   # Given When Then in Norwegian
-    #   Cucumber.alias_steps %w{Gitt Naar Saa}
-    #
-    # You cannot use special characters here, because methods
-    # with special characters is not valid Ruby code
-    #
-    def alias_steps(keywords)
-      keywords.each do |adverb|
-        StepMother.class_eval do
-          alias_method adverb, :register_step_definition
-        end
-
-        StepMother::WorldMethods.class_eval do
-          alias_method adverb, :__cucumber_invoke
-        end
-      end
-    end
-  end  
-
-  # Make sure we always have English aliases
-  alias_step_definitions('en')
-end

data/rails_generators/cucumber/USAGE

@@ -1,14 +0,0 @@
-Description:
-    Sets up Cucumber in your Rails project. After running this generator you will
-    get a new rake task called features.
-    
-    This also generates the necessary files in the features directory.
-    
-    Also see the feature generator, which you can use to generate skeletons
-    for new features.
-    
-    If you set the language option, then a subdirectory features/[language] will be generated instead. 
-    Now your are able to use features in different languages.
-    
-Examples:
-    `./script/generate cucumber`