aslakhellesoy-gherkin 0.0.1

data/lib/gherkin/parser.rb

@@ -0,0 +1,11 @@
+require 'gherkin/parser/table'
+require 'gherkin/parser/misc'
+
+module Gherkin
+  module Parser
+    def self.[](lang)
+      require "gherkin/parser/feature_#{lang}"
+      Feature
+    end
+  end
+end

data/ragel/feature.rb.rl.erb

@@ -0,0 +1,117 @@
+module Gherkin
+  module Parser
+    class Feature
+      %%{
+        machine feature;
+ 
+        action begin_content {
+          @content_start = p
+        }
+      
+        action store_feature_content {
+          if !@backup or (p==eof)
+            con = data[@content_start...p].pack("c*")
+          else
+            con = data[@content_start...@backup].pack("c*")
+          end
+          con.strip!
+          @listener.feature(@keyword, con, @current_line)
+          if @backup
+            p = @backup-1
+          end
+          @backup = nil
+        }
+      
+        action store_background_content {
+          if !@backup or (p==eof)
+            con = data[@content_start...p].pack("c*")
+          else
+            con = data[@content_start...@backup].pack("c*")
+          end
+          @listener.background(@keyword, multiline_strip(con), @current_line)
+          if @backup
+            p = @backup-1
+          end
+          @backup = nil
+        }
+          
+        action store_scenario_content {
+          if !@backup or (p==eof)
+            con = data[@content_start...p].pack("c*")
+          else
+            con = data[@content_start...@backup].pack("c*")
+          end
+          @listener.scenario(@keyword, multiline_strip(con), @current_line)
+          if @backup
+            p = @backup-1
+          end
+          @backup = nil
+        }
+      
+        action store_step_content {
+          con = data[@content_start...p].pack("c*")
+          con.strip!
+          @listener.step(@keyword, con, @current_line)
+        }
+        
+        action store_comment_content {
+          con = data[@content_start...p].pack("c*")
+          con.strip!
+          @listener.comment(con, @line_number)
+        }
+        
+        action store_tag_content {
+          con = data[@content_start...p].pack("c*")
+          con.strip!
+          @listener.tag(con, @current_line)
+        }
+  
+        action inc_line_number {
+          @line_number += 1
+        }
+ 
+        action current_line {
+          @current_line = @line_number
+        }
+
+        action start_keyword {
+          @keyword_start ||= p
+        }
+ 
+        action end_keyword {
+          @keyword = data[@keyword_start...p].pack("c*").sub(/:$/,'').strip
+          @keyword_start = nil
+        }
+ 
+        action backup {
+          @backup = p
+        }
+  
+        action end_table {
+          table_to_parse = '|' + data[@content_start...p].pack("c*").strip
+          Gherkin::Parser::Table.new(@listener, @current_line).scan(table_to_parse)
+          p = p-1
+        }
+
+        include feature_common "feature_common.<%= lang %>.rl"; 
+      }%%
+  
+      def initialize(listener)
+        @listener = listener
+        %% write data;
+      end
+  
+      def scan(data)
+        data = data.unpack("c*") if data.is_a?(String)
+        @line_number = 1
+        eof = data.size
+        %% write init;
+        %% write exec;
+      end
+ 
+      def multiline_strip(text)
+        text.split("\n").map{|s| s.strip!}.join("\n")
+      end
+    end
+  end
+end

data/ragel/feature_common.rl.erb

