kwalify 0.3.0 → 0.4.0

data/lib/kwalify/rule.rb

@@ -1,6 +1,6 @@
 ###
-### $Rev: 22 $
-### $Release: 0.3.0 $
+### $Rev: 35 $
+### $Release: 0.4.0 $
 ### copyright(c) 2005 kuwata-lab all rights reserved.
 ###
 
@@ -250,23 +250,29 @@ module Kwalify
                if val != nil && !val.is_a?(Hash)
                   #* key=:mapping_notmap  msg="not a mapping."
                   raise schema_error(:mapping_notmap, rule, curr_path, val)
-               elsif val == nil || val.empty?
+               elsif val == nil || (val.empty? && !val.default)
                   #* key=:mapping_noelem  msg="required at least one element."
                   raise schema_error(:mapping_noelem, rule, curr_path, val)
                else
                   @mapping = {}
+                  if val.default
+                     elem = val.default  # hash
+                     rule = rule_table[elem.__id__]
+                     rule ||= Rule.new(nil, self).configure(elem, "#{curr_path}/=", rule_table)
+                     @mapping.default = rule
+                  end
                   val.each do |key, elem|
                      ##* key=:key_duplicate  msg="key duplicated."
                      #raise schema_error(:key_duplicate, rule, curr_path, key) if @mapping.key?(key)
                      elem ||= {}
                      rule = rule_table[elem.__id__]
                      rule ||= Rule.new(nil, self).configure(elem, "#{curr_path}/#{key}", rule_table)
-                     if key == '*'
+                     if key == '='
                         @mapping.default = rule
                      else
                         @mapping[key] = rule
                      end
-                  end
+                  end if val
                end
 
             else
@@ -277,7 +283,7 @@ module Kwalify
 
          if @type == 'seq'
             #* key=:seq_nosequence  msg="type 'seq' requires 'sequence:'."
-            raise Kwalify.validate_error(:seq_nosequence, rule, path, nil) unless hash.key?('sequence')
+            raise schema_error(:seq_nosequence, rule, path, nil) unless hash.key?('sequence')
             #* key=:seq_conflict  msg="not available with sequence."
             raise schema_error(:seq_conflict, rule, path, 'enum:')        if @enum
             raise schema_error(:seq_conflict, rule, path, 'pattern:')     if @pattern
@@ -286,7 +292,7 @@ module Kwalify
             raise schema_error(:seq_conflict, rule, path, 'length:')      if @length
          elsif @type == 'map'
             #* key=:map_nomapping  msg="type 'map' requires 'mapping:'."
-            raise Kwalify.validate_error(:map_nomapping, rule, path, nil)  unless hash.key?('mapping')
+            raise schema_error(:map_nomapping, rule, path, nil)  unless hash.key?('mapping')
             #* key=:map_conflict  msg="not available with mapping."
             raise schema_error(:map_conflict, rule, path, 'enum:')        if @enum
             raise schema_error(:map_conflict, rule, path, 'pattern:')     if @pattern

data/lib/kwalify/types.rb

@@ -1,6 +1,6 @@
 ###
-### $Rev: 18 $
-### $Release: 0.3.0 $
+### $Rev: 25 $
+### $Release: 0.4.0 $
 ### copyright(c) 2005 kuwata-lab all rights reserved.
 ###
 
@@ -114,20 +114,21 @@ module Kwalify
 
 
    module TypeHelper
-      def collection_class?(klass)
-         return klass == Array || klass == Hash
-      end
-
-      def scalar_class?(klass)
-         return klass != Array && klass != Hash && klass != Object
-      end
+      #--
+      #def collection_class?(klass)
+      #   return klass.is_a?(Array) || klass.is_a?(Hash)
+      #end
+      #
+      #def scalar_class?(klass)
+      #   return !klass.is_a?(Array) && !klass.is_a?(Hash) && klass != Object
+      #end
 
       def collection?(val)
-         return collection_class?(val.class)
+         return val.is_a?(Array) || val.is_a?(Hash)
       end
 
       def scalar?(val)
-         return scalar_class?(val.class)
+         return !val.is_a?(Array) && !val.is_a?(Hash) && val.class != Object
       end
    end
 

data/lib/kwalify/util/assert-diff.rb

@@ -1,6 +1,6 @@
 ###
 ### $Rev: 5 $
-### $Release: 0.3.0 $
+### $Release: 0.4.0 $
 ### copyright(c) 2005 kuwata-lab all rights reserved.
 ###
 

data/lib/kwalify/util/option-parser.rb

@@ -1,6 +1,6 @@
 ###
 ### $Rev: 6 $
-### $Release: 0.3.0 $
+### $Release: 0.4.0 $
 ### copyright(c) 2005 kuwata-lab all rights reserved.
 ###
 

data/lib/kwalify/util/yaml-helper.rb

@@ -1,6 +1,6 @@
 ###
 ### $Rev: 10 $
-### $Release: 0.3.0 $
+### $Release: 0.4.0 $
 ### copyright(c) 2005 kuwata-lab all rights reserved.
 ###
 

data/lib/kwalify/validator.rb

@@ -1,6 +1,6 @@
 ###
-### $Rev: 21 $
-### $Release: 0.3.0 $
+### $Rev: 32 $
+### $Release: 0.4.0 $
 ### copyright(c) 2005 kuwata-lab all rights reserved.
 ###
 
@@ -39,9 +39,9 @@ module Kwalify
       end
 
 
