gherkin 2.12.2 → 3.2.0

data/tasks/bench.rake

@@ -1,184 +0,0 @@
-%w{/../lib /bench}.each do |l| 
-  $LOAD_PATH << File.expand_path(File.dirname(__FILE__) + l)
-end
-
-require 'benchmark'
-
-GENERATED_FEATURES = File.expand_path(File.dirname(__FILE__) + "/bench/generated")
-
-class RandomFeatureGenerator
-  def initialize(number)
-    require 'faker'
-    require 'feature_builder'
-    
-    @number = number
-  end
-  
-  def generate
-    @number.times do
-      name = catch_phrase
-      feature = FeatureBuilder.new(name) do |f|
-        num_scenarios = rand_in(1..10)
-        num_scenarios.times do
-          f.scenario(bs) do |steps|
-            num_steps = rand_in(3..10)
-            num_steps.times do
-              steps.step(sentence, self)
-            end
-          end
-        end
-      end      
-      write feature.to_s, name
-    end    
-  end
-  
-  def write(content, name)
-    File.open(GENERATED_FEATURES + "/#{name.downcase.gsub(/[\s\-\/]/, '_')}.feature", "w+") do |file|
-      file << content
-    end
-  end
-  
-  def rand_in(range)
-    ary = range.to_a
-    ary[rand(ary.length - 1)]
-  end
-  
-  def catch_phrase
-    Faker::Company.catch_phrase
-  end
-  
-  def bs
-    Faker::Company.bs.capitalize
-  end
-  
-  def sentence
-    Faker::Lorem.sentence
-  end
-
-  def table_cell
-    Faker::Lorem.words(rand(2)+1).join(" ")
-  end
-end
-
-class Benchmarker
-  def initialize
-    @features = Dir[GENERATED_FEATURES + "/**/*feature"]
-  end
-  
-  def report(lexer)
-    Benchmark.bm do |x|
-      x.report("#{lexer}:") { send :"run_#{lexer}" }
-    end
-  end
-  
-  def report_all 
-    Benchmark.bmbm do |x|
-      x.report("native_gherkin:") { run_native_gherkin }
-      x.report("native_gherkin_no_parser:") { run_native_gherkin_no_parser }
-      x.report("rb_gherkin:") { run_rb_gherkin }
-      x.report("cucumber:") { run_cucumber }
-      x.report("tt:") { run_tt }
-    end
-  end
-  
-  def run_cucumber
-    require 'cucumber'
-    require 'logger'
-    step_mother = Cucumber::StepMother.new
-    logger = Logger.new(STDOUT)
-    logger.level = Logger::INFO
-    step_mother.log = logger
-    step_mother.load_plain_text_features(@features)
-  end
-  
-  def run_tt
-    require 'cucumber'
-    # Using Cucumber's Treetop lexer, but never calling #build to build the AST
-    lexer = Cucumber::Parser::NaturalLanguage.new(nil, 'en').parser
-    @features.each do |file|
-      source = IO.read(file)
-      parse_tree = lexer.parse(source)
-      if parse_tree.nil?
-        raise Cucumber::Parser::SyntaxError.new(lexer, file, 0)
-      end
-    end
-  end
-
-  def run_rb_gherkin    
-    require 'gherkin'
-    require 'null_formatter'
-    parser = Gherkin::Parser::Parser.new(NullFormatter.new, true, "root", true)
-    @features.each do |feature|
-      parser.parse(File.read(feature), feature, 0)
-    end
-  end
-
-  def run_native_gherkin
-    require 'gherkin'
-    require 'null_listener'
-    parser = Gherkin::Parser::Parser.new(NullFormatter.new, true, "root", false)
-    @features.each do |feature|
-      parser.parse(File.read(feature), feature, 0)
-    end
-  end
-
-  def run_native_gherkin_no_parser
-    require 'gherkin'
-    require 'gherkin/lexer/i18n_lexer'
-    require 'null_listener'
-    lexer = Gherkin::Lexer::I18nLexer.new(NullListener.new, false)
-    @features.each do |feature|
-      lexer.scan(File.read(feature), feature, 0)
-    end
-  end
-end
-
-desc "Generate 500 random features and benchmark Cucumber, Treetop and Gherkin with them"
-task :bench => ["bench:clean", "bench:gen"] do
-  benchmarker = Benchmarker.new
-  benchmarker.report_all
-end
-
-namespace :bench do
-  desc "Generate [number] features with random content, or 500 features if number is not provided"
-  task :gen, :number do |t, args|
-    args.with_defaults(:number => 500)
-    generator = RandomFeatureGenerator.new(args.number.to_i)
-    generator.generate    
-  end
-
-  desc "Benchmark Cucumber AST building from the features in tasks/bench/generated"
-  task :cucumber do
-    benchmarker = Benchmarker.new
-    benchmarker.report("cucumber")
-  end
-  
-  desc "Benchmark the Treetop parser with the features in tasks/bench/generated"
-  task :tt do
-    benchmarker = Benchmarker.new
-    benchmarker.report("tt")
-  end
-
-  desc "Benchmark the Ruby Gherkin lexer+parser with the features in tasks/bench/generated"
-  task :rb_gherkin do
-    benchmarker = Benchmarker.new
-    benchmarker.report("rb_gherkin")
-  end
-
-  desc "Benchmark the ntive Gherkin lexer+parser with the features in tasks/bench/generated"
-  task :native_gherkin do
-    benchmarker = Benchmarker.new
-    benchmarker.report("native_gherkin")
-  end
-
-  desc "Benchmark the native Gherkin lexer (no parser) with the features in tasks/bench/generated"
-  task :native_gherkin_no_parser do
-    benchmarker = Benchmarker.new
-    benchmarker.report("native_gherkin_no_parser")
-  end
-
-  desc "Remove all generated features in tasks/bench/generated"
-  task :clean do
-    rm_f FileList[GENERATED_FEATURES + "/**/*feature"]
-  end
-end

