testml 0.0.1 → 0.0.2

data/lib/testml/compiler/pegex.rb

@@ -0,0 +1,50 @@
+require 'pegex/parser'
+require 'testml/compiler'
+
+class TestML::Compiler::Pegex < TestML::Compiler
+  attr_accessor :parser
+
+  def compile_code
+    @parser = ::Pegex::Parser.new do |p|
+      p.grammar = TestML::Compiler::Pegex::Grammar.new
+      p.receiver = TestML::Compiler::Pegex::AST.new
+    end
+    fixup_grammar
+    parser.parse(@code, 'code_section') \
+      or fail "Parse TestML code section failed"
+  end
+
+  def compile_data
+    if !@data.empty?
+      parser.parse(@data, 'data_section') \
+        or fail "Parse TestML data section failed"
+    end
+    @function = parser.receiver.function
+  end
+
+  def fixup_grammar
+    tree = @parser.grammar.tree
+    point_lines = tree['point_lines']['.rgx']
+
+    block_marker = @directives['BlockMarker']
+    if block_marker
+      block_marker.gsub! /([\$\%\^\*\+\?\|])/, '\\\\\1'
+      tree['block_marker']['.rgx'] = %r!\A#{block_marker}!
+      tree['point_lines']['.rgx'] = Regexp.new(
+        point_lines.to_s.sub!(/===/, block_marker)
+      )
+    end
+
+    point_marker = @directives['PointMarker']
+    if point_marker
+      point_marker.gsub! /([\$\%\^\*\+\?\|])/, '\\\\\1'
+      tree['point_marker']['.rgx'] = %r!\A#{point_marker}!
+      tree['point_lines']['.rgx'] = Regexp.new(
+        point_lines.to_s.sub!(/\\-\\-\\-/, point_marker)
+      )
+    end
+  end
+end
+
+require 'testml/compiler/pegex/grammar'
+require 'testml/compiler/pegex/ast'

data/lib/testml/compiler/pegex/ast.rb

@@ -0,0 +1,145 @@
+require 'pegex/tree'
+require 'testml/compiler/pegex'
+
+class TestML::Compiler::Pegex::AST < Pegex::Tree
+  require 'testml/runtime'
+
+  attr_accessor :points
+  attr_accessor :function
+
+  def initialize
+    @points = []
+    @function = TestML::Function.new
+  end
+
+  def got_code_section(code)
+    @function.statements = code
+  end
+
+  def got_assignment_statement(match)
+    return TestML::Assignment.new(match[0], match[1])
+  end
+
+  def got_code_statement(list)
+    expression, assertion = nil, nil
+    points = @points
+    @points = []
+    list.each do |e|
+      if e.kind_of? TestML::Assertion
+        assertion = e
+      else
+        expression = e
+      end
+    end
+    return TestML::Statement.new(
+      expression,
+      assertion,
+      !points.empty? ? points : nil,
+    )
+  end
+
+  def got_code_expression(list)
+    calls = []
+    calls.push(list.shift) if !list.empty?
+    list = !list.empty? ? list.shift : []
+    list.each do |e|
+      call = e[1]   # XXX this is e[0] in perl
+      calls.push(call)
+    end
+    return calls[0] if calls.size == 1
+    return TestML::Expression.new(calls)
+  end
+
+  def got_string_object(string)
+    return TestML::Str.new(string)
+  end
+
+  def got_number_object(number)
+    return TestML::Num.new(number.to_i)
+  end
+
+  def got_point_object(point)
+    point.sub!(/^\*/, '') or fail
+    @points.push(point)
+    return TestML::Point.new(point)
+  end
+
+  def got_assertion_call(call)
+    name, expr = nil, nil
+    %w( eq has ok ).each do |a|
+      if expr = call["assertion_#{a}"]
+        name = a.upcase
+        expr =
+          expr.fetch("assertion_operator_#{a}", [])[0] ||
+          expr.fetch("assertion_function_#{a}", [])[0]
+        break
+      end
+    end
+    return TestML::Assertion.new(name, expr)
+  end
+
+  def got_assertion_function_ok(ok)
+    return { 'assertion_function_ok' => [] }
+  end
+
+  def got_function_start(dummy)
+    function = TestML::Function.new
+    function.outer = @function
+    @function = function
+    return true
+  end
+
+  def got_function_object(object)
+    function = @function
+    @function = function.outer
+
+    if object[0].kind_of? Array and object[0][0].kind_of? Array
+      function.signature = object[0][0]
+    end
+    function.statements = object[-1]
+
+    return function
+  end
+
+  def got_call_name(name)
+    return TestML::Call.new(name)
+  end
+
+  def got_call_object(object)
+    call = object[0]
+    args = object[1] && object[1][-1]
+    if args
+      args = args.map do |arg|
+        (arg.kind_of?(TestML::Expression) and arg.calls.size == 1 and
+        (
+           arg.calls[0].kind_of?(TestML::Point) ||
+           arg.calls[0].kind_of?(TestML::Object)
+        )) ? arg.calls[0] : arg
+      end
+      call.args = args
+    end
+    return call
+  end
+
+  def got_call_argument_list(list)
+    return list
+  end
+
+  def got_call_indicator(dummy)
+    return
+  end
+
+  def got_data_section(data)
+    @function.data = data
+  end
+
+  def got_data_block(block)
+    label = block[0][0][0]
+    points = block[1].inject({}){|r, h| r.merge!(h)}
+    return TestML::Block.new(label, points)
+  end
+
+  def got_block_point(point)
+    return { point[0] => point[1] }
+  end
+end

