gherkin 1.0.2-java

data/ragel/lexer.rb.rl.erb

@@ -0,0 +1,171 @@
+require 'gherkin/core_ext/array'
+
+module Gherkin
+  module RbLexer
+    class <%= @i18n.sanitized_key.capitalize %> #:nodoc:
+      %%{
+        machine lexer;
+ 
+        action begin_content {
+          @content_start = p
+          @current_line = @line_number
+        }
+
+        action start_pystring {
+          @current_line = @line_number
+          @start_col = p - @last_newline
+        }
+        
+        action begin_pystring_content {
+          @content_start = p
+        }
+
+        action store_pystring_content {
+          con = unindent(@start_col, data[@content_start...@next_keyword_start-1].utf8_pack("c*").sub(/(\r?\n)?( )*\Z/, ''))
+          @listener.py_string(con, @current_line) 
+        }
+ 
+        action store_feature_content {
+          store_keyword_content(:feature, data, p, eof) { |con| multiline_strip(con) }
+          p = @next_keyword_start - 1 if @next_keyword_start          
+          @next_keyword_start = nil
+        }
+ 
+        action store_background_content {
+          store_keyword_content(:background, data, p, eof) { |con| multiline_strip(con) }
+          p = @next_keyword_start - 1 if @next_keyword_start                    
+          @next_keyword_start = nil
+        }
+
+        action store_scenario_content {
+          store_keyword_content(:scenario, data, p, eof) { |con| multiline_strip(con) }
+          p = @next_keyword_start - 1 if @next_keyword_start                    
+          @next_keyword_start = nil
+        }
+
+        action store_scenario_outline_content {
+          store_keyword_content(:scenario_outline, data, p, eof) { |con| multiline_strip(con) }
+          p = @next_keyword_start - 1 if @next_keyword_start                    
+          @next_keyword_start = nil
+        }
+
+        action store_examples_content {
+          store_keyword_content(:examples, data, p, eof) { |con| multiline_strip(con) }
+          p = @next_keyword_start - 1 if @next_keyword_start                    
+          @next_keyword_start = nil
+        }
+
+        action store_step_content {
+          con = data[@content_start...p].utf8_pack("c*").strip
+          @listener.step(@keyword, con, @current_line)
+        }
+ 
+        action store_comment_content {
+          con = data[@content_start...p].utf8_pack("c*").strip
+          @listener.comment(con, @line_number)
+          @keyword_start = nil
+        }
+ 
+        action store_tag_content {
+          con = data[@content_start...p].utf8_pack("c*").strip
+          @listener.tag(con, @current_line)
+          @keyword_start = nil
+        }
+ 
+        action inc_line_number {
+          @line_number += 1
+        }
+ 
+        action last_newline {
+          @last_newline = p + 1
+        }
+
+        action start_keyword {
+          @keyword_start ||= p
+        }
+ 
+        action end_keyword {
+          @keyword = data[@keyword_start...p].utf8_pack("c*").sub(/:$/,'').strip
+          @keyword_start = nil
+        }
+ 
+        action next_keyword_start {
+          @next_keyword_start = p
+        }
+
+        action start_table {
+          p = p - 1
+          @rows = []
+          @current_line = @line_number
+        }
+
+        action start_row {
+          current_row = []
+        }
+ 
+        action begin_cell_content {
+          @content_start = p
+        }
+
+        action store_cell_content {
+          con = data[@content_start...p].utf8_pack("c*").strip
+          current_row << con
+        }
+
+        action store_row {
+          @rows << current_row
+        }
+
+        action store_table {
+          if @rows.size != 0
+            @listener.table(@rows, @current_line)
+          end 
+        }
+ 
+        action end_feature {
+          if cs < lexer_first_final
+            content = current_line_content(data, p)
+            raise Lexer::LexingError.new("Lexing error on line %d: '%s'." % [@line_number, content])
+          end
+        }
+
+        include lexer_common "lexer_common.<%= @i18n.sanitized_key %>.rl"; 
+      }%%
+ 
+      def initialize(listener)
+        @listener = listener
+        %% write data;
+      end
+ 
+      def scan(data)
+        data = (data + "\n%_FEATURE_END_%").unpack("c*") # Explicit EOF simplifies things considerably
+        eof = pe = data.length
+ 
+        @line_number = 1
+        @last_newline = 0
+ 
+        %% write init;
+        %% write exec;
+      end
+ 
+      def multiline_strip(text)
+        text.split("\n").map{|s| s.strip}.join("\n").strip
+      end
+
+      def unindent(startcol, text)
+        text.gsub(/^ {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 data[@content_start...end_point].utf8_pack("c*")
+        @listener.send(event, @keyword, con, @current_line)
+      end
+      
+      def current_line_content(data, p)
+        rest = data[@last_newline..-1]
+        rest[0..rest.index(10)||-1].utf8_pack("c*").strip
+      end
+    end
+  end
+end

data/ragel/lexer_common.rl.erb

@@ -0,0 +1,46 @@
+%%{
+  machine lexer_common;
+
+  # Language specific
+  I18N_Feature = (<%= ragel_list(@i18n.feature_keywords) %> ':') >start_keyword %end_keyword; 
+  I18N_Background = (<%= ragel_list(@i18n.background_keywords) %> ':') >start_keyword %end_keyword;
+  I18N_ScenarioOutline = (<%= ragel_list(@i18n.scenario_outline_keywords) %> ':') >start_keyword %end_keyword;
+  I18N_Scenario = (<%= ragel_list(@i18n.scenario_keywords) %> ':') >start_keyword %end_keyword;
+  I18N_Step = <%= ragel_list(@i18n.step_keywords) %> >start_keyword %end_keyword;
+  I18N_Examples = (<%= ragel_list(@i18n.examples_keywords) %> ':') >start_keyword %end_keyword;
+
+  EOF = '%_FEATURE_END_%'; # Explicit EOF added before scanning begins 
+  EOL = ('\r'? '\n') @inc_line_number @last_newline;
+
+  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;
+ 
+  FeatureHeading = space* I18N_Feature %begin_content ^FeatureHeadingEnd* :>> FeatureHeadingEnd @store_feature_content;
+  BackgroundHeading = space* I18N_Background %begin_content ^BackgroundHeadingEnd* :>> BackgroundHeadingEnd @store_background_content;
+  ScenarioHeading = space* I18N_Scenario %begin_content ^ScenarioHeadingEnd* :>> ScenarioHeadingEnd @store_scenario_content;
+  ScenarioOutlineHeading = space* I18N_ScenarioOutline %begin_content ^ScenarioOutlineHeadingEnd* :>> ScenarioOutlineHeadingEnd @store_scenario_outline_content;
+  ExamplesHeading = space* I18N_Examples %begin_content ^ExamplesHeadingEnd* :>> ExamplesHeadingEnd @store_examples_content;
+
+  Step = space* I18N_Step %begin_content ^EOL+ %store_step_content EOL+;
+  Comment = space* '#' >begin_content ^EOL* %store_comment_content EOL+;
+  
+  Tag = ( '@' [^@\r\n\t ]+ >begin_content ) %store_tag_content;
+  Tags = space* (Tag space*)+ EOL+;
+  
+  StartTable = space* '|' >start_table;
+  EndTable = EOL space* ^('|') >next_keyword_start;    
+  Cell = '|' (any - '|')* >begin_cell_content %store_cell_content;
+  Row = space* Cell* >start_row '|' :>> (space* EOL+ space*) %store_row;
+  Table = StartTable :>> Row+ %store_table <: EndTable?;
+  
+  StartPyString = '"""' >start_pystring space* :>> EOL; 
+  EndPyString = (space* '"""') >next_keyword_start; 
+  PyString = space* StartPyString %begin_pystring_content (^EOL | EOL)* :>> EndPyString %store_pystring_content space* EOL+;
+  
+  Tokens = (space | EOL)* (Tags | Comment | FeatureHeading | BackgroundHeading | ScenarioHeading | ScenarioOutlineHeading | ExamplesHeading | Step | Table | PyString)* (space | EOL)* EOF;
+
+  main := Tokens %end_feature @!end_feature;
+}%%

data/spec/gherkin/c_lexer_spec.rb

@@ -0,0 +1,21 @@
+#encoding: utf-8
+unless defined?(JRUBY_VERSION)
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+require 'gherkin/c_lexer'
+
+module Gherkin
+  module Lexer
+    describe "C Lexer" do
+      before do
+        @listener = Gherkin::SexpRecorder.new
+        @lexer = Gherkin::CLexer['en'].new(@listener)
+      end
+
+      it_should_behave_like "a Gherkin lexer"
+      it_should_behave_like "a Gherkin lexer lexing tags"
+      it_should_behave_like "a Gherkin lexer lexing py_strings"
+      it_should_behave_like "a Gherkin lexer lexing tables"
+    end
+  end
+end
+end

data/spec/gherkin/fixtures/1.feature

@@ -0,0 +1,8 @@
+Feature: Logging in
+  So that I can be myself
+  # Comment
+  Scenario: Anonymous user can get a login form.
+    Scenery here
+
+  @tag
+  Scenario: Another one

data/spec/gherkin/fixtures/complex.feature

@@ -0,0 +1,43 @@
+#Comment on line 1
+#Comment on line 2
+@tag1 @tag2
+Feature: Feature Text
+  In order to test multiline forms
+  As a ragel writer
+  I need to check for complex combinations
+
+  #Comment on line 9
+
+  #Comment on line 11
+
+  Background:
+    Given this is a background step
+    And this is another one
+
+  @tag3 @tag4
+  Scenario: Reading a Scenario
+    Given there is a step
+    But not another step
+
+  @tag3
+  Scenario: Reading a second scenario
+    #Comment on line 24
+    Given a third step with 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
+    #Comment on line 29
+    Then I am happy
+
+  Scenario: Hammerzeit
+    Given All work and no play
+      """
+      Makes Homer something something
+      """
+    Then crazy

data/spec/gherkin/fixtures/i18n_fr.feature

@@ -0,0 +1,13 @@
+Fonctionnalité: Addition
+  Plan du scénario: Addition de produits dérivés
+    Soit une calculatrice
+    Etant donné qu'on tape <a>
+    Et qu'on tape <b>
+    Lorsqu'on tape additionner
+    Alors le résultat doit être <somme>
+ 
+    Exemples:
+      | a | b | somme |
+      | 2 | 2 | 4     |
+      | 2 | 3 | 5     |
+

data/spec/gherkin/fixtures/i18n_no.feature

@@ -0,0 +1,6 @@
+Egenskap: i18n support
+
+  Scenario: Parsing many languages
+    Gitt Gherkin supports many languages
+    Når Norwegian keywords are parsed
+    Så they should be recognized

data/spec/gherkin/fixtures/i18n_zh-CN.feature

@@ -0,0 +1,8 @@
+功能:加法
+
+  场景: 两个数相加
+    假如我已经在计算器里输入6
+    而且我已经在计算器里输入7
+    当我按相加按钮
+    那么我应该在屏幕上看到的结果是13
+

data/spec/gherkin/fixtures/simple.feature

@@ -0,0 +1,3 @@
+Feature: Feature Text
+  Scenario: Reading a Scenario
+    Given there is a step

data/spec/gherkin/fixtures/simple_with_comments.feature

@@ -0,0 +1,7 @@
+# Here is a comment
+Feature: Feature Text
+# Here is another # comment
+  Scenario: Reading a Scenario
+# Here is a third comment
+    Given there is a step
+# Here is a fourth comment

data/spec/gherkin/fixtures/simple_with_tags.feature

@@ -0,0 +1,11 @@
+# FC
+@ft
+Feature: hi
+
+@st1 @st2   
+Scenario: First
+Given Pepper
+
+@st3 
+@st4    @ST5  @#^%&ST6**!
+Scenario: Second

data/spec/gherkin/i18n_lexer_spec.rb

@@ -0,0 +1,22 @@
+#encoding: utf-8
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+module Gherkin
+  describe I18nLexer do
+    before do
+      @lexer = I18nLexer.new(SexpRecorder.new)
+    end
+
+    it "should store the i18n language of the last scanned feature" do
+      @lexer.scan("# language: fr\n")
+      @lexer.language.key.should == "fr"
+      @lexer.scan("# language: no\n")
+      @lexer.language.key.should == "no"
+    end
+
+    it "should use English i18n by default" do
+      @lexer.scan("Feature: foo\n")
+      @lexer.language.key.should == "en"
+    end
+  end
+end

data/spec/gherkin/i18n_spec.rb

@@ -0,0 +1,57 @@
+#encoding: utf-8
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+module Gherkin
+  module Lexer
+    describe "i18n parsing" do
+      before do
+        @listener = Gherkin::SexpRecorder.new
+      end
+
+      def scan_file(lexer, file)
+        lexer.scan(File.new(File.dirname(__FILE__) + "/fixtures/" + file).read)
+      end
+
+      it "should recognize keywords in the language of the lexer" do
+        lexer = Gherkin::Lexer['no'].new(@listener)
+        scan_file(lexer, "i18n_no.feature")
+        @listener.to_sexp.should == [
+          [:feature, "Egenskap", "i18n support", 1], 
+          [:scenario, "Scenario", "Parsing many languages", 3], 
+          [:step, "Gitt", "Gherkin supports many languages", 4],
+          [:step, "Når",  "Norwegian keywords are parsed", 5],
+          [:step, "Så", "they should be recognized", 6]
+        ]
+      end
+
+      it "should parse languages without a space after keywords" do
+        lexer = Gherkin::Lexer['zh-CN'].new(@listener)
+        scan_file(lexer, "i18n_zh-CN.feature")
+        @listener.to_sexp.should == [
+          [:feature, "功能", "加法", 1],
+          [:scenario, "场景", "两个数相加", 3],
+          [:step, "假如", "我已经在计算器里输入6", 4],
+          [:step, "而且", "我已经在计算器里输入7", 5],
+          [:step, "当", "我按相加按钮", 6],
+          [:step, "那么", "我应该在屏幕上看到的结果是13", 7]
+        ] 
+      end
+
+      it "should parse languages with spaces after some keywords but not others" do
+        lexer = Gherkin::Lexer['fr'].new(@listener)
+        scan_file(lexer, "i18n_fr.feature")
+        @listener.to_sexp.should == [
+          [:feature, "Fonctionnalité", "Addition", 1],
+          [:scenario_outline, "Plan du scénario", "Addition de produits dérivés", 2],
+          [:step, "Soit", "une calculatrice", 3],
+          [:step, "Etant donné", "qu'on tape <a>", 4],
+          [:step, "Et", "qu'on tape <b>", 5],
+          [:step, "Lorsqu'", "on tape additionner", 6],
+          [:step, "Alors", "le résultat doit être <somme>", 7],
+          [:examples, "Exemples", "", 9],
+          [:table, [["a","b","somme"],["2","2","4"],["2","3","5"]], 10]
+        ]
+      end
+    end
+  end
+end

data/spec/gherkin/java_lexer_spec.rb

@@ -0,0 +1,20 @@
+#encoding: utf-8
+if defined?(JRUBY_VERSION)
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+module Gherkin
+  module JavaLexer
+    describe "Java Lexer" do
+      before do
+        @listener = Gherkin::SexpRecorder.new
+        @lexer = Gherkin::Lexer.java['en'].new(@listener)
+      end
+
+      it_should_behave_like "a Gherkin lexer"
+      it_should_behave_like "a Gherkin lexer lexing tags"
+      it_should_behave_like "a Gherkin lexer lexing py_strings"
+      it_should_behave_like "a Gherkin lexer lexing tables"
+    end
+  end
+end
+end