gherkin-ruby 0.0.2 → 0.1.0

data/.gitignore

@@ -2,3 +2,4 @@
 .bundle
 Gemfile.lock
 pkg/*
+.rbx

data/Rakefile

@@ -8,4 +8,22 @@ Rake::TestTask.new do |t|
   t.test_files = FileList['./test/**/*_test.rb']
 end
 
-task :default => [:test]
+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/parser/gherkin.rex -o lib/gherkin/parser/lexer.rb`
+    `racc lib/gherkin/parser/gherkin.y -o lib/gherkin/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

@@ -1,10 +1,9 @@
 # gherkin-ruby
-Gherkin-ruby is a pure Ruby implementation of a [Gherkin](http://github.com/cucumber/gherkin) parser, using [Parslet](http://github.com/kschiess/parslet).
+Gherkin-ruby is a pure Ruby implementation of a [Gherkin](http://github.com/cucumber/gherkin) parser.
 
 ## Why this one over the official, fast, Ragel-based Gherkin parser?
 
 * Less than 200 LOC.
-* No C-exts
 * No Java/.NET crap.
 * Fast enough for our purposes (using it for the [Spinach](http://github.com/codegram/spinach) project)
 
@@ -74,3 +73,4 @@ visitor.visit(ast)
 ## Todo
 
 * Some optimization
+

data/gherkin-ruby.gemspec

@@ -13,7 +13,8 @@ Gem::Specification.new do |s|
 
   s.rubyforge_project = "gherkin-ruby"
 
-  s.add_runtime_dependency 'parslet'
+  s.add_runtime_dependency 'rexical'
+  s.add_runtime_dependency 'racc'
   s.add_development_dependency 'minitest'
 
   s.files         = `git ls-files`.split("\n")

data/lib/gherkin/ast.rb

@@ -1,25 +1,28 @@
 module Gherkin
   module AST
     class Node
-      attr_reader :line, :column
+      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
+      attr_writer :background, :scenarios
 
       include Enumerable
 
       def initialize(name, scenarios=[], background=nil)
-        @line, @column = name.line_and_column
-
-        @name      = name.to_s
+        @name       = name
         @background = background
-        @scenarios = scenarios
+        @scenarios  = scenarios
       end
 
       def each
@@ -29,18 +32,18 @@ module Gherkin
 
     class Background < Node
       attr_reader :steps
+      attr_writer :steps
 
       include Enumerable
 
       def initialize(steps=[])
-        if steps.any?
-          @line   = steps.first.line - 1
-          @column = 3
-        end
-
         @steps = steps
       end
 
+      def line
+        @steps.first.line - 1 if @steps.any?
+      end
+
       def each
         @steps.each
       end
@@ -52,13 +55,15 @@ module Gherkin
       include Enumerable
 
       def initialize(name, steps=[], tags=[])
-        @line, @column = name.line_and_column
-
         @name  = name.to_s
         @steps = steps
         @tags  = tags
       end
 
+      def line
+        @steps.first.line - 1 if @steps.any?
+      end
+
       def each
         @steps.each
       end
@@ -67,8 +72,6 @@ module Gherkin
     class Step < Node
       attr_reader :name, :keyword
       def initialize(name, keyword)
-        @line, @column = name.line_and_column
-
         @name    = name.to_s
         @keyword = keyword.to_s
       end
@@ -77,9 +80,7 @@ module Gherkin
     class Tag < Node
       attr_reader :name
       def initialize(name)
-        @line, @column = name.line_and_column
-
-        @name = name.to_s
+        @name = name
       end
     end
   end

data/lib/gherkin/parser/gherkin.rex

@@ -0,0 +1,44 @@
+# Compile with: rex gherkin.rex -o lexer.rb
+
+class Gherkin::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/parser/gherkin.y

@@ -0,0 +1,100 @@
+# Compile with: racc gherkin.y -o parser.rb
+
+class Gherkin::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] }
+  ;
+
+  Newline:
+    NEWLINE
+  | Newline NEWLINE
+  ;
+
+  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] }
+  ;
+
+  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
+  | Description TEXT Newline
+  ;
+
+  Background:
+    BackgroundHeader
+      Steps               { result = val[0]; result.steps = val[1] }
+  ;
+
+  BackgroundHeader:
+    BACKGROUND Newline    { result = AST::Background.new; result.pos(filename, lineno) }
+  ;
+
+  Steps:
+    Step Newline          { result = [val[0]] }
+  | Steps Step Newline    { result = val[0] << val[1] }
+  ;
+
+  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] }
+  | Scenarios Newline Scenario { result = val[0] << val[2] }
+  ;
+
+  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)
+    scan_str(input)
+  end

data/lib/gherkin/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/parser/gherkin.rex".
+#++
+
+require 'racc/parser'
+# Compile with: rex gherkin.rex -o lexer.rb
+
+class Gherkin::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