kwalify 0.6.1 → 0.7.0

data/lib/kwalify/messages.rb

@@ -1,7 +1,7 @@
 ###
-### $Rev: 51 $
-### $Release: 0.6.1 $
-### copyright(c) 2005 kuwata-lab all rights reserved.
+### $Rev: 95 $
+### $Release: 0.7.0 $
+### copyright(c) 2005-2008 kuwata-lab all rights reserved.
 ###
 
 module Kwalify
@@ -15,21 +15,28 @@ module Kwalify
 
 
    @@messages[:command_help] = <<END
-kwalify - tiny schema validator for YAML and JSON
-Usage1: kwalify [..options..] -f schema.yaml doc.yaml [doc2.yaml ...]
-Usage2: kwalify [..options..] -m schema.yaml [schema2.yaml ...]
-Usage3: kwalify [..options..] -a action -f schema.yaml [schema2.yaml ...]
-  -h, --help      :  help
-  -v              :  version
-  -s              :  silent
-  -f schema.yaml  :  schema definition file
-  -m              :  meta-validation mode
-  -t              :  expand tab characters
-  -l              :  show linenumber when errored (experimental)
-  -E              :  show errors in emacs-style (implies '-l')
-  -a action       :  action ('genclass-ruby' or 'genclass-java')
-                     (use '-ha action' option to show action properites)
+kwalify - schema validator and data binding tool for YAML and JSON
+## Usage1: validate yaml document
+kwalify [..options..] -f schema.yaml doc.yaml [doc2.yaml ...]
+## Usage2: validate schema definition
+kwalify [..options..] -m schema.yaml [schema2.yaml ...]
+## Usage3: do action
+kwalify [..options..] -a action -f schema.yaml [schema2.yaml ...]
+  -h, --help     : help
+  -v             : version
+  -q             : quiet
+  -s             : silent (obsolete, use '-q' instead)
+  -f schema.yaml : schema definition file
+  -m             : meta-validation mode
+  -t             : expand tab characters
+  -l             : show linenumber when errored (experimental)
+  -E             : show errors in emacs-style (experimental, implies '-l')
+  -a action      : action ('genclass-ruby', 'genclass-php', 'genclass-java')
+                   (try '-ha genclass-ruby' for details)
+  -I path        : template path (for '-a')
+  -P             : allow preceding alias
 END
+#  -z              :  syntax checking of schema file
 #  -I path         :  path for template of action
 
 
@@ -40,12 +47,12 @@ END
    @@messages[:command_option_noaction] = "command-line option '-f' or '-m' required."
    @@messages[:command_option_notemplate] = "%s: invalid action (template not found).\n"
    @@messages[:schema_empty]         = "%s: empty schema.\n"
+   @@messages[:validation_empty]     = "%s#%d: empty."
    @@messages[:validation_empty]     = "%s#%d: empty.\n"
-   @@messages[:validation_valid]     = "%s#%d: valid.\n"
-   @@messages[:validation_invalid]   = "%s#%d: INVALID\n"
-   @@messages[:command_option_noschema] = "-%s: schema filename required."
-   @@messages[:command_option_noaction] = "-%s: action required."
-   @@messages[:command_option_notpath] = "-%s: template path required."
+   @@messages[:validation_valid]     = "%s#%d: valid."
+   @@messages[:command_option_schema_required] = "-%s: schema filename required."
+   @@messages[:command_option_action_required] = "-%s: action required."
+   @@messages[:command_option_tpath_required] = "-%s: template path required."
    @@messages[:command_property_invalid] = "%s: invalid property."
    @@messages[:command_option_invalid] = "-%s: invalid command option."
    # --
@@ -54,7 +61,7 @@ END
    @@messages[:key_unknown]          = "unknown key."
    @@messages[:type_notstr]          = "not a string."
    @@messages[:type_unknown]         = "unknown type."
-   @@messages[:classname_notmap]     = "available only with map type."
+   @@messages[:class_notmap]         = "available only with map type."
    @@messages[:required_notbool]     = "not a boolean."
    @@messages[:pattern_notstr]       = "not a string (or regexp)"
    @@messages[:pattern_notmatch]     = "should be '/..../'."
@@ -93,6 +100,9 @@ END
    @@messages[:unique_notbool]       = "not a boolean."
    @@messages[:unique_notscalar]     = "is available only with a scalar type."
    @@messages[:unique_onroot]        = "is not available on root element."
