kwalify 0.4.1 → 0.5.0

data/lib/kwalify/messages.rb

@@ -1,6 +1,6 @@
 ###
-### $Rev: 22 $
-### $Release: 0.4.1 $
+### $Rev: 42 $
+### $Release: 0.5.0 $
 ### copyright(c) 2005 kuwata-lab all rights reserved.
 ###
 
@@ -14,26 +14,32 @@ module Kwalify
 
    
    ##----- begin
-   # filename: lib/kwalify/main-program.rb
-   @@messages[:action_required]      = "command-line option '-f' or '-m' required."
-   @@messages[:meta_schema_empty]    = "%s: empty.\n"
-   @@messages[:meta_validation_valid] = "%s: ok.\n"
-   @@messages[:meta_validation_invalid] = "%s: NG!\n"
+   # filename: lib/kwalify/main.rb
+   @@messages[:command_option_noaction] = "command-line option '-f' or '-m' required."
+   @@messages[:meta_empty]           = "%s: empty.\n"
+   @@messages[:meta_valid]           = "%s: ok.\n"
+   @@messages[:meta_invalid]         = "%s: NG!\n"
    @@messages[:schema_empty]         = "%s#%d: empty.\n"
    @@messages[:validation_valid]     = "%s#%d: valid.\n"
    @@messages[:validation_invalid]   = "%s#%d: INVALID\n"
+   @@messages[:command_property_invalid] = "%s: invalid property."
+   @@messages[:command_option_noarg] = "-%s: argument required."
+   @@messages[:command_option_noschema] = "-%s: schema filename required."
+   @@messages[:command_option_invalid] = "-%s: invalid command option."
    # --
    # filename: lib/kwalify/rule.rb
    @@messages[:schema_notmap]        = "schema definition is not a mapping."
+   @@messages[:key_unknown]          = "unknown key."
    @@messages[:type_notstr]          = "not a string."
    @@messages[:type_unknown]         = "unknown type."
    @@messages[:required_notbool]     = "not a boolean."
+   @@messages[:pattern_notstr]       = "not a string (or regexp)"
    @@messages[:pattern_notmatch]     = "should be '/..../'."
    @@messages[:pattern_syntaxerr]    = "has regexp error."
    @@messages[:enum_notseq]          = "not a sequence."
    @@messages[:enum_notscalar]       = "not available with seq or map."
-   @@messages[:enum_duplicate]       = "duplicated enum value."
    @@messages[:enum_type_unmatch]    = "%s type expected."
+   @@messages[:enum_duplicate]       = "duplicated enum value."
    @@messages[:assert_notstr]        = "not a string."
    @@messages[:assert_noval]         = "'val' is not used."
    @@messages[:assert_syntaxerr]     = "expression syntax error."
@@ -43,12 +49,20 @@ module Kwalify
    @@messages[:range_undefined]      = "undefined key."
    @@messages[:range_twomax]         = "both 'max' and 'max-ex' are not available at once."
    @@messages[:range_twomin]         = "both 'min' and 'min-ex' are not available at once."
+   @@messages[:range_maxltmin]       = "max '%s' is less than min '%s'."
+   @@messages[:range_maxleminex]     = "max '%s' is less than or equal to min-ex '%s'."
+   @@messages[:range_maxexlemin]     = "max-ex '%s' is less than or equal to min '%s'."
+   @@messages[:range_maxexleminex]   = "max-ex '%s' is less than or equal to min-ex '%s'."
    @@messages[:length_notmap]        = "not a mapping."
    @@messages[:length_nottext]       = "is available only with string or text."
    @@messages[:length_notint]        = "not an integer."
    @@messages[:length_undefined]     = "undefined key."
    @@messages[:length_twomax]        = "both 'max' and 'max-ex' are not available at once."
    @@messages[:length_twomin]        = "both 'min' and 'min-ex' are not available at once."
+   @@messages[:length_maxltmin]      = "max '%s' is less than min '%s'."
+   @@messages[:length_maxleminex]    = "max '%s' is less than or equal to min-ex '%s'."
+   @@messages[:length_maxexlemin]    = "max-ex '%s' is less than or equal to min '%s'."
+   @@messages[:length_maxexleminex]  = "max-ex '%s' is less than or equal to min-ex '%s'."
    @@messages[:ident_notbool]        = "not a boolean."
    @@messages[:ident_notscalar]      = "is available only with a scalar type."
    @@messages[:ident_onroot]         = "is not available on root element."
@@ -61,7 +75,6 @@ module Kwalify
    @@messages[:sequence_toomany]     = "required just one element."
    @@messages[:mapping_notmap]       = "not a mapping."
    @@messages[:mapping_noelem]       = "required at least one element."
