gherkin 2.2.5-x86-mingw32

data/features/pretty_formatter.feature

@@ -0,0 +1,15 @@
+Feature: Pretty Formatter
+  In order to have pretty gherkin
+  I want to verify that all prettified cucumber features parse OK
+
+  Scenario: Parse all the features in Cucumber
+    Given I have Cucumber's source code next to Gherkin's
+    And I find all of the .feature files
+    When I send each prettified original through the "pretty" machinery
+    Then the machinery output should be identical to the prettified original
+
+  Scenario: Parse all the features in Cucumber with JSON
+    Given I have Cucumber's source code next to Gherkin's
+    And I find all of the .feature files
+    When I send each prettified original through the "json" machinery
+    Then the machinery output should be identical to the prettified original

data/features/step_definitions/eyeball_steps.rb

@@ -0,0 +1,3 @@
+Given /^they have arrived$/ do |table|
+  announce table.raw
+end

data/features/step_definitions/gherkin_steps.rb

@@ -0,0 +1,29 @@
+Given /^a "(ruby|native)" "([^\"]*)" parser$/ do |ruby_or_native, parser_name|
+  @parser = Gherkin::Parser::Parser.new(@formatter, false, parser_name, ruby_or_native=="ruby")
+end
+
+Given "the following text is parsed:" do |text|
+  @parser.parse(text, "test.feature", 0)
+end
+
+Then "there should be no parse errors" do
+  @formatter.errors.should == []
+end
+
+Then /^there should be a parse error on (line \d+)$/ do |line|
+  @formatter.line(line).should include(:syntax_error, line)
+end
+
+Then /^there should be parse errors on (lines .*)$/ do |lines|
+  lines.each do |line|
+    Then "there should be a parse error on line #{line}"
+  end
+end
+
+Transform /^line \d+$/ do |step_arg|
+  tr_line_number(step_arg)
+end
+
+Transform /^lines .*$/ do |step_arg|
+  tr_line_numbers(step_arg)
+end

data/features/step_definitions/json_formatter_steps.rb

@@ -0,0 +1,28 @@
+require 'ap' # awesome_print gem
+require 'stringio'
+require 'gherkin/formatter/json_formatter'
+require 'gherkin/listener/formatter_listener'
+
+# Monkey patching so that Hash.to_json has a predictable result.
+class Hash
+  alias orig_keys keys
+  def keys
+    orig_keys.sort
+  end
+end
+
+Given /^a JSON formatter$/ do
+  @io = StringIO.new
+  @formatter = Gherkin::Formatter::JSONFormatter.new(@io)
+end
+
+Then /^the outputted JSON should be:$/ do |expected_json|
+  require 'json'
+  announce JSON.pretty_generate(JSON.parse(@io.string))
+  expected = JSON.parse(expected_json).ai
+  actual   = JSON.parse(@io.string).ai
+  actual.should == expected
+end
+
+
+

data/features/step_definitions/json_parser_steps.rb

@@ -0,0 +1,20 @@
+require 'stringio'
+require 'gherkin/formatter/pretty_formatter'
+require 'gherkin/json_parser'
+
+Given /^a PrettyFormatter$/ do
+  @io = StringIO.new
+  @formatter = Gherkin::Formatter::PrettyFormatter.new(@io, true)
+end
+
+Given /^a JSON lexer$/ do
+  @json_parser = Gherkin::JSONParser.new(@formatter)
+end
+
+Given /^the following JSON is parsed:$/ do |text|
+  @json_parser.parse(JSON.pretty_generate(JSON.parse(text)), "unknown.json", 0)
+end
+
+Then /^the outputted text should be:$/ do |expected_text|
+  @io.string.strip.should == expected_text
+end

data/features/step_definitions/pretty_formatter_steps.rb