+   @@messages[:default_nonscalarval] = "not a scalar."
+   @@messages[:default_notscalar]    = "is available only with a scalar type."
+   @@messages[:default_unmatch]      = "not a %s."
    @@messages[:sequence_notseq]      = "not a sequence."
    @@messages[:sequence_noelem]      = "required one element."
    @@messages[:sequence_toomany]     = "required just one element."
@@ -104,10 +114,14 @@ END
    @@messages[:map_conflict]         = "not available with mapping."
    @@messages[:scalar_conflict]      = "not available with scalar type."
    @@messages[:enum_conflict]        = "not available with 'enum:'."
+   @@messages[:default_conflict]     = "not available when 'required:' is true."
    # --
    # filename: lib/kwalify/validator.rb
    @@messages[:required_novalue]     = "value required but none."
    @@messages[:type_unmatch]         = "not a %s."
+   @@messages[:key_undefined]        = "key '%s' is undefined."
+   @@messages[:required_nokey]       = "key '%s:' is required."
+   @@messages[:value_notunique]      = "is already used at '%s'."
    @@messages[:assert_failed]        = "assertion expression failed (%s)."
    @@messages[:enum_notexist]        = "invalid %s value."
    @@messages[:pattern_unmatch]      = "not matched to pattern %s."
@@ -119,18 +133,18 @@ END
    @@messages[:length_tooshort]      = "too short (length %d < min %d)."
    @@messages[:length_toolongex]     = "too long (length %d >= max %d)."
    @@messages[:length_tooshortex]    = "too short (length %d <= min %d)."
-   @@messages[:value_notunique]      = "is already used at '%s'."
-   @@messages[:required_nokey]       = "key '%s:' is required."
-   @@messages[:key_undefined]        = "key '%s' is undefined."
    # --
    # filename: lib/kwalify/yaml-parser.rb
    @@messages[:flow_hastail]         = "flow style sequence is closed but got '%s'."
    @@messages[:flow_eof]             = "found EOF when parsing flow style."
+   @@messages[:flow_alias_label]     = "alias name expected."
+   @@messages[:flow_anchor_label]    = "anchor name expected."
    @@messages[:flow_noseqitem]       = "sequence item required (or last comma is extra)."
    @@messages[:flow_seqnotclosed]    = "flow style sequence requires ']'."
    @@messages[:flow_mapnoitem]       = "mapping item required (or last comma is extra)."
    @@messages[:flow_mapnotclosed]    = "flow style mapping requires '}'."
-   @@messages[:flow_nocolon]         = "':' expected but got '%s'."
+   @@messages[:flow_nocolon]         = "':' expected but got %s."
+   @@messages[:flow_str_notclosed]   = "%s: string not closed."
    @@messages[:anchor_duplicated]    = "anchor '%s' is already used."
    @@messages[:alias_extradata]      = "alias cannot take any data."
    @@messages[:anchor_notfound]      = "anchor '%s' not found"

data/lib/kwalify/meta-validator.rb

@@ -1,355 +1,275 @@
 ###
-### $Rev: 51 $
-### $Release: 0.6.1 $
-### copyright(c) 2005 kuwata-lab all rights reserved.
+### $Rev: 95 $
+### $Release: 0.7.0 $
+### copyright(c) 2005-2008 kuwata-lab all rights reserved.
 ###
 
 require 'kwalify/errors'
 require 'kwalify/rule'
 require 'kwalify/validator'
-require 'yaml'
+require 'kwalify/parser/yaml'
+#require 'yaml'
 
 module Kwalify
 
 
-   ##
-   ## ex.
-   ##   meta_validator = Kwalify::MetaValidator.instance()
-   ##   schema = File.load_file('schema.yaml')
-   ##   errors = meta_validator.validate(schema)
-   ##   if !errors.empty?
-   ##     errors.each do |error|
-   ##       puts "[#{error.path}] #{error.message}"
-   ##     end
-   ##   end
-   ##
-   class MetaValidator < Validator
+  ##
+  ## ex.
+  ##   meta_validator = Kwalify::MetaValidator.instance()
+  ##   schema = File.load_file('schema.yaml')
+  ##   errors = meta_validator.validate(schema)
+  ##   if !errors.empty?
+  ##     errors.each do |error|
+  ##       puts "[#{error.path}] #{error.message}"
+  ##     end
+  ##   end
+  ##
+  class MetaValidator < Validator
 