data/tasks/bench/feature_builder.rb

@@ -1,49 +0,0 @@
-class StepsBuilder
-  def initialize
-    @steps = []
-  end
-
-  def step(content, generator)
-    @steps << "    Given #{content}"
-    if(rand(5) == 0)
-      cols = rand(8) + 1
-      rows = rand(10)
-      rows.times do
-        row = "      |"
-        cols.times do
-          row << generator.table_cell << "|"
-        end
-        @steps << row
-      end
-    end
-  end
-
-  def to_s
-    @steps.join("\n")
-  end
-end
-
-class FeatureBuilder
-  def initialize(name, &block)
-    @name = name
-    @scenarios = {}
-    block.call(self)
-  end
-
-  def scenario(name, &block)
-    @scenarios[name] = StepsBuilder.new
-    block.call(@scenarios[name])
-  end
-
-  def to_s
-    str = "Feature: #{@name}\n"
-    @scenarios.each do |scenario, steps|
-      str += "\n"
-      str += "  Scenario: #{scenario}\n"
-      str += steps.to_s
-      str += "\n"
-    end
-    str
-  end
-end
-

data/tasks/bench/null_listener.rb

@@ -1,4 +0,0 @@
-class NullListener
-  def method_missing(*args)
-  end
-end

data/tasks/compile.rake