@@ -0,0 +1,37 @@
+%%{
+  machine feature_common;
+
+  # Language specific
+  FEATURE = '<%= i18n['feature'] %>:' >start_keyword %end_keyword; 
+  BACKGROUND = '<%= i18n['background'] %>:' >start_keyword %end_keyword;
+  SCENARIO = '<%= i18n['scenario'] %>:' >start_keyword %end_keyword;
+  STEP = ('<%= i18n['given'] %> ' | '<%= i18n['when'] %> ' | '<%= i18n['and'] %> ' | '<%= i18n['then'] %> ' | '<%= i18n['but'] %> ') >start_keyword %end_keyword;
+ 
+  EOL = ('\r'? '\n') @inc_line_number;
+  BAR = '|' >start_keyword %end_keyword;
+
+  # Terminators
+  EndFeatureHeading = EOL+ space* (BACKGROUND | SCENARIO | '@' | '#');
+  EndScenarioHeading = EOL+ space* ( SCENARIO | STEP | '@' | '#' );
+  EndBackgroundHeading = EOL+ space* ( SCENARIO | STEP | '@' | '#' );
+  StartTable = space* '|';
+  EndTable = EOL space* ^('|' | space);
+
+  FeatureHeading = space* FEATURE %begin_content %current_line ^EndFeatureHeading* %/store_feature_content :>> EndFeatureHeading >backup @store_feature_content;
+  BackgroundHeading = space* BACKGROUND %begin_content %current_line ^EndBackgroundHeading* %/store_background_content :>> EndBackgroundHeading >backup @store_background_content;
+  ScenarioHeading = space* SCENARIO %begin_content %current_line ^EndScenarioHeading* %/store_scenario_content :>> EndScenarioHeading >backup @store_scenario_content;
+
+  Step = space* STEP %begin_content %current_line ^EOL+ %store_step_content %/store_step_content EOL+;  
+  Comment = space* '#' >begin_content ^EOL+ %store_comment_content %/store_comment_content EOL+;
+  Tag = ( '@' [^@\r\n\t ]+ >begin_content ) %store_tag_content;
+  Tags = space* (Tag @current_line space*)+ EOL+;  
+  Table = StartTable %begin_content %current_line any+ %/end_table :>> EndTable >backup @end_table;
+  
+  MultilineStep = Step Table?;
+  Scenario = ScenarioHeading (Comment | MultilineStep)*;
+  Background = BackgroundHeading (Comment | MultilineStep)*;
+
+  Feature = (Tags | Comment)* FeatureHeading (Tags | Comment)* Background? ((Tags | Comment)* Scenario)*;
+
+  main := Feature;
+}%%

data/ragel/misc.c.rl

@@ -0,0 +1,4 @@
+int main() {
+  printf("hello, world");
+  return 0;
+}

data/ragel/misc.rb.rl

@@ -0,0 +1,52 @@
+module Gherkin
+  module Parser
+    class Misc
+      %%{
+        machine misc;
+        
+        action start {
+          start_col = p - @last_newline
+          start = p + 4
+        }
+        
+        action start_line {
+          line_col = p - @last_newline
+          line_start = p
+        }
+        
+        action end_line {
+          line = data[line_start...p].pack("U*")
+          offset = line_col - start_col
+          @lines << (offset >= 0 ? line.gsub(/^/, ' ' * offset) : line)
+        }
+        
+        newline = ('\r'? '\n') @{ @last_newline = p + 1} ;
+        
+        PyStringStart = '"""' >start space* newline ;
+        PyStringEnd = '"""' ;
+        PyStringLine = space* ^newline* >start_line %end_line newline;
+        
+        PyString = PyStringStart PyStringLine* PyStringEnd ;
+
+        main := space* PyString ;
+      }%%
+      
+      def initialize(listener)
+        @listener = listener
+        @last_newline = 0
+        @lines = []
+        %% write data;
+      end
+      
+      def scan(data)
+        data = data.unpack("U*") if data.is_a?(String)
+        eof = data.length
+        
+        %% write init;
+        %% write exec;
+        
+        @listener.pystring(@lines.join("\n"))
+      end
+    end
+  end
+end

data/ragel/table.rb.rl

@@ -0,0 +1,54 @@
+module Gherkin
+  module Parser
+    class Table
+      %%{      
+        machine table;
+
+        action initialize {
+          current_row = []
+        }
+
+        action begin_content {
+          @content_start = p
+        }
+
+        action store_row {
+          @rows << current_row
+        }
+
+        action store_cell_content {
+          con = data[@content_start...p].pack("U*")
+          con.strip!
+          current_row << (con.empty? ? nil : con)
+        }
+
+        action no_content {
+          current_row << nil
+        }
+
+        include table_common "table_common.rl";
+      }%%
+
+      def initialize(listener,line=nil)
+        @line = line
+        @listener = listener
+        %% write data;
+      end
+
+      def scan(data)
+        @rows = []
+        data = data.unpack("U*") if data.is_a?(String)
+        eof = data.size
+    
+        %% write init;
+        %% write exec;
+      
+        if @line
+          @listener.table(@rows, @line)
+        else
+          @listener.table(@rows)
+        end
+      end
+    end
+  end
+end