-      META_SCHEMA = <<'END'
-name:      MAIN
-type:      map
-required:  yes
-mapping:   &main-rule
- "name":
-    type:      str
- "desc":
-    type:      str
- "classname":
-    type:      str
- "type":
-    type:      str
-    #required:  yes
-    enum:
-      - seq
-      #- sequence
-      #- list
-      - map
-      #- mapping
-      #- hash
-      - str
-      #- string
-      - int
-      #- integer
-      - float
-      - number
-      #- numeric
-      - bool
-      #- boolean
-      - text
-      - date
-      - time
-      - timestamp
-      #- object
-      - any
-      - scalar
-      #- collection
- "required":
-    type:      bool
- "enum":
-    type:      seq
-    sequence:
-      - type:     scalar
-        unique:   yes
- "pattern":
-    type:      str
- "assert":
-    type:      str
-    pattern:   /\bval\b/
- "range":
-    type:      map
-    mapping:
-     "max":
-        type:     scalar
-     "min":
-        type:     scalar
-     "max-ex":
-        type:     scalar
-     "min-ex":
-        type:     scalar
- "length":
-    type:      map
-    mapping:
-     "max":
-        type:     int
-     "min":
-        type:     int
-     "max-ex":
-        type:     int
-     "min-ex":
-        type:     int
- "ident":
-    type:      bool
- "unique":
-    type:      bool
- "sequence":
-    name:      SEQUENCE
-    type:      seq
-    sequence:
-      - type:      map
-        mapping:   *main-rule
-        name:      MAIN
-        #required:  yes
- "mapping":
-    name:      MAPPING
-    type:      map
-    mapping:
-      =:
-        type:      map
-        mapping:   *main-rule
-        name:      MAIN
-        #required:  yes
-END
+    filename = File.join(File.dirname(__FILE__), 'kwalify.schema.yaml')
+    META_SCHEMA = File.read(filename)
 
-
-      def initialize(schema, &block)
-         super
+    def self.instance()
+      unless @instance
+        schema = Kwalify::Yaml::Parser.new().parse(META_SCHEMA)
+        @instance = MetaValidator.new(schema)
       end
+      return @instance
+    end
 
