kwalify 0.3.0 → 0.4.0

data/examples/address-book/Makefile

@@ -1,5 +1,5 @@
 
 all:
-	kwalify -m address-book.schema.yaml
-	kwalify -f address-book.schema.yaml address-book.yaml
+	kwalify -lm address-book.schema.yaml
+	kwalify -lf address-book.schema.yaml address-book.yaml
 

data/examples/address-book/address-book.schema.yaml

@@ -1,7 +1,7 @@
 ##
 ## Kwalify schema example for address book
 ##
-## $Release: 0.3.0 $
+## $Release: 0.4.0 $
 ## copyright(c) 2005 kuwata-lab all rights reserved.
 ##
 ##

data/examples/invoice/Makefile

@@ -1,4 +1,4 @@
 all:
-	kwalify -m invoice.schema.yaml
-	kwalify -f invoice.schema.yaml invoice.yaml
+	kwalify -lm invoice.schema.yaml
+	kwalify -lf invoice.schema.yaml invoice.yaml
 

data/examples/invoice/invoice.schema.yaml

@@ -2,7 +2,7 @@
 ### Kwalify schema example for invoice
 ###
 ### $Rev: 20 $
-### $Release: 0.3.0 $
+### $Release: 0.4.0 $
 ### copyright(c) 2005 kuwata-lab all rights reserved.
 ###
 

data/examples/tapkit/Makefile

@@ -1,5 +1,5 @@
 
 all:
-	kwalify -m tapkit.schema.yaml
-	kwalify -f tapkit.schema.yaml tapkit.yaml
+	kwalify -lm tapkit.schema.yaml
+	kwalify -lf tapkit.schema.yaml tapkit.yaml
 

data/examples/tapkit/tapkit.schema.yaml

@@ -1,7 +1,7 @@
 ##
 ## Kwalify schema example for TapKit
 ##
-## $Release: 0.3.0 $
+## $Release: 0.4.0 $
 ## copyright(c) 2005 kuwata-lab all rights reserved.
 ##
 

data/lib/kwalify.rb

@@ -1,13 +1,13 @@
 ###
-### $Rev: 18 $
-### $Release: 0.3.0 $
+### $Rev: 26 $
+### $Release: 0.4.0 $
 ### copyright(c) 2005 kuwata-lab all rights reserved.
 ###
 
 
 module Kwalify
 
-   RELEASE = ("$Release: 0.3.0 $" =~ /[.\d]+/) && $&
+   RELEASE = ("$Release: 0.4.0 $" =~ /[.\d]+/) && $&
 
 end
 
@@ -17,3 +17,4 @@ require 'kwalify/errors'
 require 'kwalify/rule'
 require 'kwalify/validator'
 require 'kwalify/meta-validator'
+require 'kwalify/parser'

data/lib/kwalify/errors.rb

@@ -1,6 +1,6 @@
 ###
-### $Rev: 18 $
-### $Release: 0.3.0 $
+### $Rev: 27 $
+### $Release: 0.4.0 $
 ### copyright(c) 2005 kuwata-lab all rights reserved.
 ###
 
@@ -28,6 +28,7 @@ module Kwalify
          @value        = value
       end
       attr_reader :error_symbol, :rule, :path, :value
+      attr_accessor :linenum
 
       def path
          return @path == '' ? "/" : @path
@@ -59,6 +60,15 @@ module Kwalify
    end
 
 
+   class ParseError < KwalifyError
+      def initialize(msg, linenum)
+         super("line #{linenum}: #{msg}")
+         @linenum = linenum
+      end
+      attr_accessor :linenum
+   end
+
+
    module ErrorHelper
 
       def assert_error(message="")
@@ -77,7 +87,7 @@ module Kwalify
          msg = Kwalify.msg(error_symbol)
          assert_error("error_symbol=#{error_symbol.inspect}") unless msg
          msg = msg % args if args
-         msg = "'#{val.to_s.gsub(/\n/, '\n')}': #{msg}" if val != nil && Kwalify.scalar_class?(val.class)
+         msg = "'#{val.to_s.gsub(/\n/, '\n')}': #{msg}" if val != nil && Kwalify.scalar?(val)
          return error_klass.new(msg, path, val, rule, error_symbol)
       end
 

data/lib/kwalify/main-program.rb

@@ -1,6 +1,6 @@
 ###