-   @@messages[:key_unknown]          = "unknown key."
    @@messages[:seq_nosequence]       = "type 'seq' requires 'sequence:'."
    @@messages[:seq_conflict]         = "not available with sequence."
    @@messages[:map_nomapping]        = "type 'map' requires 'mapping:'."
@@ -87,6 +100,22 @@ module Kwalify
    @@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_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[:anchor_duplicated]    = "anchor '%s' is already used."
+   @@messages[:alias_extradata]      = "alias cannot take any data."
+   @@messages[:anchor_notfound]      = "anchor '%s' not found"
+   @@messages[:sequence_noitem]      = "sequence item is expected."
+   @@messages[:sequence_badindent]   = "illegal indent of sequence."
+   @@messages[:mapping_noitem]       = "mapping item is expected."
+   @@messages[:mapping_badindent]    = "illegal indent of mapping."
+   # --
    ##----- end
 
 

data/lib/kwalify/meta-validator.rb

@@ -1,6 +1,6 @@
 ###
-### $Rev: 35 $
-### $Release: 0.4.1 $
+### $Rev: 42 $
+### $Release: 0.5.0 $
 ### copyright(c) 2005 kuwata-lab all rights reserved.
 ###
 
@@ -11,7 +11,21 @@ require 'yaml'
 
 module Kwalify
 
-   META_SCHEMA = <<'END'
+
+   ##
+   ## 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
@@ -53,6 +67,7 @@ mapping:   &main-rule
     type:      seq
     sequence:
       - type:     scalar
+        unique:   yes
  "pattern":
     type:      str
  "assert":
@@ -69,8 +84,6 @@ mapping:   &main-rule
         type:     scalar
      "min-ex":
         type:     scalar
-     #complement":
-     #   type:     boolean
  "length":
     type:      map
     mapping:
@@ -106,18 +119,6 @@ mapping:   &main-rule
 END
 
 
-   ##
-   ## ex.
-   ##   meta_validator = Kwalify.meta_validator()
-   ##   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
       def initialize(schema, &block)
          super
       end
@@ -128,14 +129,11 @@ END
          #
          hash = value
          type = hash['type']
-         type = Kwalify::DEFAULT_TYPE if type == nil
-         unless type.is_a?(String)
-            errors << validate_error(:type_notstr, rule, "#{path}/type", type.to_s)
-         end
-         klass = Kwalify.get_type_class(type)
-         unless klass
-            errors << validate_error(:type_unknown, rule, "#{path}/type", type.to_s)
-         end
+         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?('pattern')
             val = hash['pattern']
@@ -148,15 +146,15 @@ END
          end
          #
          if hash.key?('enum')
-            if type == 'seq' || type == 'map'   # unless Kwalify.scalar_class?(klass)
+            if Types.collection_type?(type)
                errors << validate_error(:enum_notscalar, rule, path, 'enum:')
             else
-               elem_table = {}
+               #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
+                  #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
@@ -166,7 +164,7 @@ END
          #
          if hash.key?('assert')
             val =  hash['assert']
-            val =~ /\bval\b/ or errors << validate_error(:assert_noval, rule, "#{path}/assert", val)
+            #val =~ /\bval\b/ or errors << validate_error(:assert_noval, rule, "#{path}/assert", val)
             begin
                eval "proc { |val| #{val} }"
             rescue SyntaxError => ex
@@ -177,9 +175,10 @@ 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 type == 'seq' || type == 'map' || type == 'bool' || type == 'any'
+            #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|
@@ -200,35 +199,63 @@ 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)
+            #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
+            #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'] && (type == 'map' || type == 'seq')
+            if hash['unique'] && Types.collection_type?(type)
                errors << validate_error(:unique_notscalar, rule, path, "unique:")
             end
             if path.empty?
@@ -237,7 +264,7 @@ END
          end
          #
          if hash.key?('ident')
-            if hash['ident'] && (type == 'map' || type == 'seq')
+            if hash['ident'] && Types.collection_type?(type)
                errors << validate_error(:ident_notscalar, rule, path, "ident:")
             end
             if path.empty?
@@ -247,21 +274,18 @@ 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 val == nil || val.empty?
+            #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
-               child = hash['sequence'][0]
-               if child.is_a?(Hash)
-                  if child['ident'] && child['type'] != 'map'
-                     errors << validate_error(:ident_notmap, nil, "#{path}/sequence/0", 'ident:')
-                  end
-                  #if child['unique'] && child['type'] != 'map'
-                  #   errors << validate_error(:unique_notmap, nil, "#{path}/sequence/0", 'unique:')
-                  #end
+               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
@@ -281,14 +305,14 @@ END
             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')
+            #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')
+            #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')
@@ -301,13 +325,21 @@ END
 
       end  # end of def validate_hook()
 
