pione 0.1.0

data/test/parser/spec_block-parser.rb

@@ -0,0 +1,5 @@
+require_relative '../test-util'
+
+describe 'Pione::Parser::BlockParser' do
+  TestUtil::Parser.spec(Pione::Parser::BlockParser, __FILE__, self)
+end

data/test/parser/spec_block-parser.yml

@@ -0,0 +1,85 @@
+flow_block_begin_line:
+  valid:
+    - "Flow"
+    - "Flow-"
+    - "Flow--"
+    - "Flow---"
+    - "Flow----"
+    - "Flow-----"
+  invalid:
+    - "-Flow"
+    - "--Flow"
+    - "---Flow"
+action_block_begin_line:
+  valid:
+    - "Action"
+    - "Action-"
+    - "Action--"
+    - "Action---"
+    - "Action----"
+    - "Action-----"
+  invalid:
+    - "-Action"
+    - "--Action"
+    - "---Action"
+block_end_line:
+  valid:
+    - "End"
+    - "-End"
+    - "--End"
+    - "---End"
+    - "----End"
+    - "-----End"
+  invalid:
+    - "End-"
+    - "End--"
+    - "End---"
+flow_block:
+  valid:
+    - |
+      Flow
+        rule Test
+      End
+    - |
+      Flow
+        rule Test1
+        rule Test2
+        rule Test3
+      End
+    - |
+      Flow
+        rule Test1
+        if $Var
+          rule Test2
+        end
+      End
+    - |
+      Flow
+        rule Test1
+        case $Var
+        when 2
+          rule Test2
+        when 3
+          rule Test3
+        end
+      End
+    - |
+      Flow
+        rule Test1
+        if $Var1
+          rule Test2
+        end
+        case $Var2
+        when 3
+          rule Test3
+        when 4
+          rule Test4
+        end
+      End
+  invalid:
+    - |
+      Flow
+      End
+    - |
+      Flow
+        rule Test

data/test/parser/spec_common-parser.rb

