aslakhellesoy-cucumber 0.1.16.4 → 0.1.16.5

data/lib/cucumber/parser/feature.tt

@@ -0,0 +1,206 @@
+module Cucumber
+  module Parser
+    # TIP: When you hack on the grammar, just delete feature.rb in this directory.
+    # Treetop will then generate the parser in-memory. When you're happy, just generate
+    # the rb file with tt feature.tt
+    grammar Feature
+      include FileParser
+      include I18n
+
+      rule feature
+        white comment white tags white header:(!(scenario_outline / scenario) .)* feature_elements {
+          def build
+            Ast::Feature.new(comment.build, tags.build, header.text_value, feature_elements.build)
+          end
+        }
+      end
+
+      rule tags
+        white ts:(tag (space/eol)+)* {
+          def build
+            tag_names = ts.elements.map{|e| e.tag.tag_name.text_value}
+            Ast::Tags.new(ts.line, tag_names)
+          end
+        }
+      end
+
+      rule tag
+        '@' tag_name:([a-z0-9])+
+      end
+
+      rule comment
+        (comment_line eol+)* {
+          def build
+            Ast::Comment.new(text_value)
+          end
+        }
+      end
+
+      rule comment_line
+        '#' line_to_eol
+      end
+
+      rule feature_elements
+        (scenario / scenario_outline)* {
+          def build
+            elements.map{|s| s.build}
+          end
+        }
+      end
+
+      rule scenario
+        comment tags white scenario_keyword space* name:line_to_eol (eol+ / eof) steps {
+          def build
+            Ast::Scenario.new(
+              comment.build, 
+              tags.build,
+              scenario_keyword.line,
+              scenario_keyword.text_value, 
+              name.text_value, 
+              steps.build
+            )
+          end
+        }
+      end
+
+      rule scenario_outline
+        comment tags white scenario_outline_keyword space* name:line_to_eol white steps examples_sections {
+          def build
+            Ast::ScenarioOutline.new(
+              comment.build, 
+              tags.build,
+              scenario_outline_keyword.line, 
+              scenario_outline_keyword.text_value, 
+              name.text_value, 
+              steps.build, 
+              examples_sections.build
+            )
+          end
+        }
+      end
+
+      rule steps
+        step* {
+          def build
+            elements.map{|e| e.build}
+          end
+        }
+      end
+
+      rule step
+        space* step_keyword space* name:line_to_eol (eol+ / eof) multi:multiline_arg? {
+          def build
+            if multi.respond_to?(:build)
+              Ast::Step.new(step_keyword.line, step_keyword.text_value, name.text_value, multi.build)
+            else
+              Ast::Step.new(step_keyword.line, step_keyword.text_value, name.text_value)
+            end
+          end
+        }
+      end
+
+      rule examples_sections
+        examples+ {
+          def build
+            elements.map{|e| e.build}
+          end
+        }
+      end
+
+      rule examples
+        space* examples_keyword white table {
+          def build
+            [examples_keyword.line, examples_keyword.text_value, "", table.raw]
+          end
+        }
+      end
+
+      rule multiline_arg
+        table / py_string
+      end
+
+      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 line_to_eol
+        (!eol .)+
+      end
+
+      rule py_string
+        open_py_string s:(!close_py_string .)* close_py_string {
+          def build
+            Ast::PyString.new(open_py_string.line, close_py_string.line, s.text_value, open_py_string.indentation)
+          end
+        }
+      end
+
+      rule open_py_string
+        white '"""' space* eol {
+          def indentation
+            white.text_value.length
+          end
+
+          def line
+            white.line
+          end
+        }
+      end
+
+      rule close_py_string
+        eol space* quotes:'"""' white {
+          def line
+            quotes.line
+          end
+        }
+      end
+
+      rule white
+        (space / eol)*
+      end
+
+      rule space
+        [ \t]
+      end
+
+      rule eol
+        "\n" / ("\r" "\n"?)
+      end
+      
+      rule eof
+        !.
+      end
+
+    end
+  end
+end

data/lib/cucumber/parser/file_parser.rb

@@ -0,0 +1,50 @@
+module Cucumber
+  module Parser
+    module FileParser
+      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
+
+        feature = File.open(path, Cucumber.file_mode('r')) do |io|
+          parse_or_fail(io.read, path)
+        end
+        feature.lines = lines
+        feature
+      end
+      
+      def parse_or_fail(s, file=nil)
+        parse_tree = parse(s)
+        if parse_tree.nil?
+          raise SyntaxError.new(file, self)
+        else
+          ast = parse_tree.build
+          ast.file = file
+          ast
+        end
+      end
+    end
+
+    class SyntaxError < StandardError
+      def initialize(file, parser)
+        tf = parser.terminal_failures
+        expected = tf.size == 1 ? tf[0].expected_string.inspect : "one of #{tf.map{|f| f.expected_string.inspect}.uniq*', '}"
+        after = parser.input[parser.index...parser.failure_index]
+        found = parser.input[parser.failure_index..parser.failure_index]
+        @message = "#{file}:#{parser.failure_line}:#{parser.failure_column}: " +
+          "Parse error, expected #{expected}. After #{after.inspect}. Found: #{found.inspect}"
+      end
+
+      def message
+        @message
+      end
+    end
+  end
+end