-### $Rev: 18 $
-### $Release: 0.3.0 $
+### $Rev: 26 $
+### $Release: 0.4.0 $
 ### copyright(c) 2005 kuwata-lab all rights reserved.
 ###
 
@@ -62,6 +62,19 @@ module Kwalify
       private
 
 
+      def _load_yaml(str)
+         str = YamlHelper.untabify(tr) if @options[:untabify]
+         if @options[:linenum]
+            @parser = Kwalify::Parser.new(str)
+            doc = @parser.parse()
+         else
+            doc = YAML.load(str)
+            doc = doc.value if doc.is_a?(YAML::Syck::DomainType)
+         end
+         return doc
+      end
+
+
       def _meta_validate(filenames)
          filenames = [ nil ] if filenames.empty?
          meta_validator = @options[:meta2] ? nil : Kwalify.meta_validator()
@@ -76,9 +89,7 @@ module Kwalify
 
       def __meta_validate(meta_validator, filename=nil)
          str = filename ? File.open(filename) { |f| f.read() } : $stdin.read()
-         str = YamlHelper.untabify(tr) if @options[:untabify]
-         schema = YAML.load(str)
-         schema = schema.value if schema.is_a?(YAML::Syck::DomainType)
+         schema = _load_yaml(str)
          filename ||= "(stdin)"
          if !schema || schema.empty?
             #* key=:meta_schema_empty  msg="%s: empty.\n"
@@ -101,7 +112,25 @@ module Kwalify
          else
             #* key=:meta_validation_invalid  msg="%s: NG!\n"
             s << (Kwalify.msg(:meta_validation_invalid) % filename)
-            errors.each { |error| s << "  - [#{error.path}] #{error.message}\n" }
+            s << _errors_to_str(errors)
+         end
+         return s
+      end
+
+
+      def _errors_to_str(errors)
+         s = ''
+         flag_linenum = @options[:linenum]
+         if flag_linenum
+            @parser.set_error_linenums(errors)
+            errors = errors.sort { |e1, e2| e1.linenum <=> e2.linenum }
+         end
+         errors.each do |error|
+            if flag_linenum
+               s << "  - (line #{error.linenum}) [#{error.path}] #{error.message}\n"
+            else
+               s << "  - [#{error.path}] #{error.message}\n"
+            end
          end
          return s
       end
@@ -110,9 +139,7 @@ module Kwalify
       def _validate(filenames)
          schema_filename = @options[:schema]
          str = File.open(schema_filename) { |f| f.read() }
-         str = YamlHelper.untabify(str) if @options[:untabify]
-         schema = YAML.load(str)
-         schema = schema.value if schema.is_a?(YAML::Syck::DomainType)
+         schema = _load_yaml(str)
          validator = Kwalify::Validator.new(schema)
          #
          filenames = [ nil ] if filenames.empty?
@@ -126,14 +153,11 @@ module Kwalify
 
       def __validate(validator, filename=nil)
          str = filename ? File.open(filename) { |f| f.read() } : $stdin.read()
-         str = YamlHelper.untabify(str) if @options[:untabify]
-         stream = YAML::load_stream(str)
          filename ||= "(stdin)"
-         i = -1   # or 0?  *index*
          s = ''
-         stream.documents.each do |document|
+         i = -1
+         _each_yaml_documents(str) do |document|
             i += 1
-            document = document.value if document.is_a?(YAML::Syck::DomainType)
             if !document || document.empty?
                #* key=:schema_empty  msg="%s#%d: empty.\n"
                s << (Kwalify.msg(:schema_empty) % i)
@@ -146,19 +170,32 @@ module Kwalify
             else
                #* key=:validation_invalid  msg="%s#%d: INVALID\n"
                s << (Kwalify.msg(:validation_invalid) % [filename, i])
-               errors.each { |error| s << "  - [#{error.path}] #{error.message}\n" }
+               s << _errors_to_str(errors)
             end
          end
          return s
       end
 
 
+      def _each_yaml_documents(str, &block)
+         str = YamlHelper.untabify(str) if @options[:untabify]
+         if @options[:linenum]
+            @parser = Kwalify::Parser.new(str)
+            doc = @parser.parse()
+            yield(doc)
+         else
+            YAML::load_documents(str) do |doc|
+               doc = doc.value if doc.is_a?(YAML::Syck::DomainType)
+               yield(doc)
+            end
+         end
+      end
+
+
       def _inspect_schema(schema_filename)
          filename = schema_filename
          str = filename ? File.open(filename) { |f| f.read() } : $stdin.read()