-      def validate_hook(value, rule, path, errors)
-         return if value == nil     ## realy?
-         return unless rule.name == "MAIN"
-         #
-         hash = value
-         type = hash['type']
-         type = Types::DEFAULT_TYPE if type == nil
-         klass = Types.type_class(type)
-         #unless klass
-         #   errors << validate_error(:type_unknown, rule, "#{path}/type", type)
-         #end
-         #
-         if hash.key?('classname')
-            val = hash['classname']
-            unless val.nil? || type == 'map'
-               errors << validate_error(:classname_notmap, rule, "#{path}/classname", 'classname:')
-            end
-         end
-         #
-         if hash.key?('pattern')
-            val = hash['pattern']
-            pat = (val =~ /\A\/(.*)\/([mi]?[mi]?)\z/ ? $1 : val)
-            begin
-               Regexp.compile(pat)
-            rescue RegexpError => ex
-               errors << validate_error(:pattern_syntaxerr, rule, "#{path}/pattern", val)
-            end
-         end
-         #
-         if hash.key?('enum')
-            if Types.collection_type?(type)
-               errors << validate_error(:enum_notscalar, rule, path, 'enum:')
-            else
-               #elem_table = {}
-               hash['enum'].each do |elem|
-                  #if elem_table[elem]
-                  #   errors << validate_error(:enum_duplicate, rule, "#{path}/enum", elem.to_s)
-                  #end
-                  #elem_table[elem] = true
-                  unless elem.is_a?(klass)
-                     errors << validate_error(:enum_type_unmatch, rule, "#{path}/enum", elem, [Kwalify.word(type)])
-                  end
-               end
-            end
-         end
-         #
-         if hash.key?('assert')
-            val =  hash['assert']
-            #val =~ /\bval\b/ or errors << validate_error(:assert_noval, rule, "#{path}/assert", val)
-            begin
-               eval "proc { |val| #{val} }"
-            rescue SyntaxError => ex
-               errors << validate_error(:assert_syntaxerr, rule, "#{path}/assert", val)
-            end
-         end
-         #
-         if hash.key?('range')
-            val = hash['range']
-            curr_path = path + "/range"
-            #if ! val.is_a?(Hash)
-            #   errors << validate_error(:range_notmap, rule, curr_path, val)
-            #elsif ...
-            if Types.collection_type?(type) || type == 'bool' || type == 'any'
-               errors << validate_error(:range_notscalar, rule, path, 'range:')
-            else
-               val.each do |rkey, rval|
-                  #case rkey
-                  #when 'max', 'min', 'max-ex', 'min-ex'
-                     unless rval.is_a?(klass)
-                        typename = Kwalify.word(type) || type
-                        errors << validate_error(:range_type_unmatch, rule, "#{curr_path}/#{rkey}", rval, [typename])
-                     end
-                  #else
-                  #   errors << validate_error(:range_undefined, rule, curr_path, "#{rkey}:")
-                  #end
-               end
-            end
-            if val.key?('max') && val.key?('max-ex')
-               errors << validate_error(:range_twomax, rule, curr_path, nil)
-            end
-            if val.key?('min') && val.key?('min-ex')
-               errors << validate_error(:range_twomin, rule, curr_path, nil)
-            end
-            max, min, max_ex, min_ex = val['max'], val['min'], val['max-ex'], val['min-ex']
-            if max
-               if min && max < min
-                  errors << validate_error(:range_maxltmin, rule, curr_path, nil, [max, min])
-               elsif min_ex && max <= min_ex
-                  errors << validate_error(:range_maxleminex, rule, curr_path, nil, [max, min_ex])
-               end
-            elsif max_ex
-               if min && max_ex <= min
-                  errors << validate_error(:range_maxexlemin, rule, curr_path, nil, [max_ex, min])
-               elsif min_ex && max_ex <= min_ex
-                  errors << validate_error(:range_maxexleminex, rule, curr_path, nil, [max_ex, min_ex])
-               end
-            end
-         end
-         #
-         if hash.key?('length')
-            val = hash['length']
-            curr_path = path + "/length"
-            #val.is_a?(Hash) or errors << validate_error(:length_notmap, rule, curr_path, val)
-            unless type == 'str' || type == 'text'
-               errors << validate_error(:length_nottext, rule, path, 'length:')
-            end
-            #val.each do |lkey, lval|
-            #   #case lkey
-            #   #when 'max', 'min', 'max-ex', 'min-ex'
-            #      unless lval.is_a?(Integer)
-            #         errors << validate_error(:length_notint, rule, "#{curr_path}/#{lkey}", lval)
-            #      end
-            #   #else
-            #   #   errors << validate_error(:length_undefined, rule, curr_path, "#{lkey}:")
-            #   #end
+    def initialize(schema, &block)
+      super
+    end
+
+    def validate_hook(value, rule, path, errors)
+      return if value.nil?    ## realy?
+      return unless rule.name == "MAIN"
+      #
+      hash = value
+      type = hash['type']
+      type = Types::DEFAULT_TYPE if type.nil?
+      klass = Types.type_class(type)
+      #unless klass
+      #  errors << validate_error(:type_unknown, rule, "#{path}/type", type)
+      #end
+      #
+      if hash.key?('class')
+        val = hash['class']
+        unless val.nil? || type == 'map'
+          errors << validate_error(:class_notmap, rule, "#{path}/class", 'class:')
+        end
+      end
+      #
+      if hash.key?('pattern')
+        val = hash['pattern']
+        pat = (val =~ /\A\/(.*)\/([mi]?[mi]?)\z/ ? $1 : val)
+        begin
+          Regexp.compile(pat)
+        rescue RegexpError => ex
+          errors << validate_error(:pattern_syntaxerr, rule, "#{path}/pattern", val)
+        end
+      end
+      #
+      if hash.key?('enum')
+        if Types.collection_type?(type)
+          errors << validate_error(:enum_notscalar, rule, path, 'enum:')
+        else
+          #elem_table = {}
+          hash['enum'].each do |elem|
+            #if elem_table[elem]
+            #  errors << validate_error(:enum_duplicate, rule, "#{path}/enum", elem.to_s)
             #end
