gherkin_jruby 0.3.1.pre.jruby

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 38b437fd9881eff6dfbe7bd8d3c3b7fae7635ab2
+  data.tar.gz: 6c7f61a399113bfeac0ae3115029a1974e8a9f90
+SHA512:
+  metadata.gz: 068fb7ebc94d293c51a52734d13cfea9d14b66cd79ecf5b40064735511db9736471f7dbdedaa9317921bb96e53e9e15a06e7771f201c4a70bd0ea0e5333abd7c
+  data.tar.gz: 57137563b34f849e71ed29278983991488e2f87e7d7b78b28568a1028963c7c2572c90584c2f5d0dd4ec1025ea0db4a4d151cd05a464434b61f46af4d4a5d523

data/.gitignore

@@ -0,0 +1,5 @@
+*.gem
+.bundle
+Gemfile.lock
+pkg/*
+.rbx

data/.travis.yml

@@ -0,0 +1,8 @@
+env:
+ - RBXOPT=-X19
+rvm:
+  - 1.9.3
+  - 2.0.0
+  - rbx-2.0.0
+  - ruby-head
+  - rbx-head

data/Gemfile

@@ -0,0 +1,5 @@
+source "http://rubygems.org"
+
+# Specify your gem's dependencies in gherkin.gemspec
+gemspec
+gem 'rake'

data/Rakefile

@@ -0,0 +1,29 @@
+# encoding: utf-8
+require 'bundler'
+Bundler::GemHelper.install_tasks
+
+require 'rake/testtask'
+Rake::TestTask.new do |t|
+  t.libs << "test"
+  t.test_files = FileList['./test/**/*_test.rb']
+end
+
+desc "Regenerate Gherkin-ruby lexer and parser."
+task :regenerate do
+  has_rex  = `which rex`
+  has_racc = `which racc`
+
+  if has_rex && has_racc
+    `rex lib/gherkin_ruby/parser/gherkin.rex -o lib/gherkin_ruby/parser/lexer.rb`
+    `racc #{'--debug' if ENV['DEBUG_RACC']} lib/gherkin_ruby/parser/gherkin.y -o lib/gherkin_ruby/parser/parser.rb`
+  else
+    puts "You need both Rexical and Racc to do that. Install them by doing:"
+    puts
+    puts "\t\tgem install rexical"
+    puts "\t\tgem install racc"
+    puts
+    puts "Or just type `bundle install`."
+  end
+end
+
+task :default => [:regenerate, :test]

data/Readme.md