-      def validate(val)
+      def validate(value)
          path = "";  errors = [];  done = {}
-         _validate(val, @rule, path, errors, done)
+         _validate(value, @rule, path, errors, done)
          return errors
       end
 
@@ -49,107 +49,107 @@ module Kwalify
       protected
 
 
-      def validate_hook(val, rule, path, errors)
+      def validate_hook(value, rule, path, errors)
       end
 
 
-      def _validate(val, rule, path, errors, done)
-         if Kwalify.collection_class?(val.class)
-            return true if done[val.__id__]     # avoid infinite loop
-            done[val.__id__] = true
+      def _validate(value, rule, path, errors, done)
+         if Kwalify.collection?(value)
+            return true if done[value.__id__]     # avoid infinite loop
+            done[value.__id__] = true
          end
-         if rule.required && val == nil
+         if rule.required && value == nil
             #* key=:required_novalue  msg="value required but none."
-            errors << validate_error(:required_novalue, rule, path, val)
+            errors << validate_error(:required_novalue, rule, path, value)
             return
          end
-         if rule.klass && val != nil && !val.is_a?(rule.klass)
+         if rule.klass && value != nil && !value.is_a?(rule.klass)
             #* key=:type_unmatch  msg="not a %s."
-            errors << validate_error(:type_unmatch, rule, path, val, [Kwalify.word(rule.type)])
+            errors << validate_error(:type_unmatch, rule, path, value, [Kwalify.word(rule.type)])
             return
          end
          #
          n = errors.length
          if rule.sequence
-            _validate_sequence(val, rule, path, errors, done)
+            _validate_sequence(value, rule, path, errors, done)
          elsif rule.mapping
-            _validate_mapping(val, rule, path, errors, done)
+            _validate_mapping(value, rule, path, errors, done)
          else
-            _validate_scalar(val, rule, path, errors, done)
+            _validate_scalar(value, rule, path, errors, done)
          end
          return unless errors.length == n
          #
-         validate_hook(val, rule, path, errors)
-         @block.call(val, rule, path, errors) if @block
+         validate_hook(value, rule, path, errors)
+         @block.call(value, rule, path, errors) if @block
       end
 
 
       private
 
 
-      def _validate_scalar(val, rule, path, errors, done)
+      def _validate_scalar(value, rule, path, errors, done)
          assert_error("rule.sequence.class==#{rule.sequence.class.name} (expected NilClass)") if rule.sequence
          assert_error("rule.mapping.class==#{rule.mapping.class.name} (expected NilClass)") if rule.mapping
          if rule.assert_proc
-            unless rule.assert_proc.call(val)
+            unless rule.assert_proc.call(value)
                #* key=:assert_failed  msg="assertion expression failed (%s)."
-               errors << validate_error(:assert_failed, rule, path, val, [rule.assert])
+               errors << validate_error(:assert_failed, rule, path, value, [rule.assert])
             end
          end
          if rule.enum
-            unless rule.enum.include?(val)
+            unless rule.enum.include?(value)
                keyname = File.basename(path)
                keyname = 'enum' if keyname =~ /\A\d+\z/
                #* key=:enum_notexist  msg="invalid %s value."
-               errors << validate_error(:enum_notexist, rule, path, val, [keyname])
+               errors << validate_error(:enum_notexist, rule, path, value, [keyname])
             end
          end
          #
-         return if val == nil
+         return if value == nil
          #
          if rule.pattern
-            unless val.to_s =~ rule.pattern
+            unless value.to_s =~ rule.pattern
                #* key=:pattern_unmatch  msg="not matched to pattern %s."
-               errors << validate_error(:pattern_unmatch, rule, path, val, [rule.pattern.inspect])
+               errors << validate_error(:pattern_unmatch, rule, path, value, [rule.pattern.inspect])
             end
          end
          if rule.range
-            assert_error("val.class=#{val.class.name}") unless Kwalify.scalar?(val)
-            if rule.range['max'] && rule.range['max'] < val
+            assert_error("value.class=#{value.class.name}") unless Kwalify.scalar?(value)
+            if rule.range['max'] && rule.range['max'] < value
                #* key=:range_toolarge  msg="too large (> max %s)."
-               errors << validate_error(:range_toolarge, rule, path, val, [rule.range['max'].to_s])
+               errors << validate_error(:range_toolarge, rule, path, value, [rule.range['max'].to_s])
             end
-            if rule.range['min'] && rule.range['min'] > val
+            if rule.range['min'] && rule.range['min'] > value
                #* key=:range_toosmall  msg="too small (< min %s)."
-               errors << validate_error(:range_toosmall, rule, path, val, [rule.range['min'].to_s])
+               errors << validate_error(:range_toosmall, rule, path, value, [rule.range['min'].to_s])
             end
-            if rule.range['max-ex'] && rule.range['max-ex'] <= val
+            if rule.range['max-ex'] && rule.range['max-ex'] <= value
                #* key=:range_toolargeex  msg="too large (>= max %s)."
-               errors << validate_error(:range_toolargeex, rule, path, val, [rule.range['max-ex'].to_s])
+               errors << validate_error(:range_toolargeex, rule, path, value, [rule.range['max-ex'].to_s])
             end
-            if rule.range['min-ex'] && rule.range['min-ex'] >= val
+            if rule.range['min-ex'] && rule.range['min-ex'] >= value
                #* key=:range_toosmallex  msg="too small (<= min %s)."