@@ -0,0 +1,82 @@
+require 'stringio'
+require 'fileutils'
+require 'gherkin'
+require 'gherkin/formatter/pretty_formatter'
+require 'gherkin/formatter/json_formatter'
+require 'gherkin/json_parser'
+
+module PrettyPlease
+  def pretty_machinery(gherkin, feature_path)
+    io        = StringIO.new
+    formatter = Gherkin::Formatter::PrettyFormatter.new(io, false)
+    parser    = Gherkin::Parser::Parser.new(formatter, true)
+    parse(parser, gherkin, feature_path)
+    io.string
+  end
+
+  def json_machinery(gherkin, feature_path)
+    json                = StringIO.new
+    json_formatter      = Gherkin::Formatter::JSONFormatter.new(json)
+    gherkin_parser      = Gherkin::Parser::Parser.new(json_formatter, true)
+    parse(gherkin_parser, gherkin, feature_path)
+
+    result              = StringIO.new
+    pretty_formatter    = Gherkin::Formatter::PrettyFormatter.new(result, false)
+    json_parser         = Gherkin::JSONParser.new(pretty_formatter)
+    json_parser.parse(json.string, "#{feature_path}.json", 0)
+    
+    result.string
+  end
+  
+  def parse(parser, gherkin, feature_path)
+    begin
+      parser.parse(gherkin, feature_path, 0)
+    rescue => e
+      if e.message =~ /Lexing error/
+        FileUtils.mkdir "tmp" unless File.directory?("tmp")
+        written_path = "tmp/#{File.basename(feature_path)}"
+        File.open(written_path, "w") {|io| io.write(gherkin)}
+        e.message << "\nSee #{written_path}"
+      end
+      raise e
+    end
+  end
+end
+
+World(PrettyPlease)
+
+Given /^I have Cucumber's source code next to Gherkin's$/ do
+  @cucumber_home = File.dirname(__FILE__) + '/../../../cucumber'
+  raise "No Cucumber source in #{@cucumber_home}" unless File.file?(@cucumber_home + '/bin/cucumber')
+end
+
+Given /^I find all of the \.feature files$/ do
+  @feature_paths = Dir["#{@cucumber_home}/**/*.feature"].sort
+end
+
+When /^I send each prettified original through the "([^"]*)" machinery$/ do |machinery|
+  @error = false
+  @feature_paths.each do |feature_path|
+    begin
+      original = pretty_machinery(IO.read(feature_path), feature_path)
+      via_machinery = self.__send__("#{machinery}_machinery", original, feature_path)
+      via_machinery.should == original
+    rescue RSpec::Expectations::ExpectationNotMetError => e
+      announce "=========="
+      announce feature_path
+      if(e.message =~ /(@@.*)/m)
+        announce $1
+        @error = true
+      else
+        announce "Identical, except for newlines"
+      end
+    rescue => e
+      e.message << "\nFatal error happened when parsing #{feature_path}."
+      raise e
+    end
+  end
+end
+
+Then /^the machinery output should be identical to the prettified original$/ do
+  raise "Some features didn't make it through the machinery" if @error
+end

data/features/steps_parser.feature

@@ -0,0 +1,46 @@
+Feature: Gherkin Steps parser
+  In order to save time and make my features clearer
+  As a Cucumber developer
+  I want a steps parser to make writing compound steps easier
+
+  Background: 
+    Given a "ruby" "steps" parser
+
+  Scenario: Parsing steps
+    Given the following text is parsed:
+      """
+      Given a one step
+      And a two step
+        \"\"\"
+        Here is a multiline string
+        That follows a step
+        With an argument #{arg}
+        \"\"\"
+      And a one two three step
+      When another step
+      Then there should be a table
+        | one | two | three  |
+        | foo | bar | #{arg} |
+      """
+    Then there should be no parse errors
+
+  Scenario: Trying to parse a full feature with the step parser
+    Given the following text is parsed:
+      """
+      Feature: A Feature
+        Scenario: Yes, there is one
+          Given I have a step
+          When I execute this step
+          Then something should happen
+      """
+    Then there should be parse errors on lines 1 and 2
+
+  Scenario: Tags
+    Given the following text is parsed:
+      """
+      @a_tag
+      Given a step
+      When I trip
+      Then I should sign up for dancing lessons
+      """
+    Then there should be a parse error on line 1

data/features/support/env.rb

