gherkin 1.0.30-i386-mingw32 → 2.0.0-i386-mingw32

data/ragel/lexer.java.rl.erb

@@ -34,36 +34,36 @@ public class <%= @i18n.underscored_iso_code.upcase %> implements Lexer {
     }
 
     action store_feature_content {
-      String con = multilineStrip(keywordContent(data, p, eof, nextKeywordStart, contentStart).trim());
-      listener.feature(keyword, con, currentLine);
+      String[] nameDescription = nameAndDescriptionWithPlatformNewlinesIntact(keywordContent(data, p, eof, nextKeywordStart, contentStart));
+      listener.feature(keyword, nameDescription[0], nameDescription[1], currentLine);
       if(nextKeywordStart != -1) p = nextKeywordStart - 1;
       nextKeywordStart = -1;
     }
 
     action store_background_content {
-      String con = multilineStrip(keywordContent(data, p, eof, nextKeywordStart, contentStart));
-      listener.background(keyword, con, currentLine);
+      String[] nameDescription = nameAndDescriptionWithPlatformNewlinesIntact(keywordContent(data, p, eof, nextKeywordStart, contentStart));
+      listener.background(keyword, nameDescription[0], nameDescription[1], currentLine);
       if(nextKeywordStart != -1) p = nextKeywordStart - 1;
       nextKeywordStart = -1;
     }
 
     action store_scenario_content {
-      String con = multilineStrip(keywordContent(data, p, eof, nextKeywordStart, contentStart));
-      listener.scenario(keyword, con, currentLine);
+      String[] nameDescription = nameAndDescriptionWithPlatformNewlinesIntact(keywordContent(data, p, eof, nextKeywordStart, contentStart));
+      listener.scenario(keyword, nameDescription[0], nameDescription[1], currentLine);
       if(nextKeywordStart != -1) p = nextKeywordStart - 1;
       nextKeywordStart = -1;
     }
 
     action store_scenario_outline_content {
-      String con = multilineStrip(keywordContent(data, p, eof, nextKeywordStart, contentStart));
-      listener.scenarioOutline(keyword, con, currentLine);
+      String[] nameDescription = nameAndDescriptionWithPlatformNewlinesIntact(keywordContent(data, p, eof, nextKeywordStart, contentStart));
+      listener.scenarioOutline(keyword, nameDescription[0], nameDescription[1], currentLine);
       if(nextKeywordStart != -1) p = nextKeywordStart - 1;
       nextKeywordStart = -1;
     }
 
     action store_examples_content {
-      String con = multilineStrip(keywordContent(data, p, eof, nextKeywordStart, contentStart));
-      listener.examples(keyword, con, currentLine);
+      String[] nameDescription = nameAndDescriptionWithPlatformNewlinesIntact(keywordContent(data, p, eof, nextKeywordStart, contentStart));
+      listener.examples(keyword, nameDescription[0], nameDescription[1], currentLine);
       if(nextKeywordStart != -1) p = nextKeywordStart - 1;
       nextKeywordStart = -1;
     }
