kosmas58-cucumber 0.1.16.6 → 0.1.99.21

data/lib/cucumber/parser/table.tt

@@ -0,0 +1,59 @@
+module Cucumber
+  module Parser
+    # TIP: When you hack on the grammar, just delete feature.rb in this directory.
+    # Also make sure you have uninstalled all cucumber gems (don't forget xxx-cucumber
+    # github gems).
+    #
+    # Treetop will then generate the parser in-memory. When you're happy, just generate
+    # the rb file with tt feature.tt
+    grammar Table
+
+      rule table
+        table_row+ {
+          def build
+            Ast::Table.new(raw)
+          end
+
+          def raw
+            elements.map{|e| e.build}
+          end
+        }
+      end
+
+      rule table_row
+        space* '|' cells:(cell '|')+ space* (eol+ / eof) {
+          def build
+            row = cells.elements.map do |elt| 
+              value = elt.cell.text_value.strip
+              value.empty? ? nil : value
+            end
+
+            class << row
+              attr_accessor :line
+            end
+            row.line = cells.line
+
+            row
+          end
+        }
+      end
+
+      rule cell
+        (!('|' / eol) .)*
+      end
+
+      rule space
+        [ \t]
+      end
+
+      rule eol
+        "\n" / ("\r" "\n"?)
+      end
+
+      rule eof
+        !.
+      end
+
+    end
+  end
+end

data/lib/cucumber/parser/treetop_ext.rb

@@ -0,0 +1,75 @@
+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/platform.rb

@@ -1,9 +1,11 @@
 # 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/
@@ -12,21 +14,5 @@ module Cucumber
   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  
+  EXCEPTION_STATUS = Hash.new(:failed)
 end

data/lib/cucumber/rails/rspec.rb

@@ -1,5 +1,8 @@
+require 'cucumber/rails/world'
 require 'spec/expectations'
 require 'spec/rails/matchers'
 
-ActionController::Integration::Session.send(:include, Spec::Matchers)
-ActionController::Integration::Session.send(:include, Spec::Rails::Matchers)
+Cucumber::Rails::World.class_eval do
+  include Spec::Matchers
+  include Spec::Rails::Matchers
+end

data/lib/cucumber/step_definition.rb

@@ -0,0 +1,87 @@
+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,98 +1,183 @@
-require 'cucumber/tree/top_down_visitor'
+require 'cucumber/step_definition'
+require 'cucumber/core_ext/instance_exec'
 
 module Cucumber
-  class Pending < StandardError
-  end
+  class Undefined < StandardError
+    attr_reader :step_name
 
-  class ForcedPending < Pending
+    def initialize(step_name)
+      super %{Undefined step: "#{step_name}"}
+      @step_name = step_name
+    end
+    Cucumber::EXCEPTION_STATUS[self] = :undefined
   end
 
-  class Duplicate < StandardError
+  class Pending < StandardError
+    Cucumber::EXCEPTION_STATUS[self] = :pending
   end
 
-  class Multiple < StandardError
+  # 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
 
-  class MissingProc < StandardError
-    def message
-      "Step definitions must always have a proc"
+  # 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
 
-  class StepMother
-    PENDING = lambda do |*_| 
-      raise Pending
+  # 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
-    require 'cucumber/core_ext/proc'
-    PENDING.extend(CoreExt::CallIn)
-    PENDING.name = "PENDING"
 
-    def initialize
-      @step_procs = Hash.new(PENDING)
+    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
 
-    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
+    # 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
 
-      if @step_procs.has_key?(regexp)
-        first_proc = @step_procs[regexp]
-        message = %{Duplicate step definitions:
+    def After(&proc)
+      (@after_procs ||= []) << proc
+    end
 
-#{first_proc.to_backtrace_line}
-#{proc.to_backtrace_line}
+    # 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
 
-}
-        raise Duplicate.new(message)
+    # Creates a new world instance
+    def new_world #:nodoc:
+      world = Object.new
+      (@world_procs ||= []).each do |proc|
+        world = proc.call(world)
       end
 
-      @step_procs[regexp] = proc
-    end
+      world.extend(WorldMethods)
+      world.__cucumber_step_mother = self
 
-    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}:
+      world.extend(::Spec::Matchers) if defined?(::Spec::Matchers)
+      world
+    end
 
-#{candidates.map{|regexp, args, proc| proc.to_backtrace_line}.join("\n")}
+    # 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
 
-}
-        raise Multiple.new(message)
+    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 proc_for(regexp)
-      @step_procs[regexp]
     end
     
-    def has_step_definition?(step_name)
-      _, _, proc = regexp_args_proc(step_name)
-      proc != PENDING
+    def step_definitions
+      @step_definitions ||= []
     end
+
+    def snippet_text(step_keyword, step_name)
+      @snippet_generator.snippet_text(step_keyword, step_name)
+    end
+
+    private
     
-    # TODO - move execute here?
-    def execute(step)
+    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