-            if val.key?('max') && val.key?('max-ex')
-               errors << validate_error(:length_twomax, rule, curr_path, nil)
-            end
-            if val.key?('min') && val.key?('min-ex')
-               errors << validate_error(:length_twomin, rule, curr_path, nil)
-            end
-            max, min, max_ex, min_ex = val['max'], val['min'], val['max-ex'], val['min-ex']
-            if max
-               if min && max < min
-                  errors << validate_error(:length_maxltmin, rule, curr_path, nil, [max, min])
-               elsif min_ex && max <= min_ex
-                  errors << validate_error(:length_maxleminex, rule, curr_path, nil, [max, min_ex])
-               end
-            elsif max_ex
-               if min && max_ex <= min
-                  errors << validate_error(:length_maxexlemin, rule, curr_path, nil, [max_ex, min])
-               elsif min_ex && max_ex <= min_ex
-                  errors << validate_error(:length_maxexleminex, rule, curr_path, nil, [max_ex, min_ex])
-               end
-            end
-         end
-         #
-         if hash.key?('unique')
-            if hash['unique'] && Types.collection_type?(type)
-               errors << validate_error(:unique_notscalar, rule, path, "unique:")
-            end
-            if path.empty?
-               errors << validate_error(:unique_onroot, rule, "/", "unique:")
-            end
-         end
-         #
-         if hash.key?('ident')
-            if hash['ident'] && Types.collection_type?(type)
-               errors << validate_error(:ident_notscalar, rule, path, "ident:")
-            end
-            if path.empty?
-               errors << validate_error(:ident_onroot, rule, "/", "ident:")
+            #elem_table[elem] = true
+            unless elem.is_a?(klass)
+              errors << validate_error(:enum_type_unmatch, rule, "#{path}/enum", elem, [Kwalify.word(type)])
             end