+
+      schema = YAML.load(META_SCHEMA)
+      @instance = MetaValidator.new(schema)
+
+      def self.instance()
+         return @instance
+      end
+
+
    end # end of class MetaValidator
 
 
-   schema = YAML.load(META_SCHEMA)
-   META_VALIDATOR = MetaValidator.new(schema)
+   META_VALIDATOR = MetaValidator.instance()
 
-   def self.meta_validator
+   def self.meta_validator           # obsolete
       return META_VALIDATOR
    end
 

data/lib/kwalify/rule.rb

@@ -1,6 +1,6 @@
 ###
-### $Rev: 39 $
-### $Release: 0.4.1 $
+### $Rev: 42 $
+### $Release: 0.5.0 $
 ### copyright(c) 2005 kuwata-lab all rights reserved.
 ###
 
@@ -14,273 +14,375 @@ module Kwalify
       include Kwalify::ErrorHelper
 
       def initialize(hash=nil, parent=nil)
-         configure(hash, "", {}) if hash
+         init(hash, "", {}) if hash
          @parent = parent
       end
+
       attr_accessor :parent
+      #attr_reader   :id
+      attr_reader :name
+      attr_reader :desc
+      attr_reader :enum
+      attr_reader :required
+      attr_reader :type
+      attr_reader :type_class
+      attr_reader :pattern
+      attr_reader :regexp
+      attr_reader :sequence
+      attr_reader :mapping
+      attr_reader :assert
+      attr_reader :assert_proc
+      attr_reader :range
+      attr_reader :length
+      attr_reader :ident
+      attr_reader :unique
+
 
-      def configure(hash, path="", rule_table={})
+      def init(hash, path="", rule_table={})
          unless hash.is_a?(Hash)
             #* key=:schema_notmap  msg="schema definition is not a mapping."
             raise Kwalify.schema_error(:schema_notmap, nil, (!path || path.empty? ? "/" : path), nil)
          end
-
          rule = self
          rule_table[hash.__id__] = rule
+         ## 'type:' entry
+         _init_type_value(hash['type'], rule, path)
+         ## other entries
+         hash.each do |key, val|
+            code = key.intern
+            curr_path = "#{path}/#{key}"
+            case code
+            #when "id"
+            #   @id       = val
+            when :type      ;  # done
+            when :name      ;  _init_name_value(    val, rule, path)
+            when :desc      ;  _init_desc_value(    val, rule, path)
+            when :required  ;  _init_required_value(val, rule, path)
+            when :pattern   ;  _init_pattern_value( val, rule, path)
+            when :enum      ;  _init_enum_value(    val, rule, path)
+            when :assert    ;  _init_assert_value(  val, rule, path)
+            when :range     ;  _init_range_value(   val, rule, path)
+            when :length    ;  _init_length_value(  val, rule, path)
+            when :ident     ;  _init_ident_value(   val, rule, path)
+            when :unique    ;  _init_unique_value(  val, rule, path)
+            when :sequence  ;  _init_sequence_value(val, rule, path, rule_table)
+            when :mapping   ;  _init_mapping_value( val, rule, path, rule_table)
+            else
+               #* key=:key_unknown  msg="unknown key."
+               raise schema_error(:key_unknown, rule, curr_path, "#{key}:")
+            end
+         end
+         check_confliction(hash, rule, path)
+         return self
+      end # end of def init
+
+
+      private
 
-         ## 'type:'
-         @type = hash['type']
-         @type = Kwalify::DEFAULT_TYPE if @type == nil
+
+      def _init_type_value(val, rule, path)
+         @type = val
+         @type = Types::DEFAULT_TYPE if @type == nil
          unless @type.is_a?(String)
             #* key=:type_notstr  msg="not a string."
             raise schema_error(:type_notstr, rule, "#{path}/type", @type.to_s)
          end
-         @klass = Kwalify.get_type_class(@type)
-         #if @klass == nil
+         @type_class = Types.type_class(@type)
+         #if @type_class == nil
          #   begin
-         #      @klass = Kernel.const_get(@type)
+         #      @type_class = Kernel.const_get(@type)
          #   rescue NameError
          #   end
          #end
-         unless @klass
+         unless @type_class
             #* key=:type_unknown  msg="unknown type."
             raise schema_error(:type_unknown, rule, "#{path}/type", @type.to_s)
          end
+      end
 
-         ## other key
-         hash.each do |key, val|
-            curr_path = "#{path}/#{key}"
-            case key
-            #when "id"
-            #   @id       = val
-            when "name"
-               @name = val
 
-            when "desc"
-               @desc = val
+      def _init_name_value(val, rule, path)
+         @name = val
+      end
 
-            when "type"
-               # done
 
-            when "required"
-               @required = val
-               unless val.is_a?(Boolean)  #|| val == nil
-                  #* key=:required_notbool  msg="not a boolean."
-                  raise schema_error(:required_notbool, rule, curr_path, val)
-               end
+      def _init_desc_value(val, rule, path)
+         @desc = val
+      end
 
