gherkin 1.0.2 → 1.0.3

data/spec/gherkin/shared/py_string_spec.rb

@@ -50,6 +50,7 @@ EOS
         @lexer.scan ps("A\n\nB")
         @listener.to_sexp.should == [
           [:py_string, "A\n\nB", 1],
+          [:eof]
         ]
       end
       
@@ -119,6 +120,11 @@ EOS
         @listener.should_receive(:py_string).with("PyString text\n\n",1)
         @lexer.scan(str)
       end        
+
+      it "should preserve CRLFs within py_strings" do
+        @listener.should_receive(:py_string).with("Line one\r\nLine two\r\n", 1)
+        @lexer.scan("\"\"\"\r\nLine one\r\nLine two\r\n\r\n\"\"\"")
+      end
     end
   end
 end

data/spec/gherkin/shared/row_spec.rb

@@ -0,0 +1,107 @@
+# encoding: utf-8
+require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
+
+module Gherkin
+  module Lexer
+    shared_examples_for "a Gherkin lexer lexing rows" do
+      rows = {
+        "|a|b|\n"        => %w{a b},
+        "|a|b|c|\n"      => %w{a b c},
+      }
+    
+      rows.each do |text, expected|
+        it "should parse #{text}" do
+          @listener.should_receive(:row).with(r(expected), 1)
+          @lexer.scan(text.dup)
+        end
+      end
+
+      it "should parse a row with many cells" do
+        @listener.should_receive(:row).with(r(%w{a b c d e f g h i j k l m n o p}), 1)
+        @lexer.scan("|a|b|c|d|e|f|g|h|i|j|k|l|m|n|o|p|\n")
+      end
+    
+      it "should parse multicharacter cell content" do
+        @listener.should_receive(:row).with(r(%w{foo bar}), 1)
+        @lexer.scan("| foo | bar |\n")
+      end
+    
+      it "should parse cells with spaces within the content" do
+        @listener.should_receive(:row).with(r(["Dill pickle", "Valencia orange"]), 1)
+        @lexer.scan("| Dill pickle | Valencia orange |\n")
+      end
+      
+      it "should allow utf-8" do
+        #  Fails in 1.9.1! 
+        #  'Gherkin::Lexer::Table should allow utf-8 with using == to evaluate' FAILED 
+        #    expected: [[:row, [["ůﻚ", "2"]], 1]],
+        #         got: [[:row, [["\xC5\xAF\xEF\xBB\x9A", "2"]], 1]] (using ==)
+        #  BUT, simply running:
+        #     [[:row, [["ůﻚ", "2"]], 1]].should == [[:row, [["\xC5\xAF\xEF\xBB\x9A", "2"]], 1]] 
+        #  passes
+        #
+        @lexer.scan(" | ůﻚ | 2 | \n")
+        @listener.to_sexp.should == [
+          [:row, ["ůﻚ", "2"], 1],
+          [:eof]
+        ]
+      end 
+
+      it "should allow utf-8 using should_receive" do
+        @listener.should_receive(:row).with(r(['繁體中文  而且','並且','繁體中文  而且','並且']), 1)
+        @lexer.scan("| 繁體中文  而且|並且| 繁體中文  而且|並且|\n")
+      end
+
+      it "should parse a 2x2 table" do
+        @listener.should_receive(:row).with(r(%w{1 2}), 1)
+        @listener.should_receive(:row).with(r(%w{3 4}), 2)
+        @lexer.scan("| 1 | 2 |\n| 3 | 4 |\n")
+      end
+
+      it "should parse a 2x2 table with empty cells" do
+        @listener.should_receive(:row).with(r(['1', '']), 1)
+        @listener.should_receive(:row).with(r(['', '4']), 2)
+        @lexer.scan("| 1 |  |\n|| 4 |\n")
+      end
+
+      it "should parse a row with empty cells" do
+        @listener.should_receive(:row).with(r(['1', '']), 1).twice
+        @lexer.scan("| 1 |  |\n")
+        @lexer.scan("|1||\n")
+      end
+    
+      it "should parse a 1x2 table that does not end in a newline" do
+        @listener.should_receive(:row).with(r(%w{1 2}), 1)
+        @lexer.scan("| 1 | 2 |")
+      end
+
+      it "should parse a row without spaces and with a newline" do
+        @listener.should_receive(:row).with(r(%w{1 2}), 1)
+        @lexer.scan("|1|2|\n")
+      end
+      
+      it "should parse a row with whitespace after the rows" do
+        @listener.should_receive(:row).with(r(%w{1 2}), 1)
+        @lexer.scan("| 1 | 2 | \n ")
+      end
+      
+      it "should parse a row with lots of whitespace" do
+        @listener.should_receive(:row).with(r(["abc", "123"]), 1)
+        @lexer.scan("  \t| \t   abc\t| \t123\t \t\t| \t\t   \t \t\n  ")
+      end
+
+      it "should parse a table with a commented-out row" do
+        @listener.should_receive(:row).with(r(["abc"]), 1)
+        @listener.should_receive(:comment).with("#|123|", 2)
+        @listener.should_receive(:row).with(r(["def"]), 3)
+        @lexer.scan("|abc|\n#|123|\n|def|\n") 
+      end
+      
+      it "should raise LexingError for rows that aren't closed" do
+        lambda { 
+          @lexer.scan("|| oh hello \n") 
+        }.should raise_error(/Parsing error on line 1: '|| oh hello/)
+      end
+    end
+  end
+end

data/spec/gherkin/shared/tags_spec.rb

@@ -1,4 +1,4 @@
-#encoding: utf-8
+# encoding: utf-8
 require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
 
 module Gherkin

data/spec/gherkin/tools/colors_spec.rb

@@ -0,0 +1,19 @@
+require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
+require 'gherkin/tools/pretty_listener'
+
+
+module Gherkin
+  module Tools
+    describe Colors do
+      include Colors
+
+      it "should colour stuff red" do
+        failed("hello").should == "\e[31mhello\e[0m"
+      end
+
+      it "should be possible to specify no colouring" do
+        failed("hello", true).should == "hello"
+      end
+    end
+  end
+end

data/spec/gherkin/tools/pretty_listener_spec.rb

@@ -0,0 +1,147 @@
+# encoding: utf-8
+require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
+require 'gherkin/tools/pretty_listener'
+require 'gherkin/format/argument'
+require 'stringio'
+
+module Gherkin
+  module Tools
+    describe PrettyListener do
+      def assert_io(s)
+        @io.rewind
+        actual = @io.read
+        actual.should == s
+      end
+      
+      def assert_pretty(text)
+        io = StringIO.new
+        l = PrettyListener.new(io, true)
+        parser = Gherkin::Parser.new(l, true, "root")
+        lexer  = Gherkin::I18nLexer.new(parser, true)
+        lexer.scan(text)
+        io.rewind
+        actual = io.read
+        actual.should == text
+      end
+
+      before do
+        @io = StringIO.new
+        @l = PrettyListener.new(@io, true)
+      end
+
+      it "should print comments when scenario is longer" do
+        @l.feature("Feature", "Hello\nWorld", 1)
+        @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, "features/step_definitions/bar.rb:56")
+        @l.step("When ", "foo", 6, nil, nil, "features/step_definitions/bar.rb:96")
+
+        assert_io(%{Feature: Hello
+  World
+
+  Scenario: The scenario # features/foo.feature:4
+    Given some stuff     # features/step_definitions/bar.rb:56
+    When foo             # features/step_definitions/bar.rb:96
+})
+      end
+
+      it "should print comments when step is longer" 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, "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 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, "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, [Gherkin::Format::Argument.new(7, '999')], nil)
+        assert_io("    Given I have 999 cukes in my belly\n")
+      end
+
+      it "should prettify scenario" do
+        assert_pretty(%{Feature: Feature Description
+  Some preamble
+
+  Scenario: Scenario Description
+    Given there is a step
+      """
+      with
+        pystrings
+      """
+    And there is another step
+      | æ | o |
+      | a | ø |
+    Then we will see steps
+})
+      end
+
+
+      it "should prettify scenario outline with table" do
+        assert_pretty(%{# A feature comment
+@foo
+Feature: Feature Description
+  Some preamble
+
+  # A Scenario Outline comment
+  @bar
+  Scenario Outline: Scenario Ouline Description
+    Given there is a
+      """
+      string with <foo>
+      """
+    And a table with
+      | <bar> |
+      | <baz> |
+
+    @zap @boing
+    Examples: Examples Description
+      | foo    | bar  | baz         |
+      | Banana | I    | am hungry   |
+      | Beer   | You  | are thirsty |
+      | Bed    | They | are tired   |
+})
+      end
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -2,6 +2,7 @@ $LOAD_PATH.unshift(File.dirname(__FILE__))
 $LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
 $LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'spec/gherkin'))
 require 'gherkin'
