dwaite-cucumber 0.3.101

data/lib/cucumber/rb_support/rb_world.rb

@@ -0,0 +1,93 @@
+module Cucumber
+  module RbSupport
+    # All steps are run in the context of an object that extends this module.
+    module RbWorld
+      class << self
+        def alias_adverb(adverb)
+          alias_method adverb, :__cucumber_invoke
+        end
+      end
+    
+      attr_writer :__cucumber_step_mother
+
+      # Call a step from within a step definition. This method is aliased to
+      # the same i18n as RbDsl.
+      def __cucumber_invoke(name, multiline_argument=nil) #:nodoc:
+        begin
+          step_match = @__cucumber_step_mother.step_match(name)
+          step_match.invoke(multiline_argument)
+        rescue Exception => e
+          e.nested! if Undefined === e
+          raise e
+        end
+      end
+
+      # Returns a Cucumber::Ast::Table for +text_or_table+, which can either
+      # be a String:
+      #
+      #   table(%{
+      #     | account | description | amount |
+      #     | INT-100 | Taxi        | 114    |
+      #     | CUC-101 | Peeler      | 22     |
+      #   })
+      #
+      # or a 2D Array:
+      #
+      #   table([
+      #     %w{ account description amount },
+      #     %w{ INT-100 Taxi        114    },
+      #     %w{ CUC-101 Peeler      22     }
+      #   ])
+      #
+      def table(text_or_table, file=nil, line_offset=0)
+        if Array === text_or_table
+          Ast::Table.new(text_or_table)
+        else
+          @table_parser ||= Parser::TableParser.new
+          @table_parser.parse_or_fail(text_or_table.strip, file, line_offset)
+        end
+      end
+
+      # Output +announcement+ alongside the formatted output.
+      # This is an alternative to using Kernel#puts - it will display
+      # nicer, and in all outputs (in case you use several formatters)
+      #
+      # Beware that the output will be printed *before* the corresponding
+      # step. This is because the step itself will not be printed until
+      # after it has run, so it can be coloured according to its status.
+      def announce(announcement)
+        @__cucumber_step_mother.announce(announcement)
+      end
+
+      # Mark the matched step as pending.
+      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
+
+      # The default implementation of Object#inspect recursively
+      # traverses all instance variables and invokes inspect. 
+      # This can be time consuming if the object graph is large.
+      #
+      # This can cause unnecessary delays when certain exceptions 
+      # occur. For example, MRI internally invokes #inspect on an 
+      # object that raises a NoMethodError. (JRuby does not do this).
+      #
+      # A World object can have many references created by the user
+      # or frameworks (Rails), so to avoid long waiting times on
+      # such errors in World we define it to just return a simple String.
+      #
+      def inspect #:nodoc:
+        sprintf("#<%s:0x%x>", self.class, self.object_id)
+      end
+    end
+  end
+end

data/lib/cucumber/rspec_neuter.rb

@@ -0,0 +1,23 @@
+require 'optparse'
+
+module Spec #:nodoc:
+  module Runner #:nodoc:
+    # Neuters RSpec's option parser.
+    # (RSpec's option parser tries to parse ARGV, which
+    # will fail when running cucumber)
+    class OptionParser < ::OptionParser #:nodoc:
+      NEUTERED_RSPEC = Object.new
+      def NEUTERED_RSPEC.method_missing(m, *args); self; end
+      
+      def self.method_added(m)
+        unless @__neutering_rspec
+          @__neutering_rspec = true
+          define_method(m) do |*a|
+            NEUTERED_RSPEC
+          end
+          @__neutering_rspec = false
+        end
+      end
+    end
+  end
+end

data/lib/cucumber/step_match.rb