@@ -1,83 +0,0 @@
-require File.dirname(__FILE__) + '/ragel_task'
-BYPASS_NATIVE_IMPL = true
-require 'gherkin/i18n'
-
-CLEAN.include [
-  'pkg', 'tmp',
-  '**/*.{o,bundle,jar,so,obj,pdb,lib,def,exp,log,rbc}', 'ext',
-  'java/target',
-  'lib/*.dll',
-  'ext/**/*.c',
-  'doc'
-]
-
-desc "Compile the Java extensions"
-task :jar => 'lib/gherkin.jar'
-
-file 'lib/gherkin.jar' => Dir['java/src/main/java/**/*.java'] do
-  sh("mvn -f java/pom.xml package")
-end
-
-desc "Build JavaScript lexers"
-task :js
-
-rl_langs = ENV['RL_LANGS'] ? ENV['RL_LANGS'].split(',') : []
-langs = Gherkin::I18n.all.select { |lang| rl_langs.empty? || rl_langs.include?(lang.iso_code) }
-
-langs.each do |i18n|
-  java = RagelTask.new('java', i18n)
-  rb   = RagelTask.new('rb', i18n)
-  js   = RagelTask.new('js', i18n)
-
-  file 'lib/gherkin.jar' => [java.target]
-
-  begin
-  if !defined?(JRUBY_VERSION)
-    require 'rake/extensiontask'
-
-    c = RagelTask.new('c', i18n)
-
-    extconf = "ext/gherkin_lexer_#{i18n.underscored_iso_code}/extconf.rb"
-    file extconf do
-      FileUtils.mkdir(File.dirname(extconf)) unless File.directory?(File.dirname(extconf))
-      File.open(extconf, "w") do |io|
-        io.write(<<-EOF)
-require 'mkmf'
-CONFIG['warnflags'].gsub!(/-Wshorten-64-to-32/, '') if CONFIG['warnflags']
-$CFLAGS << ' -O0 -Wall' if CONFIG['CC'] =~ /gcc|clang/
-dir_config("gherkin_lexer_#{i18n.underscored_iso_code}")
-have_library("c", "main")
-create_makefile("gherkin_lexer_#{i18n.underscored_iso_code}")
-EOF
-      end
-    end
-
-    Rake::ExtensionTask.new("gherkin_lexer_#{i18n.underscored_iso_code}") do |ext|
-      if ENV['RUBY_CC_VERSION']
-        ext.cross_compile = true
-        ext.cross_platform = 'x86-mingw32'
-      end
-    end
-
-    # The way tasks are defined with compile:xxx (but without namespace) in rake-compiler forces us
-    # to use these hacks for setting up dependencies. Ugly!
-    Rake::Task["compile:gherkin_lexer_#{i18n.underscored_iso_code}"].prerequisites.unshift(extconf)
-    Rake::Task["compile:gherkin_lexer_#{i18n.underscored_iso_code}"].prerequisites.unshift(c.target)
-    Rake::Task["compile:gherkin_lexer_#{i18n.underscored_iso_code}"].prerequisites.unshift(rb.target)
-    Rake::Task["compile:gherkin_lexer_#{i18n.underscored_iso_code}"].prerequisites.unshift(js.target) if ENV['GHERKIN_JS']
-
-    Rake::Task["compile"].prerequisites.unshift(extconf)
-    Rake::Task["compile"].prerequisites.unshift(c.target)
-    Rake::Task["compile"].prerequisites.unshift(rb.target)
-    Rake::Task["compile"].prerequisites.unshift(js.target) if ENV['GHERKIN_JS']
-    
-    Rake::Task["js"].prerequisites.unshift(js.target) if ENV['GHERKIN_JS']
-  end
-  rescue LoadError
-    unless defined?($c_warned)
-      warn "WARNING: Rake::ExtensionTask not installed. Skipping C compilation." 
-      $c_warned = true
-      task :compile # no-op
-    end
-  end
-end

data/tasks/cucumber.rake

@@ -1,23 +0,0 @@
-
-unless ENV['RUBY_CC_VERSION']
-require 'cucumber/rake/task'
-
-Cucumber::Rake::Task.new(:cucumber) do |t|
-  profile = ENV['TRAVIS'] ? 'travis' : 'default'
-  profile = 'javascript' if ENV['GHERKIN_JS_NATIVE']
-  t.cucumber_opts = "--profile #{profile}"
-end
-
-namespace :cucumber do
-  Cucumber::Rake::Task.new(:rcov, "Run Cucumber using RCov") do |t|
-    t.cucumber_opts = "--profile default"
-    t.rcov = RUBY_VERSION =~ /^1\.8/
-    t.rcov_opts = %w{--exclude spec\/}
-  end
-
-  Cucumber::Rake::Task.new(:native_lexer, "Run Native lexer Cucumber features") do |t|
-    t.cucumber_opts = "--profile native_lexer"
-  end
-  task :native_lexer => [:clean, :compile]
-end
-end

