gherkin 2.2.5-x86-mingw32

data/spec/spec_helper.rb

@@ -0,0 +1,68 @@
+require 'rubygems'
+require 'bundler'
+Bundler.setup
+
+require 'gherkin'
+require 'stringio'
+require 'gherkin/sexp_recorder'
+require 'gherkin/output_stream_string_io'
+require 'gherkin/json'
+require 'gherkin/shared/lexer_group'
+require 'gherkin/shared/tags_group'
+require 'gherkin/shared/py_string_group'
+require 'gherkin/shared/row_group'
+
+module GherkinSpecHelper
+  def scan_file(file)
+    @lexer.scan(fixture(file))
+  end
+
+  def fixture(file)
+    File.new(File.dirname(__FILE__) + "/gherkin/fixtures/" + file).read
+  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|
+    def row.inspect
+      "r " + self.map{|cell| cell}.inspect
+    end
+    row.map{|cell| cell}.should == expected
+  end
+end
+
+RSpec::Matchers.define :a do |expected|
+  match do |array|
+    def array.inspect
+      "a " + self.map{|e| e.to_sym}.inspect
+    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/bench.rake

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

@@ -0,0 +1,49 @@
+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/generated/.gitignore

@@ -0,0 +1 @@
+*.feature

data/tasks/bench/null_listener.rb

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

data/tasks/compile.rake

@@ -0,0 +1,102 @@
+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',
+  'ragel/i18n/*.rl',
+  'lib/gherkin/rb_lexer/*.rb',
+  'lib/*.dll',
+  'ext/**/*.c',
+  'java/src/main/java/gherkin/lexer/i18n/*.java',
+  'java/src/main/resources/gherkin/*.properties',
+]
+
+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
+
+rl_langs = ENV['RL_LANGS'] ? ENV['RL_LANGS'].split(',') : []
+langs = Gherkin::I18n.all.select { |lang| rl_langs.empty? || rl_langs.include?(lang.iso_code) }
+
+# http://bugs.sun.com/bugdatabase/view_bug.do?bug_id=6457127
+file 'lib/gherkin.jar' => "java/src/main/resources/gherkin/I18nKeywords_in.properties"
+file "java/src/main/resources/gherkin/I18nKeywords_in.properties" => "java/src/main/resources/gherkin/I18nKeywords_id.properties" do
+  cp "java/src/main/resources/gherkin/I18nKeywords_id.properties", "java/src/main/resources/gherkin/I18nKeywords_in.properties"
+end
+
+# http://forums.sun.com/thread.jspa?threadID=5335461
+file 'lib/gherkin.jar' => "java/src/main/resources/gherkin/I18nKeywords_iw.properties"
+file "java/src/main/resources/gherkin/I18nKeywords_iw.properties" => "java/src/main/resources/gherkin/I18nKeywords_he.properties" do
+  cp "java/src/main/resources/gherkin/I18nKeywords_he.properties", "java/src/main/resources/gherkin/I18nKeywords_iw.properties"
+end
+
+langs.each do |i18n|
+  java = RagelTask.new('java', i18n)
+  rb   = RagelTask.new('rb', i18n)
+
+  lang_country = i18n.iso_code.split(/-/)
+  suffix = lang_country.length == 1 ? lang_country[0] : "#{lang_country[0]}_#{lang_country[1].upcase}"
+  java_properties = "java/src/main/resources/gherkin/I18nKeywords_#{suffix}.properties"
+  file java_properties => 'lib/gherkin/i18n.yml' do
+    File.open(java_properties, 'wb') do |io|
+      io.puts("# Generated file. Do not edit.")
+      (Gherkin::I18n::KEYWORD_KEYS + %w{name native}).each do |key|
+        value = Gherkin::I18n.unicode_escape(i18n.keywords(key).join("|"))
+        io.puts("#{key}:#{value}")
+      end
+    end
+  end
+  file 'lib/gherkin.jar' => [java.target, rb.target, java_properties]
+
+  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 -Werror' if CONFIG['CC'] =~ /gcc/
+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"].prerequisites.unshift(extconf)
+    Rake::Task["compile"].prerequisites.unshift(c.target)
+    Rake::Task["compile"].prerequisites.unshift(rb.target)
+  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

@@ -0,0 +1,18 @@
+require 'cucumber/rake/task'
+
+Cucumber::Rake::Task.new(:cucumber) do |t|
+  t.cucumber_opts = "--profile default"
+end
+
+namespace :cucumber do
+  Cucumber::Rake::Task.new(:rcov, "Run Cucumber using RCov") do |t|
+    t.cucumber_opts = "--profile default"
+    t.rcov = true
+    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

data/tasks/gems.rake

@@ -0,0 +1,42 @@
+namespace :gems do
+  task :win do
+    unless File.directory?(File.expand_path('~/.rake-compiler'))
+      STDERR.puts <<-EOM
+
+You must install Windows rubies to ~/.rake-compiler with:
+
+  rake-compiler cross-ruby VERSION=1.8.6-p287
+  # (Later 1.9.1 patch levels don't compile on mingw) 
+  rake-compiler cross-ruby VERSION=1.9.1-p243
+EOM
+      exit(1)
+    end
+    # rvm and mingw ruby versions have to match to avoid errors
+    sh "rvm 1.8.6@cucumber rake cross compile RUBY_CC_VERSION=1.8.6"
+    sh "rvm 1.9.1@cucumber rake cross compile RUBY_CC_VERSION=1.9.1"
+    # This will copy the .so files to the proper place
+    sh "rake cross compile RUBY_CC_VERSION=1.8.6:1.9.1"
+  end
+
+  desc 'Prepare JRuby binares'
+  task :jruby => [:jar] do
+    sh "rvm jruby@cucumber -S rspec spec"
+  end
+
+  desc 'Prepare IronRuby binaries'
+  task :ironruby => [:jruby, 'ikvm:dll', 'ikvm:copy_ikvm_dlls']
+
+  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,
+    :ironruby
+  ]
+
+end