-            when "pattern"
-               unless val =~ /\A\/(.*)\/([mi]?[mi]?)\z/
-                  #* key=:pattern_notmatch  msg="should be '/..../'."
-                  raise schema_error(:pattern_notmatch, rule, curr_path, val)
-               end
-               pat = $1; opt = $2
-               flag = 0
-               flag += Regexp::IGNORECASE if opt.include?("i")
-               flag += Regexp::MULTILINE  if opt.include?("m")
-               begin
-                  @pattern = Regexp.compile(pat, flag)
-               rescue RegexpError => ex
-                  #* key=:pattern_syntaxerr  msg="has regexp error."
-                  raise schema_error(:pattern_syntaxerr, rule, curr_path, val)
-               end
 
-            when "enum"
-               @enum = val
-               unless val.is_a?(Array)
-                  #* key=:enum_notseq  msg="not a sequence."
-                  raise schema_error(:enum_notseq, rule, curr_path, val)
-               end
-               if @type == 'seq' || @type == 'map'   # unless Kwalify.scalar_class?(@klass)
-                  #* key=:enum_notscalar  msg="not available with seq or map."
-                  raise schema_error(:enum_notscalar, rule, path, 'enum:')
-               end
-               elem_table = {}
-               @enum.each do |elem|
-                  unless !elem_table[elem]
-                     #* key=:enum_duplicate  msg="duplicated enum value."
-                     raise schema_error(:enum_duplicate, rule, curr_path, elem.to_s)
-                  end
-                  elem_table[elem] = true
-                  unless elem.is_a?(@klass)
-                     #* key=:enum_type_unmatch  msg="%s type expected."
-                     raise schema_error(:enum_type_unmatch, rule, curr_path, elem, [Kwalify.word(@type)])
-                  end
-               end
+      def _init_required_value(val, rule, path)
+         @required = val
+         unless val.is_a?(Boolean)  #|| val == nil
+            #* key=:required_notbool  msg="not a boolean."
+            raise schema_error(:required_notbool, rule, "#{path}/required", val)
+         end
+      end
 
-            when "assert"   # or "cond-expr" ?
-               @assert = val
-               unless val.is_a?(String)
-                  #* key=:assert_notstr  msg="not a string."
-                  raise schema_error(:assert_notstr, rule, curr_path, val)
-               end
-               unless val =~ /\bval\b/
-                  #* key=:assert_noval  msg="'val' is not used."
-                  raise schema_error(:assert_noval, rule, curr_path, val)
-               end
-               begin
-                  @assert_proc = eval "proc { |val| #{val} }"
-               rescue SyntaxError => ex
-                  #* key=:assert_syntaxerr  msg="expression syntax error."
-                  raise schema_error(:assert_syntaxerr, rule, curr_path, val)
-               end
+      def _init_pattern_value(val, rule, path)
+         @pattern = val
+         unless val.is_a?(String) || val.is_a?(Regexp)
+            #* key=:pattern_notstr  msg="not a string (or regexp)"
+            raise schema_error(:pattern_notstr, rule, "#{path}/pattern", val)
+         end
+         unless val =~ /\A\/(.*)\/([mi]?[mi]?)\z/
+            #* key=:pattern_notmatch  msg="should be '/..../'."
+            raise schema_error(:pattern_notmatch, rule, "#{path}/pattern", val)
+         end
+         pat = $1; opt = $2
+         flag = 0
+         flag += Regexp::IGNORECASE if opt.include?("i")
+         flag += Regexp::MULTILINE  if opt.include?("m")
+         begin
+            @regexp = Regexp.compile(pat, flag)
+         rescue RegexpError => ex
+            #* key=:pattern_syntaxerr  msg="has regexp error."
+            raise schema_error(:pattern_syntaxerr, rule, "#{path}/pattern", val)
+         end
+      end
 
-            when "range"
-               @range = val
-               unless val.is_a?(Hash)
-                  #* key=:range_notmap  msg="not a mapping."
-                  raise schema_error(:range_notmap, rule, curr_path, val)
-               end
-               if @type == 'map' || @type == 'seq' || @type == 'bool'
-                  #* key=:range_notscalar  msg="is available only with scalar type."
-                  raise schema_error(:range_notscalar, rule, path, 'range:')
-               end
-               val.each do |rkey, rval|
-                  case rkey
-                  when 'max', 'min', 'max-ex', 'min-ex'
-                     unless rval.is_a?(@klass)
-                        typename = Kwalify.word(@type) || @type
-                        #* key=:range_type_unmatch  msg="not a %s."
-                        raise schema_error(:range_type_unmatch, rule, "#{curr_path}/#{rkey}", rval, [typename])
-                     end
-                  else
-                     #* key=:range_undefined  msg="undefined key."
-                     raise schema_error(:range_undefined, rule, "#{curr_path}/#{rkey}", "#{rkey}:")
-                  end
-               end
-               if val.key?('max') && val.key?('max-ex')
-                  #* key=:range_twomax msg="both 'max' and 'max-ex' are not available at once."
-                  raise schema_error(:range_twomax, rule, curr_path, nil)
-               end
-               if val.key?('min') && val.key?('min-ex')
-                  #* key=:range_twomin msg="both 'min' and 'min-ex' are not available at once."
-                  raise schema_error(:range_twomin, rule, curr_path, nil)
-               end
 