-         str = YamlHelper.untabify(tr) if @options[:untabify]
-         schema = YAML.load(str)
-         schema = schema.value if schema.is_a?(YAML::Syck::DomainType)
+         schema = _load_yaml(str)
          return nil if !schema || schema.empty?
          validator = Kwalify::Validator.new(schema)  # error raised when schema is wrong
          s = validator._inspect()
@@ -169,14 +206,15 @@ module Kwalify
 
       def _usage()
          s = ''
-         s <<  "Usage1: #{@command} [-hvst] -f schema.yaml document.yaml [document2.yaml ...]\n"
-         s <<  "Usage2: #{@command} [-hvst] -m schema.yaml [schema2.yaml ...]\n"
+         s <<  "Usage1: #{@command} [-hvstl] -f schema.yaml document.yaml [document2.yaml ...]\n"
+         s <<  "Usage2: #{@command} [-hvstl] -m schema.yaml [schema2.yaml ...]\n"
          s <<  "  -h, --help      :  help\n"
          s <<  "  -v              :  version\n"
          s <<  "  -s              :  silent\n"
          s <<  "  -f schema.yaml  :  schema definition file\n"
          s <<  "  -m              :  meta-validation mode\n"
          s <<  "  -t              :  expand tab character automatically\n"
+         s <<  "  -l              :  show linenumber when errored (experimental)\n"
          return s
       end
 
@@ -187,7 +225,7 @@ module Kwalify
 
 
       def _parse_argv(argv)
-         opt_parser = CommandOptionParser.new("hvstmMD", "f")
+         opt_parser = CommandOptionParser.new("hvstlmMD", "f")
          #opts, props = opt_parser.parse(argv)
          #properties = {}
          #props.each do |pname, pvalue|
@@ -202,6 +240,7 @@ module Kwalify
          options[:version]  = opts[?v] || properties[:version]
          options[:silent]   = opts[?s]
          options[:schema]   = opts[?f]
+         options[:linenum]  = opts[?l]
          options[:meta]     = opts[?m]
          options[:meta2]    = opts[?M]
          options[:untabify] = opts[?t]

data/lib/kwalify/messages.rb

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

data/lib/kwalify/meta-validator.rb

@@ -1,6 +1,6 @@
 ###
-### $Rev: 21 $
-### $Release: 0.3.0 $
+### $Rev: 35 $
+### $Release: 0.4.0 $
 ### copyright(c) 2005 kuwata-lab all rights reserved.
 ###
 
@@ -98,7 +98,7 @@ mapping:   &main-rule
     name:      MAPPING
     type:      map
     mapping:
-     '*':
+      =:
         type:      map
         mapping:   *main-rule
         name:      MAIN
@@ -110,7 +110,7 @@ END
    ## ex.
    ##   meta_validator = Kwalify.meta_validator()
    ##   schema = File.load_file('schema.yaml')
-   ##   errors << meta_validator.validate(schema)
+   ##   errors = meta_validator.validate(schema)
    ##   if !errors.empty?
    ##     errors.each do |error|
    ##       puts "[#{error.path}] #{error.message}"
@@ -269,9 +269,9 @@ END
          if hash.key?('mapping')
             val = hash['mapping']
             if val != nil && !val.is_a?(Hash)
-               errors << validate_error(:mapping_notmap,   rule, "#{path}/mapping", val)
-            elsif val == nil || val.empty?
-               errors << validate_error(:mapping_noelem,   rule, "#{path}/mapping", val)
+               errors << validate_error(:mapping_notmap, rule, "#{path}/mapping", val)
+            elsif val == nil || (val.empty? && !val.default)
+               errors << validate_error(:mapping_noelem, rule, "#{path}/mapping", val)
             end
          end
          #

data/lib/kwalify/parser.rb

