jwilger-cucumber 0.3.11.200906161550

data/lib/cucumber/parser/table.rb

@@ -0,0 +1,414 @@
+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
+    module Table
+      include Treetop::Runtime
+
+      def root
+        @root || :table
+      end
+
+      module Table0
+        def at_line?(line)
+          elements.detect{|table_row| table_row.at_line?(line)}
+        end
+
+        def build(filter=nil)
+          Ast::Table.new(raw)
+        end
+
+        def raw(filter=nil, scenario_outline=nil)
+          elements.map do |table_row|
+            if(filter.nil? || table_row == elements[0] || filter.at_line?(table_row) || (scenario_outline && filter.outline_at_line?(scenario_outline)))
+              table_row.build
+            end
+          end.compact
+        end
+      end
+
+      def _nt_table
+        start_index = index
+        if node_cache[:table].has_key?(index)
+          cached = node_cache[:table][index]
+          @index = cached.interval.end if cached
+          return cached
+        end
+
+        s0, i0 = [], index
+        loop do
+          r1 = _nt_table_row
+          if r1
+            s0 << r1
+          else
+            break
+          end
+        end
+        if s0.empty?
+          self.index = i0
+          r0 = nil
+        else
+          r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
+          r0.extend(Table0)
+        end
+
+        node_cache[:table][start_index] = r0
+
+        return r0
+      end
+
+      module TableRow0
+        def cell
+          elements[0]
+        end
+
+      end
+
+      module TableRow1
+        def cells
+          elements[2]
+        end
+
+      end
+
+      module TableRow2
+        def at_line?(line)
+          cells.line == line
+        end
+
+        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
+
+      def _nt_table_row
+        start_index = index
+        if node_cache[:table_row].has_key?(index)
+          cached = node_cache[:table_row][index]
+          @index = cached.interval.end if cached
+          return cached
+        end
+
+        i0, s0 = index, []
+        s1, i1 = [], index
+        loop do
+          r2 = _nt_space
+          if r2
+            s1 << r2
+          else
+            break
+          end
+        end
+        r1 = instantiate_node(SyntaxNode,input, i1...index, s1)
+        s0 << r1
+        if r1
+          if input.index('|', index) == index
+            r3 = instantiate_node(SyntaxNode,input, index...(index + 1))
+            @index += 1
+          else
+            terminal_parse_failure('|')
+            r3 = nil
+          end
+          s0 << r3
+          if r3
+            s4, i4 = [], index
+            loop do
+              i5, s5 = index, []
+              r6 = _nt_cell
+              s5 << r6
+              if r6
+                if input.index('|', index) == index
+                  r7 = instantiate_node(SyntaxNode,input, index...(index + 1))
+                  @index += 1
+                else
+                  terminal_parse_failure('|')
+                  r7 = nil
+                end
+                s5 << r7
+              end
+              if s5.last
+                r5 = instantiate_node(SyntaxNode,input, i5...index, s5)
+                r5.extend(TableRow0)
+              else
+                self.index = i5
+                r5 = nil
+              end
+              if r5
+                s4 << r5
+              else
+                break
+              end
+            end
+            if s4.empty?
+              self.index = i4
+              r4 = nil
+            else
+              r4 = instantiate_node(SyntaxNode,input, i4...index, s4)
+            end
+            s0 << r4
+            if r4
+              s8, i8 = [], index
+              loop do
+                r9 = _nt_space
+                if r9
+                  s8 << r9
+                else
+                  break
+                end
+              end
+              r8 = instantiate_node(SyntaxNode,input, i8...index, s8)
+              s0 << r8
+              if r8
+                i10 = index
+                s11, i11 = [], index
+                loop do
+                  r12 = _nt_eol
+                  if r12
+                    s11 << r12
+                  else
+                    break
+                  end
+                end
+                if s11.empty?
+                  self.index = i11
+                  r11 = nil
+                else
+                  r11 = instantiate_node(SyntaxNode,input, i11...index, s11)
+                end
+                if r11
+                  r10 = r11
+                else
+                  r13 = _nt_eof
+                  if r13
+                    r10 = r13
+                  else
+                    self.index = i10
+                    r10 = nil
+                  end
+                end
+                s0 << r10
+              end
+            end
+          end
+        end
+        if s0.last
+          r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
+          r0.extend(TableRow1)
+          r0.extend(TableRow2)
+        else
+          self.index = i0
+          r0 = nil
+        end
+
+        node_cache[:table_row][start_index] = r0
+
+        return r0
+      end
+
+      module Cell0
+      end
+
+      def _nt_cell
+        start_index = index
+        if node_cache[:cell].has_key?(index)
+          cached = node_cache[:cell][index]
+          @index = cached.interval.end if cached
+          return cached
+        end
+
+        s0, i0 = [], index
+        loop do
+          i1, s1 = index, []
+          i2 = index
+          i3 = index
+          if input.index('|', index) == index
+            r4 = instantiate_node(SyntaxNode,input, index...(index + 1))
+            @index += 1
+          else
+            terminal_parse_failure('|')
+            r4 = nil
+          end
+          if r4
+            r3 = r4
+          else
+            r5 = _nt_eol
+            if r5
+              r3 = r5
+            else
+              self.index = i3
+              r3 = nil
+            end
+          end
+          if r3
+            r2 = nil
+          else
+            self.index = i2
+            r2 = instantiate_node(SyntaxNode,input, index...index)
+          end
+          s1 << r2
+          if r2
+            if index < input_length
+              r6 = instantiate_node(SyntaxNode,input, index...(index + 1))
+              @index += 1
+            else
+              terminal_parse_failure("any character")
+              r6 = nil
+            end
+            s1 << r6
+          end
+          if s1.last
+            r1 = instantiate_node(SyntaxNode,input, i1...index, s1)
+            r1.extend(Cell0)
+          else
+            self.index = i1
+            r1 = nil
+          end
+          if r1
+            s0 << r1
+          else
+            break
+          end
+        end
+        r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
+
+        node_cache[:cell][start_index] = r0
+
+        return r0
+      end
+
+      def _nt_space
+        start_index = index
+        if node_cache[:space].has_key?(index)
+          cached = node_cache[:space][index]
+          @index = cached.interval.end if cached
+          return cached
+        end
+
+        if input.index(Regexp.new('[ \\t]'), index) == index
+          r0 = instantiate_node(SyntaxNode,input, index...(index + 1))
+          @index += 1
+        else
+          r0 = nil
+        end
+
+        node_cache[:space][start_index] = r0
+
+        return r0
+      end
+
+      module Eol0
+      end
+
+      def _nt_eol
+        start_index = index
+        if node_cache[:eol].has_key?(index)
+          cached = node_cache[:eol][index]
+          @index = cached.interval.end if cached
+          return cached
+        end
+
+        i0 = index
+        if input.index("\n", index) == index
+          r1 = instantiate_node(SyntaxNode,input, index...(index + 1))
+          @index += 1
+        else
+          terminal_parse_failure("\n")
+          r1 = nil
+        end
+        if r1
+          r0 = r1
+        else
+          i2, s2 = index, []
+          if input.index("\r", index) == index
+            r3 = instantiate_node(SyntaxNode,input, index...(index + 1))
+            @index += 1
+          else
+            terminal_parse_failure("\r")
+            r3 = nil
+          end
+          s2 << r3
+          if r3
+            if input.index("\n", index) == index
+              r5 = instantiate_node(SyntaxNode,input, index...(index + 1))
+              @index += 1
+            else
+              terminal_parse_failure("\n")
+              r5 = nil
+            end
+            if r5
+              r4 = r5
+            else
+              r4 = instantiate_node(SyntaxNode,input, index...index)
+            end
+            s2 << r4
+          end
+          if s2.last
+            r2 = instantiate_node(SyntaxNode,input, i2...index, s2)
+            r2.extend(Eol0)
+          else
+            self.index = i2
+            r2 = nil
+          end
+          if r2
+            r0 = r2
+          else
+            self.index = i0
+            r0 = nil
+          end
+        end
+
+        node_cache[:eol][start_index] = r0
+
+        return r0
+      end
+
+      def _nt_eof
+        start_index = index
+        if node_cache[:eof].has_key?(index)
+          cached = node_cache[:eof][index]
+          @index = cached.interval.end if cached
+          return cached
+        end
+
+        i0 = index
+        if index < input_length
+          r1 = instantiate_node(SyntaxNode,input, index...(index + 1))
+          @index += 1
+        else
+          terminal_parse_failure("any character")
+          r1 = nil
+        end
+        if r1
+          r0 = nil
+        else
+          self.index = i0
+          r0 = instantiate_node(SyntaxNode,input, index...index)
+        end
+
+        node_cache[:eof][start_index] = r0
+
+        return r0
+      end
+
+    end
+
+    class TableParser < Treetop::Runtime::CompiledParser
+      include Table
+    end
+
+  end
+end

