bryanl-gherkin 2.11.1.1

data/features/pretty_formatter.feature

@@ -0,0 +1,16 @@
+@cucumber-source-available
+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|
+  puts 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|
+    step "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,30 @@
+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
+  @out = StringIO.new
+  @formatter = Gherkin::Formatter::JSONFormatter.new(@out)
+end
+
+Then /^the outputted JSON should be:$/ do |expected_json|
+  require 'json'
+  @formatter.done
+  actual_json = @out.string
+  puts actual_json
+  puts JSON.pretty_generate(JSON.parse(actual_json))
+  expected = JSON.parse(expected_json)
+  actual   = JSON.parse(actual_json)
+  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, false)
+end
+
+Given /^a JSON lexer$/ do
+  @json_parser = Gherkin::JSONParser.new(@formatter, @formatter)
+end
+
+Given /^the following JSON is parsed:$/ do |text|
+  @json_parser.parse(JSON.pretty_generate(JSON.parse(text)))
+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,85 @@
+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, true, 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)
+    json_formatter.done
+
+    io                  = StringIO.new
+    pretty_formatter    = Gherkin::Formatter::PrettyFormatter.new(io, true, false)
+    json_parser         = Gherkin::JSONParser.new(pretty_formatter, pretty_formatter)
+    json_parser.parse(json.string)
+    
+    io.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
+      next if feature_path =~ /iso-8859-1\.feature/
+      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,42 @@
+if RUBY_VERSION =~ /1.9/
+  Encoding.default_external = Encoding::UTF_8
+  Encoding.default_internal = Encoding::UTF_8
+end
+
+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'
+
+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,77 @@
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name        = "bryanl-gherkin"
+  # If the major version is bumped, verify that the change is ok:
+  #
+  # * Comment out the cucumber dependency below
+  # * Uncomment the cucumber location in Gemfile
+  # * Bump cucumber's gherkin dependency to the new version
+  # * bundle update
+  # * bundle exec rake
+  #
+  # Repeat these step for cucumber (swap `cucumber` with `gherkin`).
+  #
+  # When both are building OK, do a `bundle exec rake install` in both cucumber and gherkin projects, revert the changes in the first 2 steps 
+  # and release both projects. Do this for both ruby 1.8.7, ruby 1.9.3 and jruby.
+  #
+  s.version     = "2.11.1.1"
+  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     = "bryanl's #{s.name}-#{s.version}"
+  s.email       = "cukes@googlegroups.com"
+  s.homepage    = "http://github.com/cucumber/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.rdoc_options     = ["--charset=UTF-8"]
+  s.require_path     = "lib"
+
+  s.files -= Dir['ikvm/**/*']
+  s.files -= Dir['java/**/*']
+  s.files -= Dir['js/**/*']
+  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 += Dir['lib/*.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.8.0')
+  end
+  s.files -= Dir['**/.gitignore']
+
+  s.add_runtime_dependency('json', '>= 1.4.6')
+
+  s.add_development_dependency('cucumber', '>= 1.2.1')
+  s.add_development_dependency('rake', '>= 0.9.2')
+  s.add_development_dependency('bundler', '>= 1.1.0')
+  s.add_development_dependency('rspec', '~> 2.10.0')
+  s.add_development_dependency('rubyzip', '>= 0.9.8')
+
+  unless ENV['RUBY_CC_VERSION'] || defined?(JRUBY_VERSION)
+    s.add_development_dependency('therubyracer', '>= 0.10.1') if ENV['GHERKIN_JS']
+    # For Documentation:
+    s.add_development_dependency('yard', '>= 0.8.0')
+    s.add_development_dependency('rdiscount', '>= 1.6.8')
+  end
+
+  # Only needed by Cucumber. Remove when Cucumber no longer needs those.
+  s.add_development_dependency('term-ansicolor', '>= 1.0.6')
+  s.add_development_dependency('builder', '>= 2.1.2')
+end

data/install_mingw_os_x.sh

@@ -0,0 +1,7 @@
+#!/bin/sh
+
+mkdir -p /usr/local/mingw
+cd /usr/local/mingw
+# Don't attempt any of the newer versions - they don't work (gcc 4.7.0)
+wget http://downloads.sourceforge.net/project/mingw-w64/Toolchains%20targetting%20Win32/Automated%20Builds/mingw-w32-1.0-bin_i686-darwin_20110819.tar.bz2
+tar xvfj mingw-w32-1.0-bin_i686-darwin_20110819.tar.bz2

data/js/.npmignore

@@ -0,0 +1 @@
+example

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 = RbConfig::CONFIG['arch'] =~ /mswin|mingw/ ? "#{RbConfig::CONFIG['MAJOR']}.#{RbConfig::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/formatter/ansi_escapes.rb

@@ -0,0 +1,97 @@
+module Gherkin
+  module Formatter
+    # Defines aliases for ANSI coloured output. Default colours can be overridden 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
+    # $LSCOLORS: http://linux-sxs.org/housekeeping/lscolors.html
+    #
+    # 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_arg</tt>::   defaults to <tt>yellow,bold</tt>
+    # <tt>executing</tt>::     defaults to <tt>grey</tt>
+    # <tt>executing_arg</tt>:: defaults to <tt>grey,bold</tt>
+    # <tt>failed</tt>::        defaults to <tt>red</tt>
+    # <tt>failed_arg</tt>::    defaults to <tt>red,bold</tt>
+    # <tt>passed</tt>::        defaults to <tt>green</tt>
+    # <tt>passed_arg</tt>::    defaults to <tt>green,bold</tt>
+    # <tt>outline</tt>::       defaults to <tt>cyan</tt>
+    # <tt>outline_arg</tt>::   defaults to <tt>cyan,bold</tt>
+    # <tt>skipped</tt>::       defaults to <tt>cyan</tt>
+    # <tt>skipped_arg</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_arg=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 AnsiEscapes
+      COLORS = {
+        'black'   => "\e[30m",
+        'red'     => "\e[31m",
+        'green'   => "\e[32m",
+        'yellow'  => "\e[33m",
+        'blue'    => "\e[34m",
+        'magenta' => "\e[35m",
+        'cyan'    => "\e[36m",
+        'white'   => "\e[37m",
+        'grey'    => "\e[90m",
+        'bold'    => "\e[1m"
+      }
+
+      ALIASES = Hash.new do |h,k|
+        if k.to_s =~ /(.*)_arg/
+          h[$1] + ',bold'
+        end
+      end.merge({
+        'undefined' => 'yellow',
+        'pending'   => 'yellow',
+        'executing' => 'grey',
+        '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.keys.each do |key|
+        define_method(key) do
+          ALIASES[key].split(',').map{|color| COLORS[color]}.join('')
+        end
+
+        define_method("#{key}_arg") do
+          ALIASES["#{key}_arg"].split(',').map{|color| COLORS[color]}.join('')
+        end
+      end
+      
+      def reset
+        "\e[0m"
+      end
+
+      def up(n)
+        "\e[#{n}A"
+      end
+
+      extend self
+    end
+  end
+end