@@ -0,0 +1,759 @@
+###
+### $Rev: 35 $
+### $Release: 0.4.0 $
+### copyright(c) 2005 kuwata-lab all rights reserved.
+###
+
+require 'kwalify/messages'
+require 'kwalify/errors'
+require 'kwalify/types'
+
+require 'date'
+
+
+module Kwalify
+
+
+   ##
+   ## ex.
+   ##   str = ARGF.read()
+   ##   parser = Kwalify::PlainParser.new(str)
+   ##   doc = parser.parse()
+   ##   p doc
+   ##
+   class PlainParser
+
+      class Alias
+         def initialize(label, linenum)
+            @label   = label
+            @linenum = linenum
+         end
+         attr_reader :label, :linenum
+      end
+
+
+      def initialize(yaml_str)
+         @lines = yaml_str.to_a()
+         @line  = nil
+         @linenum = 0
+         @anchors = {}
+         @aliases = {}
+      end
+
+
+      def parse()
+         data = parse_child(0)
+         if data == nil && @end_flag == '---'
+            data = parse_child(0)
+         end
+         resolve_aliases(data) unless @aliases.empty?
+         return data
+      end
+
+
+      protected
+
+
+      def create_sequence(linenum=nil)
+         return []
+      end
+
+      def add_to_seq(seq, value, linenum)
+         seq << value
+      end
+
+      def set_seq_at(seq, i, value, linenum)
+         seq[i] = value
+      end
+
+      def create_mapping(linenum=nil)
+         return {}
+      end
+
+      def add_to_map(map, key, value, linenum)
+         map[key] = value
+      end
+
+      def set_map_with(map, key, value, linenum)
+         map[key] = value
+      end
+
+      def set_default(map, value, linenum)
+         map.value = value
+      end
+
+      def merge_map(map, map2, linenum)
+         map2.each do |key, val|
+            map[key] = value unless map.key?(key)
+         end
+      end
+
+      def create_scalar(value, linenum=nil)
+         return value
+      end
+
+
+      def current_line
+         return @line
+      end
+
+      def current_linenum
+         return @linenum
+      end
+
+
+      private
+
+
+      def getline
+         line = _getline()
+         line = _getline() while line && line =~ /^\s*($|\#)/
+         return line
+      end
+
+      def _getline
+         @line = @lines[@linenum]
+         @linenum += 1
+         case @line
+         when nil             ; @end_flag = 'EOF'
+         when /^\.\.\.$/      ; @end_flag = '...'; @line = nil
+         when /^---(\s+.*)?$/ ; @end_flag = '---'; @line = nil
+         else                 ; @end_flag = nil
+         end
+         return @line
+      end
+
+
+      def reset_sbuf(str)
+         @sbuf = str[-1] == ?\n ? str : str + "\n"
+         @index = -1
+      end
+
+
+      def _getchar
+         @index += 1
+         ch = @sbuf[@index]
+         while ch == nil
+            break if (line = getline()) == nil
+            reset_sbuf(line)
+            @index += 1
+            ch = @sbuf[@index]
+         end
+         return ch
+      end
+
+      def getchar
+         ch = _getchar()
+         ch = _getchar() while ch && white?(ch)
+         return ch
+      end
+
+      def getchar_or_nl
+         ch = _getchar()
+         ch = _getchar() while ch && white?(ch) && ch != ?\n
+         return ch
+      end
+
+      def current_char
+         return @sbuf[@index]
+      end
+
+
+      def syntax_error(msg, linenum=@linenum)
+         return Kwalify::ParseError.new(msg, linenum)
+      end
+
+
+      def parse_child(column)
+         line = getline()
+         return create_scalar(nil) if !line
+         line =~ /^( *)(.*)/
+         indent = $1.length
+         return create_scalar(nil) if indent < column
+         value = $2
+         return parse_value(column, value, indent)
+      end
+
+
+      def parse_value(column, value, value_start_column)
+         case value
+         when /^-( |$)/
+            data = parse_sequence(value_start_column, value)
+         when /^(:?[-.\w]+|'.*?'|".*?"|=|<<) *:( |$)/
+         #when /^:?["']?[-.\w]+["']? *:( |$)/			#'
+            data = parse_mapping(value_start_column, value)
+         when /^\[/, /^\{/
+            data = parse_flowstyle(column, value)
+         when /^\&[-\w]+( |$)/
+            data = parse_anchor(column, value)
+         when /^\*[-\w]+( |$)/
+            data = parse_alias(column, value)
+         when /^[|>]/
+            data = parse_block_text(column, value)
+         when /^!/
+            data = parse_tag(column, value)
+         when /^\#/
+            data = parse_child(column)
+         else
+            data = parse_scalar(column, value)
+         end
+         return data
+      end
+
+      def white?(ch)
+         return ch == ?\  || ch == ?\t || ch == ?\n || ch == ?\r
+      end
+
+
+      ##
+      ## flowstyle     ::=  flow_seq | flow_map | flow_scalar
+      ##
+      ## flow_seq      ::=  '[' [ flow_seq_item { ',' sp flow_seq_item } ] ']'
+      ## flow_seq_item ::=  flowstyle
+      ##
+      ## flow_map      ::=  '{' [ flow_map_item { ',' sp flow_map_item } ] '}'
+      ## flow_map_item ::=  flowstyle ':' sp flowstyle
+      ##
+      ## flow_scalar   ::=  string | number | boolean | symbol | date
+      ##
+
+      def parse_flowstyle(column, value)
+         reset_sbuf(value)
+         getchar()
+         data = parse_flow(0)
+         ch = current_char
+         assert ch == ?] || ch == ?}
+         ch = getchar_or_nl()
+         unless ch == ?\n || ch == ?# || ch == nil
+            raise syntax_error("flow style sequence is closed but got '#{ch.chr}'.")
+         end
+         getline() if ch != nil
+         return data
+      end
+
+      def parse_flow(depth)
+         ch = current_char()
+         #ch = getchar()
+         if ch == nil
+            rase syntax_error("found EOF when parsing flow style.")
+         end
+         if ch == ?[
+            data = parse_flow_seq(depth)
+         elsif ch == ?{
+            data = parse_flow_map(depth)
+         else
+            data = parse_flow_scalar(depth)
+         end
+         return data
+      end
+
+      def parse_flow_seq(depth)
+         assert current_char() == ?[
+         seq = create_sequence()  # []
+         ch = getchar()
+         if ch != ?}
+            linenum = current_linenum()
+            #seq << parse_flow_seq_item(depth + 1)
+            add_to_seq(seq, parse_flow_seq_item(depth + 1), linenum)
+            while (ch = current_char()) == ?,
+               ch = getchar()
+               if ch == ?]
+                  raise syntax_error("sequence item required (or last comma is extra).")
+               end
+               #break if ch == ?]
+               linenum = current_linenum()
+               #seq << parse_flow_seq_item(depth + 1)
+               add_to_seq(seq, parse_flow_seq_item(depth + 1), linenum)
+            end
+         end
+         unless current_char() == ?]
+            raise syntax_error("flow style sequence requires ']'.")
+         end
+         getchar() if depth > 0
+         return seq
+      end
+
+      def parse_flow_seq_item(depth)
+         return parse_flow(depth)
+      end
+
+      def parse_flow_map(depth)
+         assert current_char() == ?{          #}
+         map = create_mapping()  # {}
+         ch = getchar()
+         if ch != ?}
+            linenum = current_linenum()
+            key, value = parse_flow_map_item(depth + 1)
+            #map[key] = value
+            add_to_map(map, key, value, linenum)
+            while (ch = current_char()) == ?,
+               ch = getchar()
+               if ch == ?}
+                  raise syntax_error("mapping item required (or last comma is extra).")
+               end
+               #break if ch == ?}
+               linenum = current_linenum()
+               key, value = parse_flow_map_item(depth + 1)
+               #map[key] = value
+               add_to_map(map, key, value, linenum)
+            end
+         end
+         unless current_char() == ?}
+            raise syntax_error("flow style mapping requires '}'.")
+         end
+         getchar() if depth > 0
+         return map
+      end
+
+      def parse_flow_map_item(depth)
+         key = parse_flow(depth)
+         unless (ch = current_char()) == ?:
+            s = ch ? "'#{ch.chr}'" : "EOF"
+            raise syntax_error("':' expected but got #{s}.")
+         end
+         getchar()
+         value = parse_flow(depth)
+         return key, value
+      end
+
+      def parse_flow_scalar(depth)
+         case ch = current_char()
+         when ?", ?'         #"
+            endch = ch
+            s = ''
+            while (ch = _getchar()) != nil && ch != endch
+               s << ch.chr
+            end
+            getchar()
+            scalar = s
+         else
+            s = ch.chr
+            while (ch = _getchar()) != nil && ch != ?: && ch != ?, && ch != ?] && ch != ?}
+               s << ch.chr
+            end
+            scalar = to_scalar(s.strip)
+         end
+         return create_scalar(scalar)
+      end
+
+
+      def parse_tag(column, value)
+         assert value =~ /^!\S+/
+         value =~ /^!(\S+)((\s+)(.*))?$/
+         tag    = $1
+         space  = $3
+         value2 = $4
+         if value2 && !value2.empty?
+            value_start_column = column + 1 + tag.length + space.length
+            data = parse_value(column, value2, value_start_column)
+         else
+            data = parse_child(column)
+         end
+         return data
+      end
+
+
+      def parse_anchor(column, value)
+         assert value =~ /^\&([-\w]+)(( *)(.*))?$/
+         label  = $1
+         space  = $3
+         value2 = $4
+         if value2 && !value2.empty?
+            #column2 = column + 1 + label.length + space.length
+            #data = parse_value(column2, value2)
+            value_start_column = column + 1 + label.length + space.length
+            data = parse_value(column, value2, value_start_column)
+         else
+            #column2 = column + 1
+            #data = parse_child(column2)
+            data = parse_child(column)
+         end
+         register_anchor(label, data)
+         return data
+      end
+
+      def register_anchor(label, data)
+         if @anchors[label]
+            raise syntax_error("anchor '#{label}' is already used.")
+         end
+         @anchors[label] = data
+      end
+
+      def parse_alias(column, value)
+         assert value =~ /^\*([-\w]+)(( *)(.*))?$/
+         label  = $1
+         space  = $3
+         value2 = $4
+         if value2 && !value2.empty? && value2[0] != ?\#
+            raise syntax_error("alias cannot take any data.")
+         end
+         data = @anchors[label]
+         unless data
+            data = register_alias(label)
+            #raise syntax_error("anchor '#{label}' not found (cannot refer to backward or child anchor).")
+         end
+         getline()
+         return data
+      end
+
+      def register_alias(label)
+         @aliases[label] ||= 0
+         @aliases[label] += 1
+         return Alias.new(label, @linenum)
+      end
+
+
+      def resolve_aliases(data)
+         @resolved ||= {}
+         return if @resolved[data.__id__]
+         @resolved[data.__id__] = data
+         case data
+         when Array
+            seq = data
+            seq.each_with_index do |val, i|
+               if val.is_a?(Alias)
+                  anchor = val
+                  if @anchors.key?(anchor.label)
+                     #seq[i] = @anchors[anchor.label]
+                     set_seq_at(seq, i, @anchors[anchor.label], anchor.linenum)
+                  else
+                     raise syntax_error("anchor '#{val.label}' not found", val.linenum)
+                  end
+               elsif val.is_a?(Array) || val.is_a?(Hash)
+                  resolve_aliases(val)
+               end
+            end
+         when Hash
+            map = data
+            map.each do |key, val|
+               if val.is_a?(Alias)
+                  if @anchors.key?(val.label)
+                     anchor = val
+                     #map[key] = @anchors[anchor.label]
+                     set_map_with(map, key, @anchors[anchor.label], anchor.linenum)
+                  else
+                     raise syntax_error("anchor '#{val.label}' not found", val.linenum)
+                  end
+               elsif val.is_a?(Array) || val.is_a?(Hash)
+                  resolve_aliases(val)
+               end
+            end
+         else
+            assert !data.is_a?(Alias)
+         end
+      end
+
+
+      def parse_block_text(column, value)
+         assert value =~ /^[>|\|]/
+         value =~ /^([>|\|])([-+]?)\s*(.*)$/
+         char = $1
+         indicator = $2
+         sep = char == "|" ? "\n" : " "
+         #text = $3.empty? ? '' :  $3 + sep
+         text = $3
+         s = ''
+         empty = ''
+         min_indent = -1
+         while line = _getline()
+            line =~ /^( *)(.*)/
+            indent = $1.length
+            if $2.empty?
+               empty << "\n"
+            elsif indent < column
+               break
+            else
+               min_indent = indent if min_indent < 0 || min_indent > indent
+               s << empty << line
+               empty = ''
+            end
+         end
+         s << empty if indicator == '+'
+         s[-1] = "" if indicator == '-'
+         if min_indent > 0
+            sp = ' ' * min_indent
+            s.gsub!(/^#{sp}/, '')
+         end
+         if char == '>'
+            s.gsub!(/([^\n])\n([^\n])/, '\1 \2')
+            s.gsub!(/\n(\n+)/, '\1')
+         end
+         getline() if current_line() =~ /^\s*\#/
+         return create_scalar(text + s)
+      end
+
+
+      def parse_sequence(column, value)
+         assert value =~ /^-(( +)(.*))?$/
+         seq = create_sequence()  # []
+         while true
+            unless value =~ /^-(( +)(.*))?$/
+               raise syntax_error("sequence item is expected.")
+            end
+            value2 = $3
+            space  = $2
+            column2 = column + 1
+            linenum = current_linenum()
+            #
+            if !value2 || value2.empty?
+               elem = parse_child(column2)
+            else
+               value_start_column = column2 + space.length
+               elem = parse_value(column2, value2, value_start_column)
+            end
+            add_to_seq(seq, elem, linenum)    #seq << elem
+            #
+            line = current_line()
+            break unless line
+            line =~ /^( *)(.*)/
+            indent = $1.length
+            if    indent < column
+               break
+            elsif indent > column
+               raise syntax_error("invalid indent of sequence.")
+            end
+            value = $2
+         end
+         return seq
+      end
+
+
+      def parse_mapping(column, value)
+         #assert value =~ /^(:?["']?[-.\w]+["']? *):(( +)(.*))?$/         #'
+         assert value =~ /^((?::?[-.\w]+|'.*?'|".*?"|=|<<) *):(( +)(.*))?$/
+         map = create_mapping()  # {}
+         while true
+            #unless value =~ /^(:?["']?[-.\w]+["']? *):(( +)(.*))?$/      #'
+            unless value =~ /^((?::?[-.\w]+|'.*?'|".*?"|=|<<) *):(( +)(.*))?$/
+               raise syntax_error("mapping item is expected.")
+            end
+            v = $1.strip
+            key = to_scalar(v)
+            value2 = $4
+            column2 = column + 1
+            linenum = current_linenum()
+            #
+            if !value2 || value2.empty?
+               elem = parse_child(column2)
+            else
+               value_start_column = column2 + $1.length + $3.length
+               elem = parse_value(column2, value2, value_start_column)
+            end
+            case v
+            when '='
+               set_default(map, elem, linenum)
+            when '<<'
+               merge_map(map, elem, linenum)
+            else
+               add_to_map(map, key, elem, linenum)    # map[key] = elem
+            end
+            #
+            line = current_line()
+            break unless line
+            line =~ /^( *)(.*)/
+            indent = $1.length
+            if    indent < column
+               break
+            elsif indent > column
+               raise syntax_error("invalid indent of mapping.")
+            end
+            value = $2
+         end
+         return map
+      end
+
+
+      def parse_scalar(indent, value)
+         data = create_scalar(to_scalar(value))
+         getline()
+         return data
+      end
+
+
+      def to_scalar(str)
+         case str
+         when /^"(.*)"([ \t]*\#.*$)?/    ; return $1
+         when /^'(.*)'([ \t]*\#.*$)?/    ; return $1
+         when /^(.*\S)[ \t]*\#/          ; str = $1
+         end
+
+         case str
+         when /^-?\d+$/              ;  return str.to_i    # integer
+         when /^-?\d+\.\d+$/         ;  return str.to_f    # float
+         when "true", "yes", "on"    ;  return true        # true
+         when "false", "no", "off"   ;  return false       # false
+         when "null", "~"            ;  return nil         # nil
+         #when /^"(.*)"$/             ;  return $1          # "string"
+         #when /^'(.*)'$/             ;  return $1          # 'string'
+         when /^:(\w+)$/             ;  return $1.intern   # :symbol
+         when /^(\d\d\d\d)-(\d\d)-(\d\d)$/                 # date
+            year, month, day = $1.to_i, $2.to_i, $3.to_i
+            return Date.new(year, month, day)
+         when /^(\d\d\d\d)-(\d\d)-(\d\d)(?:[Tt]|[ \t]+)(\d\d?):(\d\d):(\d\d)(\.\d*)?(?:Z|[ \t]*([-+]\d\d?)(?::(\d\d))?)?$/
+            year, mon, mday, hour, min, sec, usec, tzone_h, tzone_m = $1, $2, $3, $4, $5, $6, $7, $8, $9
+            #Time.utc(sec, min, hour, mday, mon, year, wday, yday, isdst, zone)
+            #t = Time.utc(sec, min, hour, mday, mon, year, nil, nil, nil, nil)
+            #Time.utc(year[, mon[, day[, hour[, min[, sec[, usec]]]]]])
+            time = Time.utc(year, mon, day, hour, min, sec, usec)
+            if tzone_h
+               diff_sec = tzone_h.to_i * 60 * 60
+               if tzone_m
+                  if diff_sec > 0 ; diff_sec += tzone_m.to_i * 60
+                  else            ; diff_sec -= tzone_m.to_i * 60
+                  end
+               end
+               p diff_sec
+               time -= diff_sec
+            end
+            return time
+         end
+         return str
+      end
+
+
+      def assert(bool_expr)
+         raise "*** assertion error" unless bool_expr
+      end
+
+   end
+
+
+
+   ##
+   ## ex.
+   ##  # load document with Parser
+   ##  str = ARGF.read()
+   ##  parser = Kwalify::Parser.new(str)
+   ##  document = parser.parse()
+   ##
+   ##  # validate document
+   ##  schema = YAML.load(File.read('schema.yaml'))
+   ##  validator = Kwalify::Validator.new(schema)
+   ##  errors = validator.validate(document)
+   ##
+   ##  # print validation result
+   ##  if errors && !errors.empty?
+   ##    parser.set_error_linenums(errors)
+   ##    errors.sort { |e1, e2| e1.linenum <=> e2.linenum }.each do |error|
+   ##      print "line %d: path %s: %s" % [error.linenum, error.path, error.message]
+   ##    end
+   ##  end
+   ##
+   class Parser < PlainParser
+
+      def initialize(*args)
+         super
+         @linenums_table = {}     # object_id -> hash or array
+      end
+
+      def parse()
+         @doc = super()
+         return @doc
+      end
+
+      def path_linenum(path)
+         return 1 if path.empty? || path == '/'
+         elems = path.split('/')
+         elems.shift if path[0] == ?/    # delete empty string on head
+         last_elem = elems.pop
+         c = @doc   # collection
+         elems.each do |elem|
+            if c.is_a?(Array)
+               c = c[elem.to_i]
+            elsif c.is_a?(Hash)
+               c = c[elem]
+            else
+               assert false
+            end
+         end
+         linenums = @linenums_table[c.__id__]
+         if c.is_a?(Array)
+            linenum = linenums[last_elem.to_i]
+         elsif c.is_a?(Hash)
+            linenum = linenums[last_elem]
+         end
+         return linenum
+      end
+
+      def set_error_linenums(errors)
+         errors.each do |error|
+            error.linenum = path_linenum(error.path)
+         end
+      end
+
+      protected
+
+      def create_sequence(linenum=current_linenum())
+         seq = []
+         @linenums_table[seq.__id__] = []
+         return seq
+      end
+
+      def add_to_seq(seq, value, linenum)
+         seq << value
+         @linenums_table[seq.__id__] << linenum
+      end
+
+      def set_seq_at(seq, i, value, linenum)
+         seq[i] = value
+         @linenums_table[seq.__id__][i] = linenum
+      end
+
+      def create_mapping(linenum=current_linenum())
+         map = {}
+         @linenums_table[map.__id__] = {}
+         return map
+      end
+
+      def add_to_map(map, key, value, linenum)
+         map[key] = value
+         @linenums_table[map.__id__][key] = linenum
+      end
+
+      def set_map_with(map, key, value, linenum)
+         map[key] = value
+         @linenums_table[map.__id__][key] = linenum
+      end
+
+      def set_default(map, value, linenum)
+         map.default = value
+         @linenums_table[map.__id__][:'='] = linenum
+      end
+
+      def merge_map(map, collection, linenum)
+         t = @linenums_table[map.__id__]
+         list = collection.is_a?(Array) ? collection : [ collection ]
+         list.each do |m|
+            t2 = @linenums_table[m.__id__]
+            m.each do |key, val|
+               unless map.key?(key)
+                  map[key] = val
+                  t[key] = t2[key]
+               end
+            end
+         end
+      end
+
+      def create_scalar(value, linenum=current_linenum())
+         data = super(value)
+         #return Scalar.new(data, linenum)
+         return data
+      end
+
+   end
+
+end
+
+
+if __FILE__ == $0
+   require 'yaml'
+   require 'pp'
+   if $plain
+      parser = Kwalify::PlainParser.new(ARGF.read())
+   else
+      parser = Kwalify::Parser.new(ARGF.read())
+   end
+   doc = parser.parse()
+   pp doc
+   #y doc
+end