@@ -0,0 +1,281 @@
+# -*- coding: utf-8 -*-
+require_relative '../test-util'
+
+class TestParser < Parslet::Parser
+  include Pione::Parser::CommonParser
+
+  rule(:test_line_end) {
+    str('begin') >> line_end >> str('end')
+  }
+
+  rule(:test_empty_lines_1) {
+    str('begin') >> empty_lines >> str('end')
+  }
+
+  rule(:test_empty_lines_2) {
+    str('begin') >> empty_lines? >> str('end')
+  }
+
+  rule(:test_empty_lines_3) {
+    (str('item') >> empty_lines).repeat
+  }
+
+  rule(:test_empty_lines_4) {
+    (str('item') >> empty_lines?).repeat
+  }
+end
+
+describe 'Pione::Parser::CommonParser' do
+  describe 'symbols' do
+    it 'should parse symbols' do
+      Parser::CommonParser::SYMBOLS.values.each do |val|
+        should.not.raise(Parslet::ParseFailed) do
+          TestParser.new.symbols.parse(val)
+        end
+      end
+    end
+
+    it 'should fail with other characters' do
+      ('a'..'z').each do |val|
+        should.raise(Parslet::ParseFailed) do
+          TestParser.new.symbols.parse(val)
+        end
+      end
+    end
+  end
+
+  describe 'keywords' do
+    it 'should parse keywords' do
+      Parser::CommonParser::KEYWORDS.each do |key, val|
+        should.not.raise(Parslet::ParseFailed) do
+          TestParser.new.send(key).parse(val)
+        end
+      end
+    end
+
+    it 'should fail with other words' do
+      words = ['abc', '', 'RULE', 'enD', 'Input']
+      Parser::CommonParser::KEYWORDS.keys.each do |key|
+        words.each do |word|
+          should.raise(Parslet::ParseFailed) do
+            TestParser.new.send(key).parse(word)
+          end
+        end
+      end
+    end
+  end
+
+  describe 'digit' do
+    it 'should parse digit' do
+      (0..9).each do |n|
+        should.not.raise(Parslet::ParseFailed) do
+          TestParser.new.digit.parse(n.to_s)
+        end
+      end
+    end
+
+    it 'should fail with number sequences' do
+      (10..100).each do |n|
+        should.raise(Parslet::ParseFailed) do
+          TestParser.new.digit.parse(n.to_s)
+        end
+      end
+    end
+
+    it 'should fail with other characters' do
+      ('a'..'z').each do |char|
+        should.raise(Parslet::ParseFailed) do
+          TestParser.new.digit.parse(char)
+        end
+      end
+    end
+  end
+
+  describe 'space / space?' do
+    it 'should parse space string' do
+      strings = [' ', '  ', "\t", "\t\t", " \t ", "\t \t"]
+      strings.each do |s|
+        should.not.raise(Parslet::ParseFailed) do
+          TestParser.new.space.parse(s)
+        end
+
+        should.not.raise(Parslet::ParseFailed) do
+          TestParser.new.space?.parse(s)
+        end
+      end
+    end
+
+    it 'should fail with other characters' do
+      strings = [' a ', "\n", "abc", '　']
+      strings.each do |s|
+        should.raise(Parslet::ParseFailed) do
+          TestParser.new.space.parse(s)
+        end
+
+        should.raise(Parslet::ParseFailed) do
+          TestParser.new.space?.parse(s)
+        end
+      end
+    end
+
+    it 'should get different results with empty string' do
+      should.raise(Parslet::ParseFailed) do
+        TestParser.new.space.parse("")
+      end
+
+      should.not.raise(Parslet::ParseFailed) do
+        TestParser.new.space?.parse("")
+      end
+    end
+  end
+
+  describe 'line_end' do
+    it 'should parse line ended string' do
+      strings = ['', ' ', '  ', "  \n"]
+      strings.each do |s|
+        should.not.raise(Parslet::ParseFailed) do
+          TestParser.new.line_end.parse(s)
+        end
+      end
+    end
+
+    it 'should fail with other string' do
+      strings = ['a', ' a', '  _', '   1', "  \n "]
+      strings.each do |s|
+        should.raise(Parslet::ParseFailed) do
+          TestParser.new.line_end.parse(s)
+        end
+      end
+    end
+
+    it 'should succeed in test_line_end' do
+      strings = ["begin\nend", "begin \nend", "begin \t\nend"]
+      strings.each do |s|
+        should.not.raise(Parslet::ParseFailed) do
+          TestParser.new.test_line_end.parse(s)
+        end
+      end
+    end
+
+    it 'should fail in test_line_end' do
+      strings = ["beginend", "begin\n end", "begin\n\nend"]
+      strings.each do |s|
+        should.raise(Parslet::ParseFailed) do
+          TestParser.new.test_line_end.parse(s)
+        end
+      end
+    end
+  end
+
+  describe 'empty_lines / empty_lines?' do
+    it 'should parse empty lines' do
+      strings = ["\n", "\n\n", " \n ", "\n \n", " \n \n "]
+      strings.each do |s|
+        should.not.raise(Parslet::ParseFailed) do
+          TestParser.new.empty_lines.parse(s)
+        end
+
+        should.not.raise(Parslet::ParseFailed) do
+          TestParser.new.empty_lines?.parse(s)
+        end
+      end
+    end
+
+    it 'should fail with other string' do
+      strings = ['a', ' a', '  _', '   1']
+      strings.each do |s|
+        should.raise(Parslet::ParseFailed) do
+          TestParser.new.empty_lines.parse(s)
+        end
+
+        should.raise(Parslet::ParseFailed) do
+          TestParser.new.empty_lines?.parse(s)
+        end
+      end
+    end
+
+    it 'should get different results whether empty_line or empty_line?' do
+      should.raise(Parslet::ParseFailed) do
+        TestParser.new.empty_lines.parse("")
+      end
+
+      should.not.raise(Parslet::ParseFailed) do
+        TestParser.new.empty_lines?.parse("")
+      end
+    end
+
+    it 'should succeed in test_empty_lines_1' do
+      strings = ["begin\n\nend", "begin \nend", "begin\n\nend"]
+      strings.each do |s|
+        should.not.raise(Parslet::ParseFailed) do
+          TestParser.new.test_empty_lines_1.parse(s)
+        end
+      end
+    end
+
+    it 'should fail in test_empty_lines_1' do
+      strings = ["beginend", "begin end", "begin\n end", "begin\na\nend"]
+      strings.each do |s|
+        should.raise(Parslet::ParseFailed) do
+          TestParser.new.test_empty_lines_1.parse(s)
+        end
+      end
+    end
+
+    it 'should suceed in test_empty_lines_2' do
+      strings = ["begin\n\nend", "begin \nend", "begin\n\nend", "beginend"]
+      strings.each do |s|
+        should.not.raise(Parslet::ParseFailed) do
+          TestParser.new.test_empty_lines_2.parse(s)
+        end
+      end
+    end
+
+    it 'should fail in test_empty_lines_2' do
+      strings = ["begin end", "begin\n end", "begin\na\nend"]
+      strings.each do |s|
+        should.raise(Parslet::ParseFailed) do
+          TestParser.new.test_empty_lines_2.parse(s)
+        end
+      end
+    end
+
+    it 'should suceed in test_empty_lines_3' do
+      strings = ["item\n", "item \n", "item\n ",
+                 "item\n\nitem\n", "item \nitem \n "]
+      strings.each do |s|
+        should.not.raise(Parslet::ParseFailed) do
+          TestParser.new.test_empty_lines_3.parse(s)
+        end
+      end
+    end
+
+    it 'should fail in test_empty_lines_3' do
+      strings = ["item", "item\nitem", "itemitem", "item item"]
+      strings.each do |s|
+        should.raise(Parslet::ParseFailed) do
+          TestParser.new.test_empty_lines_3.parse(s)
+        end
+      end
+    end
+
+    it 'should suceed in test_empty_lines_4' do
+      strings = ["item", "item\n", "item \n", "item\n ", "itemitem",
+                 "item\nitem", "item\n\nitem\n", "item \nitem \n "]
+      strings.each do |s|
+        should.not.raise(Parslet::ParseFailed) do
+          TestParser.new.test_empty_lines_4.parse(s)
+        end
+      end
+    end
+
+    it 'should fail in test_empty_lines_4' do
+      strings = [ "item item", "item "]
+      strings.each do |s|
+        should.raise(Parslet::ParseFailed) do
+          TestParser.new.test_empty_lines_4.parse(s)
+        end
+      end
+    end
+  end
+end

