gherkin-ruby 0.0.1

data/.gitignore

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

data/Gemfile

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

data/Rakefile

@@ -0,0 +1,11 @@
+# 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
+
+task :default => [:test]

data/Readme.md

@@ -0,0 +1,57 @@
+# 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).
+
+## 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

data/gherkin-ruby.gemspec

@@ -0,0 +1,23 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "gherkin/version"
+
+Gem::Specification.new do |s|
+  s.name        = "gherkin-ruby"
+  s.version     = Gherkin::VERSION
+  s.authors     = ["Marc Divins", "Josep M. Bach"]
+  s.email       = ["marcdivc@gmail.com", "josep.m.bach@gmail.com"]
+  s.homepage    = "http://github.com/codegram/gherkin"
+  s.summary     = %q{Gherkin-ruby is a Gherkin parser in pure Ruby using Parslet}
+  s.description = %q{Gherkin-ruby is a Gherkin parser in pure Ruby using Parslet}
+
+  s.rubyforge_project = "gherkin-ruby"
+
+  s.add_runtime_dependency 'parslet'
+  s.add_development_dependency 'minitest'
+
+  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/ast.rb

@@ -0,0 +1,83 @@
+module Gherkin
+  module AST
+    class Node
+      attr_reader :line, :column
+
+      def accept(visitor)
+        name = self.class.name.split('::').last
+        visitor.send("visit_#{name}".to_sym, self)
+      end
+    end
+
+    class Feature < Node
+      attr_reader :name, :background, :scenarios
+
+      include Enumerable
+
+      def initialize(name, scenarios=[], background=nil)
+        @line, @column = name.line_and_column
+
+        @name      = name.to_s
+        @background = background
+        @scenarios = scenarios
+      end
+
+      def each
+        @scenarios.each
+      end
+    end
+
+    class Background < Node
+      attr_reader :steps
+
+      include Enumerable
+
+      def initialize(steps=[])
+        @line   = steps.first.line - 1
+        @column = 3
+
+        @steps = steps
+      end
+
+      def each
+        @steps.each
+      end
+    end
+
+    class Scenario < Node
+      attr_reader :name, :steps, :tags
+
+      include Enumerable
+
+      def initialize(name, steps=[], tags=[])
+        @line, @column = name.line_and_column
+
+        @name  = name.to_s
+        @steps = steps
+        @tags  = tags
+      end
+
+      def each
+        @steps.each
+      end
+    end
+
+    class Step < Node
+      attr_reader :name
+      def initialize(name)
+        @line, @column = name.line_and_column
+
+        @name = name.to_s
+      end
+    end
+
+    class Tag < Node
+      attr_reader :name
+      def initialize(name)
+        @line, @column = name.line_and_column
+
+        @name = name.to_s
+      end
+    end
+  end
+end

data/lib/gherkin/parser.rb

@@ -0,0 +1,40 @@
+require 'parslet'
+
+module Gherkin
+  class Parser < Parslet::Parser
+    def indent(num=2)
+      str(' ' * num)
+    end
+
+    rule(:space)    { match('\s').repeat }
+    rule(:space?)   { space.maybe }
+    rule(:newline)  { match('\n').repeat }
+    rule(:text)     { match('[^\n]').repeat }
+    rule(:identifier) { match('\w').repeat }
+
+    rule(:feature_line)  { str('Feature:') >> space? >> text.as(:name) }
+    rule(:scenario_line) { indent(2) >> str('Scenario:') >> space? >> text.as(:name) }
+    rule(:background_line) { indent(2) >> str('Background:') }
+
+    rule(:step_keyword) { str('Given') | str('When') | str('Then') | str('And') | str('But') }
+
+    rule(:comment) { str('#') >> text.as(:comment) }
+    rule(:description) { indent(2) >> text.as(:description) }
+
+    rule(:step) { indent(4) >> step_keyword >> space? >> text.as(:name) }
+    rule(:steps) { (step.as(:step) >> newline.maybe).repeat }
+
+    rule(:tags) { indent(2) >> (str('@') >> identifier.as(:tag) >> str(' ').maybe).repeat(1) }
+
+    rule(:scenario) { (tags.as(:tags) >> newline).maybe >> scenario_line >> newline >> steps.as(:steps) }
+    rule(:scenarios) { (scenario.as(:scenario) >> newline.maybe).repeat }
+
+    rule(:background) { background_line >> newline >> steps.as(:steps) }
+
+    rule(:feature) { feature_line >> newline >> background.as(:background).maybe >> scenarios.as(:scenarios) }
+
+    rule(:main) { feature.as(:feature) }
+
+    root :main
+  end
+end

data/lib/gherkin/transform.rb