-         end
-         #
-         if hash.key?('sequence')
-            val = hash['sequence']
-            #if val != nil && !val.is_a?(Array)
-            #   errors << validate_error(:sequence_notseq,  rule, "#{path}/sequence", val)
-            #elsif ...
-            if val == nil || val.empty?
-               errors << validate_error(:sequence_noelem,  rule, "#{path}/sequence", val)
-            elsif val.length > 1
-               errors << validate_error(:sequence_toomany, rule, "#{path}/sequence", val)
-            else
-               elem = val[0]
-               assert_error("elem.class=#{elem.class}") unless elem.is_a?(Hash)
-               if elem['ident'] && elem['type'] != 'map'
-                  errors << validate_error(:ident_notmap, nil, "#{path}/sequence/0", 'ident:')
-               end
-            end
-         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? && !val.default)
-               errors << validate_error(:mapping_noelem, rule, "#{path}/mapping", val)
-            end
-         end
-         #
-         if type == 'seq'
-            errors << validate_error(:seq_nosequence, rule, path, nil)      unless hash.key?('sequence')
-            #errors << validate_error(:seq_conflict, rule, path, 'enum:')        if hash.key?('enum')
-            errors << validate_error(:seq_conflict, rule, path, 'pattern:')     if hash.key?('pattern')
-            errors << validate_error(:seq_conflict, rule, path, 'mapping:')     if hash.key?('mapping')
-            #errors << validate_error(:seq_conflict, rule, path, 'range:')       if hash.key?('range')
-            #errors << validate_error(:seq_conflict, rule, path, 'length:')      if hash.key?('length')
-         elsif type == 'map'
-            errors << validate_error(:map_nomapping, rule, path, nil)       unless hash.key?('mapping')
-            #errors << validate_error(:map_conflict, rule, path, 'enum:')        if hash.key?('enum')
-            errors << validate_error(:map_conflict, rule, path, 'pattern:')     if hash.key?('pattern')
-            errors << validate_error(:map_conflict, rule, path, 'sequence:')    if hash.key?('sequence')
-            #errors << validate_error(:map_conflict, rule, path, 'range:')       if hash.key?('range')
-            #errors << validate_error(:map_conflict, rule, path, 'length:')      if hash.key?('length')
-         else
-            errors << validate_error(:scalar_conflict, rule, path, 'sequence:') if hash.key?('sequence')
-            errors << validate_error(:scalar_conflict, rule, path, 'mapping:')  if hash.key?('mapping')
-            if hash.key?('enum')
-               errors << validate_error(:enum_conflict, rule, path, 'range:')   if hash.key?('range')
-               errors << validate_error(:enum_conflict, rule, path, 'length:')  if hash.key?('length')
-               errors << validate_error(:enum_conflict, rule, path, 'pattern:') if hash.key?('pattern')
-            end
-         end
-
-      end  # end of def validate_hook()
-
-
-      schema = YAML.load(META_SCHEMA)
-      @instance = MetaValidator.new(schema)
-
-      def self.instance()
-         return @instance
+          end
+        end
+      end
+      #
+      if hash.key?('assert')
+        val =  hash['assert']
+        #val =~ /\bval\b/ or errors << validate_error(:assert_noval, rule, "#{path}/assert", val)
+        begin
+          eval "proc { |val| #{val} }"
+        rescue ::SyntaxError => ex
+          errors << validate_error(:assert_syntaxerr, rule, "#{path}/assert", val)
+        end
+      end
+      #
+      if hash.key?('range')
+        val = hash['range']
+        curr_path = path + "/range"
+        #if ! val.is_a?(Hash)
+        #  errors << validate_error(:range_notmap, rule, curr_path, val)
+        #elsif ...
+        if Types.collection_type?(type) || type == 'bool' || type == 'any'
+          errors << validate_error(:range_notscalar, rule, path, 'range:')
+        else
+          val.each do |rkey, rval|
+            #case rkey
+            #when 'max', 'min', 'max-ex', 'min-ex'
+              unless rval.is_a?(klass)
+                typename = Kwalify.word(type) || type
+                errors << validate_error(:range_type_unmatch, rule, "#{curr_path}/#{rkey}", rval, [typename])
+              end
+            #else
+            #  errors << validate_error(:range_undefined, rule, curr_path, "#{rkey}:")
+            #end
+          end
+        end
+        if val.key?('max') && val.key?('max-ex')
+          errors << validate_error(:range_twomax, rule, curr_path, nil)
+        end
+        if val.key?('min') && val.key?('min-ex')
+          errors << validate_error(:range_twomin, rule, curr_path, nil)
+        end
+        max, min, max_ex, min_ex = val['max'], val['min'], val['max-ex'], val['min-ex']
+        if max
+          if min && max < min
+            errors << validate_error(:range_maxltmin, rule, curr_path, nil, [max, min])
+          elsif min_ex && max <= min_ex
+            errors << validate_error(:range_maxleminex, rule, curr_path, nil, [max, min_ex])
+          end
+        elsif max_ex
+          if min && max_ex <= min
+            errors << validate_error(:range_maxexlemin, rule, curr_path, nil, [max_ex, min])
+          elsif min_ex && max_ex <= min_ex
+            errors << validate_error(:range_maxexleminex, rule, curr_path, nil, [max_ex, min_ex])
+          end
+        end
+      end
+      #
+      if hash.key?('length')
+        val = hash['length']
+        curr_path = path + "/length"
+        #val.is_a?(Hash) or errors << validate_error(:length_notmap, rule, curr_path, val)
+        unless type == 'str' || type == 'text'
+          errors << validate_error(:length_nottext, rule, path, 'length:')
+        end
+        #val.each do |lkey, lval|
+        #  #case lkey
+        #  #when 'max', 'min', 'max-ex', 'min-ex'
+        #    unless lval.is_a?(Integer)
+        #      errors << validate_error(:length_notint, rule, "#{curr_path}/#{lkey}", lval)
+        #    end
+        #  #else
+        #  #  errors << validate_error(:length_undefined, rule, curr_path, "#{lkey}:")
+        #  #end
+        #end
+        if val.key?('max') && val.key?('max-ex')
+          errors << validate_error(:length_twomax, rule, curr_path, nil)
+        end
+        if val.key?('min') && val.key?('min-ex')
+          errors << validate_error(:length_twomin, rule, curr_path, nil)
+        end
+        max, min, max_ex, min_ex = val['max'], val['min'], val['max-ex'], val['min-ex']
+        if max
+          if min && max < min
+            errors << validate_error(:length_maxltmin, rule, curr_path, nil, [max, min])
+          elsif min_ex && max <= min_ex
+            errors << validate_error(:length_maxleminex, rule, curr_path, nil, [max, min_ex])
+          end
+        elsif max_ex
+          if min && max_ex <= min
+            errors << validate_error(:length_maxexlemin, rule, curr_path, nil, [max_ex, min])
+          elsif min_ex && max_ex <= min_ex
+            errors << validate_error(:length_maxexleminex, rule, curr_path, nil, [max_ex, min_ex])
+          end
+        end
+      end
+      #
+      if hash.key?('unique')
+        if hash['unique'] && Types.collection_type?(type)
+          errors << validate_error(:unique_notscalar, rule, path, "unique:")
+        end
+        if path.empty?
+          errors << validate_error(:unique_onroot, rule, "/", "unique:")
+        end
+      end
+      #
+      if hash.key?('ident')
+        if hash['ident'] && Types.collection_type?(type)
+          errors << validate_error(:ident_notscalar, rule, path, "ident:")
+        end
+        if path.empty?
+          errors << validate_error(:ident_onroot, rule, "/", "ident:")
+        end
+      end
+      #
+      if hash.key?('default')
+        val = hash['default']
+        if Types.collection_type?(type)
+          errors << validate_error(:default_notscalar, rule, path, "default:")
+        elsif !val.nil? && !val.is_a?(klass)
+          errors << validate_error(:default_unmatch, rule, "#{path}/default", val, [Kwalify.word(type)])
+        end
       end
