aslakhellesoy-gherkin 0.0.1

data/spec/gherkin/gherkin_parser/complex.feature

@@ -0,0 +1,23 @@
+#Comment on line 1
+@tag1 @tag2
+#Comment on line 3
+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
+
+  @tag3 @tag4
+  Scenario: Reading a Scenario
+    Given there is a step
+    But not another step
+
+  @tag3
+  Scenario: Reading a second scenario
+    #Comment on line 20
+    Given a third step
+    #Comment on line 22
+    Then I am happy

data/spec/gherkin/gherkin_parser/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/gherkin_parser/simple.feature

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

data/spec/gherkin/gherkin_parser/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/gherkin_parser/simple_with_tags.feature

@@ -0,0 +1,5 @@
+@tag1 @tag2
+Feature: Feature Text
+  @tag3 @tag4
+  Scenario: Reading a Scenario
+    Given there is a step

data/spec/gherkin/i18n_spec.rb

@@ -0,0 +1,28 @@
+#encoding: utf-8
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+module Gherkin
+  module Parser
+    describe "i18n parsing" do
+      before do
+        @listener = Gherkin::SexpRecorder.new
+        @parser = Parser['no'].new(@listener)
+      end
+
+      def scan_file(file)
+        @parser.scan(File.new(File.dirname(__FILE__) + "/gherkin_parser/" + file).read)
+      end
+
+      it "should recognize keywords in the language of the parser" do
+        scan_file("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
+    end
+  end
+end

data/spec/gherkin/multiline_step_args_spec.rb

@@ -0,0 +1,98 @@
+# encoding: utf-8
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+module Gherkin
+  module Parser
+    describe "parsing multiline step arguments (pystrings)" do
+            
+      def ps(content)
+        '"""%s"""' % ("\n" + content + "\n")
+      end
+      
+      def indent(s, n)
+        if n >= 0
+          s.gsub(/^/, ' ' * n)
+        else
+          s.gsub(/^ {0,#{-n}}/, "")
+        end
+      end
+            
+      before do
+        @listener = mock('listener')
+        @parser = Misc.new(@listener)
+      end
+      
+      it "should provide the amount of indentation to the listener"
+
+      it "should parse a simple pystring" do
+        @listener.should_receive(:pystring).with("I am a pystring")
+        @parser.scan ps("I am a pystring")
+      end
+
+      it "should parse an empty pystring" do
+        @listener.should_receive(:pystring).with("")
+        @parser.scan ps("")
+      end
+
+      it "should parse a string containing only newlines" do
+        @listener.should_receive(:pystring).with("\n\n")
+        @parser.scan ps("\n\n")
+      end
+      
+      it "should parse a content separated by two newlines" do
+        @listener.should_receive(:pystring).with("A\n\nB")
+        @parser.scan ps("A\n\nB")
+      end
+      
+      it "should parse a multiline string" do
+        @listener.should_receive(:pystring).with("A\nB\nC\nD")
+        @parser.scan ps("A\nB\nC\nD")
+      end
+            
+      it "should ignore unescaped quotes inside the string delimeters" do
+        @listener.should_receive(:pystring).with("What does \"this\" mean?")
+        @parser.scan ps('What does "this" mean?')
+      end
+      
+      it "should remove whitespace up to the column of the opening quote" do
+        @listener.should_receive(:pystring).with("I have been indented for reasons of style")
+        @parser.scan indent(ps('I have been indented for reasons of style'), 4)
+      end
+      
+      it "should preserve whitespace after the column of the opening quote" do
+        @listener.should_receive(:pystring).with("  I have been indented to preserve whitespace")
+        @parser.scan indent(ps('  I have been indented to preserve whitespace'), 4)
+      end
+      
+      it "should preserve tabs within the content" do
+        @listener.should_receive(:pystring).with("I have\tsome tabs\nInside\t\tthe content")
+        @parser.scan ps("I have\tsome tabs\nInside\t\tthe content")
+      end
+  
+      it "should handle complex pystrings" do
+        pystring = %{
+# Feature comment
+@one
+Feature: Sample
+
+  @two @three
+  Scenario: Missing
+    Given missing
+
+1 scenario (1 passed)
+1 step (1 passed)
+
+}
+        
+        @listener.should_receive(:pystring).with(pystring)
+        @parser.scan ps(pystring)
+      end
+
+      it "should set indentation to zero if the content begins before the start delimeter" do
+        pystring = "    \"\"\"\nContent\n\"\"\""
+        @listener.should_receive(:pystring).with("Content")
+        @parser.scan(pystring)
+      end
+    end
+  end
+end

data/spec/gherkin/sexp_recorder.rb

@@ -0,0 +1,15 @@
+module Gherkin
+  class SexpRecorder
+    def initialize
+      @sexps = []
+    end
+
+    def method_missing(m, *args)
+      @sexps << [m] + args
+    end
+
+    def to_sexp
+      @sexps
+    end
+  end
+end

data/spec/gherkin/table_spec.rb

@@ -0,0 +1,83 @@
+# encoding: utf-8
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+module Gherkin
+  module Parser
+    describe Table do
+      before do
+        @listener = Gherkin::SexpRecorder.new
+        @table = Table.new(@listener)
+      end
+    
+      tables = {
+        "|a|b|\n"        => [%w{a b}],
+        "|a|b|c|\n"      => [%w{a b c}],
+        "|c|d|\n|e|f|\n" => [%w{c d}, %w{e f}]
+      }
+    
+      tables.each do |text, expected|
+        it "should parse #{text}" do
+          @listener.should_receive(:table).with(expected)
+          @table.scan(text)
+        end
+      end      
+    
+      it "should parse a multicharacter cell content" do
+        @listener.should_receive(:table).with([%w{foo bar}])
+        @table.scan("| foo | bar |\n")
+      end
+    
+      it "should parse cells with spaces within the content" do
+        @listener.should_receive(:table).with([["Dill pickle", "Valencia orange"], ["Ruby red grapefruit", "Tire iron"]])
+        @table.scan("| Dill pickle | Valencia orange |\n| Ruby red grapefruit | Tire iron |\n")
+      end
+
+      it "should parse a 1x2 table with newline" do
+        @listener.should_receive(:table).with([%w{1 2}])
+        @table.scan("| 1 | 2 |\n")
+      end
+    
+      it "should allow utf-8" do
+        @listener.should_receive(:table).with([%w{ůﻚ 2}])
+        @table.scan(" | ůﻚ | 2 | \n")
+      end
+
+      it "should parse a 2x2 table" do
+        @listener.should_receive(:table).with([%w{1 2}, %w{3 4}])
+        @table.scan("| 1 | 2 |\n| 3 | 4 |\n")
+      end
+
+      it "should parse a 2x2 table with several newlines" do
+        @listener.should_receive(:table).with([%w{1 2}, %w{3 4}])
+        @table.scan("| 1 | 2 |\n| 3 | 4 |\n\n\n")
+      end
+
+      it "should parse a 2x2 table with empty cells" do
+        @listener.should_receive(:table).with([['1', nil], [nil, '4']])
+        @table.scan("| 1 |  |\n|| 4 |\n")
+      end
+    
+      it "should parse a 1x2 table without newline" do
+        @listener.should_receive(:table).with([%w{1 2}])
+        @table.scan("| 1 | 2 |")
+      end
+
+      it "should parse a 1x2 table without spaces and newline" do
+        @listener.should_receive(:table).with([%w{1 2}])
+        @table.scan("|1|2|")
+      end
+
+      it "should not parse a 2x2 table that isn't closed" do
+        @table.scan("| 1 |  |\n|| 4 ")
+        @listener.to_sexp.should == [
+          [:table, [['1', nil]]]
+        ]
+      end
+      
+      it "should parse a table with tab spacing" do
+        @listener.should_receive(:table).with([["abc", "123"]])
+        @table.scan("|\tabc\t|\t123\t\t\t|\n")
+      end
+    end
+  end
+end

data/spec/gherkin/tags_spec.rb

@@ -0,0 +1,57 @@
+#encoding: utf-8
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+module Gherkin
+  module Parser
+    describe "parsing" do
+      describe "tags" do
+        before do
+          @listener = mock('listener')
+          @feature = Parser['en'].new(@listener)
+        end
+      
+        it "should parse a single tag" do
+          @listener.should_receive(:tag).with("dog", 1)
+          @feature.scan("@dog\n")
+        end
+    
+        it "should parse multiple tags" do
+          @listener.should_receive(:tag).twice
+          @feature.scan("@dog @cat\n")
+        end
+    
+        it "should parse UTF-8 tags" do
+          @listener.should_receive(:tag).with("シナリオテンプレート", 1)
+          @feature.scan("@シナリオテンプレート\n")
+        end
+          
+        it "should parse mixed tags" do
+          @listener.should_receive(:tag).with("wip", 1).ordered
+          @listener.should_receive(:tag).with("Значения", 1).ordered
+          @feature.scan("@wip @Значения\n")
+        end
+    
+        it "should parse wacky identifiers" do
+          @listener.should_receive(:tag).exactly(4).times
+          @feature.scan("@BJ-x98.77 @BJ-z12.33 @O_o" "@#not_a_comment\n")
+        end
+
+        # TODO: Ask on ML for opinions about this one
+        it "should parse tags without spaces between them?" do
+          @listener.should_receive(:tag).twice
+          @feature.scan("@one@two\n")
+        end
+      
+        it "should not parse tags beginning with two @@ signs" do
+          @listener.should_not_receive(:tag)
+          @feature.scan("@@test\n")
+        end
+      
+        it "should not parse a lone @ sign" do
+          @listener.should_not_receive(:tag)
+          @feature.scan("@\n")
+        end
+      end
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,10 @@
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+require 'gherkin'
+require 'gherkin/sexp_recorder'
+require 'spec'
+require 'spec/autorun'
+
+Spec::Runner.configure do |config|
+  
+end

data/tasks/ext.rake

@@ -0,0 +1,35 @@
+CLEAN.include %w(**/*.{o,bundle,jar,so,obj,pdb,lib,def,exp,log} ext/*/Makefile ext/*/*.c ext/*/conftest.dSYM)
+WIN      = (RUBY_PLATFORM =~ /mswin|cygwin/)
+
+def ext_task(name)
+  ext_dir    = "ext/#{name}"
+  ext_bundle = "#{ext_dir}/#{name}.#{Config::CONFIG['DLEXT']}"
+  ext_files  = FileList[
+    "#{ext_dir}/*.c",
+    "#{ext_dir}/*.h",
+    "#{ext_dir}/*.rl",
+    "#{ext_dir}/extconf.rb",
+    "#{ext_dir}/Makefile",
+    "lib"
+  ]
+  
+  task "compile:#{name}" => ["#{ext_dir}/Makefile", ext_bundle]
+  task :compile => ['ragel:c', "compile:#{name}"]
+  
+  file "#{ext_dir}/Makefile" => ["#{ext_dir}/extconf.rb"] do
+    cd(ext_dir) { ruby "extconf.rb" }
+  end
+
+  file ext_bundle => ext_files do
+    cd ext_dir do
+      sh(WIN ? 'nmake' : 'make')
+    end
+    cp ext_bundle, 'lib/'
+  end
+end
+
+ext_task :gherkin
+  
+desc "Compile the C extensions"
+task :compile
+task :package => :compile

data/tasks/ragel.rake

@@ -0,0 +1,81 @@
+class RagelCompiler
+  def initialize
+    require 'yaml'
+    require 'erb'
+    
+    @impl = ERB.new(IO.read(File.dirname(__FILE__) + '/../ragel/feature.rb.rl.erb'))
+    @common = ERB.new(IO.read(File.dirname(__FILE__) + '/../ragel/feature_common.rl.erb'))
+    @langs = YAML.load_file(File.dirname(__FILE__) + '/../lib/gherkin/i18n.yml')
+  end
+
+  def compile_all
+    @langs.keys.each do |lang|
+      compile(lang)
+    end
+  end
+
+  def compile(lang)
+    i18n = @langs['en'].merge(@langs[lang])
+    common_file = File.dirname(__FILE__) + "/../ragel/feature_common.#{lang}.rl"
+    impl_file = File.dirname(__FILE__) + "/../ragel/feature_#{lang}.rb.rl"
+
+    common = @common.result(binding)
+    impl = @impl.result(binding)
+
+    write common, common_file
+    write impl, impl_file
+
+    sh "ragel -R #{impl_file} -o lib/gherkin/parser/feature_#{lang}.rb"
+
+    FileUtils.rm([impl_file, common_file])
+  end
+
+  def write(content, filename)
+    File.open(filename, "wb") do |file|
+      file.write(content)
+    end
+  end
+end
+
+namespace :ragel do
+  desc "Generate Ruby from the Ragel rule files"
+  task :rb => :i18n_en do
+    Dir["ragel/*.rb.rl"].each do |rl|
+      basename = File.basename(rl[0..-4])
+      sh "ragel -R #{rl} -o lib/gherkin/parser/#{basename}"
+    end
+  end
+
+  desc "Generate C from the Ragel rule files"
+  task :c do
+    Dir["ragel/*.c.rl"].each do |rl|
+      basename = File.basename(rl[0..-3])
+      sh "ragel -C #{rl} -o ext/gherkin/#{basename}" 
+    end
+  end
+
+  desc "Generate all Ruby i18n parsers"
+  task :i18n do
+    RagelCompiler.new.compile_all
+  end
+
+  desc "Generate Ruby English language parser"
+  task :i18n_en do
+    RagelCompiler.new.compile('en')
+  end
+
+  desc "Generate a dot file of the Ragel state machine"
+  task :dot do
+    Dir["ragel/*.rb.rl"].each do |path|
+      sh "ragel -V #{path} -o #{File.basename(path, '.rl')}.dot"
+    end
+  end
+
+  desc "Generate a png diagram of the Ragel state machine"
+  task :png => :dot do
+    Dir["*dot"].each do |path|
+      sh "dot -Tpng #{path} > #{File.basename(path, '.dot')}.png"
+    end
+  end
+end
+