@@ -125,7 +125,7 @@ public class <%= @i18n.underscored_iso_code.upcase %> implements Lexer {
     action end_feature {
       if(cs < lexer_first_final) {
         String content = currentLineContent(data, lastNewline);
-        throw new LexingError("Lexing error on line " + lineNumber + ": '" + content + "'");
+        throw new LexingError("Lexing error on line " + lineNumber + ": '" + content + "'. See http://wiki.github.com/aslakhellesoy/gherkin/lexingerror for more information.");
       } else {
         listener.eof();
       }
@@ -142,8 +142,9 @@ public class <%= @i18n.underscored_iso_code.upcase %> implements Lexer {
 
   %% write data noerror;
 
-  public void scan(String inputSequence)  {
-    String input = inputSequence.toString() + "\n%_FEATURE_END_%";
+  public void scan(String inputSequence, String uri, int offset)  {
+    listener.location(uri, offset);
+    String input = inputSequence + "\n%_FEATURE_END_%";
     byte[] data = null;
     try {
       data = input.getBytes("UTF-8");
@@ -178,16 +179,24 @@ public class <%= @i18n.underscored_iso_code.upcase %> implements Lexer {
   private static final String CRLF = "\r\n";
   private static final String LF = "\n";
 
-  private String multilineStrip(String text) {
+  private String[] nameAndDescriptionWithPlatformNewlinesIntact(String text) {
     int crlfCount = matchCount(CRLF_RE.matcher(text));
     int lfCount = matchCount(LF_RE.matcher(text));
     String eol = crlfCount > lfCount ? CRLF : LF;
 
-    StringBuffer result = new StringBuffer();
+    String name = null;
+    StringBuffer description = new StringBuffer();
     for(String s : text.split("\r?\n")) {
-      result.append(s.trim()).append(eol);
+      if(name == null) {
+        name = s.trim();
+      } else {
+        description.append(s.trim()).append(eol);
+      }
+    }
+    if(name == null) {
+      name = "";
     }
-    return result.toString().trim();
+    return new String[]{name, description.toString().trim()};
   }
 
   private int matchCount(Matcher m) {

data/ragel/lexer.rb.rl.erb

@@ -113,7 +113,7 @@ module Gherkin
         action end_feature {
           if cs < lexer_first_final
             content = current_line_content(data, p)
-            raise LexingError.new("Lexing error on line %d: '%s'." % [@line_number, content])
+            raise LexingError.new("Lexing error on line %d: '%s'. See http://wiki.github.com/aslakhellesoy/gherkin/lexingerror for more information." % [@line_number, content])
           else
             @listener.eof
           end
@@ -127,7 +127,8 @@ module Gherkin
         %% write data;
       end
  
-      def scan(data)
+      def scan(data, uri, offset)
+        @listener.location(uri, offset)
         data = (data + "\n%_FEATURE_END_%").unpack("c*") # Explicit EOF simplifies things considerably
         eof = pe = data.length
  
@@ -153,11 +154,15 @@ module Gherkin
       def unindent(startcol, text)
         text.gsub(/^[\t ]{0,#{startcol}}/, "")
       end
- 
+
       def store_keyword_content(event, data, p, eof)
         end_point = (!@next_keyword_start or (p == eof)) ? p : @next_keyword_start
-        con = yield utf8_pack(data[@content_start...end_point])
-        @listener.send(event, @keyword, con, @current_line)
+        content = yield utf8_pack(data[@content_start...end_point])
+        content_lines = content.split("\n")
+        name = content_lines.shift || ""
+        name.strip!
+        description = content_lines.join("\n")
+        @listener.__send__(event, @keyword, name, description, @current_line)
       end
       
       def current_line_content(data, p)

data/ragel/lexer_common.rl.erb

@@ -16,11 +16,11 @@
   PIPE = '|';
   ESCAPED_PIPE = '\\|';
 
-  FeatureHeadingEnd = EOL+ space* (I18N_Background | I18N_Scenario | I18N_ScenarioOutline | '@' | '#' | EOF) >next_keyword_start;
-  ScenarioHeadingEnd = EOL+ space* ( I18N_Scenario | I18N_ScenarioOutline | I18N_Step | '@' | '#' | EOF ) >next_keyword_start;
-  BackgroundHeadingEnd = EOL+ space* ( I18N_Scenario | I18N_ScenarioOutline | I18N_Step | '@' | '#'| EOF ) >next_keyword_start;
-  ScenarioOutlineHeadingEnd = EOL+ space* ( I18N_Scenario | I18N_Step | '@' | '#' | EOF ) >next_keyword_start;
-  ExamplesHeadingEnd = EOL+ space* '|' >next_keyword_start;
+  FeatureHeadingEnd = EOL+ space* (I18N_Feature | I18N_Background | I18N_Scenario | I18N_ScenarioOutline | I18N_Examples | '@' | '#' | EOF) >next_keyword_start;
+  ScenarioHeadingEnd = EOL+ space* ( I18N_Feature | I18N_Background | I18N_Scenario | I18N_ScenarioOutline | I18N_Step | '@' | '#' | EOF ) >next_keyword_start;
+  BackgroundHeadingEnd = EOL+ space* ( I18N_Feature | I18N_Scenario | I18N_ScenarioOutline | I18N_Step | '@' | '#'| EOF ) >next_keyword_start;
+  ScenarioOutlineHeadingEnd = EOL+ space* ( I18N_Feature | I18N_Scenario | I18N_Step | '@' | '#' | EOF ) >next_keyword_start;
+  ExamplesHeadingEnd = EOL+ space* ( I18N_Feature | '|' ) >next_keyword_start;
  
   FeatureHeading = space* I18N_Feature %begin_content ^FeatureHeadingEnd* :>> FeatureHeadingEnd @store_feature_content;
   BackgroundHeading = space* I18N_Background %begin_content ^BackgroundHeadingEnd* :>> BackgroundHeadingEnd @store_background_content;
@@ -36,7 +36,7 @@
   
   StartRow = space* PIPE >start_row;
   EndRow = EOL space* ^PIPE >next_keyword_start;    
-  Cell = PIPE (ESCAPED_PIPE | (any - PIPE)+ )* >begin_cell_content %store_cell_content;
+  Cell = PIPE (ESCAPED_PIPE | (any - (PIPE|EOL))+ )* >begin_cell_content %store_cell_content;
   RowBody = space* Cell** PIPE :>> (space* EOL+ space*) %store_row;
   Row = StartRow :>> RowBody <: EndRow?;
   

data/spec/gherkin/c_lexer_spec.rb

@@ -1,6 +1,6 @@
 #encoding: utf-8
-unless defined?(JRUBY_VERSION)
-require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+unless defined?(JRUBY_VERSION) || (defined?(RUBY_ENGINE) && RUBY_ENGINE == "ironruby")
+require 'spec_helper'
 require 'gherkin_lexer_en'
 
 module Gherkin

data/spec/gherkin/fixtures/complex.js

@@ -0,0 +1,105 @@
+{ "name" : "Feature Text\nIn order to test multiline forms",
+  "tags" : [
+    "@tag1",
+    "@tag2"
+  ],
+  "background" : {
+    "name" : "", 
+    "steps" : [
+      { "name" : "this is a background step" },
+      { "name" : "this is another one",
+        "keyword" : "When ",
+        "line" : 412 }
+    ]
+  },
+  "elements" : [
+    { "type" : "Scenario Outline",
+      "name" : "An Scenario Outline",
+      "tags" : [ "@foo" ],
+      "steps" : [
+        { "name" : "A step with a table",
+          "table" : [
+            {"cells":
+              [ { "text":"a" },
+                { "text":"row" },
+                { "text":"for" },
+                { "text":"a"   },
+                { "text":"step"}
+              ]
+            }
+          ]
+        }
+      ],
+      "examples" : [
+        { "name" : "Sweet Example", 
+          "table" : [
+            {"cells" :
+              [ { "text":"Fill" },
+                { "text":"In"   }]},
+            {"cells" :
+              [ { "text":"The" },
+                { "text": "Blanks" }]}
+          ],
+          "tags" : [ "@exampletag" ]
+        }
+      ]
+    },
+    { "type" : "Scenario",
+      "name" : "Reading a Scenario",
+      "tags" : [
+        "@tag3",
+        "@tag4"
+      ],
+      "steps" : [
+        { "name" : "there is a step" },
+        { "name" : "not another step" }
+      ]
+    },
+    { "type" : "Scenario",
+      "name" : "Reading a second scenario\nWith two lines of text",
+      "tags" : [ "@tag3" ],
+      "steps" : [
+        { "name" : "a third step with a table",
+          "table" : [
+            { "cells" :
+              [ { "text":"a" },
+                { "text":"b" }]},
+            { "cells" :
+              [ { "text":"c" },
+                { "text":"d" }]},
+            { "cells" :
+              [ { "text":"e" },
+                { "text":"f" }]}
+          ]
+        },
+        { "name" : "I am still testing things",
+          "table" : [
+            { "cells" :
+              [ { "text":"g" },
+                { "text":"h" }]},
+            { "cells" :
+              [ { "text":"e" },
+                { "text":"r" }]},
+            { "cells" :
+              [ { "text":"k" },
+                { "text":"i" }]},
+            { "cells" :
+              [ { "text":"n" },
+                { "text":"" }]}
+          ]
+        },
+        { "name" : "I am done testing these tables" },
+        { "name" : "I am happy" }
+      ]
+    },
+    { "type" : "Scenario",
+     "name" : "Hammerzeit", 
+      "steps" : [
+        { "name" : "All work and no play", 
+          "py_string" : "Makes Homer something something\nAnd something else" },
+        { "name" : "crazy" }
+      ]
+    }
+  ]
+}
+

data/spec/gherkin/formatter/argument_spec.rb

@@ -1,5 +1,5 @@
 # encoding: utf-8
-require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
+require 'spec_helper'
 require 'gherkin/formatter/argument'
 
 module Gherkin
@@ -18,8 +18,8 @@ module Gherkin
     
     describe Argument do
       it "should replace one arg" do
-        argument_class = defined?(JRUBY_VERSION) ? ::Java::GherkinFormatter::Argument : Argument
-        argument_class.format("I have 10 cukes", BracketFormat.new, [Argument.new(7, '10')]).should == "I have [10] cukes"
+        argument_class = defined?(JRUBY_VERSION) ? ::Java::GherkinFormatter::Argument : Gherkin::Formatter::Argument
+        argument_class.format("I have 10 cukes", Gherkin::Formatter::BracketFormat.new, [Gherkin::Formatter::Argument.new(7, '10')]).should == "I have [10] cukes"
       end
       
       # TODO: Add this spec: http://github.com/alg/cucumber/commit/33188e9db51f59ced74c4861524d7b2e69454630

data/spec/gherkin/formatter/colors_spec.rb

@@ -1,11 +1,10 @@
-require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
-require 'gherkin/formatter/pretty_formatter'
-
+require 'spec_helper'
+require 'gherkin/formatter/colors'
 
 module Gherkin
   module Formatter
     describe Colors do
-      include Colors
+      include Gherkin::Formatter::Colors
 
       it "should colour stuff red" do
         failed("hello").should == "\e[31mhello\e[0m"

data/spec/gherkin/formatter/pretty_formatter_spec.rb

@@ -1,45 +1,46 @@
 # encoding: utf-8
-require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
+require 'spec_helper'
 require 'gherkin/formatter/pretty_formatter'
 require 'gherkin/formatter/argument'
+require 'gherkin/parser/formatter_listener'
+require 'gherkin/parser/row'
 require 'stringio'
 
 module Gherkin
   module Formatter
     describe PrettyFormatter do
       def assert_io(s)
-        @io.rewind
-        actual = @io.read
+        actual = @io.string
         actual.should == s
       end
       
       def assert_pretty(input, output=input)
         [true, false].each do |force_ruby|
           io = StringIO.new
-          l = PrettyFormatter.new(io, true)
+          pf = Gherkin::Formatter::PrettyFormatter.new(io, true)
+          l  = Gherkin::Parser::FormatterListener.new(pf)
           parser = Gherkin::Parser::Parser.new(l, true, "root")
           lexer  = Gherkin::I18nLexer.new(parser, force_ruby)
-          lexer.scan(input)
-          io.rewind
-          actual = io.read
+          lexer.scan(input, "test.feature", 0)
+          actual = io.string
           actual.should == output
         end
       end
 
       before do
         @io = StringIO.new
-        @l = PrettyFormatter.new(@io, true)
+        @l = Gherkin::Formatter::PrettyFormatter.new(@io, true)
       end
 
       it "should print comments when scenario is longer" do
-        @l.feature("Feature", "Hello\nWorld", 1)
+        @l.feature([], [], "Feature", "Hello", "World", "features/foo.feature")
         @l.steps([
           ['Given ', 'some stuff'],
           ['When ', 'foo']
         ])
-        @l.scenario("Scenario", "The scenario", 4, "features/foo.feature:4")
-        @l.step("Given ", "some stuff", 5, nil, nil, nil, "features/step_definitions/bar.rb:56")
-        @l.step("When ", "foo", 6, nil, nil, nil, "features/step_definitions/bar.rb:96")
+        @l.scenario([], [], "Scenario", "The scenario", "", 4)
+        @l.step([], "Given ", "some stuff", 5, nil, nil, nil, nil, "features/step_definitions/bar.rb:56")
+        @l.step([], "When ", "foo", 6, nil, nil, nil, nil, "features/step_definitions/bar.rb:96")
 
         assert_io(%{Feature: Hello
   World
@@ -51,12 +52,12 @@ module Gherkin
       end
 
       it "should print comments when step is longer" do
-        @l.feature("Feature", "Hello\nWorld", 1)
+        @l.feature([], [], "Feature", "Hello", "World", "features/foo.feature")
         @l.steps([
           ['Given ', 'some stuff that is longer']
         ])
-        @l.scenario("Scenario", "The scenario", 4, "features/foo.feature:4")
-        @l.step("Given ", "some stuff that is longer", 5, nil, nil, nil, "features/step_definitions/bar.rb:56")
+        @l.scenario([], [], "Scenario", "The scenario", "", 4)
+        @l.step([], "Given ", "some stuff that is longer", 5, nil, nil, nil, nil, "features/step_definitions/bar.rb:56")
 
         assert_io(%{Feature: Hello
   World
@@ -66,38 +67,9 @@ module Gherkin
 })
       end
 
-      it "should print ANSI coloured steps" do
-        @l.feature("Feature", "Hello\nWorld", 1)
-        @l.steps([
-          ['Given ', 'some stuff that is longer']
-        ])
-        @l.scenario("Scenario", "The scenario", 4, "features/foo.feature:4")
-        @l.step("Given ", "some stuff that is longer", 5, nil, nil, nil, "features/step_definitions/bar.rb:56")
-
-        assert_io(%{Feature: Hello
-  World
-
-  Scenario: The scenario            # features/foo.feature:4
-    Given some stuff that is longer # features/step_definitions/bar.rb:56
-})
-      end
-
-      it "should prettify a whole table with padding (typically ANSI)" do
-        @l.row(%w(a bb), 1)
-        @l.row(%w(ccc d), 2)
-        @l.row(%w(ee ffff), 3)
-        @l.flush_table
-
-        assert_io(
-          "      | a   | bb   |\n" +
-          "      | ccc | d    |\n" +
-          "      | ee  | ffff |\n"
-        )
-      end
-
       it "should highlight arguments for regular steps" do
         passed = defined?(JRUBY_VERSION) ? 'passed' : :passed
-        @l.step("Given ", "I have 999 cukes in my belly", 3, passed, nil, [Gherkin::Formatter::Argument.new(7, '999')], nil)
+        @l.step([], "Given ", "I have 999 cukes in my belly", 3, nil, passed, nil, [Gherkin::Formatter::Argument.new(7, '999')], nil)
         assert_io("    Given I have 999 cukes in my belly\n")
       end
 
@@ -106,6 +78,7 @@ module Gherkin
   Some preamble
 
   Scenario: Scenario Description
+    description has multiple lines
     Given there is a step
       """
       with
@@ -151,11 +124,9 @@ Feature: Feature Description
 
       it "should escape backslashes and pipes" do
         io = StringIO.new
-        l = PrettyFormatter.new(io, true)
-        l.row(['|', '\\'], 1)
-        l.flush_table
-        io.rewind
-        io.read.should == '      | \\| | \\\\ |' + "\n"
+        l = Gherkin::Formatter::PrettyFormatter.new(io, true)
+        l.__send__(:table, [Gherkin::Parser::Row.new(['|', '\\'], [], nil)])
+        io.string.should == '      | \\| | \\\\ |' + "\n"
       end
     end
   end

data/spec/gherkin/i18n_lexer_spec.rb

@@ -1,26 +1,26 @@
 #encoding: utf-8
-require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+require 'spec_helper'
 
 module Gherkin
   describe I18nLexer do
     before do
-      @lexer = I18nLexer.new(SexpRecorder.new, false)
+      @lexer = Gherkin::I18nLexer.new(Gherkin::SexpRecorder.new, false)
     end
 
     it "should store the i18n language of the last scanned feature" do
-      @lexer.scan("# language: fr\n")
+      @lexer.scan("# language: fr\n", "fr.feature", 0)
       @lexer.i18n_language.iso_code.should == "fr"
-      @lexer.scan("# language: no\n")
+      @lexer.scan("# language: no\n", "en.feature", 0)
       @lexer.i18n_language.iso_code.should == "no"
     end
 
     it "should use English i18n by default" do
-      @lexer.scan("Feature: foo\n")
+      @lexer.scan("Feature: foo\n", "foo.feature", 0)
       @lexer.i18n_language.iso_code.should == "en"
     end
 
     it "should === its ruby class, even when the impl is Java" do
-      I18nLexer.should === I18nLexer.new(SexpRecorder.new, true)
+      Gherkin::I18nLexer.should === Gherkin::I18nLexer.new(Gherkin::SexpRecorder.new, true)
     end
   end
 end