@@ -0,0 +1,98 @@
+# gherkin-ruby [![Build Status](https://secure.travis-ci.org/codegram/gherkin-ruby.png)](http://travis-ci.org/codegram/gherkin-ruby) [![Dependency Status](https://gemnasium.com/codegram/gherkin-ruby.png)](http://gemnasium.com/codegram/gherkin-ruby)
+Gherkin-ruby is a pure Ruby implementation of a [Gherkin](http://github.com/cucumber/gherkin) parser.
+
+Tested with MRI 1.9.3, 2.0.0, head, Rubinius 2.0.0-rc1 and Rubinius head.
+
+## WARNING: Will be deprecated after Gherkin 3.0
+
+A new rewrite of the Gherkin parser used by Cucumber is planned (for version
+3.0) gherkin-ruby will not add any more features until then, and will
+eventually be deprecated in favor of Gherkin 3.0.
+
+## FAQ
+
+### Why this one over the official, fast, Ragel-based Gherkin parser?
+
+* Less than 200 LOC.
+* No Java/.NET crap.
+* Fast enough for our purposes (using it for the [Spinach](http://github.com/codegram/spinach) project)
+
+### Why don't you support tables?
+
+* Because we believe it's a BDD anti-pattern. Tables show the need for more
+  unit tests.
+
+## Install
+
+    $ gem install gherkin-ruby
+
+Or in your Gemfile:
+
+```ruby
+# Gemfile
+
+gem 'gherkin-ruby'
+```
+
+## Usage
+You can easily implement your own visitors to traverse the Abstract Syntax Tree. The following example just prints the step names to standard output:
+
+```ruby
+class MyVisitor
+  def visit(ast)
+    ast.accept(self)
+  end
+
+  def visit_Feature(feature)
+    # Do something nasty with the feature
+    # Set whatever state you want:
+    #   @current_feature = feature
+    # etc etc
+    # And keep visiting its children:
+
+    feature.each { |scenario| scenario.accept(self) }
+  end
+
+  def visit_Scenario(scenario)
+    # Do something nasty with the scenario
+    # Set whatever state you want:
+    #   @current_scenario = scenario
+    # etc etc
+    # And keep visiting its children:
+
+    scenario.each { |step| step.accept(self) }
+  end
+
+  def visit_Background(background)
+    # Do something nasty with the background
+    # And keep visiting its children:
+
+    background.each { |step| step.accept(self) }
+  end
+
+  def visit_Tag(tag)
+    # Do something nasty with the tag
+  end
+
+  def visit_Step(step)
+    # Finally, print the step name.
+    puts "STEP: #{step.name}"
+  end
+end
+
+ast = Gherkin.parse(File.read('some.feature'))
+visitor = MyVisitor.new
+visitor.visit(ast)
+```
+
+## Todo
+
+* Some optimization
+
+## FAQ
+
+
+
+## License
+
+MIT (Expat) License. Copyright 2011-2013 [Codegram Technologies](http://codegram.com)

data/gherkin_jruby.gemspec

@@ -0,0 +1,21 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "gherkin_ruby/version"
+
+Gem::Specification.new do |s|
+  s.name        = "gherkin_jruby"
+  s.version     = GherkinRuby::VERSION
+  s.authors     = ["Marc Divins", "Josep M. Bach", "Rodrigo Alvarez"]
+  s.email       = ["marcdivc@gmail.com", "josep.m.bach@gmail.com", "papipo@gmail.com"]
+  s.homepage    = "http://github.com/Papipo/gherkin-jruby"
+  s.summary     = %q{Gherkin-ruby is a Gherkin parser in pure Ruby using Rexical and Racc that works on jruby}
+  s.description = %q{Gherkin-ruby is a Gherkin parser in pure Ruby using Rexical and Racc that works on jruby}
+
+  s.add_development_dependency 'minitest'
+  s.add_development_dependency 'rexical'
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+end

data/lib/gherkin_jruby.rb

@@ -0,0 +1,10 @@
+require_relative "gherkin_ruby/version"
+require_relative 'gherkin_ruby/ast'
+require_relative 'gherkin_ruby/parser'
+
+module GherkinRuby
+  def self.parse(input)
+    parser = Parser.new
+    parser.parse(input)
+  end
+end

data/lib/gherkin_ruby/ast.rb

@@ -0,0 +1,89 @@
+module GherkinRuby
+  module AST
+    class Node
+      attr_reader :filename, :line
+
+      def accept(visitor)
+        name = self.class.name.split('::').last
+        visitor.send("visit_#{name}".to_sym, self)
+      end
+
+      def pos(filename, line=nil)
+        @filename, @line = filename, line
+      end
+    end
+
+    class Feature < Node
+      attr_reader :name, :background, :scenarios, :tags
+      attr_writer :background, :scenarios, :tags
+      attr_accessor :description
+
+      include Enumerable
+
+      def initialize(name, scenarios=[], tags=[], background=nil)
+        @name       = name
+        @background = background
+        @tags       = tags
+        @scenarios  = scenarios
+      end
+
+      def each
+        @scenarios.each
+      end
+    end
+
+    class Background < Node
+      attr_reader :steps
+      attr_writer :steps
+
+      include Enumerable
+
+      def initialize(steps=[])
+        @steps = steps
+      end
+
+      def line
+        @steps.first.line - 1 if @steps.any?
+      end
+
+      def each
+        @steps.each
+      end
+    end
+
+    class Scenario < Node
+      attr_reader :name, :steps, :tags
+
+      include Enumerable
+
+      def initialize(name, steps=[], tags=[])
+        @name  = name.to_s
+        @steps = steps
+        @tags  = tags
+      end
+
+      def line
+        @steps.first.line - 1 if @steps.any?
+      end
+
+      def each
+        @steps.each
+      end
+    end
+
+    class Step < Node
+      attr_reader :name, :keyword
+      def initialize(name, keyword)
+        @name    = name.to_s
+        @keyword = keyword.to_s
+      end
+    end
+
+    class Tag < Node
+      attr_reader :name
+      def initialize(name)
+        @name = name
+      end
+    end
+  end
+end

data/lib/gherkin_ruby/parser.rb

@@ -0,0 +1 @@
+require_relative 'parser/parser'

data/lib/gherkin_ruby/parser/gherkin.rex

@@ -0,0 +1,44 @@
+# Compile with: rex gherkin.rex -o lexer.rb
+
+class GherkinRuby::Parser
+
+macro
+  BLANK         [\ \t]+
+
+rule
+  # Whitespace
+  {BLANK}       # no action
+  \#.*$
+
+  # Literals
+  \n                                    { [:NEWLINE, text] }
+
+  # Keywords
+  Feature:                              { [:FEATURE, text[0..-2]] }
+  Background:                           { [:BACKGROUND, text[0..-2]] }
+  Scenario:                             { [:SCENARIO, text[0..-2]] }
+
+  # Tags
+  @(\w|-)+                              { [:TAG, text[1..-1]] }
+
+  # Step keywords
+  Given                                 { [:GIVEN, text] }
+  When                                  { [:WHEN, text] }
+  Then                                  { [:THEN, text] }
+  And                                   { [:AND, text] }
+  But                                   { [:BUT, text] }
+
+  # Text
+  [^#\n]*                               { [:TEXT, text.strip] }
+
+inner
+  def tokenize(code)
+    scan_setup(code)
+    tokens = []
+    while token = next_token
+      tokens << token
+    end
+    tokens
+  end
+
+end

data/lib/gherkin_ruby/parser/gherkin.y

@@ -0,0 +1,108 @@
+# Compile with: racc gherkin.y -o parser.rb
+
+class GherkinRuby::Parser
+
+# Declare tokens produced by the lexer
+token NEWLINE
+token FEATURE BACKGROUND SCENARIO
+token TAG
+token GIVEN WHEN THEN AND BUT
+token TEXT
+
+rule
+
+  Root:
+    Feature     { result = val[0]; }
+  |
+    Feature
+      Scenarios { result = val[0]; result.scenarios = val[1] }
+  | FeatureTags Feature { result = val[1]; result.tags = val[0] }
+  | FeatureTags Feature 
+      Scenarios { result = val[1]; result.scenarios = val[2]; result.tags = val[0] }
+  ;
+
+  Newline:
+    NEWLINE
+  | Newline NEWLINE
+  ;
+
+  FeatureTags:
+    Tags { result = val[0] }
+  | Newline Tags { result = val[1] }
+
+  Feature:
+    FeatureHeader { result = val[0] }
+  | FeatureHeader
+      Background  { result = val[0]; result.background = val[1] }
+  ;
+
+  FeatureHeader:
+    FeatureName           { result = val[0] }
+  | FeatureName Newline   { result = val[0] }
+  | FeatureName Newline
+      Description         { result = val[0]; result.description = val[2] }
+  ;
+
+  FeatureName:
+    FEATURE TEXT          { result = AST::Feature.new(val[1]); result.pos(filename, lineno) }
+  | Newline FEATURE TEXT  { result = AST::Feature.new(val[2]); result.pos(filename, lineno) }
+  ;
+
+  Description:
+    TEXT Newline             { result = val[0] }
+  | Description TEXT Newline { result = val[0...-1].flatten }
+  ;
+
+  Background:
+    BackgroundHeader
+      Steps               { result = val[0]; result.steps = val[1] }
+  ;
+
+  BackgroundHeader:
+    BACKGROUND Newline    { result = AST::Background.new; result.pos(filename, lineno) }
+  ;
+
+  Steps:
+    Step                  { result = [val[0]] }
+  | Step Newline          { result = [val[0]] }
+  | Step Newline Steps    { val[2].unshift(val[0]); result = val[2] }
+  ;
+
+  Step:
+    Keyword TEXT          { result = AST::Step.new(val[1], val[0]); result.pos(filename, lineno) }
+  ;
+
+  Keyword:
+    GIVEN | WHEN | THEN | AND | BUT
+  ;
+
+  Scenarios:
+    Scenario              { result = [val[0]] }
+  | Scenarios Scenario    { result = val[0] << val[1] }
+  ;
+
+  Scenario:
+    SCENARIO TEXT Newline
+      Steps { result = AST::Scenario.new(val[1], val[3]); result.pos(filename, lineno - 1) }
+  | Tags Newline
+    SCENARIO TEXT Newline
+      Steps { result = AST::Scenario.new(val[3], val[5], val[0]); result.pos(filename, lineno - 2) }
+  ;
+
+  Tags:
+    TAG         { result = [AST::Tag.new(val[0])] }
+  | Tags TAG    { result = val[0] << AST::Tag.new(val[1]) }
+  ;
+
+end
+
+---- header
+  require_relative "lexer"
+  require_relative "../ast"
+
+---- inner
+
+  def parse(input)
+    @yydebug = true if ENV['DEBUG_RACC']
+    scan_str(input)
+  end

data/lib/gherkin_ruby/parser/lexer.rb

@@ -0,0 +1,120 @@
+#--
+# DO NOT MODIFY!!!!
+# This file is automatically generated by rex 1.0.5
+# from lexical definition file "lib/gherkin_ruby/parser/gherkin.rex".
+#++
+
+require 'racc/parser'
+# Compile with: rex gherkin.rex -o lexer.rb
+
+class GherkinRuby::Parser < Racc::Parser
+  require 'strscan'
+
+  class ScanError < StandardError ; end
+
+  attr_reader   :lineno
+  attr_reader   :filename
+  attr_accessor :state
+
+  def scan_setup(str)
+    @ss = StringScanner.new(str)
+    @lineno =  1
+    @state  = nil
+  end
+
+  def action
+    yield
+  end
+
+  def scan_str(str)
+    scan_setup(str)
+    do_parse
+  end
+  alias :scan :scan_str
+
+  def load_file( filename )
+    @filename = filename
+    open(filename, "r") do |f|
+      scan_setup(f.read)
+    end
+  end
+
+  def scan_file( filename )
+    load_file(filename)
+    do_parse
+  end
+
+
+  def next_token
+    return if @ss.eos?
+    
+    # skips empty actions
+    until token = _next_token or @ss.eos?; end
+    token
+  end
+
+  def _next_token
+    text = @ss.peek(1)
+    @lineno  +=  1  if text == "\n"
+    token = case @state
+    when nil
+      case
+      when (text = @ss.scan(/[ \t]+/))
+        ;
+
+      when (text = @ss.scan(/\#.*$/))
+        ;
+
+      when (text = @ss.scan(/\n/))
+         action { [:NEWLINE, text] }
+
+      when (text = @ss.scan(/Feature:/))
+         action { [:FEATURE, text[0..-2]] }
+
+      when (text = @ss.scan(/Background:/))
+         action { [:BACKGROUND, text[0..-2]] }
+
+      when (text = @ss.scan(/Scenario:/))
+         action { [:SCENARIO, text[0..-2]] }
+
+      when (text = @ss.scan(/@(\w|-)+/))
+         action { [:TAG, text[1..-1]] }
+
+      when (text = @ss.scan(/Given/))
+         action { [:GIVEN, text] }
+
+      when (text = @ss.scan(/When/))
+         action { [:WHEN, text] }
+
+      when (text = @ss.scan(/Then/))
+         action { [:THEN, text] }
+
+      when (text = @ss.scan(/And/))
+         action { [:AND, text] }
+
+      when (text = @ss.scan(/But/))
+         action { [:BUT, text] }
+
+      when (text = @ss.scan(/[^#\n]*/))
+         action { [:TEXT, text.strip] }
+
+      else
+        text = @ss.string[@ss.pos .. -1]
+        raise  ScanError, "can not match: '" + text + "'"
+      end  # if
+
+    else
+      raise  ScanError, "undefined state: '" + state.to_s + "'"
+    end  # case state
+    token
+  end  # def _next_token
+
+  def tokenize(code)
+    scan_setup(code)
+    tokens = []
+    while token = next_token
+      tokens << token
+    end
+    tokens
+  end
+end # class