-            when "length"   # or "width"
-               @length = val
-               unless val.is_a?(Hash)
-                  #* key=:length_notmap  msg="not a mapping."
-                  raise schema_error(:length_notmap, rule, curr_path, val)
-               end
-               unless @type == 'str' || @type == 'text'
-                  #* key=:length_nottext  msg="is available only with string or text."
-                  raise schema_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)
-                        #* key=:length_notint  msg="not an integer."
-                        raise schema_error(:length_notint, rule, "#{curr_path}/#{lkey}", lval)
-                     end
-                  else
-                     #* key=:length_undefined  msg="undefined key."
-                     raise schema_error(:length_undefined, rule, "#{curr_path}/#{lkey}", "#{lkey}:")
-                  end
-               end
-               if val.key?('max') && val.key?('max-ex')
-                  #* key=:length_twomax msg="both 'max' and 'max-ex' are not available at once."
-                  raise schema_error(:length_twomax, rule, curr_path, nil)
-               end
-               if val.key?('min') && val.key?('min-ex')
-                  #* key=:length_twomin msg="both 'min' and 'min-ex' are not available at once."
-                  raise schema_error(:length_twomin, rule, curr_path, nil)
-               end
+      def _init_enum_value(val, rule, path)
+         @enum = val
+         unless val.is_a?(Array)
+            #* key=:enum_notseq  msg="not a sequence."
+            raise schema_error(:enum_notseq, rule, "#{path}/enum", val)
+         end
+         if Types.collection_type?(@type)   # unless Kwalify.scalar_class?(@type_class)
+            #* key=:enum_notscalar  msg="not available with seq or map."
+            raise schema_error(:enum_notscalar, rule, path, 'enum:')
+         end
+         elem_table = {}
+         @enum.each do |elem|
+            unless elem.is_a?(@type_class)
+               #* key=:enum_type_unmatch  msg="%s type expected."
+               raise schema_error(:enum_type_unmatch, rule, "#{path}/enum", elem, [Kwalify.word(@type)])
+            end
+            if elem_table[elem]
+               #* key=:enum_duplicate  msg="duplicated enum value."
+               raise schema_error(:enum_duplicate, rule, "#{path}/enum", elem.to_s)
+            end
+            elem_table[elem] = true
+         end
+      end
 
-            when "ident"
-               @ident = val
-               @required = true
-               unless val.is_a?(Boolean)
-                  #* key=:ident_notbool  msg="not a boolean."
-                  raise schema_error(:ident_notbool, rule, curr_path, val)
-               end
-               if @type == 'map' || @type == 'seq'
-                  #* key=:ident_notscalar  msg="is available only with a scalar type."
-                  raise schema_error(:ident_notscalar, rule, path, "ident:")
-               end
-               if path.empty?
-                  #* key=:ident_onroot  msg="is not available on root element."
-                  raise schema_error(:ident_onroot, rule, "/", "ident:")
-               end
-               unless @parent && @parent.type == 'map'
-                  #* key=:ident_notmap  msg="is available only with an element of mapping."
-                  raise schema_error(:ident_notmap, rule, path, "ident:")
-               end
 