data/tasks/gems.rake

@@ -1,46 +0,0 @@
-namespace :gems do
-  task :win do
-    unless File.directory?(File.expand_path('~/.rake-compiler'))
-      STDERR.puts "[ERROR] You must install MinGW rubies to build gherkin gems for Windows. See README.md"
-      exit(1)
-    end
-    # rvm and mingw ruby versions have to match to avoid errors
-    rbenv('1.9.3-p448') do
-      sh "bundle exec rake cross compile RUBY_CC_VERSION=1.9.3"
-    end
-    rbenv('2.0.0-p247') do
-      sh "bundle exec rake cross compile RUBY_CC_VERSION=2.0.0"
-    end
-    # This will copy the .so files to the proper place
-    sh "bundle exec rake -t cross compile RUBY_CC_VERSION=1.9.3:2.0.0"
-  end
-
-  desc 'Prepare JRuby binares'
-  task :jruby => [:jar] do
-    rbenv('jruby-1.7.4') do
-      sh "bundle exec rspec spec"
-    end
-  end
-
-  task :sanity do
-    raise "The jruby gem looks too small" if File.stat("release/gherkin-#{GHERKIN_VERSION}-java.gem").size < 1000000
-  end
-
-  desc "Prepare binaries for all gems"
-  task :prepare => [
-    :clean,
-    :spec,
-    :win,
-    :jruby
-  ]
-
-  # https://github.com/sstephenson/rbenv/issues/121
-  def rbenv(version)
-    old_version = ENV['RBENV_VERSION']
-    ENV['RBENV_VERSION'] = version
-    yield
-  ensure
-    ENV['RBENV_VERSION'] = old_version
-  end
-
-end

data/tasks/ikvm.rake