@@ -0,0 +1,38 @@
+require 'rubygems'
+require 'bundler'
+Bundler.setup
+
+# I'm sure there's a better way than this...
+%w{ /../../spec /../../lib}.each do |path|
+  $LOAD_PATH << File.expand_path(File.dirname(__FILE__) + path)
+end
+require 'gherkin'
+require 'gherkin/sexp_recorder'
+require 'gherkin/output_stream_string_io'
+require 'gherkin/json'
+
+module TransformHelpers
+  def tr_line_number(step_arg)
+    /(\d+)$/.match(step_arg)[0].to_i
+  end
+
+  def tr_line_numbers(step_arg)
+    if step_arg =~ /through/
+      Range.new(*step_arg.scan(/\d+/).collect { |i| i.to_i })
+    else
+      step_arg.scan(/\d+/).collect { |i| i.to_i }
+    end
+  end
+end
+
+class GherkinWorld
+  include TransformHelpers
+  
+  def initialize
+    @formatter = Gherkin::SexpRecorder.new
+  end
+end
+
+World do 
+  GherkinWorld.new
+end

data/gherkin.gemspec

@@ -0,0 +1,59 @@
+# -*- encoding: utf-8 -*-
+gherkin_dir = Dir.pwd =~ /gherkin\/tmp/ ? File.expand_path("../../../..", Dir.pwd) : File.expand_path("..", __FILE__)
+$LOAD_PATH.unshift File.join(gherkin_dir, 'lib')
+require "gherkin/version"
+
+Gem::Specification.new do |s|
+  s.name        = "gherkin"
+  s.version     = Gherkin::VERSION
+  s.authors     = ["Mike Sassak", "Gregory Hnatiuk", "Aslak Hellesøy"]
+  s.description = "A fast Gherkin lexer/parser based on the Ragel State Machine Compiler."
+  s.summary     = "gherkin-#{Gherkin::VERSION}"
+  s.email       = "cukes@googlegroups.com"
+  s.homepage    = "http://github.com/aslakhellesoy/gherkin"
+
+  s.rubygems_version   = "1.3.7"
+  s.default_executable = "gherkin"
+
+  s.files            = `git ls-files`.split("\n")
+  s.test_files       = `git ls-files -- {spec,features}/*`.split("\n")
+  s.executables      = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.extra_rdoc_files = ["LICENSE", "README.rdoc", "History.txt"]
+  s.rdoc_options     = ["--charset=UTF-8"]
+  s.require_path     = "lib"
+
+  s.files -= Dir['ikvm/**/*']
+  s.files -= Dir['java/**/*']
+  s.files -= Dir['ext/**/*']
+  s.files -= Dir['lib/gherkin.jar']
+  s.files -= Dir['lib/**/*.dll']
+  s.files -= Dir['lib/**/*.bundle']
+  s.files -= Dir['lib/**/*.so']
+  
+  if ENV['GEM_PLATFORM']
+    puts "GEM_PLATFORM:#{ENV['GEM_PLATFORM']}"
+  end
+  s.platform = ENV['GEM_PLATFORM'] if ENV['GEM_PLATFORM'] 
+  case s.platform.to_s
+  when /java/
+    s.files += ['lib/gherkin.jar']
+  when /mswin|mingw32/
+    s.files += Dir['lib/*/*.so']
+  when /dotnet/
+    s.files += Dir['lib/*.dll']
+  else # MRI or Rubinius
+    s.files += Dir['lib/gherkin/rb_lexer/*.rb']
+    s.files += Dir['ext/**/*.c']
+    s.extensions = Dir['ext/**/extconf.rb']
+    s.add_development_dependency('rake-compiler', '~> 0.7.1')
+  end
+
+  s.add_dependency('trollop', '~> 1.16.2')
+  s.add_dependency('json', '~> 1.4.6')
+  s.add_dependency('term-ansicolor','~> 1.0.5')
+
+  s.add_development_dependency('rake', '~> 0.8.7')
+  s.add_development_dependency('awesome_print', '~> 0.2.1')
+  s.add_development_dependency('rspec', '~> 2.0.0.beta.22')
+  s.add_development_dependency('cucumber', '~> 0.9.0')
+end

data/ikvm/.gitignore

@@ -0,0 +1,3 @@
+bin
+*.pidb
+*.userprefs

data/java/.gitignore

@@ -0,0 +1,2 @@
+.idea
+target