data/lib/cucumber/parser/table.tt

@@ -0,0 +1,71 @@
+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 at_line?(line)
+            elements.detect{|table_row| table_row.at_line?(line)}
+          end
+
+          def build(filter=nil)
+            Ast::Table.new(raw)
+          end
+
+          def raw(filter=nil, scenario_outline=nil)
+            elements.map do |table_row|
+              if(filter.nil? || table_row == elements[0] || filter.at_line?(table_row) || (scenario_outline && filter.outline_at_line?(scenario_outline)))
+                table_row.build
+              end
+            end.compact
+          end
+        }
+      end
+
+      rule table_row
+        space* '|' cells:(cell '|')+ space* (eol+ / eof) {
+          def at_line?(line)
+            cells.line == line
+          end
+
+          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,52 @@
+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
+    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
+    
+    module TreetopExt
+      def parse_or_fail(source, file=nil, filter=nil, line_offset=0)
+        parse_tree = parse(source)
+        if parse_tree.nil?
+          raise Cucumber::Parser::SyntaxError.new(self, file, line_offset)
+        else
+          ast = parse_tree.build(filter) # may return nil if it doesn't match filter.
+          ast.file = file unless ast.nil?
+          ast
+        end
+      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
+    end
+  end
+end

data/lib/cucumber/parser.rb

@@ -0,0 +1,6 @@
+require 'erb'
+require 'cucumber/platform'
+require 'cucumber/ast'
+require 'cucumber/parser/treetop_ext'
+require 'cucumber/parser/table'
+require 'cucumber/parser/feature'

data/lib/cucumber/platform.rb

@@ -0,0 +1,23 @@
+# Detect the platform we're running on so we can tweak behaviour
+# in various places.
+require 'rbconfig'
+require 'yaml'
+
+module Cucumber
+  # TODO: Move these constants and the file to Language. Update wiki
+  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')
+  LIBDIR        = File.expand_path(File.dirname(__FILE__) + '/../../lib')
+  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/
+  
+  def self.file_mode(m)
+    RUBY_1_9 ? "#{m}:UTF-8" : m
+  end
+end

data/lib/cucumber/rails/rspec.rb

@@ -0,0 +1,10 @@
+require 'cucumber/rails/world'
+require 'spec/expectations'
+require 'spec/rails/matchers'
+
+[Cucumber::Rails::World, ActionController::Integration::Session].each do |klass|
+  klass.class_eval do
+    include Spec::Matchers
+    include Spec::Rails::Matchers
+  end
+end

data/lib/cucumber/rails/world.rb

@@ -0,0 +1,99 @@
+# 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
+
+begin
+  require 'test/unit/testresult'
+rescue LoadError => e
+  e.message << "\nYou must gem install test-unit. For more info see https://rspec.lighthouseapp.com/projects/16211/tickets/292"
+  e.message << "\nAlso make sure you have rack 1.0.0 or higher."
+  raise e
+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
+
+      unless ::Rails.configuration.cache_classes
+        warn "WARNING: You have set Rails' config.cache_classes to false (most likely in config/environments/test.rb).  This setting is known to break Cucumber's use_transactional_fixtures method. Set config.cache_classes to true if you want to use transactional fixtures.  For more information see https://rspec.lighthouseapp.com/projects/16211/tickets/165."
+      end
+
+      World.use_transactional_fixtures = true
+      if defined?(ActiveRecord::Base)
+        $__cucumber_toplevel.Before do
+          @__cucumber_ar_connection = ActiveRecord::Base.connection
+          if @__cucumber_ar_connection.respond_to?(:increment_open_transactions)
+            @__cucumber_ar_connection.increment_open_transactions
+          else
+            ActiveRecord::Base.__send__(:increment_open_transactions)
+          end
+          @__cucumber_ar_connection.begin_db_transaction
+          ActionMailer::Base.deliveries = [] if defined?(ActionMailer::Base)
+        end
+        
+        $__cucumber_toplevel.After do
+          @__cucumber_ar_connection.rollback_db_transaction
+          if @__cucumber_ar_connection.respond_to?(:decrement_open_transactions)
+            @__cucumber_ar_connection.decrement_open_transactions
+          else
+            ActiveRecord::Base.__send__(:decrement_open_transactions)
+          end
+        end
+      end
+    end
+
+    def self.bypass_rescue
+      ActionController::Base.class_eval do
+        alias_method :rescue_action_without_bypass, :rescue_action
+
+        def rescue_action(exception)
+          raise exception
+        end
+      end
+
+      begin
+        ActionController::Failsafe.class_eval do
+          alias_method :failsafe_response_without_bypass, :failsafe_response
+        
+          def failsafe_response(exception)
+            raise exception
+          end
+        end
+      rescue NameError # Failsafe was introduced in Rails 2.3.2
+        ActionController::Dispatcher.class_eval do
+          def self.failsafe_response(output, status, exception = nil)
+            raise exception
+          end
+        end
+      end
+    end
+  end
+end
+
+World do
+  Cucumber::Rails::World.new
+end