data/lib/testml/compiler/pegex/grammar.rb

@@ -0,0 +1,173 @@
+require 'pegex/grammar'
+require 'testml/compiler/pegex'
+
+class TestML::Compiler::Pegex::Grammar < Pegex::Grammar
+  File = '../testml-pgx/testml.pgx'
+
+  def make_tree
+    {"+toprule"=>"testml_document",
+    "assertion_call"=>
+      {".any"=>
+        [{"-wrap"=>1, ".ref"=>"assertion_eq"},
+        {"-wrap"=>1, ".ref"=>"assertion_ok"},
+        {"-wrap"=>1, ".ref"=>"assertion_has"}]},
+    "assertion_call_test"=>
+      {".rgx"=>
+        /\A(?:\.(?:[\ \t]|\r?\n|\#.*\r?\n)*|(?:[\ \t]|\r?\n|\#.*\r?\n)*\.)(?:EQ|OK|HAS)/},
+    "assertion_eq"=>
+      {".any"=>
+        [{"-wrap"=>1, ".ref"=>"assertion_operator_eq"},
+        {"-wrap"=>1, ".ref"=>"assertion_function_eq"}]},
+    "assertion_function_eq"=>
+      {".all"=>
+        [{".rgx"=>
+          /\A(?:\.(?:[\ \t]|\r?\n|\#.*\r?\n)*|(?:[\ \t]|\r?\n|\#.*\r?\n)*\.)EQ\(/},
+        {".ref"=>"code_expression"},
+        {".rgx"=>/\A\)/}]},
+    "assertion_function_has"=>
+      {".all"=>
+        [{".rgx"=>
+          /\A(?:\.(?:[\ \t]|\r?\n|\#.*\r?\n)*|(?:[\ \t]|\r?\n|\#.*\r?\n)*\.)HAS\(/},
+        {".ref"=>"code_expression"},
+        {".rgx"=>/\A\)/}]},
+    "assertion_function_ok"=>
+      {".rgx"=>
+        /\A(?:\.(?:[\ \t]|\r?\n|\#.*\r?\n)*|(?:[\ \t]|\r?\n|\#.*\r?\n)*\.)(OK)(?:\((?:[\ \t]|\r?\n|\#.*\r?\n)*\))?/},
+    "assertion_has"=>
+      {".any"=>
+        [{"-wrap"=>1, ".ref"=>"assertion_operator_has"},
+        {"-wrap"=>1, ".ref"=>"assertion_function_has"}]},
+    "assertion_ok"=>{".ref"=>"assertion_function_ok"},
+    "assertion_operator_eq"=>
+      {".all"=>
+        [{".rgx"=>/\A(?:[\ \t]|\r?\n|\#.*\r?\n)+==(?:[\ \t]|\r?\n|\#.*\r?\n)+/},
+        {".ref"=>"code_expression"}]},
+    "assertion_operator_has"=>
+      {".all"=>
+        [{".rgx"=>/\A(?:[\ \t]|\r?\n|\#.*\r?\n)+\~\~(?:[\ \t]|\r?\n|\#.*\r?\n)+/},
+        {".ref"=>"code_expression"}]},
+    "assignment_statement"=>
+      {".all"=>
+        [{".ref"=>"variable_name"},
+        {".rgx"=>/\A\s+=\s+/},
+        {".ref"=>"code_expression"},
+        {".ref"=>"ending"}]},
+    "blank_line"=>{".rgx"=>/\A[\ \t]*\r?\n/},
+    "block_header"=>
+      {".all"=>
+        [{".ref"=>"block_marker"},
+        {"+max"=>1, ".all"=>[{".rgx"=>/\A[\ \t]+/}, {".ref"=>"block_label"}]},
+        {".rgx"=>/\A[\ \t]*\r?\n/}]},
+    "block_label"=>{".ref"=>"unquoted_string"},
+    "block_marker"=>{".rgx"=>/\A===/},
+    "block_point"=>{".any"=>[{".ref"=>"lines_point"}, {".ref"=>"phrase_point"}]},
+    "call_argument"=>{".ref"=>"code_expression"},
+    "call_argument_list"=>
+      {".all"=>
+        [{".rgx"=>/\A\((?:[\ \t]|\r?\n|\#.*\r?\n)*/},
+        {"+min"=>0,
+          ".ref"=>"call_argument",
+          ".sep"=>
+          {".rgx"=>/\A(?:[\ \t]|\r?\n|\#.*\r?\n)*,(?:[\ \t]|\r?\n|\#.*\r?\n)*/}},
+        {".rgx"=>/\A(?:[\ \t]|\r?\n|\#.*\r?\n)*\)/}]},
+    "call_call"=>
+      {".all"=>
+        [{"+asr"=>-1, ".ref"=>"assertion_call_test"},
+        {".ref"=>"call_indicator"},
+        {".ref"=>"code_object"}]},
+    "call_indicator"=>
+      {".rgx"=>
+        /\A(?:\.(?:[\ \t]|\r?\n|\#.*\r?\n)*|(?:[\ \t]|\r?\n|\#.*\r?\n)*\.)/},
+    "call_name"=>{".any"=>[{".ref"=>"user_call"}, {".ref"=>"core_call"}]},
+    "call_object"=>
+      {".all"=>[{".ref"=>"call_name"}, {"+max"=>1, ".ref"=>"call_argument_list"}]},
+    "code_expression"=>
+      {".all"=>[{".ref"=>"code_object"}, {"+min"=>0, ".ref"=>"call_call"}]},
+    "code_object"=>
+      {".any"=>
+        [{".ref"=>"function_object"},
+        {".ref"=>"point_object"},
+        {".ref"=>"string_object"},
+        {".ref"=>"number_object"},
+        {".ref"=>"call_object"}]},
+    "code_section"=>
+      {"+min"=>0,
+      ".any"=>
+        [{".rgx"=>/\A(?:[\ \t]|\r?\n|\#.*\r?\n)+/},
+        {".ref"=>"assignment_statement"},
+        {".ref"=>"code_statement"}]},
+    "code_statement"=>
+      {".all"=>
+        [{".ref"=>"code_expression"},
+        {"+max"=>1, ".ref"=>"assertion_call"},
+        {".ref"=>"ending"}]},
+    "comment"=>{".rgx"=>/\A\#.*\r?\n/},
+    "core_call"=>{".rgx"=>/\A([A-Z]\w*)/},
+    "data_block"=>
+      {".all"=>
+        [{".ref"=>"block_header"},
+        {"+min"=>0,
+          "-skip"=>1,
+          ".any"=>[{".ref"=>"blank_line"}, {".ref"=>"comment"}]},
+        {"+min"=>0, ".ref"=>"block_point"}]},
+    "data_section"=>{"+min"=>0, ".ref"=>"data_block"},
+    "double_quoted_string"=>{".rgx"=>/\A(?:"((?:[^\n\\"]|\\"|\\\\|\\[0nt])*?)")/},
+    "ending"=>{".rgx"=>/\A(?:;|\r?\n)/},
+    "function_object"=>
+      {".all"=>
+        [{"+max"=>1, ".ref"=>"function_signature"},
+        {".ref"=>"function_start"},
+        {"+min"=>0,
+          ".any"=>
+          [{".rgx"=>/\A(?:[\ \t]|\r?\n|\#.*\r?\n)+/},
+            {".ref"=>"assignment_statement"},
+            {".ref"=>"code_statement"}]},
+        {".rgx"=>/\A(?:[\ \t]|\r?\n|\#.*\r?\n)*\}/}]},
+    "function_signature"=>
+      {".all"=>
+        [{".rgx"=>/\A\((?:[\ \t]|\r?\n|\#.*\r?\n)*/},
+        {"+max"=>1, ".ref"=>"function_variables"},
+        {".rgx"=>/\A(?:[\ \t]|\r?\n|\#.*\r?\n)*\)/}]},
+    "function_start"=>
+      {".rgx"=>/\A(?:[\ \t]|\r?\n|\#.*\r?\n)*(\{)(?:[\ \t]|\r?\n|\#.*\r?\n)*/},
+    "function_variable"=>{".rgx"=>/\A([a-zA-Z]\w*)/},
+    "function_variables"=>
+      {"+min"=>1,
+      ".ref"=>"function_variable",
+      ".sep"=>
+        {".rgx"=>/\A(?:[\ \t]|\r?\n|\#.*\r?\n)*,(?:[\ \t]|\r?\n|\#.*\r?\n)*/}},
+    "lines_point"=>
+      {".all"=>
+        [{".ref"=>"point_marker"},
+        {".rgx"=>/\A[\ \t]+/},
+        {".ref"=>"point_name"},
+        {".rgx"=>/\A[\ \t]*\r?\n/},
+        {".ref"=>"point_lines"}]},
+    "number"=>{".rgx"=>/\A([0-9]+)/},
+    "number_object"=>{".ref"=>"number"},
+    "phrase_point"=>
+      {".all"=>
+        [{".ref"=>"point_marker"},
+        {".rgx"=>/\A[\ \t]+/},
+        {".ref"=>"point_name"},
+        {".rgx"=>/\A:[\ \t]/},
+        {".ref"=>"point_phrase"},
+        {".rgx"=>/\A\r?\n/},
+        {".rgx"=>/\A(?:\#.*\r?\n|[\ \t]*\r?\n)*/}]},
+    "point_lines"=>{".rgx"=>/\A((?:(?!===|\-\-\-).*\r?\n)*)/},
+    "point_marker"=>{".rgx"=>/\A\-\-\-/},
+    "point_name"=>{".rgx"=>/\A([a-z]\w*|[A-Z]\w*)/},
+    "point_object"=>{".rgx"=>/\A(\*[a-z]\w*)/},
+    "point_phrase"=>{".ref"=>"unquoted_string"},
+    "quoted_string"=>
+      {".any"=>
+        [{".ref"=>"single_quoted_string"}, {".ref"=>"double_quoted_string"}]},
+    "single_quoted_string"=>{".rgx"=>/\A(?:'((?:[^\n\\']|\\'|\\\\)*?)')/},
+    "string_object"=>{".ref"=>"quoted_string"},
+    "testml_document"=>
+      {".all"=>[{".ref"=>"code_section"}, {"+max"=>1, ".ref"=>"data_section"}]},
+    "unquoted_string"=>{".rgx"=>/\A([^\ \t\n\#](?:[^\n\#]*[^\ \t\n\#])?)/},
+    "user_call"=>{".rgx"=>/\A([a-z]\w*)/},
+    "variable_name"=>{".rgx"=>/\A([a-zA-Z]\w*)/}}
+  end
+end

data/lib/testml/library.rb

@@ -0,0 +1,7 @@
+class TestML::Library
+  def runtime
+    $TestMLRuntimeSingleton
+  end
+end
+
+

data/lib/testml/library/debug.rb

@@ -0,0 +1,18 @@
+require 'testml/library'
+
+# TODO Either require or duplicate wxyz.rb here
+class TestML::Library::Debug < TestML::Library
+  def XXX(*args)
+    require 'yaml'
+    args.each {|node| puts YAML.dump(node)}
+    puts 'XXX from: ' + caller.first
+    exit
+  end
+
+  def YYY(*args)
+    require 'yaml'
+    args.each {|node| puts YAML.dump(node)}
+    puts 'YYY from: ' + caller.first
+    return *args
+  end
+end

data/lib/testml/library/standard.rb

@@ -0,0 +1,86 @@
+require 'testml/library'
+require 'testml/util'
+
+class TestML::Library::Standard < TestML::Library
+  include TestML::Util
+
+  def Get(key)
+    key = key.str.value
+    return runtime.function.getvar(key)
+  end
+
+#   def Set(key, value)
+#     return runtime.function.setvar(key, value)
+#   end
+
+  def GetLabel
+    return str(runtime.get_label)
+  end
+
+  def Type(var)
+    return str(var.type)
+  end
+
+  def Catch(*args)
+    error = runtime.error \
+      or fail "Catch called but no TestML error found"
+    runtime.error = nil
+    return str(error)
+  end
+
+  def Throw(msg)
+    fail(msg.value)
+  end
+
+  def Str(object)
+    return str(object.str.value)
+  end
+
+#   def Num(object)
+#     return num(object.num.value)
+#   end
+
+#   def Bool(object)
+#     return bool(object.bool.value)
+#   end
+
+  def List(*args)
+    return list(args)
+  end
+
+  def Join(list, separator=nil)
+    separator = separator ? separator.value : ''
+    return str(list.list.value.map {|e| e.value}.join(separator))
+  end
+
+  def Not(bool_)
+    return bool(bool_.bool.value ? false : true)
+  end
+
+  def Text(lines)
+    value = lines.list.value
+    return str(((value.map {|l| l.value}) + ['']).join($/))
+  end
+
+  def Count(list)
+    return num(list.list.value.size)
+  end
+
+  def Lines(text)
+    return list(text.value.split(/\n/).map {|l| str(l)})
+  end
+
+  def Reverse(list)
+    return list(list.list.value.reverse)
+  end
+
+  def Sort(list)
+    return list(list.list.value.sort {|a, b| a.value <=> b.value})
+  end
+
+  def Strip(string, part)
+    string = string.str.value
+    part = part.str.value
+    return str string.sub(part, '')
+  end
+end