@@ -0,0 +1,49 @@
+module Gherkin
+  class Transform < Parslet::Transform
+    # Match feature with background
+    rule(
+      feature: {
+        name: simple(:name),
+        background: {
+          steps: subtree(:background_steps)
+        },
+        scenarios: subtree(:scenarios)
+      }
+    ) { AST::Feature.new(name, scenarios, AST::Background.new(background_steps)) }
+
+    # Match feature without background
+    rule(
+      feature: {
+        name: simple(:name),
+        scenarios: subtree(:scenarios)
+      }
+    ) { AST::Feature.new(name, scenarios, AST::Background.new([])) }
+
+    # Match scenarios without tags
+    rule(
+      scenario: {
+        name: simple(:name),
+        steps: subtree(:steps)
+      }
+    ) { AST::Scenario.new(name, steps, []) }
+
+    # Match scenarios with tags
+    rule(
+      scenario: {
+        name: simple(:name),
+        steps: subtree(:steps),
+        tags: subtree(:tags)
+      }
+    ) { AST::Scenario.new(name, steps, tags) }
+
+    rule(
+      step: {
+        name: simple(:name),
+      }
+    ) { AST::Step.new(name) }
+
+    rule(
+      tag: simple(:name)
+    ) { AST::Tag.new(name) }
+  end
+end

data/lib/gherkin/version.rb

@@ -0,0 +1,3 @@
+module Gherkin
+  VERSION = "0.0.1"
+end

data/lib/gherkin.rb

@@ -0,0 +1,15 @@
+require 'parslet'
+require_relative "gherkin/version"
+require_relative 'gherkin/ast'
+require_relative 'gherkin/parser'
+require_relative 'gherkin/transform'
+
+module Gherkin
+  def self.parse(input)
+    parser    = Parser.new
+    transform = Transform.new
+
+    parsed = parser.parse input
+    transform.apply(parsed)
+  end
+end

data/test/gherkin/ast_test.rb

@@ -0,0 +1,102 @@
+require_relative '../test_helper'
+require 'ostruct'
+
+class MyVisitor
+  def visit_MyNode(my_node)
+    my_node.elements
+  end
+end
+
+class MyNode < Gherkin::AST::Node
+  attr_reader :elements
+  def initialize(name, elements)
+    @name     = name
+    @elements = elements
+  end
+end
+
+module Gherkin
+  module AST
+    describe Node do
+      it 'is visitable' do
+        my_node = MyNode.new('My Node', ['foo', 'bar', 'baz'])
+        visitor = MyVisitor.new
+
+        my_node.accept(visitor).must_equal ['foo', 'bar', 'baz']
+      end
+    end
+
+    [Feature, Scenario, Step, Tag].each do |node|
+      describe node do
+        it 'is a Node' do
+          node.ancestors.must_include Node
+        end
+
+        it 'has a line and column' do
+          name = OpenStruct.new(line_and_column: [2, 13])
+          def name.to_s; 'Name'; end
+
+          instance = node.new(name)
+          instance.name.must_equal 'Name'
+          instance.line.must_equal 2
+          instance.column.must_equal 13
+        end
+      end
+    end
+
+    describe Feature do
+      it 'is Enumerable' do
+        name = OpenStruct.new(line_and_column: [2, 13])
+        def name.to_s; 'Name'; end
+
+        background = ['foo', 'bar']
+        elements = ['+foo', '+bar']
+
+        instance = Feature.new(name, elements, background )
+        instance.background.each.to_a.must_equal ['foo', 'bar']
+        instance.each.to_a.must_equal ['+foo', '+bar']
+      end
+    end
+
+    describe Scenario do
+      it 'is Enumerable' do
+        name = OpenStruct.new(line_and_column: [2, 13])
+        def name.to_s; 'Name'; end
+
+        elements = ['foo', 'bar']
+
+        instance = Scenario.new(name, elements)
+        instance.each.to_a.must_equal ['foo', 'bar']
+      end
+
+      it 'has tags' do
+        name = OpenStruct.new(line_and_column: [2, 13])
+        def name.to_s; 'Name'; end
+
+        steps = ['foo', 'bar']
+        tags  = ['javascript', 'wip']
+
+        instance = Scenario.new(name, steps, tags)
+        instance.tags.must_equal tags
+      end
+    end
+
+    describe Background do
+      it 'is a Node' do
+        Background.ancestors.must_include Node
+      end
+
+      it 'is Enumerable' do
+        steps = [
+          OpenStruct.new(line: 4),
+          OpenStruct.new(line: 5),
+        ]
+
+        instance = Background.new(steps)
+        instance.line.must_equal 3
+        instance.column.must_equal 3
+        instance.each.to_a.must_equal steps
+      end
+    end
+  end
+end

data/test/gherkin/parser_test.rb