-            when "unique"
-               @unique = val
-               unless val.is_a?(Boolean)
-                  #* key=:unique_notbool  msg="not a boolean."
-                  raise schema_error(:unique_notbool, rule, curr_path, val)
-               end
-               if @type == 'map' || @type == 'seq'
-                  #* key=:unique_notscalar  msg="is available only with a scalar type."
-                  raise schema_error(:unique_notscalar, rule, path, "unique:")
-               end
-               if path.empty?
-                  #* key=:unique_onroot  msg="is not available on root element."
-                  raise schema_error(:unique_onroot, rule, "/", "unique:")
-               end
-               #unless @parent && @parent.type == 'map'
-               #   #* key=:unique_notmap  msg="is available only with an element of mapping."
-               #   raise schema_error(:unique_notmap, rule, path, "unique:")
-               #end
-
-            when "sequence"
-               if val != nil && !val.is_a?(Array)
-                  #* key=:sequence_notseq  msg="not a sequence."
-                  raise schema_error(:sequence_notseq, rule, curr_path, val)
-               elsif val == nil || val.empty?
-                  #* key=:sequence_noelem  msg="required one element."
-                  raise schema_error(:sequence_noelem, rule, curr_path, val)
-               elsif val.length > 1
-                  #* key=:sequence_toomany  msg="required just one element."
-                  raise schema_error(:sequence_toomany, rule, curr_path, val)
-               else
-                  elem = val[0]
-                  elem ||= {}
-                  i = 0   # or 1?  *index*
-                  rule = rule_table[elem.__id__]
-                  rule ||= Rule.new(nil, self).configure(elem, "#{curr_path}/#{i}", rule_table)
-                  @sequence = [ rule ]
-               end
+      def _init_assert_value(val, rule, path)
+         @assert = val
+         unless val.is_a?(String)
+            #* key=:assert_notstr  msg="not a string."
+            raise schema_error(:assert_notstr, rule, "#{path}/assert", val)
+         end
+         unless val =~ /\bval\b/
+            #* key=:assert_noval  msg="'val' is not used."
+            raise schema_error(:assert_noval, rule, "#{path}/assert", val)
+         end
+         begin
+            @assert_proc = eval "proc { |val| #{val} }"
+         rescue SyntaxError => ex
+            #* key=:assert_syntaxerr  msg="expression syntax error."
+            raise schema_error(:assert_syntaxerr, rule, "#{path}/assert", val)
+         end
+      end
 
-            when "mapping"
-               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? && !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 == '='
-                        @mapping.default = rule
-                     else
-                        @mapping[key] = rule
-                     end
-                  end if val
+
+      def _init_range_value(val, rule, path)
+         @range = val
+         curr_path = "#{path}/range"
+         unless val.is_a?(Hash)
+            #* key=:range_notmap  msg="not a mapping."
+            raise schema_error(:range_notmap, rule, curr_path, val)
+         end
+         if Types.collection_type?(@type) || @type == 'bool'
+            #* key=:range_notscalar  msg="is available only with scalar type."
+            raise schema_error(:range_notscalar, rule, path, 'range:')
+         end
+         val.each do |k, v|
+            case k
+            when 'max', 'min', 'max-ex', 'min-ex'
+               unless v.is_a?(@type_class)
+                  typename = Kwalify.word(@type) || @type
+                  #* key=:range_type_unmatch  msg="not a %s."
+                  raise schema_error(:range_type_unmatch, rule, "#{curr_path}/#{k}", v, [typename])
                end
+            else
+               #* key=:range_undefined  msg="undefined key."
+               raise schema_error(:range_undefined, rule, "#{curr_path}/#{k}", "#{k}:")
+            end
+         end
+         if val.key?('max') && val.key?('max-ex')
+            #* key=:range_twomax  msg="both 'max' and 'max-ex' are not available at once."
+            raise schema_error(:range_twomax, rule, curr_path, nil)
+         end
+         if val.key?('min') && val.key?('min-ex')
+            #* key=:range_twomin  msg="both 'min' and 'min-ex' are not available at once."
+            raise schema_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
+               #* key=:range_maxltmin  msg="max '%s' is less than min '%s'."
+               raise validate_error(:range_maxltmin, rule, curr_path, nil, [max, min])
+            elsif min_ex && max <= min_ex
+               #* key=:range_maxleminex  msg="max '%s' is less than or equal to min-ex '%s'."
+               raise validate_error(:range_maxleminex, rule, curr_path, nil, [max, min_ex])
+            end
+         elsif max_ex
+            if min && max_ex <= min
+               #* key=:range_maxexlemin msg="max-ex '%s' is less than or equal to min '%s'."
+               raise validate_error(:range_maxexlemin, rule, curr_path, nil, [max_ex, min])
+            elsif min_ex && max_ex <= min_ex
+               #* key=:range_maxexleminex msg="max-ex '%s' is less than or equal to min-ex '%s'."
+               raise validate_error(:range_maxexleminex, rule, curr_path, nil, [max_ex, min_ex])
+            end
+         end
+      end
 
+
+      def _init_length_value(val, rule, path)
+         @length = val
+         curr_path = "#{path}/length"
+         unless val.is_a?(Hash)
+            #* key=:length_notmap  msg="not a mapping."
+            raise schema_error(:length_notmap, rule, curr_path, val)
+         end
+         unless @type == 'str' || @type == 'text'
+            #* key=:length_nottext  msg="is available only with string or text."
+            raise schema_error(:length_nottext, rule, path, 'length:')
+         end
+         val.each do |k, v|
+            case k
+            when 'max', 'min', 'max-ex', 'min-ex'
+               unless v.is_a?(Integer)
+                  #* key=:length_notint  msg="not an integer."
+                  raise schema_error(:length_notint, rule, "#{curr_path}/#{k}", v)
+               end
             else