data/test/parser/spec_expr-parser.rb

@@ -0,0 +1,6 @@
+require_relative '../test-util'
+
+describe 'Pione::Parser::ExprParser' do
+  TestUtil::Parser.spec(Pione::Parser::ExprParser, __FILE__, self)
+end
+

data/test/parser/spec_expr-parser.yml

@@ -0,0 +1,82 @@
+expr_operator:
+  valid:
+    - "=="
+    - "!="
+    - ">="
+    - "<="
+    - ">"
+    - "<"
+    - "&&"
+    - "||"
+    - "+"
+    - "-"
+    - "*"
+    - "%"
+    - "/"
+expr_operator_application:
+  valid:
+    - true == true
+    - true != false
+    - 10 >= 1
+    - 1 <= 10
+    - 10 > 1
+    - 1 < 10
+    - true && true
+    - true || false
+    - 1 + 1
+    - 1 - 1
+    - 1 * 1
+    - 1 % 1
+    - 1 / 1
+message:
+  valid:
+    - .abc(1)
+    - .sync
+    - .abc(1, "s", '*.txt')
+    - .abc(1.0.abc(3.def))
+rule_expr:
+  valid:
+    - "&package:rule_name"
+    - ":rule_name"
+    - "rule_name"
+  invalid:
+    - "$var:rule_name"
+    - "&package:$var"
+    - "$var:$var"
+parameters:
+  valid:
+    - "{}"
+    - "{var: 1}"
+    - "{var: true}"
+    - "{var: false}"
+    - "{var: 1.0}"
+    - "{var: \"abc\"}"
+    - "{var1: 1, var2: 2}"
+    - "{var1: 1, var2: 2, var3: 3}"
+    - "{\n}"
+    - "{var:\n 1}"
+    - "{var: \n1}"
+    - "{\n var1: \n 1, \nvar2: \n 2\n }"
+index:
+  valid:
+    - "[1]"
+    - "[1,1]"
+    - "[1,2,3]"
+    - "[1, 2, 3]"
+  invalid:
+    - "[]"
+    - "[1,\n2]"
+expr:
+  valid:
+    - "1"
+    - (1)
+    - '"a" == "a"'
+    - '"a" != "b"'
+    - true && true
+    - true || false
+    - ($Var1 == "a") && ($Var2 == "b")
+    - ($Var1 == "a") || $Var2
+    - ($Var1 == ($Var2 == "a"))
+    - true == true == true
+    - "abc[1]"
+    - "1[1]"