@@ -0,0 +1,156 @@
+require_relative '../test_helper'
+require 'parslet'
+
+def p(rule, input, tag=nil)
+  tag ||= rule
+  parser = Gherkin::Parser.new
+  parser.send(rule).parse(input)[tag]
+end
+
+module Gherkin
+  describe 'Feature parsing' do
+    it 'parses the Feature name' do
+      p(:feature_line, "Feature: Test how Gherkin works", :name).must_equal "Test how Gherkin works"
+    end
+
+    it 'parses the Scenario name' do
+      p(:scenario_line, "  Scenario: Formal greeting", :name).must_equal "Formal greeting"
+    end
+
+    describe 'Steps' do
+      it 'parses a Given step' do
+        p(:step, "    Given I have an empty array", :name).must_equal "I have an empty array"
+      end
+
+      it 'parses a When step' do
+        p(:step, "    When I have an empty array", :name).must_equal "I have an empty array"
+      end
+
+      it 'parses a Then step' do
+        p(:step, "    Then I have an empty array", :name).must_equal "I have an empty array"
+      end
+
+      it 'parses an And step' do
+        p(:step, "    And I have an empty array", :name).must_equal "I have an empty array"
+      end
+
+      it 'parses a But step' do
+        p(:step, "    But I have an empty array", :name).must_equal "I have an empty array"
+      end
+    end
+  end
+
+  describe 'Comment parsing' do
+    it 'parses a comment ignoring its content' do
+      p(:comment, "# My comment").size.must_be :>, 0
+    end
+  end
+
+  describe 'Description parsing' do
+    it 'parses descriptions ignoring their content' do
+      p(:description, "  In order to know what the heck is Gherkin").size.must_be :>, 0
+      p(:description, "  As a developer").size.must_be :>, 0
+      p(:description, "  I want it to behave in an expected way").size.must_be :>, 0
+    end
+  end
+
+  describe 'Tags parsing' do
+    it 'parses many tags' do
+      javascript = p(:tags, "  @javascript @wip", 0)
+      wip        = p(:tags, "  @javascript @wip", 1)
+      javascript[:tag].must_equal 'javascript'
+      wip[:tag].must_equal 'wip'
+    end
+
+    it 'parses one tag' do
+      p(:tags, "  @javascript", 0)[:tag].must_equal 'javascript'
+    end
+  end
+
+  describe 'Background parsing' do
+    it 'parses a background' do
+      background = "  Background:\n    When I do something\n    Then blah"
+      steps = p(:background, background, :steps)
+      steps.first[:step][:name].must_equal 'I do something'
+      steps.last[:step][:name].must_equal 'blah'
+    end
+  end
+
+  describe 'Parses scenario objects' do
+    it 'parses a Scenario' do
+      parser = Gherkin::Parser.new
+      scenario = "  Scenario: Parse a scenario\n    Given something happens\n    Then something cooler happens"
+      result = parser.scenario.parse(scenario)
+
+      result[:name].must_equal 'Parse a scenario'
+      result[:steps][0][:step][:name].must_equal 'something happens'
+      result[:steps][1][:step][:name].must_equal 'something cooler happens'
+    end
+
+    it 'parses a Scenario with a tag' do
+      parser = Gherkin::Parser.new
+      scenario = "  @javascript\n  Scenario: Parse a scenario\n    Given something happens\n    Then something cooler happens"
+      result = parser.scenario.parse(scenario)
+
+      result[:tags].first[:tag].must_equal 'javascript'
+      result[:name].must_equal 'Parse a scenario'
+      result[:steps][0][:step][:name].must_equal 'something happens'
+      result[:steps][1][:step][:name].must_equal 'something cooler happens'
+    end
+  end
+
+  describe 'Parses feature objects without background' do
+    it 'parses a Feature' do
+      parser = Gherkin::Parser.new
+      scenario = """Feature: My Feature
+  @javascript @wip
+  Scenario: something happens
+    Given something happens
+    Then something cooler happens
+
+  Scenario: something else happens
+    Given foo
+    Then bar
+"""
+      result = parser.parse(scenario)
+
+      result[:feature][:name].must_equal 'My Feature'
+
+      result[:feature][:scenarios][0][:scenario][:tags].first[:tag].must_equal 'javascript'
+      result[:feature][:scenarios][0][:scenario][:tags].last[:tag].must_equal 'wip'
+      result[:feature][:scenarios][0][:scenario][:name].must_equal 'something happens'
+      result[:feature][:scenarios][0][:scenario][:steps][0][:step][:name].must_equal 'something happens'
+      result[:feature][:scenarios][0][:scenario][:steps][1][:step][:name].must_equal 'something cooler happens'
+
+      result[:feature][:scenarios][1][:scenario][:name].must_equal 'something else happens'
+      result[:feature][:scenarios][1][:scenario][:steps][0][:step][:name].must_equal 'foo'
+      result[:feature][:scenarios][1][:scenario][:steps][1][:step][:name].must_equal 'bar'
+    end
+  end
+
+  describe 'Parses feature objects with background' do
+    it 'parses a Feature' do
+      parser = Gherkin::Parser.new
+      scenario = """Feature: My Feature
+
+  Background:
+    Given something happens
+    And something cooler happens
+
+  Scenario: something else happens
+    Given foo
+    Then bar
+"""
+      result = parser.parse(scenario)
+
+      result[:feature][:name].must_equal 'My Feature'
+
+      result[:feature][:background][:steps][0][:step][:name].must_equal 'something happens'
+      result[:feature][:background][:steps][1][:step][:name].must_equal 'something cooler happens'
+
+      result[:feature][:scenarios][0][:scenario][:name].must_equal 'something else happens'
+      result[:feature][:scenarios][0][:scenario][:steps][0][:step][:name].must_equal 'foo'
+      result[:feature][:scenarios][0][:scenario][:steps][1][:step][:name].must_equal 'bar'
+    end
+  end
+end