+require 'stringio'
 require 'gherkin/sexp_recorder'
 require 'rubygems'
 require 'spec'
@@ -9,7 +10,30 @@ require 'spec/autorun'
 require 'shared/lexer_spec'
 require 'shared/tags_spec'
 require 'shared/py_string_spec'
-require 'shared/table_spec'
+require 'shared/row_spec'
+
+if defined?(JRUBY_VERSION)
+  class OutputStreamStringIO < java.io.ByteArrayOutputStream
+    def rewind
+    end
+
+    def read
+      toString("UTF-8")
+    end
+  end
+end
+
+class StringIO
+  class << self
+    def new
+      if defined?(JRUBY_VERSION)
+        OutputStreamStringIO.new
+      else
+        super
+      end
+    end
+  end
+end
 
 module GherkinSpecHelper
   def scan_file(file)
@@ -21,13 +45,13 @@ Spec::Runner.configure do |c|
   c.include(GherkinSpecHelper)
 end
 
-# Allows comparison of Java List with Ruby Array (tables)
-Spec::Matchers.define :t do |expected|
-  match do |table|
-    def table.inspect
-      "t " + self.map{|row| row.map{|cell| cell}}.inspect
+# Allows comparison of Java List with Ruby Array (rows)
+Spec::Matchers.define :r do |expected|
+  match do |row|
+    def row.inspect
+      "r " + self.map{|cell| cell}.inspect
     end