@@ -0,0 +1,61 @@
+module Cucumber
+  class StepMatch #:nodoc:
+    attr_reader :step_definition, :args
+
+    def initialize(step_definition, step_name, formatted_step_name, args)
+      @step_definition, @step_name, @formatted_step_name, @args = step_definition, step_name, formatted_step_name, args
+    end
+
+    def name
+      @formatted_step_name
+    end
+
+    def invoke(multiline_arg)
+      all_args = @args.dup
+      all_args << multiline_arg if multiline_arg
+      @step_definition.invoke(all_args)
+    end
+
+    def format_args(format = lambda{|a| a})
+      @formatted_step_name || @step_definition.format_args(@step_name, format)
+    end
+    
+    def file_colon_line
+      @step_definition.file_colon_line
+    end
+
+    def backtrace_line
+      @step_definition.backtrace_line
+    end
+
+    def text_length
+      @step_definition.text_length
+    end
+  end
+  
+  class NoStepMatch #:nodoc:
+    attr_reader :step_definition, :name
+
+    def initialize(step, name)
+      @step = step
+      @name = name
+    end
+    
+    def format_args(format)
+      @name
+    end
+
+    def file_colon_line
+      raise "No file:line for #{@step}" unless @step.file_colon_line
+      @step.file_colon_line
+    end
+
+    def backtrace_line
+      @step.backtrace_line
+    end
+
+    def text_length
+      @step.text_length
+    end
+  end
+end

data/lib/cucumber/step_mother.rb