-               errors << validate_error(:range_toosmallex, rule, path, val, [rule.range['min-ex'].to_s])
+               errors << validate_error(:range_toosmallex, rule, path, value, [rule.range['min-ex'].to_s])
             end
          end
          if rule.length
-            assert_error("val.class=#{val.class.name}") unless val.is_a?(String) || val.is_a?(Text)
-            len = val.to_s.length
+            assert_error("value.class=#{value.class.name}") unless value.is_a?(String) || value.is_a?(Text)
+            len = value.to_s.length
             if rule.length['max'] && rule.length['max'] < len
                #* key=:length_toolong  msg="too long (length %d > max %d)."
-               errors << validate_error(:length_toolong, rule, path, val, [len, rule.length['max']])
+               errors << validate_error(:length_toolong, rule, path, value, [len, rule.length['max']])
             end
             if rule.length['min'] && rule.length['min'] > len
                #* key=:length_tooshort  msg="too short (length %d < min %d)."
-               errors << validate_error(:length_tooshort, rule, path, val, [len, rule.length['min']])
+               errors << validate_error(:length_tooshort, rule, path, value, [len, rule.length['min']])
             end
             if rule.length['max-ex'] && rule.length['max-ex'] <= len
                #* key=:length_toolongex  msg="too long (length %d >= max %d)."
-               errors << validate_error(:length_toolongex, rule, path, val, [len, rule.length['max-ex']])
+               errors << validate_error(:length_toolongex, rule, path, value, [len, rule.length['max-ex']])
             end
             if rule.length['min-ex'] && rule.length['min-ex'] >= len
                #* key=:length_tooshortex  msg="too short (length %d <= min %d)."
-               errors << validate_error(:length_tooshortex, rule, path, val, [len, rule.length['min-ex']])
+               errors << validate_error(:length_tooshortex, rule, path, value, [len, rule.length['min-ex']])
             end
          end
       end
@@ -191,7 +191,7 @@ module Kwalify
                   #  #* key=:value_notunique  msg="is already used at '%s'."
                   errors << validate_error(:value_notunique, rule, "#{path}/#{i}", val, "#{path}/#{table[val]}")
                else
-                  table[val] = i 
+                  table[val] = i
                end
             end
          end
@@ -207,15 +207,15 @@ module Kwalify
                errors << validate_error(:required_nokey, rule, path, hash, [key])
             end
          end
-         hash.each do |key, value|
+         hash.each do |key, val|
             rule = map_rule.mapping[key]
-            if rule
-               _validate(value, rule, "#{path}/#{key}", errors, done)   ## validate recursively
-            else
+            unless rule
                #* key=:key_undefined  msg="key '%s' is undefined."
-               errors << validate_error(:key_undefined, rule, path, nil, ["#{key}:"])
+               errors << validate_error(:key_undefined, rule, path, hash, ["#{key}:"])
                ##* key=:key_undefined  msg="undefined key."
                #errors << validate_error(:key_undefined, rule, path, "#{key}:")
+            else
+               _validate(val, rule, "#{path}/#{key}", errors, done)   ## validate recursively
             end
          end
       end
@@ -223,3 +223,11 @@ module Kwalify
    end
 
 end
+
+if __FILE__ == $0
+   require 'kwalify/parser'
+   parser = Kwalify::Parser.new(File.read(ARGV.shift))
+   schema = parser.parse()
+   validator = Kwalify::Validator.new(schema)
+   YARGF.read()
+end

data/test/test-metavalidator.rb

@@ -1,20 +1,21 @@
 ###
-### $Rev: 21 $
-### $Release: 0.3.0 $
+### $Rev: 31 $
+### $Release: 0.4.0 $
 ### copyright(c) 2005 kuwata-lab all rights reserved.
 ###
 
-if $0 == __FILE__
-   testdir = File.dirname(__FILE__)
-   libdir  = File.dirname(testdir) + "/lib"
-   $LOAD_PATH << libdir << testdir
-   require 'test/unit'
-   require 'test/unit/ui/console/testrunner'
-   require 'kwalify'
-   require 'kwalify/util/assert-diff'
-   require 'yaml'
+unless defined?(TESTDIR)
+   TESTDIR = File.dirname(__FILE__)
+   libdir  = File.dirname(TESTDIR) + "/lib"
+   $LOAD_PATH << libdir << TESTDIR
 end
 
+require 'test/unit'
+require 'test/unit/ui/console/testrunner'
+require 'kwalify'
+require 'kwalify/util/assert-diff'
+require 'yaml'
+
 
 class MetaValidatorTest < Test::Unit::TestCase
 
@@ -80,6 +81,10 @@ class MetaValidatorTest < Test::Unit::TestCase
 
 end
 
+#if $0 == __FILE__
+#   Test::Unit::UI::Console::TestRunner.run(MetaValidatorTest)
+#end
+
 __END__
 ---
 name:  schema_notmap

data/test/test-parser.rb