data/java/src/main/java/gherkin/lexer/i18n/.gitignore

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

data/java/src/main/resources/gherkin/.gitignore

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

data/lib/.gitignore

@@ -0,0 +1,4 @@
+*.bundle
+*.dll
+*.so
+*.jar

data/lib/gherkin.rb

@@ -0,0 +1,2 @@
+require 'gherkin/lexer/i18n_lexer'
+require 'gherkin/parser/parser'

data/lib/gherkin/c_lexer.rb

@@ -0,0 +1,17 @@
+require 'rbconfig'
+
+module Gherkin
+  module CLexer
+    def self.[](i18n_underscored_iso_code)
+      begin
+        prefix = Config::CONFIG['arch'] =~ /mswin|mingw/ ? "#{Config::CONFIG['MAJOR']}.#{Config::CONFIG['MINOR']}/" : ''
+        lib = "#{prefix}gherkin_lexer_#{i18n_underscored_iso_code}"
+        require lib
+        const_get(i18n_underscored_iso_code.capitalize)
+      rescue LoadError => e
+        e.message << %{\nCouldn't load #{lib}\nThe $LOAD_PATH was:\n#{$LOAD_PATH.join("\n")}}
+        raise e
+      end
+    end
+  end
+end

data/lib/gherkin/cli/main.rb

@@ -0,0 +1,33 @@
+begin
+  require 'trollop'
+rescue LoadError
+  require 'rubygems'
+  require 'trollop'
+end
+require 'gherkin/tools'
+
+module Gherkin
+  module Cli
+    class Main
+      def self.run(args)
+        Trollop::options(args) do
+          banner "Super fast gherkin parser"
+          stop_on Tools::SUB_COMMANDS
+        end
+
+        cmd_name = args.shift
+        die("Missing command") if cmd_name.nil?
+        begin
+          cmd = Tools.const_get(cmd_name.capitalize.to_sym).new(args)
+          cmd.run
+        rescue => e
+          Trollop::die(e.message + "\n#{e.backtrace.join("\n")}\n\nCommand: #{cmd_name}")
+        end
+      end
+
+      def self.die(msg)
+        Trollop::die("#{msg}\nusage: gherkin COMMAND [ARGS]\nAvailable commands: #{Tools::SUB_COMMANDS.join(' ')}")
+      end
+    end
+  end
+end

data/lib/gherkin/formatter/argument.rb

@@ -0,0 +1,28 @@
+require 'gherkin/native'
+
+module Gherkin
+  module Formatter
+    class Argument
+      native_impl('gherkin')
+      attr_reader :byte_offset, :val
+
+      def initialize(byte_offset, val)
+        @byte_offset, @val = byte_offset, val
+      end
+      
+      def self.format(string, argument_format, arguments)
+        arguments ||= []
+        s = string.dup
+        offset = past_offset = 0
+        arguments.each do |arg|
+          next if arg.byte_offset.nil? || arg.byte_offset < past_offset
+          replacement = argument_format.format_argument(arg.val)
+          s[arg.byte_offset + offset, arg.val.length] = replacement
+          offset += replacement.unpack("U*").length - arg.val.unpack("U*").length
+          past_offset = arg.byte_offset + arg.val.length
+        end
+        s
+      end
+    end
+  end
+end

data/lib/gherkin/formatter/colors.rb

@@ -0,0 +1,119 @@
+require 'term/ansicolor'
+
+module Gherkin
+  module Formatter
+    # Defines aliases for coloured output. You don't invoke any methods from this
+    # module directly, but you can change the output colours by defining
+    # a <tt>GHERKIN_COLORS</tt> variable in your shell, very much like how you can
+    # tweak the familiar POSIX command <tt>ls</tt> with
+    # <a href="http://mipsisrisc.com/rambling/2008/06/27/lscolorsls_colors-now-with-linux-support/">$LSCOLORS/$LS_COLORS</a>
+    #
+    # The colours that you can change are:
+    #
+    # * <tt>undefined</tt>     - defaults to <tt>yellow</tt>
+    # * <tt>pending</tt>       - defaults to <tt>yellow</tt>
+    # * <tt>pending_param</tt> - defaults to <tt>yellow,bold</tt>
+    # * <tt>failed</tt>        - defaults to <tt>red</tt>
+    # * <tt>failed_param</tt>  - defaults to <tt>red,bold</tt>
+    # * <tt>passed</tt>        - defaults to <tt>green</tt>
+    # * <tt>passed_param</tt>  - defaults to <tt>green,bold</tt>
+    # * <tt>outline</tt>       - defaults to <tt>cyan</tt>
+    # * <tt>outline_param</tt> - defaults to <tt>cyan,bold</tt>
+    # * <tt>skipped</tt>       - defaults to <tt>cyan</tt>
+    # * <tt>skipped_param</tt> - defaults to <tt>cyan,bold</tt>
+    # * <tt>comment</tt>       - defaults to <tt>grey</tt>
+    # * <tt>tag</tt>           - defaults to <tt>cyan</tt>
+    #
+    # For instance, if your shell has a black background and a green font (like the
+    # "Homebrew" settings for OS X' Terminal.app), you may want to override passed
+    # steps to be white instead of green. Examples:
+    #
+    #   export GHERKIN_COLORS="passed=white"
+    #   export GHERKIN_COLORS="passed=white,bold:passed_param=white,bold,underline"
+    #
+    # (If you're on Windows, use SET instead of export).
+    # To see what colours and effects are available, just run this in your shell:
+    #
+    #   ruby -e "require 'rubygems'; require 'term/ansicolor'; puts Term::ANSIColor.attributes"
+    #
+    # Although not listed, you can also use <tt>grey</tt>
+    module Colors
+      include Term::ANSIColor
+
+      ALIASES = Hash.new do |h,k|
+        if k.to_s =~ /(.*)_param/
+          h[$1] + ',bold'
+        end
+      end.merge({
+        'undefined' => 'yellow',
+        'pending'   => 'yellow',
+        'failed'    => 'red',
+        'passed'    => 'green',
+        'outline'   => 'cyan',
+        'skipped'   => 'cyan',
+        'comments'  => 'grey',
+        'tag'       => 'cyan'
+      })
+
+      if ENV['GHERKIN_COLORS'] # Example: export GHERKIN_COLORS="passed=red:failed=yellow"
+        ENV['GHERKIN_COLORS'].split(':').each do |pair|
+          a = pair.split('=')
+          ALIASES[a[0]] = a[1]
+        end
+      end
+
+      ALIASES.each do |method, color|
+        unless method =~ /.*_param/
+          code = <<-EOF
+          def #{method}(string=nil, monochrome=false, &proc)
+            return string if monochrome
+            #{ALIASES[method].split(",").join("(") + "(string, &proc" + ")" * ALIASES[method].split(",").length}
+          end
+          # This resets the colour to the non-param colour
+          def #{method}_param(string=nil, monochrome=false, &proc)
+            return string if monochrome
+            #{ALIASES[method+'_param'].split(",").join("(") + "(string, &proc" + ")" * ALIASES[method+'_param'].split(",").length} + #{ALIASES[method].split(",").join(' + ')}
+          end
+          EOF
+          eval(code)
+        end
+      end
+    
+      def self.define_grey #:nodoc:
+        begin
+          gem 'genki-ruby-terminfo'
+          require 'terminfo'
+          case TermInfo.default_object.tigetnum("colors")
+          when 0
+            raise "Your terminal doesn't support colours"
+          when 1
+            ::Term::ANSIColor.coloring = false
+            alias grey white
+          when 2..8
+            alias grey white
+          else
+            define_real_grey
+          end
+        rescue Exception => e
+          if e.class.name == 'TermInfo::TermInfoError'
+            STDERR.puts "*** WARNING ***"
+            STDERR.puts "You have the genki-ruby-terminfo gem installed, but you haven't set your TERM variable."
+            STDERR.puts "Try setting it to TERM=xterm-256color to get grey colour in output"
+            STDERR.puts "\n"
+            alias grey white
+          else
+            define_real_grey
+          end
+        end
+      end
+    
+      def self.define_real_grey #:nodoc:
+        def grey(m) #:nodoc:
+          "\e[90m#{m}\e[0m"
+        end
+      end
+    
+      define_grey
+    end
+  end
+end