@@ -0,0 +1,307 @@
+require 'cucumber/constantize'
+require 'cucumber/core_ext/instance_exec'
+require 'cucumber/parser/natural_language'
+require 'cucumber/language_support/language_methods'
+require 'cucumber/language_support/step_definition_methods'
+
+module Cucumber
+  # Raised when there is no matching StepDefinition for a step.
+  class Undefined < StandardError
+    attr_reader :step_name
+
+    def initialize(step_name)
+      super %{Undefined step: "#{step_name}"}
+      @step_name = step_name
+    end
+    
+    def nested!
+      @nested = true
+    end
+
+    def nested?
+      @nested
+    end
+  end
+
+  # Raised when a StepDefinition's block invokes World#pending
+  class Pending < StandardError
+  end
+
+  # Raised when a step matches 2 or more StepDefinitions
+  class Ambiguous < StandardError
+    def initialize(step_name, step_definitions, used_guess)
+      message = "Ambiguous match of \"#{step_name}\":\n\n"
+      message << step_definitions.map{|sd| sd.backtrace_line}.join("\n")
+      message << "\n\n"
+      message << "You can run again with --guess to make Cucumber be more smart about it\n" unless used_guess
+      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.backtrace_line << "\n"
+      message << step_def_2.backtrace_line << "\n\n"
+      super(message)
+    end
+  end
+
+  # This is the meaty part of Cucumber that ties everything together.
+  class StepMother
+    include Constantize    
+    @@transforms = []
+    StepArgumentTransform = Struct.new(:pattern, :transformer)
+    attr_writer :options, :visitor, :log
+
+    def initialize
+      @unsupported_programming_languages = []
+      @programming_languages = []
+      @language_map = {}
+      load_natural_language('en')
+    end
+    
+    def self.register_transform(pattern, &transformer)
+      raise Cucumber::ArityMismatchError.new('Transform must be registered with at least a one-argument block') if !block_given? || transformer.arity < 1
+      @@transforms.unshift StepArgumentTransform.new(Regexp.new(pattern), transformer.to_proc)
+    end
+
+    def self.transform_arguments(step_args)
+      matched = nil
+      step_args.map do |step_arg|
+        if transform = @@transforms.detect {|t| matched = t.pattern.match(step_arg) if step_arg.is_a?(String) }          
+          if matched.captures.empty?
+            unless transform.transformer.arity == 1
+              raise Cucumber::ArityMismatchError.new("Transforms without Regexp captures only accept a single argument (the step argument)")
+            end
+            transform.transformer.call(step_arg)
+          else
+            if transform.transformer.arity != matched.captures.size
+              raise Cucumber::ArityMismatchError.new("Number of arguments in Transform (#{transform.transformer.arity}) does not match number of Regexp captures (#{matched.captures.size})")
+            end
+            transform.transformer.call(*matched.captures)
+          end
+        else
+          step_arg
+        end
+      end
+    end
+
+    def load_plain_text_features(feature_files)
+      features = Ast::Features.new
+
+      log.debug("Features:\n")
+      feature_files.each do |f|
+        feature_file = FeatureFile.new(f)
+        feature = feature_file.parse(self, options)
+        if feature
+          features.add_feature(feature)
+          log.debug("  * #{f}\n")
+        end
+      end
+      log.debug("\n")
+      features
+    end
+
+    def load_code_files(step_def_files)
+      log.debug("Code:\n")
+      step_def_files.each do |step_def_file|
+        load_code_file(step_def_file)
+      end
+      log.debug("\n")
+    end
+
+    def load_code_file(step_def_file)
+      if programming_language = programming_language_for(step_def_file)
+        log.debug("  * #{step_def_file}\n")
+        step_definitions = programming_language.step_definitions_for(step_def_file)
+        register_step_definitions(step_definitions)
+      else
+        log.debug("  * #{step_def_file} [NOT SUPPORTED]\n")
+      end
+    end
+
+    def register_step_definitions(step_definitions)
+      step_definitions.each{|step_definition| register_step_definition(step_definition)}
+    end
+
+    # Loads and registers programming language implementation.
+    # Instances are cached, so calling with the same argument
+    # twice will return the same instance.
+    #
+    def load_programming_language(ext)
+      return @language_map[ext] if @language_map[ext]
+      programming_language_class = constantize("Cucumber::#{ext.capitalize}Support::#{ext.capitalize}Language")
+      programming_language = programming_language_class.new(self)
+      programming_language.alias_adverbs(@adverbs || [])
+      @programming_languages << programming_language
+      @language_map[ext] = programming_language
+      programming_language
+    end
+
+    # Loads a natural language. This has the effect of aliasing 
+    # Step Definition keywords for all of the registered programming 
+    # languages (if they support aliasing). See #load_programming_language
+    #
+    def load_natural_language(lang)
+      Parser::NaturalLanguage.get(self, lang)
+    end
+
+    # Returns the options passed on the command line.
+    def options
+      @options ||= {}
+    end
+
+    def step_visited(step) #:nodoc:
+      steps << step unless steps.index(step)
+    end
+
+    def steps(status = nil) #:nodoc:
+      @steps ||= []
+      if(status)
+        @steps.select{|step| step.status == status}
+      else
+        @steps
+      end
+    end
+
+    def announce(msg) #:nodoc:
+      @visitor.announce(msg)
+    end
+
+    def scenarios(status = nil) #:nodoc:
+      @scenarios ||= []
+      if(status)
+        @scenarios.select{|scenario| scenario.status == status}
+      else
+        @scenarios
+      end
+    end
+
+    def step_match(step_name, formatted_step_name=nil) #:nodoc:
+      matches = step_definitions.map { |d| d.step_match(step_name, formatted_step_name) }.compact
+      raise Undefined.new(step_name) if matches.empty?
+      matches = best_matches(step_name, matches) if matches.size > 1 && options[:guess]
+      raise Ambiguous.new(step_name, matches, options[:guess]) if matches.size > 1
+      matches[0]
+    end
+
+    def best_matches(step_name, step_matches) #:nodoc:
+      no_groups      = step_matches.select {|step_match| step_match.args.length == 0}
+      max_arg_length = step_matches.map {|step_match| step_match.args.length }.max
+      top_groups     = step_matches.select {|step_match| step_match.args.length == max_arg_length }
+
+      if no_groups.any?
+        longest_regexp_length = no_groups.map {|step_match| step_match.text_length }.max
+        no_groups.select {|step_match| step_match.text_length == longest_regexp_length }
+      elsif top_groups.any?
+        shortest_capture_length = top_groups.map {|step_match| step_match.args.inject(0) {|sum, c| sum + c.length } }.min
+        top_groups.select {|step_match| step_match.args.inject(0) {|sum, c| sum + c.length } == shortest_capture_length }
+      else
+        top_groups
+      end
+    end
+    
+    def clear! #:nodoc:
+      step_definitions.clear
+      hooks.clear
+      steps.clear
+      scenarios.clear
+    end
+
+    def step_definitions #:nodoc:
+      @step_definitions ||= []
+    end
+
+    def snippet_text(step_keyword, step_name, multiline_arg_class) #:nodoc:
+      @programming_languages.map do |programming_language|
+        programming_language.snippet_text(step_keyword, step_name, multiline_arg_class)
+      end.join("\n")
+    end
+
+    def before_and_after(scenario, skip_hooks=false) #:nodoc:
+      before(scenario) unless skip_hooks
+      yield scenario
+      after(scenario) unless skip_hooks
+      scenario_visited(scenario)
+    end
+
+    def register_adverbs(adverbs) #:nodoc:
+      @adverbs ||= []
+      @adverbs += adverbs
+      @adverbs.uniq!
+      @programming_languages.each do |programming_language|
+        programming_language.alias_adverbs(@adverbs)
+      end
+    end
+    
+    def before(scenario) #:nodoc:
+      return if options[:dry_run] || @current_scenario
+      @current_scenario = scenario
+      @programming_languages.each do |programming_language|
+        programming_language.before(scenario)
+      end
+    end
+    
+    def after(scenario) #:nodoc:
+      @current_scenario = nil
+      return if options[:dry_run]
+      @programming_languages.each do |programming_language|
+        programming_language.after(scenario)
+      end
+    end
+    
+    def after_step #:nodoc:
+      return if options[:dry_run]
+      @programming_languages.each do |programming_language|
+        programming_language.execute_after_step(@current_scenario)
+      end
+    end
+    
+    def after_configuration(configuration) #:nodoc
+      @programming_languages.each do |programming_language|
+        programming_language.after_configuration(configuration)
+      end
+    end  
+    
+    private
+
+    # Registers a StepDefinition. This can be a Ruby StepDefintion,
+    # or any other kind of object that implements the StepDefintion
+    # contract (API).
+    def register_step_definition(step_definition)
+      step_definitions.each do |already|
+        raise Redundant.new(already, step_definition) if already.same_regexp?(step_definition.regexp)
+      end
+      step_definitions << step_definition
+      step_definition
+    end
+
+    def programming_language_for(step_def_file) #:nodoc:
+      if ext = File.extname(step_def_file)[1..-1]
+        return nil if @unsupported_programming_languages.index(ext)
+        begin
+          load_programming_language(ext)
+        rescue LoadError
+          @unsupported_programming_languages << ext
+          nil
+        end
+      else
+        nil
+      end
+    end
+
+    def max_step_definition_length #:nodoc:
+      @max_step_definition_length ||= step_definitions.map{|step_definition| step_definition.text_length}.max
+    end
+
+    def scenario_visited(scenario) #:nodoc:
+      scenarios << scenario unless scenarios.index(scenario)
+    end
+
+    def log
+      @log ||= Logger.new(STDOUT)
+    end
+  end
+end