+      #
+      if hash.key?('sequence')
+        val = hash['sequence']
+        #if !val.nil? && !val.is_a?(Array)
+        #  errors << validate_error(:sequence_notseq,  rule, "#{path}/sequence", val)
+        #elsif ...
+        if val.nil? || val.empty?
+          errors << validate_error(:sequence_noelem,  rule, "#{path}/sequence", val)
+        elsif val.length > 1
+          errors << validate_error(:sequence_toomany, rule, "#{path}/sequence", val)
+        else
+          elem = val[0]
+          assert_error("elem.class=#{elem.class}") unless elem.is_a?(Hash)
+          if elem['ident'] && elem['type'] != 'map'
+            errors << validate_error(:ident_notmap, nil, "#{path}/sequence/0", 'ident:')
+          end
+        end
+      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? && !val.default)
+          errors << validate_error(:mapping_noelem, rule, "#{path}/mapping", val)
+        end
+      end
+      #
+      if type == 'seq'
+        errors << validate_error(:seq_nosequence, rule, path, nil)    unless hash.key?('sequence')
+        #errors << validate_error(:seq_conflict, rule, path, 'enum:')      if hash.key?('enum')
+        errors << validate_error(:seq_conflict, rule, path, 'pattern:')    if hash.key?('pattern')
+        errors << validate_error(:seq_conflict, rule, path, 'mapping:')    if hash.key?('mapping')
+        #errors << validate_error(:seq_conflict, rule, path, 'range:')     if hash.key?('range')
+        #errors << validate_error(:seq_conflict, rule, path, 'length:')    if hash.key?('length')
+      elsif type == 'map'
+        errors << validate_error(:map_nomapping, rule, path, nil)     unless hash.key?('mapping')
+        #errors << validate_error(:map_conflict, rule, path, 'enum:')      if hash.key?('enum')
+        errors << validate_error(:map_conflict, rule, path, 'pattern:')    if hash.key?('pattern')
+        errors << validate_error(:map_conflict, rule, path, 'sequence:')   if hash.key?('sequence')
+        #errors << validate_error(:map_conflict, rule, path, 'range:')     if hash.key?('range')
+        #errors << validate_error(:map_conflict, rule, path, 'length:')    if hash.key?('length')
+      else
+        errors << validate_error(:scalar_conflict, rule, path, 'sequence:') if hash.key?('sequence')
+        errors << validate_error(:scalar_conflict, rule, path, 'mapping:')  if hash.key?('mapping')
+        if hash.key?('enum')
+          errors << validate_error(:enum_conflict, rule, path, 'range:')  if hash.key?('range')
+          errors << validate_error(:enum_conflict, rule, path, 'length:')  if hash.key?('length')
+          errors << validate_error(:enum_conflict, rule, path, 'pattern:') if hash.key?('pattern')
+        end
+        if hash.key?('default')
+          errors << validate_error(:default_conflict, rule, path, 'default:') if hash['required']
+        end
+      end
+
+    end  # end of def validate_hook()
 
 
-   end # end of class MetaValidator
+  end # end of class MetaValidator
 
 
-   META_VALIDATOR = MetaValidator.instance()
+  META_VALIDATOR = MetaValidator.instance()
 
-   def self.meta_validator           # obsolete
-      return META_VALIDATOR
-   end
+  def self.meta_validator        # obsolete
+    return META_VALIDATOR
+  end
 
 end