data/ragel/table_common.rl

@@ -0,0 +1,12 @@
+%%{      
+  machine table_common;
+
+  EOL = '\r'? '\n';
+  BAR = '|';
+  cell_content = ^('|' | EOL);
+
+  cell = cell_content+ >begin_content BAR >store_cell_content | BAR >no_content;
+  table_row = space* BAR >initialize cell+ space* %/store_row space* :>> EOL; 
+  table = table_row+ @store_row;
+  main := table;
+}%%

data/spec/gherkin/feature_spec.rb

@@ -0,0 +1,439 @@
+#encoding: utf-8
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+module Gherkin
+  module Parser
+    describe "parsing" do
+      before do
+        @listener = Gherkin::SexpRecorder.new
+        @feature = Parser['en'].new(@listener)
+      end
+
+      def scan_file(file)
+        Feature.new(@listener).scan(File.new(File.dirname(__FILE__) + "/gherkin_parser/" + file).read)
+      end
+
+      describe "Comments" do
+        it "should parse a file with only a one line comment" do
+          @feature.scan("# My comment\nFeature: hi")
+          @listener.to_sexp.should == [
+            [:comment, "# My comment", 1],
+            [:feature, "Feature", "hi", 2],
+          ]
+        end
+
+        it "should parse a one line comment" do
+          @feature.scan("# My comment")
+          @listener.to_sexp.should == [[:comment, "# My comment", 1]]
+        end
+
+        it "should parse a file with only a multiline comment" do
+          @feature.scan("#Hello\n#World\nFeature: hi")
+          @listener.to_sexp.should == [
+            [:comment, "#Hello", 1],
+            [:comment, "#World", 2],
+            [:feature, "Feature", "hi", 3]
+          ] 
+        end
+
+        it "should parse a file with only a multiline comment" do
+          pending("TODO:  Do multiline comments need to be compressed into a single message?")
+          @feature.scan("# Hello\n# World\nFeature: hi")
+          @listener.to_sexp.should == [
+            [:comment, "# Hello\n# World", 1],
+            [:feature, "hi", 3]
+          ]
+        end
+
+        it "should parse a file with no comments" do
+          @feature.scan("Feature: hi\n")
+          @listener.to_sexp.should == [[:feature, "Feature", "hi", 1]]
+        end
+
+        it "should parse a file with only a multiline comment with newlines" do
+          pending("TODO:  Do multiline comments need to be compressed into a single message?")
+          @feature.scan("# Hello\n\n# World\n")
+          @listener.to_sexp.should == [[:comment, "# Hello\n\n# World\n"]]
+        end
+  
+        it "should not consume comments as part of a multiline name" do
+          @feature.scan("Feature: hi\n Scenario: test\n\n#hello\n Scenario: another")
+          @listener.to_sexp.should == [
+            [:feature, "Feature", "hi", 1],
+            [:scenario, "Scenario", "test", 2],
+            [:comment, "#hello", 4],
+            [:scenario, "Scenario", "another", 5]
+          ]
+        end
+      end
+
+      describe "Tags" do
+        it "should parse a file with tags on a feature" do
+          @feature.scan("# My comment\n@hello @world\nFeature: hi\n")
+          @listener.to_sexp.should == [
+            [:comment, "# My comment", 1],
+            [:tag, "hello", 2],
+            [:tag, "world", 2],
+            [:feature, "Feature", "hi", 3]
+          ]
+        end
+
+        it "should not take the tags as part of a multiline name feature element" do
+          @feature.scan("Feature: hi\n Scenario: test\n\n@hello\n Scenario: another")
+          @listener.to_sexp.should == [
+            [:feature, "Feature", "hi", 1],
+            [:scenario, "Scenario", "test", 2],
+            [:tag, "hello", 4],
+            [:scenario, "Scenario", "another", 5]
+          ]
+        end
+  
+        it "should parse a file with tags on a scenario" do
+          @feature.scan(%{# FC
+  @ft
+Feature: hi
+
+  @st1 @st2   
+  Scenario: First
+    Given Pepper
+
+@st3 
+   @st4    @ST5  @#^%&ST6**!
+  Scenario: Second})
+          @listener.to_sexp.should == [
+            [:comment, "# FC", 1],
+            [:tag, "ft",2],
+            [:feature, "Feature", "hi", 3],
+            [:tag, "st1", 5],
+            [:tag, "st2", 5],
+            [:scenario, "Scenario", "First", 6],
+            [:step, "Given", "Pepper", 7],
+            [:tag, "st3", 9],
+            [:tag, "st4", 10],
+            [:tag, "ST5", 10],
+            [:tag, "#^%&ST6**!", 10],
+            [:scenario, "Scenario", "Second", 11]
+          ]
+        end
+      end
+
+      describe "Background" do
+        it "should allow an empty background description" do
+          @feature.scan("Feature: Hi\nBackground:\nGiven I am a step\n")
+          @listener.to_sexp.should == [
+            [:feature, "Feature", "Hi", 1],
+            [:background, "Background", "", 2],
+            [:step, "Given", "I am a step", 3]
+          ]
+        end
+        
+        it "should allow multiline names ending at eof" do
+          @feature.scan("Feature: Feature Text\n  Background: I have several\n   Lines to look at\n None starting with Given")
+          @listener.to_sexp.should == [
+            [:feature, "Feature", "Feature Text", 1],
+            [:background, "Background", "I have several\nLines to look at\nNone starting with Given", 2]
+          ]
+        end
+        
+        it "should have steps" do
+          @feature.scan("Feature: Hi\nBackground: Run this first\nGiven I am a step\n")
+          @listener.to_sexp.should == [
+            [:feature, "Feature", "Hi", 1],
+            [:background, "Background", "Run this first", 2],
+            [:step, "Given", "I am a step", 3]
+          ]
+        end
+
+        it "should find scenarios after background" do
+          @feature.scan("Feature: Hi\n#This needs to run first\nBackground: Run this first\nGiven I am a step\n\n  Scenario: A Scenario\nGiven I am a step")
+          @listener.to_sexp.should == [
+            [:feature, "Feature", "Hi", 1],
+            [:comment, "#This needs to run first", 2],
+            [:background, "Background", "Run this first", 3],
+            [:step, "Given", "I am a step", 4],
+            [:scenario, "Scenario", "A Scenario", 6],
+            [:step, "Given", "I am a step", 7]
+          ]
+        end
+ 
+        it "should allow multiline names" do
+          @feature.scan(%{Feature: Hi
+Background: It is my ambition to say 
+            in ten sentences
+            what others say 
+            in a whole book.
+Given I am a step})
+          @listener.to_sexp.should == [
+            [:feature, "Feature", "Hi", 1],
+            [:background, "Background", "It is my ambition to say\nin ten sentences\nwhat others say\nin a whole book.",2],
+            [:step, "Given", "I am a step", 6]
+          ]
+        end
+      end
+
+      describe "Scenarios" do
+        it "can be empty" do
+          @feature.scan("Feature: Hi\n\nScenario: Hello\n")
+          @listener.to_sexp.should == [
+            [:feature, "Feature", "Hi", 1],
+            [:scenario, "Scenario", "Hello", 3]
+          ]
+        end
+ 
+        it "should allow whitespace lines after the Scenario line" do
+          @feature.scan(%{Feature: Foo
+
+Scenario: bar
+
+  Given baz})
+          @listener.to_sexp.should == [
+            [:feature, "Feature", "Foo", 1],
+            [:scenario, "Scenario", "bar", 3],
+            [:step, "Given", "baz", 5]
+          ]
+        end
+
+        it "should have steps" do
+          @feature.scan("Feature: Hi\nScenario: Hello\nGiven I am a step\n")
+          @listener.to_sexp.should == [
+            [:feature, "Feature", "Hi", 1],
+            [:scenario, "Scenario", "Hello", 2],
+            [:step, "Given", "I am a step", 3]
+          ]
+        end
+
+        it "should have steps with inline table" do
+          @feature.scan(%{Feature: Hi
+Scenario: Hello
+Given I have a table 
+|a|b|
+})
+          @listener.to_sexp.should == [
+            [:feature, "Feature", "Hi", 1],
+            [:scenario, "Scenario", "Hello", 2],
+            [:step, "Given", "I have a table", 3],
+            [:table, [['a','b']], 4]
+          ]
+        end
+        
+        it "should allow multiple steps each with tables" do
+          @feature.scan(%{Feature: Hi
+Scenario: Hello
+Given I have a table 
+|a|b|
+|c|d|
+|e|f|
+And I am still testing things
+  |g|h|
+  |e|r|
+  |k|i|
+  |n|| 
+And I am done testing these tables
+})
+          @listener.to_sexp.should == [
+            [:feature, "Feature", "Hi", 1],
+            [:scenario, "Scenario", "Hello", 2],
+            [:step, "Given", "I have a table", 3],
+            [:table, [['a','b'],['c','d'],['e','f']], 4],
+            [:step, "And", "I am still testing things", 7],
+            [:table, [['g','h'],['e','r'],['k','i'],['n',nil]], 8],
+            [:step, "And", "I am done testing these tables", 12],
+          ]
+        end
+
+        it "should have steps with inline py_string" do
+          pending
+          @feature.scan(%{Feature: Hi
+Scenario: Hello
+Given I have a string
+
+
+   """
+  hello
+  world
+  """
+
+})
+          @listener.to_sexp.should == [
+            [:feature, "Feature", "Hi", 1],
+            [:scenario, "Scenario", "Hello", 2],
+            [:step, "Given", "I have a string", 3],
+            [:py_string, "hello\nworld"]
+          ]
+        end
+
+        it "should allow multiline names" do
+          @feature.scan(%{Feature: Hi
+Scenario: It is my ambition to say
+          in ten sentences
+          what others say 
+          in a whole book.
+Given I am a step
+
+})
+          @listener.to_sexp.should == [
+            [:feature, "Feature", "Hi", 1],
+            [:scenario, "Scenario", "It is my ambition to say\nin ten sentences\nwhat others say\nin a whole book.", 2],
+            [:step, "Given", "I am a step", 6]
+          ]
+        end
+
+        it "should allow multiline names ending at eof" do
+          @feature.scan("Feature: Feature Text\n  And some more text\n\n  Scenario: I have several\n       Lines to look at\n None starting with Given")
+          @listener.to_sexp.should == [
+            [:feature, "Feature", "Feature Text\n  And some more text", 1],
+            [:scenario, "Scenario", "I have several\nLines to look at\nNone starting with Given", 4]
+          ]
+        end
+  
+        it "should ignore gherkin keywords which are parts of other words in the name" do
+          @feature.scan(%{Feature: Parser bug
+Scenario: I have a Button
+          Buttons are great
+  Given I have it
+})
+          @listener.to_sexp.should == [
+            [:feature, "Feature", "Parser bug", 1],
+            [:scenario, "Scenario", "I have a Button\nButtons are great", 2],
+            [:step, "Given", "I have it", 4]
+          ]
+        end
+      end
+
+      describe "A single feature, single scenario, single step" do
+        
+        it "should find the feature, scenario, and step" do
+          @feature.scan("Feature: Feature Text\n  Scenario: Reading a Scenario\n    Given there is a step\n")
+          @listener.to_sexp.should == [
+            [:feature, "Feature", "Feature Text", 1],
+            [:scenario, "Scenario", "Reading a Scenario", 2],
+            [:step, "Given", "there is a step", 3]
+          ]
+        end
+      end
+
+      describe "A single feature, single scenario, three steps" do
+        
+        it "should find the feature, scenario, and three steps" do
+          @feature.scan("Feature: Feature Text\n  Scenario: Reading a Scenario\n    Given there is a step\n    And another step\n   And a third step\n")
+          @listener.to_sexp.should == [
+            [:feature, "Feature", "Feature Text", 1],
+            [:scenario, "Scenario", "Reading a Scenario", 2],
+            [:step, "Given", "there is a step", 3],
+            [:step, "And", "another step", 4],
+            [:step, "And", "a third step", 5]
+          ]
+        end
+      end
+
+      describe "A single feature with no scenario" do
+        it "should find the feature" do
+          @feature.scan("Feature: Feature Text\n")
+          @listener.to_sexp.should == [[:feature, "Feature", "Feature Text", 1]]
+        end
+
+        it "should parse a one line feature with no newline" do
+          @feature.scan("Feature: hi")
+          @listener.to_sexp.should == [[:feature, "Feature", "hi", 1]]
+        end
+      end
+      
+      describe "A multi-line feature with no scenario" do
+        it "should find the feature" do
+          @feature.scan("Feature: Feature Text\n  And some more text")
+          @listener.to_sexp.should == [[:feature, "Feature", "Feature Text\n  And some more text", 1]]
+        end
+      end
+
+      describe "A feature with a scenario but no steps" do
+        it "should find the feature and scenario" do
+          @feature.scan("Feature: Feature Text\nScenario: Reading a Scenario\n")
+          @listener.to_sexp.should == [
+            [:feature, "Feature", "Feature Text", 1],
+            [:scenario, "Scenario", "Reading a Scenario", 2]
+          ]
+        end
+      end
+
+      describe "A feature with two scenarios" do
+        it "should find the feature and two scenarios" do
+          @feature.scan("Feature: Feature Text\nScenario: Reading a Scenario\n  Given a step\n\nScenario: A second scenario\n Given another step\n")
+          @listener.to_sexp.should == [
+            [:feature, "Feature", "Feature Text", 1],
+            [:scenario, "Scenario", "Reading a Scenario", 2],
+            [:step, "Given", "a step", 3],
+            [:scenario, "Scenario", "A second scenario", 5],
+            [:step, "Given", "another step", 6]
+          ]
+        end
+        
+        it "should find the feature and two scenarios without indentation" do
+          @feature.scan("Feature: Feature Text\nScenario: Reading a Scenario\nGiven a step\nScenario: A second scenario\nGiven another step\n")
+          @listener.to_sexp.should == [
+            [:feature, "Feature", "Feature Text", 1],
+            [:scenario, "Scenario", "Reading a Scenario", 2],
+            [:step, "Given", "a step", 3],
+            [:scenario, "Scenario", "A second scenario", 4],
+            [:step, "Given", "another step", 5]
+          ]
+        end
+      end
+
+      describe "A simple feature with comments" do
+        it "should find the feature, scenarios, steps, and comments in the proper order" do
+          scan_file("simple_with_comments.feature")
+          @listener.to_sexp.should == [
+            [:comment, "# Here is a comment", 1],
+            [:feature, "Feature", "Feature Text", 2],
+            [:comment, "# Here is another # comment", 3],
+            [:scenario, "Scenario", "Reading a Scenario", 4],
+            [:comment, "# Here is a third comment", 5],
+            [:step, "Given", "there is a step", 6],
+            [:comment, "# Here is a fourth comment", 7]
+          ]
+        end
+      end
+      
+      describe "A simple feature with tags" do
+        it "should find the feature, scenario, step, and tags in the proper order" do
+          scan_file("simple_with_tags.feature")
+          @listener.to_sexp.should == [
+            [:tag, "tag1", 1],
+            [:tag, "tag2", 1],
+            [:feature, "Feature", "Feature Text", 2],
+            [:tag, "tag3", 3],
+            [:tag, "tag4", 3],
+            [:scenario, "Scenario", "Reading a Scenario", 4],
+            [:step, "Given", "there is a step", 5]
+          ]
+        end
+      end
+   
+      describe "A complex feature with tags, comments, multiple scenarios, and multiple steps" do
+        it "should find things in the right order" do
+          scan_file("complex.feature")
+          @listener.to_sexp.should == [
+            [:comment, "#Comment on line 1", 1],
+            [:tag, "tag1", 2],
+            [:tag, "tag2", 2],
+            [:comment, "#Comment on line 3", 3],
+            [:feature, "Feature", "Feature Text\n  In order to test multiline forms\n  As a ragel writer\n  I need to check for complex combinations", 4],
+            [:comment, "#Comment on line 9", 9],
+            [:comment, "#Comment on line 11", 11],
+            [:tag, "tag3", 13],
+            [:tag, "tag4", 13],
+            [:scenario, "Scenario", "Reading a Scenario", 14],
+            [:step, "Given", "there is a step", 15],
+            [:step, "But", "not another step", 16],
+            [:tag, "tag3", 18],
+            [:scenario, "Scenario", "Reading a second scenario", 19],
+            [:comment, "#Comment on line 20", 20],
+            [:step, "Given", "a third step", 21],
+            [:comment, "#Comment on line 22", 22],
+            [:step, "Then", "I am happy", 23]
+          ]
+        end
+      end
+    end
+  end
+end