aslakhellesoy-gherkin 0.0.1 → 1.2.3

data/spec/gherkin/gherkin_parser/complex.feature

@@ -1,23 +0,0 @@
-#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

@@ -1,6 +0,0 @@
-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

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

data/spec/gherkin/gherkin_parser/simple_with_comments.feature

@@ -1,7 +0,0 @@
-# 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

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

data/spec/gherkin/i18n_spec.rb

@@ -1,28 +0,0 @@
-#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

@@ -1,98 +0,0 @@
-# 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

@@ -1,15 +0,0 @@
-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

@@ -1,83 +0,0 @@
-# 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

@@ -1,57 +0,0 @@
-#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/tasks/ext.rake

@@ -1,35 +0,0 @@
-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

@@ -1,81 +0,0 @@
-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
-