-    table.map{|row| row.map{|cell| cell}}.should == expected
+    row.map{|cell| cell}.should == expected
   end
 end
 

data/tasks/compile.rake

@@ -8,7 +8,10 @@ CLEAN.include [
   'ragel/i18n/*.rl',
   'lib/gherkin/rb_lexer/*.rb',
   'ext/**/*.c',
-  'java/src/gherkin/lexer/*.java'
+  'java/src/gherkin/lexer/*.java',
+  'dotnet/Gherkin/Lexer',
+  'dotnet/Gherkin/obj',
+  'dotnet/Gherkin/bin'
 ]
 
 desc "Compile the Java extensions"
@@ -16,12 +19,83 @@ task :jar do
   sh("ant -f java/build.xml")
 end
 
-Gherkin::I18n.all.each do |i18n|
-  java = RagelTask.new('java', i18n)
-  rb   = RagelTask.new('rb', i18n)
+namespace :dotnet do
+  require 'albacore'
 
-  task :jar     => java.target
-  task :jar     => rb.target
+  FileList['lib/gherkin/parser/*'].each do |src|
+    dst = "dotnet/Gherkin/StateMachine/#{File.basename(src)}"
+    file dst => src do
+      cp src, dst, :verbose => true    
+    end
+    task :compile => dst
+  end
+
+  task :compile => :lexer
+
+  if (`which mono` rescue "") =~ /mono/
+    xbuild :compile do |msb|
+      msb.properties :configuration => :Release
+      msb.targets :Build
+      msb.solution = 'dotnet/Gherkin.sln'
+    end
+
+    require 'rake/xunittask'
+    class XUnitTestRunner
+      def execute
+        system("mono dotnet/lib/xunit/xunit.console.exe dotnet/Gherkin.Tests/bin/Release/Gherkin.Tests.dll")
+        exit 1 if $? != 0
+      end
+    end
+  else
+    msbuild :compile do |msb|
+      msb.properties :configuration => :Release
+      msb.targets :Build
+      msb.solution = 'dotnet/Gherkin.sln'
+    end
+  end
+
+  xunit :test => :compile do |xunit|
+    xunit.path_to_command = "dotnet/lib/xunit/xunit.console.exe"
+    xunit.assembly = "dotnet/Gherkin.Tests/bin/Release/Gherkin.Tests.dll"
+  end
+
+  task :package => :test do
+    cp 'dotnet/Gherkin/bin/Release/Gherkin.dll', 'lib/Gherkin.dll'
+  end
+end
+
+desc "Compile and package the .NET extensions"
+task :dotnet => ['dotnet:package']
+
+class CSharpSByteFixTask
+  def initialize(source)
+    @source = source
+    define_tasks
+  end
+
+  def define_tasks
+    directory File.dirname(target)
+    file target => [File.dirname(target), @source] do
+      sh "cat #{@source} | sed ""s/sbyte/short/g"" > #{target}"
+    end
+  end
+
+  def target
+    "dotnet/Gherkin/Lexer/#{File.basename(@source)}"
+  end
+end
+
+rl_langs = ENV['RL_LANGS'] ? ENV['RL_LANGS'].split(',') : []
+langs = Gherkin::I18n.all.select { |lang| rl_langs.empty? || rl_langs.include?(lang.key) }
+
+langs.each do |i18n|
+  java       = RagelTask.new('java', i18n)
+  rb         = RagelTask.new('rb', i18n)
+  csharp_tmp = RagelTask.new('csharp', i18n)
+  csharp     = CSharpSByteFixTask.new(csharp_tmp.target)
+
+  task :jar             => [java.target, rb.target]
+  task 'dotnet:lexer'   => csharp.target
 
   begin
   unless defined?(JRUBY_VERSION)
@@ -67,4 +141,4 @@ EOF
       task :compile # no-op
     end
   end
-end
+end