gherkin 2.12.2 → 3.2.0

data/spec/gherkin/shared/row_group.rb

@@ -1,123 +0,0 @@
-# encoding: utf-8
-module Gherkin
-  module Lexer
-    shared_examples_for "a Gherkin lexer lexing rows" do
-      def scan(gherkin)
-        @lexer.scan(gherkin)
-      end
-
-      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)
-          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)
-        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)
-        scan("| foo | bar |\n")
-      end
-
-      it "should escape backslashed pipes" do
-        @listener.should_receive(:row).with(r(['|', 'the', '\a', '\\', '|\\|']), 1)
-        scan('| \| | the | \a | \\ |   \|\\\|    |' + "\n")
-      end
-
-      it "should parse cells with newlines" do
-        @listener.should_receive(:row).with(r(["\n"]), 1)
-        scan("|\\n|" + "\n")
-      end
-    
-      it "should parse cells with spaces within the content" do
-        @listener.should_receive(:row).with(r(["Dill pickle", "Valencia orange"]), 1)
-        scan("| Dill pickle | Valencia orange |\n")
-      end
-      
-      it "should allow utf-8" do
-        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)
-        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)
-        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)
-        scan("| 1 |  |\n|| 4 |\n")
-      end
-
-      it "should parse a row with empty cells" do
-        @listener.should_receive(:row).with(r(['1', '']), 1).twice
-        scan("| 1 |  |\n")
-        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)
-        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)
-        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)
-        scan("| 1 | 2 | \n ")
-      end
-      
-      it "should parse a row with lots of whitespace" do
-        @listener.should_receive(:row).with(r(["abc", "123"]), 1)
-        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)
-        scan("|abc|\n#|123|\n|def|\n") 
-      end
-      
-      it "should raise LexingError for rows that aren't closed" do
-        lambda { 
-          scan("|| oh hello \n") 
-        }.should raise_error(/Lexing error on line 1: '\|\| oh hello/)
-      end
-
-      it "should raise LexingError for rows that are followed by a comment" do
-        lambda { 
-          scan("|hi| # oh hello \n") 
-        }.should raise_error(/Lexing error on line 1: '\|hi\| # oh hello/)
-      end
-
-      it "should raise LexingError for rows that aren't closed" do
-        lambda { 
-          scan("|| oh hello \n  |Shoudn't Get|Here|") 
-        }.should raise_error(/Lexing error on line 1: '\|\| oh hello/)
-      end
-    end
-  end
-end

data/spec/gherkin/shared/tags_group.rb

@@ -1,52 +0,0 @@
-# encoding: utf-8
-module Gherkin
-  module Lexer
-    shared_examples_for "a Gherkin lexer lexing tags" do
-      def scan(gherkin)
-        @lexer.scan(gherkin)
-      end
-
-      it "should lex a single tag" do
-        @listener.should_receive(:tag).with("@dog", 1)
-        scan("@dog\n")
-      end
-  
-      it "should lex multiple tags" do
-        @listener.should_receive(:tag).twice
-        scan("@dog @cat\n")
-      end
-  
-      it "should lex UTF-8 tags" do
-        @listener.should_receive(:tag).with("@シナリオテンプレート", 1)
-        scan("@シナリオテンプレート\n")
-      end
-        
-      it "should lex mixed tags" do
-        @listener.should_receive(:tag).with("@wip", 1).ordered
-        @listener.should_receive(:tag).with("@Значения", 1).ordered
-        scan("@wip @Значения\n")
-      end
-  
-      it "should lex wacky identifiers" do
-        @listener.should_receive(:tag).exactly(4).times
-        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 lex tags without spaces between them?" do
-        @listener.should_receive(:tag).twice
-        scan("@one@two\n")
-      end
-    
-      it "should not lex tags beginning with two @@ signs" do
-        @listener.should_not_receive(:tag)
-        lambda { scan("@@test\n") }.should raise_error(/Lexing error on line 1/)
-      end
-    
-      it "should not lex a lone @ sign" do
-        @listener.should_not_receive(:tag)
-        lambda { scan("@\n") }.should raise_error(/Lexing error on line 1/)
-      end
-    end
-  end
-end

data/spec/gherkin/tag_expression_spec.rb

@@ -1,146 +0,0 @@
-require 'spec_helper'
-require 'gherkin/tag_expression'
-require 'gherkin/formatter/model'
-
-module Gherkin
-  describe TagExpression do
-    def tag(name)
-      Formatter::Model::Tag.new(name, 0)
-    end
-
-    context "no tags" do
-      before(:each) do
-        @e = Gherkin::TagExpression.new([])
-      end
-
-      it 'should be empty' do
-        @e.should be_empty
-      end
-
-      it "should match @foo" do
-        @e.evaluate([tag('@foo')]).should == true
-      end
-
-      it "should match empty tags" do
-        @e.evaluate([]).should == true
-      end
-    end
-
-    context "@foo" do
-      before(:each) do
-        @e = Gherkin::TagExpression.new(['@foo'])
-      end
-
-      it "should match @foo" do
-        @e.evaluate([tag('@foo')]).should == true
-      end
-
-      it "should not match @bar" do
-        @e.evaluate([tag('@bar')]).should == false
-      end
-
-      it "should not match no tags" do
-        @e.evaluate([]).should == false
-      end
-    end
-
-    context "!@foo" do
-      before(:each) do
-        @e = Gherkin::TagExpression.new(['~@foo'])
-      end
-
-      it "should match @bar" do
-        @e.evaluate([tag('@bar')]).should == true
-      end
-
-      it "should not match @foo" do
-        @e.evaluate([tag('@foo')]).should == false
-      end
-    end
-
-    context "@foo || @bar" do
-      before(:each) do
-        @e = Gherkin::TagExpression.new(['@foo,@bar'])
-      end
-
-      it "should match @foo" do
-        @e.evaluate([tag('@foo')]).should == true
-      end
-
-      it "should match @bar" do
-        @e.evaluate([tag('@bar')]).should == true
-      end
-
-      it "should not match @zap" do
-        @e.evaluate([tag('@zap')]).should == false
-      end
-    end
-
-    context "(@foo || @bar) && !@zap" do
-      before(:each) do
-        @e = Gherkin::TagExpression.new(['@foo,@bar', '~@zap'])
-      end
-
-      it "should match @foo" do
-        @e.evaluate([tag('@foo')]).should == true
-      end
-
-      it "should not match @foo @zap" do
-        @e.evaluate([tag('@foo'), tag('@zap')]).should == false
-      end
-    end
-
-    context "(@foo:3 || !@bar:4) && @zap:5" do
-      before(:each) do
-        @e = Gherkin::TagExpression.new(['@foo:3,~@bar','@zap:5'])
-      end
-
-      it "should count tags for positive tags" do
-        rubify_hash(@e.limits).should == {'@foo' => 3, '@zap' => 5}
-      end
-
-      it "should match @foo @zap" do
-        @e.evaluate([tag('@foo'), tag('@zap')]).should == true
-      end
-    end
-
-    context "Parsing '@foo:3,~@bar', '@zap:5'" do
-      before(:each) do
-        @e = Gherkin::TagExpression.new([' @foo:3 , ~@bar ', ' @zap:5 '])
-      end
-
-      unless defined?(JRUBY_VERSION)
-        it "should split and trim (ruby implementation detail)" do
-          @e.__send__(:ruby_expression).should == "(!vars['@bar']||vars['@foo'])&&(vars['@zap'])"
-        end
-      end
-
-      it "should have limits" do
-        rubify_hash(@e.limits).should == {"@zap"=>5, "@foo"=>3}
-      end
-    end
-
-    context "Tag limits" do
-      it "should be counted for negative tags" do
-        @e = Gherkin::TagExpression.new(['~@todo:3'])
-        rubify_hash(@e.limits).should == {"@todo"=>3}
-      end
-
-      it "should be counted for positive tags" do
-        @e = Gherkin::TagExpression.new(['@todo:3'])
-        rubify_hash(@e.limits).should == {"@todo"=>3}
-      end
-
-      it "should raise an error for inconsistent limits" do
-        lambda do
-          @e = Gherkin::TagExpression.new(['@todo:3', '~@todo:4'])
-        end.should raise_error(/Inconsistent tag limits for @todo: 3 and 4/)
-      end
-
-      it "should allow duplicate consistent limits" do
-        @e = Gherkin::TagExpression.new(['@todo:3', '~@todo:3'])
-        rubify_hash(@e.limits).should == {"@todo"=>3}
-      end
-    end
-  end
-end

data/spec/spec_helper.rb

@@ -1,94 +0,0 @@
-def silence_warnings(&block)
-  warn_level = $VERBOSE
-  $VERBOSE = nil
-  result = block.call
-  $VERBOSE = warn_level
-  result
-end
-
-if RUBY_VERSION =~ /1\.9|2\.0/
-  silence_warnings do
-    Encoding.default_external = Encoding::UTF_8
-    Encoding.default_internal = Encoding::UTF_8
-  end
-end
-if defined?(JRUBY_VERSION)
-  java_import java.util.ArrayList
-  ArrayList.__persistent__ = true
-end
-
-require 'rubygems'
-require 'bundler'
-Bundler.setup
-
-require 'rspec'
-require 'gherkin'
-require 'stringio'
-require 'gherkin/sexp_recorder'
-require 'gherkin/shared/encoding_group'
-require 'gherkin/shared/lexer_group'
-require 'gherkin/shared/tags_group'
-require 'gherkin/shared/doc_string_group'
-require 'gherkin/shared/row_group'
-require 'gherkin/lexer/encoding'
-$:.unshift(File.dirname(__FILE__))
-
-module GherkinSpecHelper
-  def scan_file(file)
-    @lexer.scan(fixture(file))
-  end
-
-  def fixture(file)
-    encoding = Gherkin::Lexer::Encoding.new
-    encoding.read_file(File.dirname(__FILE__) + "/gherkin/fixtures/" + file)
-  end
-
-  def rubify_hash(hash)
-    if defined?(JRUBY_VERSION)
-      h = {}
-      hash.keySet.each{|key| h[key] = hash[key]}
-      h
-    else
-      hash
-    end
-  end
-end
-
-RSpec.configure do |c|
-  c.include(GherkinSpecHelper)
-end
-
-# Allows comparison of Java List with Ruby Array (rows)
-RSpec::Matchers.define :r do |expected|
-  match do |row|
-    silence_warnings do
-      def row.inspect
-        "r " + self.map{|cell| cell}.inspect
-      end
-    end
-    row.map{|cell| cell}.should == expected
-  end
-end
-
-RSpec::Matchers.define :a do |expected|
-  match do |array|
-    silence_warnings do
-      def array.inspect
-        "a " + self.map{|e| e.to_sym}.inspect
-      end
-    end
-    array.map{|e| e.to_sym}.should == expected
-  end
-end
-
-RSpec::Matchers.define :sym do |expected|
-  match do |actual|
-    expected.to_s == actual.to_s
-  end
-end
-
-RSpec::Matchers.define :allow do |event|
-  match do |parser|
-    parser.expected.index(event)
-  end  
-end

data/tasks/apidoc.rake

@@ -1,32 +0,0 @@
-unless ENV['RUBY_CC_VERSION'] || defined?(JRUBY_VERSION)
-  require 'yard'
-  require 'yard/rake/yardoc_task'
-
-  SITE_DIR = File.expand_path(File.dirname(__FILE__) + '/../../cucumber.github.com')
-  API_DIR  = File.join(SITE_DIR, 'api', 'gherkin', GHERKIN_VERSION)
-
-  namespace :api do
-    file :dir do
-      raise "You need to git clone git@github.com:cucumber/cucumber.github.com.git #{SITE_DIR}" unless File.directory?(SITE_DIR)
-      mkdir_p API_DIR
-    end
-
-    YARD::Templates::Engine.register_template_path(File.expand_path(File.join(File.dirname(__FILE__), 'yard')))
-    YARD::Rake::YardocTask.new(:yard) do |yard|
-      dir = File.join(API_DIR, 'ruby')
-      mkdir_p dir
-      yard.options = ["--out", dir]
-    end
-    task :yard => :dir
-
-    task :mvn_javadoc => :dir do
-      Dir.chdir('java') do
-        sh("mvn javadoc:javadoc")
-        dir = File.join(API_DIR, 'java')
-        mv 'target/site/apidocs', dir
-      end
-    end
-
-    task :doc => [:mvn_javadoc, :yard]
-  end
-end