data/lib/cucumber/version.rb

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

data/lib/cucumber/webrat/element_locator.rb

@@ -0,0 +1,87 @@
+module Webrat
+  class Element
+    # Returns an Array of Array of String where each String is a
+    # "cell" in the table-like structure represented by this Element.
+    #
+    # Supported elements are table, dl, ol and ul. Different conversion
+    # strategies are used depending on the kind of element:
+    #
+    # * table    : Each tr becomes a row. The innerHTML of each td or th inside becomes a cell. The number 
+    #              of columns is determined by the number of cells in the first row.
+    # * dl       : Each dt becomes a row with 2 cells. The innerHTML of the dt itself and the next dd become cells.
+    # * ul or ol : Each li becomes a row with one cell, the innerHTML of the li.
+    #
+    def to_table
+      case element.name
+      when 'table'
+        table_from_table
+      when 'dl'
+        table_from_dl
+      when /ul|ol/
+        table_from_list
+      else
+        raise "#to_table not supported for #{element.name} elements"
+      end
+    end
+    
+    def table_from_table #:nodoc:
+      col_count = nil
+      Webrat::XML.css_search(element, 'tr').map do |row|
+        cols = Webrat::XML.css_search(row, 'th,td')
+        col_count ||= cols.length
+        cols[0...col_count].map do |col|
+          col.inner_html
+        end
+      end
+    end
+
+    def table_from_dl #:nodoc:
+      Webrat::XML.css_search(@element, 'dt').map do |dt|
+        next_node = dt.next_sibling
+        while next_node.name != 'dd'
+          next_node = next_node.next_sibling
+        end
+        [dt.inner_html, next_node.inner_html]
+      end
+    end
+
+    def table_from_list #:nodoc:
+      Webrat::XML.css_search(@element, 'li').map do |li|
+        [li.inner_html]
+      end
+    end
+
+    alias to_a to_table # Backwards compatibility with Cucumber
+  end
+  
+  module Locators
+    class ElementLocator < Locator #:nodoc:
+      def locate
+        Element.load(@session, table_element)
+      end
+
+      def table_element
+        Webrat::XML.css_search(@dom, @value)[0]
+      end
+
+      def error_message
+        "Could not find anything matching '#{@value}'"
+      end
+    end
+
+    # Returns a Webrat DOM element located by +css_selector+.
+    def element_at(css_selector)
+      ElementLocator.new(@session, dom, css_selector).locate!
+    end
+    
+    alias table_at element_at # Backwards compatibility with Cucumber
+  end
+  
+  module Methods #:nodoc:
+    delegate_to_session :element_at, :table_at
+  end
+  
+  class Session #:nodoc:
+    def_delegators :current_scope, :element_at, :table_at
+  end
+end