-               #* key=:key_unknown  msg="unknown key."
-               raise schema_error(:key_unknown, rule, curr_path, "#{key}:")
+               #* key=:length_undefined  msg="undefined key."
+               raise schema_error(:length_undefined, rule, "#{curr_path}/#{k}", "#{k}:")
+            end
+         end
+         if val.key?('max') && val.key?('max-ex')
+            #* key=:length_twomax msg="both 'max' and 'max-ex' are not available at once."
+            raise schema_error(:length_twomax, rule, curr_path, nil)
+         end
+         if val.key?('min') && val.key?('min-ex')
+            #* key=:length_twomin msg="both 'min' and 'min-ex' are not available at once."
+            raise schema_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
+               #* key=:length_maxltmin  msg="max '%s' is less than min '%s'."
+               raise validate_error(:length_maxltmin, rule, curr_path, nil, [max, min])
+            elsif min_ex && max <= min_ex
+               #* key=:length_maxleminex  msg="max '%s' is less than or equal to min-ex '%s'."
+               raise validate_error(:length_maxleminex, rule, curr_path, nil, [max, min_ex])
+            end
+         elsif max_ex
+            if min && max_ex <= min
+               #* key=:length_maxexlemin  msg="max-ex '%s' is less than or equal to min '%s'."
+               raise validate_error(:length_maxexlemin, rule, curr_path, nil, [max_ex, min])
+            elsif min_ex && max_ex <= min_ex
+               #* key=:length_maxexleminex  msg="max-ex '%s' is less than or equal to min-ex '%s'."
+               raise validate_error(:length_maxexleminex, rule, curr_path, nil, [max_ex, min_ex])
+            end
+         end
+      end
+
+
+      def _init_ident_value(val, rule, path)
+         @ident = val
+         @required = true
+         unless val.is_a?(Boolean)
+            #* key=:ident_notbool  msg="not a boolean."
+            raise schema_error(:ident_notbool, rule, "#{path}/ident", val)
+         end
+         if @type == 'map' || @type == 'seq'
+            #* key=:ident_notscalar  msg="is available only with a scalar type."
+            raise schema_error(:ident_notscalar, rule, path, "ident:")
+         end
+         if path.empty?
+            #* key=:ident_onroot  msg="is not available on root element."
+            raise schema_error(:ident_onroot, rule, "/", "ident:")
+         end
+         unless @parent && @parent.type == 'map'
+            #* key=:ident_notmap  msg="is available only with an element of mapping."
+            raise schema_error(:ident_notmap, rule, path, "ident:")
+         end
+      end
+
+
+      def _init_unique_value(val, rule, path)
+         @unique = val
+         unless val.is_a?(Boolean)
+            #* key=:unique_notbool  msg="not a boolean."
+            raise schema_error(:unique_notbool, rule, "#{path}/unique", val)
+         end
+         if @type == 'map' || @type == 'seq'
+            #* key=:unique_notscalar  msg="is available only with a scalar type."
+            raise schema_error(:unique_notscalar, rule, path, "unique:")
+         end
+         if path.empty?
+            #* key=:unique_onroot  msg="is not available on root element."
+            raise schema_error(:unique_onroot, rule, "/", "unique:")
+         end
+      end
+
+
+      def _init_sequence_value(val, rule, path, rule_table)
+         if val != nil && !val.is_a?(Array)
+            #* key=:sequence_notseq  msg="not a sequence."
+            raise schema_error(:sequence_notseq, rule, "#{path}/sequence", val)
+         elsif val == nil || val.empty?
+            #* key=:sequence_noelem  msg="required one element."
+            raise schema_error(:sequence_noelem, rule, "#{path}/sequence", val)
+         elsif val.length > 1
+            #* key=:sequence_toomany  msg="required just one element."
+            raise schema_error(:sequence_toomany, rule, "#{path}/sequence", val)
+         else
+            elem = val[0]
+            elem ||= {}
+            i = 0   # or 1?  *index*
+            rule = rule_table[elem.__id__]
+            rule ||= Rule.new(nil, self).init(elem, "#{path}/sequence/#{i}", rule_table)
+            @sequence = [ rule ]
+         end
+      end
+
+
+      def _init_mapping_value(val, rule, path, rule_table)
+         if val != nil && !val.is_a?(Hash)
+            #* key=:mapping_notmap  msg="not a mapping."
+            raise schema_error(:mapping_notmap, rule, "#{path}/mapping", val)
+         elsif val == nil || (val.empty? && !val.default)
+            #* key=:mapping_noelem  msg="required at least one element."
+            raise schema_error(:mapping_noelem, rule, "#{path}/mapping", val)
+         else
+            @mapping = {}
+            if val.default
+               elem = val.default  # hash
+               rule = rule_table[elem.__id__]
+               rule ||= Rule.new(nil, self).init(elem, "#{path}/mapping/=", rule_table)
+               @mapping.default = rule
             end
