lucid-tdl 1.0.0

data/.gitignore

@@ -0,0 +1,17 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in lucid-tdl.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2012 Jeff Nyman
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,29 @@
+# Lucid TDL
+
+This is a test description language for the Lucid tool, modeled on Gherkin.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'lucid-tdl'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install lucid-tdl
+
+## Usage
+
+Instructions will follow once I have an implementation.
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1,21 @@
+require "bundler/gem_tasks"
+
+require 'rake/testtask'
+
+Rake::TestTask.new do |t|
+  t.libs << "test"
+  t.test_files = FileList['./test/**/*_test.rb']
+end
+
+desc "Generate Lexer"
+task :lexer do
+  `rex lib/lucid-tdl/parser/lucid-tdl.rex -o lib/lucid-tdl/parser/lexer.rb`
+end
+
+desc "Generate Parser"
+task :parser do
+  `racc lib/lucid-tdl/parser/lucid-tdl.y -o lib/lucid-tdl/parser/parser.rb`
+end
+
+desc "Generate Lexer and Parser"
+task :generate => [:lexer, :parser]

data/lib/lucid-tdl/ast.rb

@@ -0,0 +1,102 @@
+module LucidTDL
+  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 = filename
+        @line = line
+      end
+      
+    end # class Node
+    
+    class Feature < Node
+      include Enumerable
+      
+      attr_reader :name
+      attr_accessor :description, :background, :scenarios, :tags
+      
+      def initialize(name, scenarios=[], tags=[], background=nil)
+        @name = name
+        @background = background
+        @scenarios = scenarios
+        @tags = tags
+      end
+      
+      def each
+        @scenarios.each
+      end
+    end # class Feature
+    
+    class Ability < Feature
+    end
+    
+    class Responsibility < Feature
+    end
+    
+    class Background < Node
+      include Enumerable
+      
+      attr_accessor :steps
+      
+      def initialize(steps=[])
+        @steps = steps
+      end
+      
+      def line
+        @steps.first.line - 1 if @steps.any?
+      end
+      
+      def each
+        @steps.each
+      end
+    end # class Background
+    
+    class Scenario < Node
+      include Enumerable
+      
+      attr_reader :name, :steps, :tags
+      
+      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 Scenario
+    
+    class Test < Scenario
+    end
+    
+    class Step < Node
+      attr_reader :name
+      attr_reader :keyword
+      
+      def initialize(name, keyword)
+        @name = name.to_s
+        @keyword = keyword.to_s
+      end
+    end # class Step
+    
+    class Tag < Node
+      attr_reader :name
+      
+      def initialize(name)
+        @name = name
+      end
+    end # class Tag
+    
+  end # module AST
+end # module LucidTDL

data/lib/lucid-tdl/parser/lexer.rb

@@ -0,0 +1,130 @@
+#--
+# DO NOT MODIFY!!!!
+# This file is automatically generated by rex 1.0.5
+# from lexical definition file "lib/lucid-tdl/parser/lucid-tdl.rex".
+#++
+
+require 'racc/parser'
+class LucidTDL::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(/\n/))
+         action { [:NEWLINE, text] }
+
+      when (text = @ss.scan(/Feature:/))
+         action { [:FEATURE,        text[0..-2]] }
+
+      when (text = @ss.scan(/Ability:/))
+         action { [:ABILITY,        text[0..-2]] }
+
+      when (text = @ss.scan(/Responsibility:/))
+         action { [:RESPONSIBILITY, text[0..-2]] }
+
+      when (text = @ss.scan(/Background:/))
+         action { [:BACKGROUND,     text[0..-2]] }
+
+      when (text = @ss.scan(/Context:/))
+         action { [:CONTEXT,        text[0..-2]] }
+
+      when (text = @ss.scan(/Scenario:/))
+         action { [:SCENARIO,       text[0..-2]] }
+
+      when (text = @ss.scan(/Test:/))
+         action { [:TEST,           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(/\*/))
+         action { [:GENERIC, 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

data/lib/lucid-tdl/parser/lucid-tdl.rex

@@ -0,0 +1,40 @@
+class LucidTDL::Parser
+
+macro
+  BLANK           [\ \t]+
+  
+rule
+  {BLANK}         # no action
+  
+  \n              { [:NEWLINE, text] }
+  
+  Feature:        { [:FEATURE,        text[0..-2]] }
+  Ability:        { [:ABILITY,        text[0..-2]] }
+  Responsibility: { [:RESPONSIBILITY, text[0..-2]] }
+  
+  Background:     { [:BACKGROUND,     text[0..-2]] }
+  Context:        { [:CONTEXT,        text[0..-2]] }
+  Scenario:       { [:SCENARIO,       text[0..-2]] }
+  Test:           { [:TEST,           text[0..-2]] }
+  
+  @(\w|-)+        { [:TAG, text[1..-1]] }
+  
+  Given           { [:GIVEN, text]   }
+  When            { [:WHEN, text]    }
+  Then            { [:THEN, text]    }
+  And             { [:AND, text]     }
+  But             { [:BUT, text]     }
+  \*              { [:GENERIC, 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/lucid-tdl/parser/lucid-tdl.y

@@ -0,0 +1,107 @@
+class LucidTDL::Parser
+
+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
+  ;
+  
+  Description:
+    TEXT Newline                { result = val[0] }
+  | Description TEXT Newline    { result = val[0...-1].flatten }
+  ;
+  
+  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) }
+  | ABILITY TEXT                { result = AST::Feature.new(val[1]); result.pos(filename, lineno) }
+  | RESPONSIBILITY TEXT         { result = AST::Feature.new(val[1]); result.pos(filename, lineno) }
+  | Newline FEATURE TEXT        { result = AST::Feature.new(val[2]); result.pos(filename, lineno) }
+  | Newline ABILITY TEXT        { result = AST::Feature.new(val[2]); result.pos(filename, lineno) }
+  | Newline RESPONSIBILITY TEXT { result = AST::Feature.new(val[2]); result.pos(filename, lineno) }
+  ;
+  
+  Background:
+    BackgroundHeader
+      Steps                     { result = val[0]; result.steps = val[1] }
+  ;
+  
+  BackgroundHeader:
+    BACKGROUND Newline          { result = AST::Background.new; result.pos(filename, lineno) }
+  | CONTEXT 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 | GENERIC
+  ;
+  
+  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) }
+  | TEST 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 Newline
+      TEST 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