bryanl-gherkin 2.11.1.1-java

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/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

data/lib/gherkin/formatter/argument.rb

@@ -0,0 +1,16 @@
+require 'gherkin/native'
+require 'gherkin/formatter/hashable'
+
+module Gherkin
+  module Formatter
+    class Argument < Hashable
+      native_impl('gherkin')
+      attr_reader :offset, :val
+
+      # Creates a new Argument that starts at character offset +offset+ with value +val+
+      def initialize(offset, val)
+        @offset, @val = offset, val
+      end
+    end
+  end
+end

data/lib/gherkin/formatter/escaping.rb

@@ -0,0 +1,15 @@
+module Gherkin
+  module Formatter
+    module Escaping
+      # Escapes a pipes and backslashes:
+      #
+      # * | becomes \|
+      # * \ becomes \\
+      #
+      # This is used in the pretty formatter.
+      def escape_cell(s)
+        s.gsub(/\\(?!\|)/, "\\\\\\\\").gsub(/\n/, "\\n").gsub(/\|/, "\\|")
+      end
+    end
+  end
+end

data/lib/gherkin/formatter/filter_formatter.rb

@@ -0,0 +1,146 @@
+require 'gherkin/tag_expression'
+require 'gherkin/formatter/regexp_filter'
+require 'gherkin/formatter/line_filter'
+require 'gherkin/formatter/tag_filter'
+require 'gherkin/formatter/model'
+require 'gherkin/native'
+
+module Gherkin
+  module Formatter
+    class FilterFormatter
+      native_impl('gherkin')
+      
+      def initialize(formatter, filters)
+        @formatter = formatter
+        @filter    = detect_filter(filters)
+
+        @feature_tags           = []
+        @feature_element_tags   = []
+        @examples_tags          = []
+
+        @feature_events         = []
+        @background_events      = []
+        @feature_element_events = []
+        @examples_events        = []
+      end
+
+      def uri(uri)
+        @formatter.uri(uri)
+      end
+
+      def feature(feature)
+        @feature_tags   = feature.tags
+        @feature_name   = feature.name
+        @feature_events = [feature]
+      end
+
+      def background(background)
+        @feature_element_name   = background.name
+        @feature_element_range  = background.line_range
+        @background_events      = [background]
+      end
+
+      def scenario(scenario)
+        replay!
+        @feature_element_tags   = scenario.tags
+        @feature_element_name   = scenario.name
+        @feature_element_range  = scenario.line_range
+        @feature_element_events = [scenario]
+      end
+
+      def scenario_outline(scenario_outline)
+        replay!
+        @feature_element_tags   = scenario_outline.tags
+        @feature_element_name   = scenario_outline.name
+        @feature_element_range  = scenario_outline.line_range
+        @feature_element_events = [scenario_outline]
+      end
+
+      def examples(examples)
+        replay!
+        @examples_tags = examples.tags
+        @examples_name = examples.name
+
+        table_body_range = case(examples.rows.length)
+          when 0 then examples.line_range.last..examples.line_range.last
+          when 1 then examples.rows[0].line..examples.rows[0].line
+          else examples.rows[1].line..examples.rows[-1].line
+        end
+
+        @examples_range = examples.line_range.first..table_body_range.last
+        if(@filter.eval([], [], [table_body_range]))
+          examples.rows = @filter.filter_table_body_rows(examples.rows)
+        end
+        @examples_events = [examples]
+      end
+
+      def step(step)
+        if @feature_element_events.any?
+          @feature_element_events << step
+        else
+          @background_events << step
+        end
+
+        @feature_element_range = @feature_element_range.first..step.line_range.last
+      end
+
+      def eof
+        replay!
+        @formatter.eof
+      end
+
+      def done
+        @formatter.done
+      end
+
+    private
+
+      def detect_filter(filters)
+        raise "Inconsistent filters: #{filters.inspect}. Only one type [line,name,tag] can be used at once." if filters.map{|filter| filter.class}.uniq.length > 1
+        case(filters[0])
+        when Fixnum 
+          LineFilter.new(filters)
+        when Regexp 
+          RegexpFilter.new(filters)
+        when String 
+          TagFilter.new(filters)
+        end
+      end
+
+      def replay!
+        feature_element_ok = @filter.eval(
+          (@feature_tags + @feature_element_tags), 
+          [@feature_name, @feature_element_name].compact, 
+          [@feature_element_range].compact
+        )
+        examples_ok = @filter.eval(
+          (@feature_tags + @feature_element_tags + @examples_tags), 
+          [@feature_name, @feature_element_name, @examples_name].compact, 
+          [@feature_element_range, @examples_range].compact
+        )
+
+        if feature_element_ok || examples_ok
+          replay_events!(@feature_events)
+          replay_events!(@background_events)
+          replay_events!(@feature_element_events)
+
+          if examples_ok
+            replay_events!(@examples_events)
+          end
+        end
+
+        @examples_events.clear
+        @examples_tags.clear
+        @examples_name = nil
+        @examples_range = nil
+      end
+
+      def replay_events!(events)
+        events.each do |event|
+          event.replay(@formatter)
+        end
+        events.clear
+      end
+    end
+  end
+end

data/lib/gherkin/formatter/hashable.rb

@@ -0,0 +1,19 @@
+module Gherkin
+  module Formatter
+    class Hashable
+      def to_hash
+        instance_variables.inject({}) do |hash, ivar|
+          value = instance_variable_get(ivar)
+          value = value.to_hash if value.respond_to?(:to_hash)
+          if Array === value
+            value = value.map do |e|
+              e.respond_to?(:to_hash) ? e.to_hash : e
+            end
+          end
+          hash[ivar[1..-1]] = value unless [[], nil].index(value)
+          hash
+        end
+      end
+    end
+  end
+end