+            val.each do |k, v|
+               ##* key=:key_duplicate  msg="key duplicated."
+               #raise schema_error(:key_duplicate, rule, "#{path}/mapping", key) if @mapping.key?(key)
+               v ||= {}
+               rule = rule_table[v.__id__]
+               rule ||= Rule.new(nil, self).init(v, "#{path}/mapping/#{k}", rule_table)
+               if k == '='
+                  @mapping.default = rule
+               else
+                  @mapping[k] = rule
+               end
+            end if val
          end
+      end
 
+
+      def check_confliction(hash, rule, path)
          if @type == 'seq'
             #* key=:seq_nosequence  msg="type 'seq' requires 'sequence:'."
             raise schema_error(:seq_nosequence, rule, path, nil) unless hash.key?('sequence')
@@ -310,28 +412,7 @@ module Kwalify
                raise schema_error(:enum_conflict, rule, path, 'pattern:') if @pattern
             end
          end
-
-         return self
-
-      end # end of def configure
-
-      #attr_reader   :id
-      attr_reader :name
-      attr_reader :desc
-      attr_reader :enum
-      attr_reader :required
-      attr_reader :type
-      attr_reader :klass
-      attr_reader :pattern
-      attr_reader :sequence
-      attr_reader :mapping
-      attr_reader :assert
-      attr_reader :assert_proc
-      attr_reader :range
-      attr_reader :length
-      attr_reader :ident
-      attr_reader :unique
-
+      end
 
       #def inspect()
       #   str = "";  level = 0;  done = {}
@@ -340,7 +421,7 @@ module Kwalify
       #end
 
 
-      #protected
+      protected
 
 
       def _inspect(str="", level=0, done={})
@@ -348,9 +429,9 @@ module Kwalify
          str << "  " * level << "name:      #{@name}\n"             if @name     != nil
          str << "  " * level << "desc:      #{@desc}\n"             if @desc     != nil
          str << "  " * level << "type:      #{@type}\n"             if @type     != nil
-         str << "  " * level << "klass:     #{@klass.name}\n"       if @klass    != nil
+         str << "  " * level << "klass:     #{@type_class.name}\n"  if @type_class    != nil
          str << "  " * level << "required:  #{@required}\n"         if @required != nil
-         str << "  " * level << "pattern:   #{@pattern.inspect}\n"  if @pattern  != nil
+         str << "  " * level << "pattern:   #{@regexp.inspect}\n"   if @pattern  != nil
          str << "  " * level << "assert:    #{@assert}\n"           if @assert   != nil
          str << "  " * level << "ident:     #{@ident}\n"            if @ident    != nil
          str << "  " * level << "unique:    #{@unique}\n"           if @unique   != nil
@@ -360,25 +441,31 @@ module Kwalify
                str << "  " * (level+1) << "- #{item}\n"
             end
          end
-         if @range  != nil
+         if @range != nil
             str << "  " * level
             str << "range:     { "
-            str << "max: #{@range['max'].inspect}"  if @range['max'] != nil
-            str << "max-ex: #{@range['max-ex'].inspect}"  if @range['max-ex'] != nil
-            str << ", "  if (@range['max'] || @range['max-ex']) && (@range['min'] || @range['min-ex'])
-            str << "min: #{@range['min'].inspect}"  if @range['min'] != nil
-            str << "min-ex: #{@range['min-ex'].inspect}"  if @range['min-ex'] != nil
-            str << "}\n"
-         end
-         if @length  != nil
+            colon = ""
+            %w[max max-ex min min-ex].each do |key|
+               val = @range[key]
+               if val != nil
+                  str << colon << "#{key}: #{val.inspect}"
+                  colon = ", "
+               end
+            end
+            str << " }\n"
+         end
+         if @length != nil
             str << "  " * level
             str << "length:     { "
-            str << "max: #{@length['max'].inspect}"  if @length['max'] != nil
-            str << "max-ex: #{@length['max-ex'].inspect}"  if @length['max-ex'] != nil
-            str << ", "  if (@length['max'] || @length['max-ex']) && (@length['min'] || @length['min-ex'])
-            str << "min: #{@length['min'].inspect}"  if @length['min'] != nil
-            str << "min-ex: #{@length['min-ex'].inspect}"  if @length['min-ex'] != nil
-            str << "}\n"
+            colon = ""
+            %w[max max-ex min min-ex].each do |key|
+               val = @length[key]
+               if val != nil
+                  str << colon << "#{key}: #{val.inspect}"
+                  colon = ", "
+               end
+            end
+            str << " }\n"
          end
          @sequence.each do |rule|
             if done[rule.__id__]