data/lib/cucumber/webrat/table_locator.rb

@@ -0,0 +1 @@
+require 'cucumber/webrat/element_locator'

data/lib/cucumber.rb

@@ -0,0 +1,10 @@
+$:.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'

data/rails_generators/cucumber/USAGE

@@ -0,0 +1,11 @@
+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.
+    
+Examples:
+    `./script/generate cucumber`

data/rails_generators/cucumber/cucumber_generator.rb

@@ -0,0 +1,70 @@
+require 'rbconfig'
+require 'cucumber/version'
+
+# This generator bootstraps a Rails project for use with Cucumber
+class CucumberGenerator < Rails::Generator::Base
+  DEFAULT_SHEBANG = File.join(Config::CONFIG['bindir'],
+                              Config::CONFIG['ruby_install_name'])
+
+  attr_accessor :framework
+
+  def manifest
+    record do |m|
+      m.directory 'features/step_definitions'
+      m.template  'webrat_steps.rb', 'features/step_definitions/webrat_steps.rb'
+      m.template  'cucumber_environment.rb', 'config/environments/cucumber.rb',
+        :assigns => { :cucumber_version => ::Cucumber::VERSION::STRING }
+
+      m.gsub_file 'config/database.yml', /test:.*\n/, "test: &TEST\n"
+      m.gsub_file 'config/database.yml', /\z/, "\ncucumber:\n  <<: *TEST"
+
+      m.directory 'features/support'
+
+      if spork?
+        m.template  'spork_env.rb',     'features/support/env.rb'
+      else
+        m.template  'env.rb',           'features/support/env.rb'
+      end
+
+      m.file      'paths.rb',         'features/support/paths.rb'
+
+      m.directory 'lib/tasks'
+      m.template  'cucumber.rake',    'lib/tasks/cucumber.rake'
+
+      m.file      'cucumber',         'script/cucumber', {
+        :chmod => 0755, :shebang => options[:shebang] == DEFAULT_SHEBANG ? nil : options[:shebang]
+      }
+    end
+  end
+
+  def framework
+    options[:framework] || :rspec
+  end
+  
+  def spork?
+    options[:spork]
+  end
+
+protected
+
+  def banner
+    "Usage: #{$0} cucumber"
+  end
+
+  def add_options!(opt)
+    opt.separator ''
+    opt.separator 'Options:'
+    opt.on('--rspec', 'Setup cucumber for use with RSpec (default)') do |value|
+      options[:framework] = :rspec
+    end
+
+    opt.on('--testunit', 'Setup cucumber for use with test/unit') do |value|
+      options[:framework] = :testunit
+    end
+
+    opt.on('--spork', 'Setup cucumber for use with Spork') do |value|
+      options[:spork] = true
+    end
+  end
+
+end

data/rails_generators/cucumber/templates/cucumber

@@ -0,0 +1,9 @@
+#!/usr/bin/env ruby
+begin
+  load File.expand_path(File.dirname(__FILE__) + "/../vendor/plugins/cucumber/bin/cucumber")
+rescue LoadError => e
+  raise unless e.to_s =~ /cucumber/  
+  require 'rubygems'
+  require 'cucumber'
+  load Cucumber::BINARY
+end