data/test/gherkin/transform_test.rb

@@ -0,0 +1,65 @@
+require_relative '../test_helper'
+require 'parslet'
+
+module Gherkin
+  describe 'Feature parsing' do
+    before do
+      @scenario = """Feature: My Feature
+
+  Background:
+    Given something happens before anything else happens
+    And more things happens before anything else happens
+
+  Scenario: something happens
+    Given something happens
+    Then something cooler happens
+
+  @javascript @wip
+  Scenario: something else happens
+    Given foo
+    Then bar
+"""
+
+      parser    = Gherkin::Parser.new
+      result    = parser.parse(@scenario)
+      transform = Gherkin::Transform.new
+      @result   = transform.apply(result)
+    end
+
+    it 'generates a nice tree' do
+      @result.must_be_kind_of AST::Feature
+      @result.line.must_equal 1
+
+      background = @result.background
+      background.must_be_kind_of AST::Background
+      background.line.must_equal 3
+      background.column.must_equal 3
+      background.steps.first.name.must_equal 'something happens before anything else happens'
+      background.steps.first.line.must_equal 4
+      background.steps.last.name.must_equal 'more things happens before anything else happens'
+      background.steps.last.line.must_equal 5
+
+      first_scenario = @result.scenarios.first
+      first_scenario.must_be_kind_of AST::Scenario
+      first_scenario.line.must_equal 7
+      first_scenario.name.must_equal 'something happens'
+      first_scenario.steps.first.name.must_equal 'something happens'
+      first_scenario.steps.first.line.must_equal 8
+      first_scenario.steps.last.name.must_equal 'something cooler happens'
+      first_scenario.steps.last.line.must_equal 9
+
+      last_scenario = @result.scenarios.last
+      last_scenario.must_be_kind_of AST::Scenario
+      last_scenario.line.must_equal 12
+      last_scenario.name.must_equal 'something else happens'
+
+      last_scenario.tags.first.name.must_equal 'javascript'
+      last_scenario.tags.last.name.must_equal 'wip'
+
+      last_scenario.steps.first.name.must_equal 'foo'
+      last_scenario.steps.first.line.must_equal 13
+      last_scenario.steps.last.name.must_equal 'bar'
+      last_scenario.steps.last.line.must_equal 14
+    end
+  end
+end

data/test/test_helper.rb

@@ -0,0 +1,4 @@
+gem 'minitest'
+require 'minitest/spec'
+require 'minitest/autorun'
+require_relative '../lib/gherkin'

metadata

@@ -0,0 +1,87 @@
+--- !ruby/object:Gem::Specification
+name: gherkin-ruby
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- Marc Divins
+- Josep M. Bach
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2011-11-09 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: parslet
+  requirement: &2160498080 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: *2160498080
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: &2160497620 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *2160497620
+description: Gherkin-ruby is a Gherkin parser in pure Ruby using Parslet
+email:
+- marcdivc@gmail.com
+- josep.m.bach@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- Rakefile
+- Readme.md
+- gherkin-ruby.gemspec
+- lib/gherkin.rb
+- lib/gherkin/ast.rb
+- lib/gherkin/parser.rb
+- lib/gherkin/transform.rb
+- lib/gherkin/version.rb
+- test/gherkin/ast_test.rb
+- test/gherkin/parser_test.rb
+- test/gherkin/transform_test.rb
+- test/test_helper.rb
+homepage: http://github.com/codegram/gherkin
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: gherkin-ruby
+rubygems_version: 1.8.10
+signing_key: 
+specification_version: 3
+summary: Gherkin-ruby is a Gherkin parser in pure Ruby using Parslet
+test_files:
+- test/gherkin/ast_test.rb
+- test/gherkin/parser_test.rb
+- test/gherkin/transform_test.rb
+- test/test_helper.rb