@@ -1,126 +0,0 @@
-# encoding: utf-8
-
-namespace :ikvm do
-  IKVM_VERSION    = '7.2.4630.5'
-  IKVM_DIR        = "ikvm/ikvm-#{IKVM_VERSION}"
-  IKVM_ZIP        = "ikvm/ikvmbin-#{IKVM_VERSION}.zip"
-  CLOBBER.include(IKVM_DIR, IKVM_ZIP)
-  IKVM_BIN_DIR    = "#{IKVM_DIR}/bin"
-  IKVMC_EXE       = "#{IKVM_BIN_DIR}/ikvmc.exe"
-  GHERKIN_EXE     = "release/gherkin.exe"
-  GHERKIN_PKG_DLL = "release/nuspec/lib/gherkin.dll"
-  GHERKIN_NUSPEC  = "release/nuspec/gherkin.nuspec"
-  GHERKIN_NUPKG   = "release/gherkin.#{GHERKIN_VERSION}.nupkg"
-  GHERKIN_LIB_DLL = 'lib/gherkin.dll'
-
-  def mono(args)
-    if(`which mono`.strip =~ /mono/)
-      # http://monomvc.wordpress.com/2012/03/06/nuget-on-mono/
-      sh("mono --runtime=v4.0.30319 #{args}")
-    else
-      raise "[ERROR] You must install Mono and IKVM build gherkin for .NET. See README.md"
-    end
-  end
-
-  def ikvmc(args)
-    begin
-      mono("#{IKVMC_EXE} #{args}")
-    rescue => e
-      if e.message =~ /Cannot open assembly/
-        e.message << "\n\n[ERROR] You must install Mono and IKVM build gherkin for .NET. See README.md"
-      end
-      raise e
-    end
-  end
-
-  def nuget(args)
-    mono("ikvm/NuGet.exe #{args}")
-  end
-
-  file GHERKIN_EXE => [IKVMC_EXE, 'lib/gherkin.jar'] do
-    ikvmc("-target:exe lib/gherkin.jar -out:#{GHERKIN_EXE}")
-  end
-
-  file GHERKIN_PKG_DLL => [IKVMC_EXE, 'lib/gherkin.jar'] do
-    mkdir_p File.dirname(GHERKIN_PKG_DLL) unless File.directory?(File.dirname(GHERKIN_PKG_DLL))
-    ikvmc("-target:library lib/gherkin.jar -out:#{GHERKIN_PKG_DLL} -version:#{GHERKIN_VERSION}")
-  end
-
-  file GHERKIN_LIB_DLL => GHERKIN_PKG_DLL do
-    cp GHERKIN_PKG_DLL, GHERKIN_LIB_DLL
-  end
-
-  file GHERKIN_NUPKG => [GHERKIN_PKG_DLL, GHERKIN_NUSPEC] do
-    pkg_dir = File.dirname(GHERKIN_EXE)
-    mkdir_p File.dirname(pkg_dir) unless File.directory?(pkg_dir)
-    nuget("Pack #{GHERKIN_NUSPEC} -Version #{GHERKIN_VERSION} -OutputDirectory #{pkg_dir}")
-    # Now, verify that we have a proper dll inside the package
-    require 'zip'
-    Zip::File.open(GHERKIN_NUPKG) do |zipfile|
-      dll = zipfile.get_entry('lib/gherkin.dll')
-      if(dll.size < 3_000_000)
-        raise "Looks like the dll is too small."
-      end
-    end
-  end
-
-  file GHERKIN_NUSPEC do
-    mkdir_p File.dirname(GHERKIN_NUSPEC) unless File.directory?(File.dirname(GHERKIN_NUSPEC))
-    File.open(GHERKIN_NUSPEC, "w") do |io|
-      io.write(<<-EOF)
-<?xml version="1.0"?>
-<package>
-  <metadata>
-    <id>gherkin</id>
-    <version>#{GHERKIN_VERSION}</version>
-    <authors>aslakhellesoy</authors>
-    <owners>Mike Sassak, Gregory Hnatiuk, Aslak Hellesøy</owners>
-    <projectUrl>https://github.com/cucumber/gherkin</projectUrl>
-    <licenseUrl>https://github.com/cucumber/gherkin/blob/master/LICENSE</licenseUrl>
-    <iconUrl>https://github.com/cucumber/cukes.info/raw/master/templates/images/gherkin/gherkin_128x128.png</iconUrl>
-    <requireLicenseAcceptance>false</requireLicenseAcceptance>
-    <description>A fast lexer and parser for the Gherkin language based on Ragel</description>
-    <copyright>Copyright (c) 2009-2013 Mike Sassak, Gregory Hnatiuk, Aslak Hellesøy</copyright>
-    <dependencies>
-      <dependency id="IKVM" version="#{IKVM_VERSION}" />
-    </dependencies>
-    <tags>gherkin cucumber specflow bdd lexer parser</tags>
-  </metadata>
-  <files>
-    <file src="lib/gherkin.dll" target="lib/gherkin.dll" />
-  </files>
-</package>
-EOF
-    end
-  end
-
-  task :nupkg => GHERKIN_NUPKG
-
-  task :check => [GHERKIN_EXE, :copy_ikvm_dlls] do
-    puts "************** Pretty printing some features with .NET. **************"
-    mono "#{GHERKIN_EXE} features"
-    puts "************** DONE Pretty printing some features with .NET. All OK. **************"
-  end
-
-  task :copy_ikvm_dlls => IKVMC_EXE do
-    exe_dir = File.dirname(GHERKIN_EXE)
-    mkdir_p File.dirname(exe_dir) unless File.directory?(exe_dir)
-    Dir["#{IKVM_BIN_DIR}/*.dll"].each do |dll|
-      cp dll, exe_dir
-    end
-  end
-
-  task :push => GHERKIN_NUPKG do
-    nuget("Push #{GHERKIN_NUPKG}")
-  end
-
-  file IKVMC_EXE do
-    sh("wget http://downloads.sourceforge.net/project/ikvm/ikvm/#{IKVM_VERSION}/ikvmbin-#{IKVM_VERSION}.zip -O #{IKVM_ZIP}")
-    Dir.chdir('ikvm') do
-      sh("unzip ikvmbin-#{IKVM_VERSION}.zip")
-    end
-  end
-end
-
-task :ikvm => ['ikvm:check']
-