data/lib/cucumber/parser/i18n.tt

@@ -0,0 +1,26 @@
+module Cucumber
+  module Parser
+    grammar I18n
+
+      rule scenario_keyword
+        '<%= keywords['scenario'] %>:'
+      end
+
+      rule scenario_outline_keyword
+        '<%= keywords['scenario_outline'] %>:'
+      end
+
+      rule step_keyword
+        '<%= keywords['given'] %>' /
+        '<%= keywords['when'] %>' /
+        '<%= keywords['then'] %>' /
+        '<%= keywords['and'] %>' /
+        '<%= keywords['but'] %>'
+      end
+
+      rule examples_keyword
+        '<%= keywords['examples'] %>' ':'?
+      end
+    end
+  end
+end

data/lib/cucumber/parser/treetop_ext.rb

@@ -0,0 +1,9 @@
+module Treetop
+  module Runtime
+    class SyntaxNode
+      def line
+        input.line_of(interval.first)
+      end
+    end
+  end
+end

data/lib/cucumber/parser.rb

@@ -0,0 +1,27 @@
+require 'erb'
+require 'treetop'
+require 'treetop/runtime'
+require 'treetop/ruby_extensions'
+require 'cucumber/platform'
+require 'cucumber/ast'
+require 'cucumber/parser/file_parser'
+require 'cucumber/parser/treetop_ext'
+
+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
+    def self.load_parser(keywords)
+      template = File.open(File.dirname(__FILE__) + "/parser/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
+  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/step_definition.rb

@@ -0,0 +1,83 @@
+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\nend"
+    end
+
+    class MissingProc < StandardError
+      def message
+        "Step definitions must always have a proc"
+      end
+    end
+
+    attr_reader :regexp
+
+    def initialize(regexp, &proc)
+      raise MissingProc if proc.nil?
+      @regexp, @proc = regexp, 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,154 @@
-require 'cucumber/tree/top_down_visitor'
+require 'cucumber/step_definition'
+require 'cucumber/core_ext/instance_exec'
 
 module Cucumber
-  class Pending < StandardError
-  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
 
-  class ForcedPending < Pending
-  end
+    class Undefined < StandardError
+      attr_reader :step_name
 
-  class Duplicate < StandardError
-  end
+      def initialize(step_name)
+        super %{Undefined step: "#{step_name}"}
+        @step_name = step_name
+      end
+      Cucumber::EXCEPTION_STATUS[self] = :undefined
+    end
 
-  class Multiple < StandardError
-  end
+    class Pending < StandardError
+      Cucumber::EXCEPTION_STATUS[self] = :pending
+    end
 
-  class MissingProc < StandardError
-    def message
-      "Step definitions must always have a proc"
+    # 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
-  end
 
-  class StepMother
-    PENDING = lambda do |*_| 
-      raise Pending
+    # 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
-    require 'cucumber/core_ext/proc'
-    PENDING.extend(CoreExt::CallIn)
-    PENDING.name = "PENDING"
 
-    def initialize
-      @step_procs = Hash.new(PENDING)
+    # 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 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}"
+    def world(scenario, &proc)
+      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) rescue nil
+        end
       end
-      proc.extend(CoreExt::CallIn)
-      proc.name = key.inspect
+    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
 
-      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
+      world.extend(WorldMethods)
+      world.__cucumber_step_mother = self
+
+      world.extend(::Spec::Matchers) if defined?(::Spec::Matchers)
+      world
     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)
+    # 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
-     end
-    
-    def proc_for(regexp)
-      @step_procs[regexp]
+      raise Undefined.new(step_name) if found.empty?
+      raise Ambiguous.new(step_name, found) if found.size > 1
+      found[0]
+    end
+
+    def step_definitions
+      @step_definitions ||= []
     end
-    
-    def has_step_definition?(step_name)
-      _, _, proc = regexp_args_proc(step_name)
-      proc != PENDING
+
+    def snippet_text(step_keyword, step_name)
+      @snippet_generator.snippet_text(step_keyword, step_name)
     end
-    
-    # TODO - move execute here?
-    def execute(step)
+
+    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
+          @__cucumber_step_mother.step_definition(name).execute(name, self, *multiline_arguments)
+        rescue Exception => e
+          @__cucumber_current_step.exception = e
+          raise e
+        end
+      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

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