@@ -0,0 +1,1276 @@
+###
+### $Rev: 35 $
+### $Release: 0.4.0 $
+### copyright(c) 2005 kuwata-lab all rights reserved.
+###
+
+unless defined?(TESTDIR)
+   TESTDIR = File.dirname(__FILE__)
+   libdir  = File.dirname(TESTDIR) + "/lib"
+   $LOAD_PATH << libdir << TESTDIR
+end
+
+require 'test/unit'
+require 'test/unit/ui/console/testrunner'
+require 'kwalify'
+require 'kwalify/util/assert-diff'
+require 'yaml'
+require 'pp'
+require 'stringio'
+
+
+class ParserTest < Test::Unit::TestCase
+   def _test()
+      parser = Kwalify::Parser.new(@input)
+      if @error_class
+         assert_raise(@error_class) do
+            doc = parser.parse()
+         end
+      else
+         doc = parser.parse()
+         sio = StringIO.new
+         PP.pp(doc, sio)
+         actual = sio.string
+         if $log
+            File.open("#{@name}.expected", 'w') { |f| f.write(@expected) }
+            File.open("#{@name}.actual", 'w') { |f| f.write(actual) }
+         end
+         if $print
+            print actual
+         else
+            assert_equal_with_diff(@expected, actual)
+         end
+      end
+   end
+
+   #str = DATA.read()        # doesn't work when required by other script
+   str = File.read(__FILE__)
+   str.gsub!(/.*^__END__$/m, '')
+   doc_table = {}
+   YAML.load_documents(str) do |doc|
+      name = doc['name']
+      raise "name '#{name}' is duplicated." if doc_table[name]
+      doc_table[name] = doc
+      next if $target && $target != doc['name']
+      #if $target && $show
+      #   puts doc.to_yaml
+      #   exit
+      #end
+      s = <<-END
+      def test_#{name}
+         @name     = #{doc['name'].dump}
+         @input    = #{doc['input'].dump}
+         @expected = #{doc['expected'].dump}
+         @error_class = #{doc['error'] ? doc['error'] : 'nil'}
+         @option   = #{doc['option'] ? doc['option'].dump : 'nil'}
+         _test()
+      end
+      END
+      if $target && $show
+         puts s
+         exit
+      end
+      eval s
+   end
+end
+
+#if $0 == __FILE__
+#   Test::Unit::UI::Console::TestRunner.run(ParserTest)
+#end
+
+__END__
+---
+name:  parse01
+desc:  basic
+#flag:  print
+#
+input: |
+  - AAA
+  - BBB
+  - CCC
+#
+expected: |
+  ["AAA", "BBB", "CCC"]
+#
+---
+name:  parse02
+desc:  scalar
+#
+input: |
+  - abc
+  - 123
+  - 3.14
+  - true
+  - false
+  - yes
+  - no
+  - ~
+  - null
+  - "123"
+  - '456'
+  - 2005-01-01
+  - :sym
+#
+expected: |
+  ["abc",
+   123,
+   3.14,
+   true,
+   false,
+   true,
+   false,
+   nil,
+   nil,
+   "123",
+   "456",
+   #<Date: 4906743/2,0,2299161>,
+   :sym]
+#  ["abc", 123, true, false, true, false, nil, nil, "123", "456", #<Date: 4906743/2,0,2299161>, :sym]
+#
+---
+name:  parse03
+desc:  nested sequence
+#
+input: |
+  - AAA
+  -
+    - BBB1
+    - BBB2
+  - CCC
+#
+expected: |
+  ["AAA", ["BBB1", "BBB2"], "CCC"]
+#
+---
+name:  parse04
+desc:  nested sequence #2
+#
+input: |
+  - A
+  -
+    - B1
+    -
+      - B1-1
+      - B1-2
+  - C
+#
+expected: |
+  ["A", ["B1", ["B1-1", "B1-2"]], "C"]
+#
+---
+name:  parse05
+desc:  null item of sequence
+#
+input: |
+  - A
+  -
+  - C
+  -
+  -
+  -
+  - G
+#
+expected: |
+  ["A", nil, "C", nil, nil, nil, "G"]
+#
+---
+name:  parse06
+desc:  null item of nested sequence
+#
+input: |
+  -
+    -
+      -
+      -
+      -
+  -
+#
+expected: |
+  [[[nil, nil, nil]], nil]
+#
+---
+name:  parse07
+desc:  sequence with empty lines
+#
+input: |
+
+  - A
+
+  -
+
+
+      - B
+
+
+  -
+#
+expected: |
+  ["A", ["B"], nil]
+#
+---
+name:  parse08
+desc:  syntax error - invalid indent of sequence.
+error: Kwalify::ParseError
+#
+input: |
+  - AAA
+    - BBB1
+    - BBB2
+  - CCC
+#
+expected: |
+#
+---
+name:  parse09
+desc:  syntax error - sequence item is exepcted.
+error: Kwalify::ParseError
+#
+input: |
+  - 
+    - a1
+    - a2
+    a3
+  -
+    - b1
+    - b2
+    b3
+#
+expected: |
+#
+---
+name:  parse11
+desc:  mapping
+#
+input: |
+  A: foo
+  B: bar
+  C  : baz
+#
+expected: |
+  {"A"=>"foo", "B"=>"bar", "C"=>"baz"}
+---
+name:  parse12
+desc:  mapping of scalar
+#
+input: |
+  abc: ABC
+  123: 1.23
+  3.14: 314
+#
+expected: |
+ {"abc"=>"ABC", 3.14=>314, 123=>1.23}
+---
+name:  parse12b
+desc:  mapping of scalar
+#
+input: |
+  true: yes
+  false: no
+#
+expected: |
+ {false=>false, true=>true}
+#
+---
+name:  parse12c
+desc:  mapping of scalar
+#
+input: |
+  :sym: :symbol
+  --: -10
+#
+expected: |
+  {"--"=>-10, :sym=>:symbol}
+#
+---
+name:  parse13
+desc:  nested mapping
+#
+input: |
+  A: 10
+  B:
+    B1: 21
+    B2: 22
+  C: 30
+#
+expected: |
+  {"A"=>10, "B"=>{"B1"=>21, "B2"=>22}, "C"=>30}
+#
+---
+name:  parse14
+desc:  nested mapping #2
+#
+input: |
+  A: 10
+  B:
+    B1:
+      B1-1: 21
+      B1-2: 22
+      B1-3: 23
+  C: 30
+#
+expected: |
+  {"A"=>10, "B"=>{"B1"=>{"B1-1"=>21, "B1-2"=>22, "B1-3"=>23}}, "C"=>30}
+#
+---
+name:  parse15
+desc:  null item in mapping
+#
+input: |
+  A:
+  B:
+  C:
+  D:
+#
+expected: |
+  {"A"=>nil, "B"=>nil, "C"=>nil, "D"=>nil}
+#
+---
+name:  parse16
+desc:  null mapping
+#
+input: |
+  A:
+  B:
+    B1:
+      B1-2:
+  C:
+#
+expected: |
+  {"A"=>nil, "B"=>{"B1"=>{"B1-2"=>nil}}, "C"=>nil}
+#
+---
+name:  parse17
+desc:  mapping with empty lines
+#
+input: |
+
+  A: 1
+
+  B: 
+
+
+    B1:
+
+
+
+      B1a: 2
+  C: 3
+  
+#
+expected: |
+  {"A"=>1, "B"=>{"B1"=>{"B1a"=>2}}, "C"=>3}
+#
+---
+name:  parse18
+desc:  parse error - invalid indent of mapping.
+error:  Kwalify::ParseError
+#
+input: |
+  A: 10
+  B: 20
+    B1: 21
+    B2: 22
+  C: 30
+#
+expected: |
+  
+#
+---
+name:  parse19
+desc:  parse error - mapping item is expected.
+error: Kwalify::ParseError
+#
+input: |
+  A:
+    a1: 1
+    a2: 2
+    a3  3
+  B:
+    b1: 1
+    b2: 2
+    b3  3
+expected: |
+#
+---
+name:  parse21
+desc:  seq of mapping
+#
+input: |
+  -
+    x: 10
+    y: 20
+  -
+    x: 15
+    y: 25
+#
+expected: |
+  [{"x"=>10, "y"=>20}, {"x"=>15, "y"=>25}]
+---
+name:  parse22
+desc:  seq of mapping (inline)
+#
+input: |
+  - x: 10
+    y: 20
+  - x: 15
+    y: 25
+#
+expected: |
+  [{"x"=>10, "y"=>20}, {"x"=>15, "y"=>25}]
+---
+name:  parse23
+desc:  seq of seq of seq (inline)
+#
+input: |
+  - - - a
+      - b
+  - - - c
+      - d
+#
+expected: |
+  [[["a", "b"]], [["c", "d"]]]
+---
+name:  parse24
+desc:  map of sequence
+#
+input: |
+  foo:
+    - 1
+    - 2
+    - 3
+  bar:
+    - 4
+    - 5
+    - 6
+#
+expected: |
+  {"foo"=>[1, 2, 3], "bar"=>[4, 5, 6]}
+---
+name:  parse25
+desc:  map of sequence (inline)
+#
+input: |
+  foo: - 1
+       - 2
+       - 3
+  bar: - 4
+       - 5
+       - 6
+#
+expected: |
+  {"foo"=>[1, 2, 3], "bar"=>[4, 5, 6]}
+---
+name:  parse26
+desc:  map of map of map (inline)
+#
+input: |
+  A: a: 1: 100
+        2: 200
+  B: b: 3: 300
+        4: 400
+#
+expected: |
+  {"A"=>{"a"=>{1=>100, 2=>200}}, "B"=>{"b"=>{3=>300, 4=>400}}}
+---
+name:  comment1
+desc:  line comment
+#
+input: |
+  # comment
+  - A
+  - B
+    # comment
+  -
+      # comment
+    - C
+#
+expected: |
+  ["A", "B", ["C"]]
+---
+name:  comment2
+desc:  escape line comment
+#
+input: |
+  # comment
+  - A
+  - B:
+     "# comment"
+  -
+    '# comment'
+#
+expected: |
+  ["A", {"B"=>"# comment"}, "# comment"]
+---
+name:  comment3
+desc:  line comment with seq and map
+#
+input: |
+  - A             # comment
+  - B:            # comment
+      C: foo      # comment
+      D: "bar#bar"    #comment
+#
+expected: |
+  ["A", {"B"=>{"C"=>"foo", "D"=>"bar#bar"}}]
+---
+name:  comment4
+desc:  line comment with anchor and alias
+#
+input: |
+  - &a1           # comment
+    foo
+  - *a1           # comment
+#
+expected: |
+  ["foo", "foo"]
+---
+name:  flowseq1
+desc:  flow style seq
+#
+input: |
+  - [ 10, 20 ]
+  - [15,25,35]
+#
+expected: |
+  [[10, 20], [15, 25, 35]]
+#
+---
+name:  flowseq2
+desc:  nested flow style seq 
+#
+input: |
+  1: [ A, [B1, B2]]
+  2: [[[X]]]
+  3: [[x1,y1],[x2,"y2"],['x3',y3]]
+#
+expected: |
+  {1=>["A", ["B1", "B2"]],
+   2=>[[["X"]]],
+   3=>[["x1", "y1"], ["x2", "y2"], ["x3", "y3"]]}
+#
+---
+name:  flowseq3
+desc:  flow style seq with some lines
+#
+input: |
+  A: [ [10,20],
+       [11,21],
+       [12,22]]
+  B: [
+    [1.1,
+     1.2,
+     1.3
+    ]
+  ]
+#
+expected: |
+  {"A"=>[[10, 20], [11, 21], [12, 22]], "B"=>[[1.1, 1.2, 1.3]]}
+#
+---
+name:  flowseq4
+desc:  invalid flow style seq (sequence item required (or last comma is extra).)
+mesg:  sequence item required (or last comma is extra).
+error: Kwalify::ParseError
+#
+input: |
+  A: [ [10,20], ]
+#
+expected: |
+#
+---
+name:  flowseq5
+desc:  invalid flow style seq (flow style sequence requires ']').
+mesg:  flow style sequence requires ']'
+error: Kwalify::ParseError
+#
+input: |
+  A: [ [10,20]
+  B: [ [30, 40]]
+#
+expected: |
+#
+---
+name:  flowseq6
+desc:  invalid flow style seq (flow style sequence requires ']').
+mesg:  flow style sequence is closed but got ']'.
+error: Kwalify::ParseError
+#
+input: |
+  [ 10 ]]
+#
+expected: |
+#
+---
+name:  flowmap1
+desc:  flow style map
+#
+input: |
+  - { A1: 10, A2: 20 }
+  - {B1: 15, 'B2': 25, "B3": 35}
+#
+expected: |
+  [{"A1"=>10, "A2"=>20}, {"B1"=>15, "B2"=>25, "B3"=>35}]
+#
+---
+name:  flowmap2
+desc:  flow style map nested
+#
+input: |
+  A: { x: {y: {z: 10}}}
+  B: { a: 1, b:{c: 2, d: 3, e:{f: 4}}, g: 5}
+#
+expected: |
+  {"A"=>{"x"=>{"y"=>{"z"=>10}}},
+   "B"=>{"a"=>1, "b"=>{"c"=>2, "d"=>3, "e"=>{"f"=>4}}, "g"=>5}}
+#
+---
+name:  flowmap3
+desc:  flow style map with some lines
+#
+input: |
+  A: { x:
+       {y:
+         {z: 10}
+       }
+     }
+  B: {
+    a: 1,
+    b: {
+      c: 2,
+      d: 3,
+      e: {
+        f: 4
+      }
+    },
+    g: 5
+  }
+#
+expected: |
+  {"A"=>{"x"=>{"y"=>{"z"=>10}}},
+   "B"=>{"a"=>1, "b"=>{"c"=>2, "d"=>3, "e"=>{"f"=>4}}, "g"=>5}}
+#
+---
+name:  flowmap4
+desc:  invalid flow style map (mapping item required (or last comma is extra).)
+mesg:  mapping item required (or last comma is extra).
+error: Kwalify::ParseError
+#
+input: |
+  - {A: 10, B: 20, }
+#
+expected: |
+#
+---
+name:  flowmap5
+desc:  invalid flow style map (flow style mapping requires '}').
+mesg:  flow style mapping requires '}'
+error: Kwalify::ParseError
+#
+input: |
+  - {A: { x: 10, y: 20 }
+  - {A: { x: 11, y: 21 }}
+#
+expected: |
+#
+---
+name:  flowmap6
+desc:  invalid flow style map (flow style mapping requires ']').
+mesg:  flow style mapping is closed but got '}'.
+error: Kwalify::ParseError
+#
+input: |
+  { x: 10 }}
+#
+expected: |
+#
+---
+name:  parse61
+desc:  combination of flow style seq and map
+#
+input: |
+  [
+    {name: '  foo  ',
+     e-mail: foo@mail.com},
+    {name: ba   z,
+     e-mail: ba__z@mail.com   }
+  ]
+#
+expected: |
+  [{"name"=>"  foo  ", "e-mail"=>"foo@mail.com"},
+   {"name"=>"ba   z", "e-mail"=>"ba__z@mail.com"}]
+#
+---
+name:  block_text1
+desc:  parse_block_text
+#
+input: |
+  - text1: |
+     foo
+     bar
+     baz
+  - text2: |
+         aaa
+        bbb
+          ccc
+  - |
+   foo
+   bar
+   baz
+  - |
+         aaa
+        bbb
+          ccc
+#
+expected: |
+  [{"text1"=>"foo\nbar\nbaz\n"},
+   {"text2"=>" aaa\nbbb\n  ccc\n"},
+   "foo\nbar\nbaz\n",
+   " aaa\nbbb\n  ccc\n"]
+#
+---
+name:  block_text2
+desc:  block text with '|+' or '|-'
+#
+input: |
+  - text1: |
+      A
+  
+      B
+      C
+  
+  
+  - text2: |+
+      A
+  
+      B
+      C
+  
+  
+  - text3: |-
+      A
+  
+      B
+      C
+  
+  
+#
+expected: |
+  [{"text1"=>"A\n\nB\nC\n"},
+   {"text2"=>"A\n\nB\nC\n\n\n"},
+   {"text3"=>"A\n\nB\nC"}]
+#
+---
+name:  block_text3
+desc:  block text with '| foo'
+#
+input: |
+  - text1: | foo  
+     A
+     
+     B
+     C
+     
+  - |  foo
+    A
+     B
+      C
+#
+expected: |
+  [{"text1"=>"foo  A\n\nB\nC\n"}, "fooA\n B\n  C\n"]
+#
+---
+name:  block_text4
+desc:  block text with '#' (comment)
+#
+input: |
+  #
+    - text1: |
+       A
+       #
+       B
+      #
+      text2: |
+       #
+       #
+      #
+    - |
+     A
+     #
+     B
+    #
+    - |
+      #
+      #
+  #
+    - x
+  
+#
+expected: |
+  [{"text1"=>"A\n#\nB\n", "text2"=>"#\n#\n"}, "A\n#\nB\n", "#\n#\n", "x"]
+#
+---
+name:  block_text6
+desc:  parse_block_text (>)
+#
+input: |
+  - text1: >
+     foo
+     bar
+     baz
+  - text2: >
+         aaa
+        bbb
+          ccc
+  - >
+   foo
+   bar
+   baz
+  - >
+         aaa
+        bbb
+          ccc
+#
+expected: |
+  [{"text1"=>"foo bar baz\n"},
+   {"text2"=>" aaa bbb   ccc\n"},
+   "foo bar baz\n",
+   " aaa bbb   ccc\n"]
+#
+---
+name:  block_text7
+desc:  block text with '>+' or '>-'
+#
+input: |
+  - text1: >
+      A
+  
+      B
+      C
+  
+  
+  - text2: >+
+      A
+  
+      B
+      C
+  
+  
+  - text3: >-
+      A
+  
+      B
+      C
+  
+  
+#
+expected: |
+  [{"text1"=>"A\nB C\n"}, {"text2"=>"A\nB C\n\n"}, {"text3"=>"A\nB C"}]
+#
+---
+name:  block_text8
+desc:  block text with '> foo'
+#
+input: |
+  - text1: > foo  
+     A
+     
+     B
+     C
+     
+  - >  foo
+    A
+     B
+      C
+#
+expected: |
+  [{"text1"=>"foo  A\nB C\n"}, "fooA  B   C\n"]
+#
+---
+name:  block_text9
+desc:  block text with '#' (comment)
+#
+input: |
+  #
+    - text1: >
+       AA
+       ##
+       BB
+      #
+      text2: >
+       #
+       #
+      #
+    - >
+     AA
+     ##
+     BB
+    #
+    - >
+      #
+      #
+  #
+    - x
+  
+#
+expected: |
+  [{"text1"=>"AA ## BB\n", "text2"=>"# #\n"}, "AA ## BB\n", "# #\n", "x"]
+#
+---
+name:  anchor1
+desc:  parse_anchor, parse_alias
+#
+input: |
+  - &a1 foo
+  - &a2
+   bar
+  - *a1
+  - *a2
+#
+expected: |
+  ["foo", "bar", "foo", "bar"]
+#
+---
+name:  anchor2
+desc:  parse_anchor, parse_alias
+#
+input: |
+  - A: &a1
+     x: 10
+     y: 20
+  - B: bar
+  - C: *a1
+#
+expected: |
+  [{"A"=>{"x"=>10, "y"=>20}}, {"B"=>"bar"}, {"C"=>{"x"=>10, "y"=>20}}]
+#
+---
+name:  anchor3
+desc:  anchor on child node
+#
+input: |
+  - A: &a1
+     x: 10
+     y: 20
+     z: *a1
+#
+expected: |
+  [{"A"=>{"x"=>10, "y"=>20, "z"=>{...}}}]
+#
+---
+name:  anchor4
+desc:  backward anchor
+#
+input: |
+  - *a1
+  - *a1
+  - foo
+  - &a1 bar
+#
+expected: |
+  ["bar", "bar", "foo", "bar"]
+#
+---
+name:  anchor5
+desc:  anchor not found
+error: Kwalify::ParseError
+mesg:  anchor 'a2' not found (Kwalify::ParseError)
+#
+input: |
+  - &a1 foo
+  - bar
+  - *a2
+#
+expected: |
+#
+---
+name:  anchor6
+desc:  anchor on child node
+#
+input: |
+  type:        seq
+  sequence:
+    - &employee
+      type:    map
+      mapping:
+        name:
+          type:   str
+        post:
+          type:   str
+          enum:
+            - exective
+            - manager
+            - clerk
+        supervisor: *employee
+#
+expected: |
+  {"sequence"=>
+    [{"type"=>"map",
+      "mapping"=>
+       {"name"=>{"type"=>"str"},
+        "post"=>{"type"=>"str", "enum"=>["exective", "manager", "clerk"]},
+        "supervisor"=>{...}}}],
+   "type"=>"seq"}
+#
+---
+name:  tag1
+desc:  tag
+#
+input: |
+  - !str 123
+  - foo: !text 123
+#
+expected: |
+  [123, {"foo"=>123}]
+#
+---
+name:  docend1
+desc:  ... (document end)
+#
+input: |
+  - aaa
+  - bbb
+  ...
+  - ccc
+#
+expected: |
+  ["aaa", "bbb"]
+#
+---
+name:  docend2
+desc:  ... (document end) in block text
+#
+input: |
+  - |
+    foo
+    ...
+    bar
+#
+expected: |
+  ["foo\n...\nbar\n"]
+#
+---
+name:  docstart1
+desc:  --- (document start)
+#
+input: |
+  # comment
+  ---
+  - foo
+  - bar
+#
+expected: |
+  ["foo", "bar"]
+#
+---
+name:  docstart2
+desc:  --- (document start) with tag
+#
+input: |
+  # comment
+  --- %YAML !seq
+  - foo
+  - bar
+#
+expected: |
+  ["foo", "bar"]
+#
+---
+name:  docstart3
+desc:  --- (document start) with tag
+#
+input: |
+  - |
+    foo
+    ---
+    bar
+    ---
+    baz
+#
+expected: |
+  ["foo\n---\nbar\n---\nbaz\n"]
+#
+---
+name:  default1
+desc:  map default value
+#
+input: |
+  A: 10
+  B: 20
+  =: 0
+#
+expected: |
+  {"A"=>10, "B"=>20}
+#
+---
+name:  merge1
+desc:  merge key '<<'
+#
+input: |
+  - &a1
+    A: 10
+    B: 20
+  - C: 30
+    <<: *a1
+    A: ~
+#
+expected: |
+  [{"A"=>10, "B"=>20}, {"A"=>nil, "B"=>20, "C"=>30}]
+---
+name:  example1
+desc:  complex combination of seq and map
+#
+input: |
+  columns:
+    - name:       id
+      type:       integer
+      primary-key: yes
+      sequence:   yes
+
+    - name:       name
+      type:       string
+      not-null:   yes
+      width:      63
+
+    - name:       desc
+      type:       string
+
+    - name:       email
+      type:       string
+      width:      63
+
+    - name:       birth
+      type:       date
+
+    - name:       age
+      type:       integer
+
+    - name:       last_update
+      type:       timestamp
+
+    - name:       gender
+      type:       string
+      values:
+        - M
+        - F
+
+  tables:
+    - name:               groups
+      class:              Group
+      desc:               Group master table
+      columns:
+        - name:           id
+        - name:           name
+        - name:           desc
+
+    - name:               users
+      class:              User
+      desc:               User master table
+      columns:
+        - name:           id
+        - name:           name
+        - name:           desc
+        - name:           email
+        - name:           group_id
+          type:           ref
+          ref:            groups.id
+        - name:           account
+          type:           string
+          maxlength:      31
+          not-null:       yes
+        - name:           password
+          not-null:       yes
+#
+expected: |
+  {"columns"=>
+    [{"name"=>"id", "sequence"=>true, "type"=>"integer", "primary-key"=>true},
+     {"name"=>"name", "not-null"=>true, "type"=>"string", "width"=>63},
+     {"name"=>"desc", "type"=>"string"},
+     {"name"=>"email", "type"=>"string", "width"=>63},
+     {"name"=>"birth", "type"=>"date"},
+     {"name"=>"age", "type"=>"integer"},
+     {"name"=>"last_update", "type"=>"timestamp"},
+     {"name"=>"gender", "type"=>"string", "values"=>["M", "F"]}],
+   "tables"=>
+    [{"columns"=>[{"name"=>"id"}, {"name"=>"name"}, {"name"=>"desc"}],
+      "name"=>"groups",
+      "class"=>"Group",
+      "desc"=>"Group master table"},
+     {"columns"=>
+       [{"name"=>"id"},
+        {"name"=>"name"},
+        {"name"=>"desc"},
+        {"name"=>"email"},
+        {"name"=>"group_id", "type"=>"ref", "ref"=>"groups.id"},
+        {"name"=>"account", "not-null"=>true, "type"=>"string", "maxlength"=>31},
+        {"name"=>"password", "not-null"=>true}],
+      "name"=>"users",
+      "class"=>"User",
+      "desc"=>"User master table"}]}
+#
+---
+name:  example2
+desc:  invoice
+#
+input: |
+  invoice: 34843
+  date   : 2001-01-23
+  bill-to: &id001
+      given  : Chris
+      family : Dumars
+      address:
+          lines: |
+              458 Walkman Dr.
+              Suite #292
+          city    : Royal Oak
+          state   : MI
+          postal  : 48046
+  ship-to: *id001
+  product:
+      - sku         : BL394D
+        quantity    : 4
+        description : Basketball
+        price       : 450.00
+      - sku         : BL4438H
+        quantity    : 1
+        description : Super Hoop
+        price       : 2392.00
+  tax  : 251.42
+  total: 4443.52
+  comments: >
+      Late afternoon is best.
+      Backup contact is Nancy
+      Billsmer @ 338-4338.
+#
+expected: |
+  {"tax"=>251.42,
+   "bill-to"=>
+    {"given"=>"Chris",
+     "family"=>"Dumars",
+     "address"=>
+      {"postal"=>48046,
+       "city"=>"Royal Oak",
+       "lines"=>"458 Walkman Dr.\nSuite #292\n",
+       "state"=>"MI"}},
+   "comments"=>
+    "Late afternoon is best. Backup contact is Nancy Billsmer @ 338-4338.\n",
+   "invoice"=>34843,
+   "date"=>#<Date: 4903865/2,0,2299161>,
+   "total"=>4443.52,
+   "product"=>
+    [{"price"=>450.0,
+      "quantity"=>4,
+      "description"=>"Basketball",
+      "sku"=>"BL394D"},
+     {"price"=>2392.0,
+      "quantity"=>1,
+      "description"=>"Super Hoop",
+      "sku"=>"BL4438H"}],
+   "ship-to"=>
+    {"given"=>"Chris",
+     "family"=>"Dumars",
+     "address"=>
+      {"postal"=>48046,
+       "city"=>"Royal Oak",
+       "lines"=>"458 Walkman Dr.\nSuite #292\n",
+       "state"=>"MI"}}}
+#