kwalify 0.2.0 → 0.3.0

data/lib/kwalify/rule.rb

@@ -1,6 +1,6 @@
 ###
-### $Rev: 18 $
-### $Release: 0.2.0 $
+### $Rev: 22 $
+### $Release: 0.3.0 $
 ### copyright(c) 2005 kuwata-lab all rights reserved.
 ###
 
@@ -13,14 +13,16 @@ module Kwalify
    class Rule
       include Kwalify::ErrorHelper
 
-      def initialize(hash=nil)
+      def initialize(hash=nil, parent=nil)
          configure(hash, "", {}) if hash
+         @parent = parent
       end
+      attr_accessor :parent
 
       def configure(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, "/", nil)
+            raise Kwalify.schema_error(:schema_notmap, nil, (!path || path.empty? ? "/" : path), nil)
          end
 
          rule = self
@@ -62,15 +64,22 @@ module Kwalify
 
             when "required"
                @required = val
-               unless val == nil || val.is_a?(Boolean)
+               unless val.is_a?(Boolean)  #|| val == nil
                   #* key=:required_notbool  msg="not a boolean."
                   raise schema_error(:required_notbool, rule, curr_path, val)
                end
 
             when "pattern"
-               pat = (val =~ /\A\/(.*)\/([mi]?[mi]?)\z/ ? $1 : val)
+               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)
+                  @pattern = Regexp.compile(pat, flag)
                rescue RegexpError => ex
                   #* key=:pattern_syntaxerr  msg="has regexp error."
                   raise schema_error(:pattern_syntaxerr, rule, curr_path, val)
@@ -100,6 +109,7 @@ module Kwalify
                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)
@@ -109,7 +119,6 @@ module Kwalify
                   raise schema_error(:assert_noval, rule, curr_path, val)
                end
                begin
-                  @assert = val
                   @assert_proc = eval "proc { |val| #{val} }"
                rescue SyntaxError => ex
                   #* key=:assert_syntaxerr  msg="expression syntax error."
@@ -128,7 +137,7 @@ module Kwalify
                end
                val.each do |rkey, rval|
                   case rkey
-                  when 'max', 'min'
+                  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."
@@ -139,6 +148,14 @@ module Kwalify
                      raise schema_error(:range_undefined, rule, curr_path, "#{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
@@ -152,7 +169,7 @@ module Kwalify
                end
                val.each do |lkey, lval|
                   case lkey
-                  when 'max', 'min'
+                  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)
@@ -162,6 +179,53 @@ module Kwalify
                      raise schema_error(:length_undefined, rule, curr_path, "#{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
+
+            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)
@@ -178,7 +242,7 @@ module Kwalify
                   elem ||= {}
                   i = 0   # or 1?  *index*
                   rule = rule_table[elem.__id__]
-                  rule ||= Rule.new.configure(elem, "#{curr_path}/#{i}", rule_table)
+                  rule ||= Rule.new(nil, self).configure(elem, "#{curr_path}/#{i}", rule_table)
                   @sequence = [ rule ]
                end
 
@@ -196,7 +260,7 @@ module Kwalify
                      #raise schema_error(:key_duplicate, rule, curr_path, key) if @mapping.key?(key)
                      elem ||= {}
                      rule = rule_table[elem.__id__]
-                     rule ||= Rule.new.configure(elem, "#{curr_path}/#{key}", rule_table)
+                     rule ||= Rule.new(nil, self).configure(elem, "#{curr_path}/#{key}", rule_table)
                      if key == '*'
                         @mapping.default = rule
                      else
@@ -259,6 +323,8 @@ module Kwalify
       attr_reader :assert_proc
       attr_reader :range
       attr_reader :length
+      attr_reader :ident
+      attr_reader :unique
 
 
       #def inspect()
@@ -280,6 +346,8 @@ module Kwalify
          str << "  " * level << "required:  #{@required}\n"         if @required != nil
          str << "  " * level << "pattern:   #{@pattern.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
          if @enum != nil
             str << "  " * level << "enum:\n"
             @enum.each do |item|
@@ -290,16 +358,20 @@ module Kwalify
             str << "  " * level
             str << "range:     { "
             str << "max: #{@range['max'].inspect}"  if @range['max'] != nil
-            str << ", "  if @range['max'] != nil && @range['min'] != 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
             str << "  " * level
             str << "length:     { "
             str << "max: #{@length['max'].inspect}"  if @length['max'] != nil
-            str << ", "  if @length['max'] != nil && @length['min'] != 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"
          end
          @sequence.each do |rule|

data/lib/kwalify/types.rb

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

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

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

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

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

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

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

data/lib/kwalify/validator.rb

@@ -1,6 +1,6 @@
 ###
-### $Rev: 18 $
-### $Release: 0.2.0 $
+### $Rev: 21 $
+### $Release: 0.3.0 $
 ### copyright(c) 2005 kuwata-lab all rights reserved.
 ###
 
@@ -123,6 +123,14 @@ module Kwalify
                #* key=:range_toosmall  msg="too small (< min %s)."
                errors << validate_error(:range_toosmall, rule, path, val, [rule.range['min'].to_s])
             end
+            if rule.range['max-ex'] && rule.range['max-ex'] <= val
+               #* key=:range_toolargeex  msg="too large (>= max %s)."
+               errors << validate_error(:range_toolargeex, rule, path, val, [rule.range['max-ex'].to_s])
+            end
+            if rule.range['min-ex'] && rule.range['min-ex'] >= val
+               #* key=:range_toosmallex  msg="too small (<= min %s)."
+               errors << validate_error(:range_toosmallex, rule, path, val, [rule.range['min-ex'].to_s])
+            end
          end
          if rule.length
             assert_error("val.class=#{val.class.name}") unless val.is_a?(String) || val.is_a?(Text)
@@ -135,6 +143,14 @@ module Kwalify
                #* key=:length_tooshort  msg="too short (length %d < min %d)."
                errors << validate_error(:length_tooshort, rule, path, val, [len, rule.length['min']])
             end
+            if rule.length['max-ex'] && rule.length['max-ex'] <= len
+               #* key=:length_toolongex  msg="too long (length %d >= max %d)."
+               errors << validate_error(:length_toolongex, rule, path, val, [len, rule.length['max-ex']])
+            end
+            if rule.length['min-ex'] && rule.length['min-ex'] >= len
+               #* key=:length_tooshortex  msg="too short (length %d <= min %d)."
+               errors << validate_error(:length_tooshortex, rule, path, val, [len, rule.length['min-ex']])
+            end
          end
       end
 
@@ -144,11 +160,41 @@ module Kwalify
          assert_error("seq_rule.sequence.length==#{seq_rule.sequence.length} (expected 1)") unless seq_rule.sequence.length == 1
          return if list == nil
          rule = seq_rule.sequence[0]
-         i = -1  # or 0?  *index*
-         list.each do |val|
-            i += 1
+         list.each_with_index do |val, i|
             _validate(val, rule, "#{path}/#{i}", errors, done)   ## validate recursively
          end
+         if rule.type == 'map'
+            unique_keys = []
+            rule.mapping.keys.each do |key|
+               map_rule = rule.mapping[key]
+               unique_keys << key if map_rule.unique || map_rule.ident
+            end
+            unique_keys.each do |key|
+               table = {}
+               list.each_with_index do |map, i|
+                  val = map[key]
+                  next if val == nil
+                  curr_path = "#{path}/#{i}/#{key}"
+                  if table[val]
+                     #* key=:value_notunique  msg="is already used at '%s'."
+                     errors << validate_error(:value_notunique, rule, "#{path}/#{i}/#{key}", val, "#{path}/#{table[val]}/#{key}")
+                  else
+                     table[val] = i
+                  end
+               end
+            end if !unique_keys.empty?
+         elsif rule.unique
+            table = {}
+            list.each_with_index do |val, i|
+               next if val == nil
+               if table[val]
+                  #  #* key=:value_notunique  msg="is already used at '%s'."
+                  errors << validate_error(:value_notunique, rule, "#{path}/#{i}", val, "#{path}/#{table[val]}")
+               else
+                  table[val] = i 
+               end
+            end
+         end
       end
 
 

data/test/test-metavalidator.rb

@@ -1,6 +1,6 @@
 ###
-### $Rev: 18 $
-### $Release: 0.2.0 $
+### $Rev: 21 $
+### $Release: 0.3.0 $
 ### copyright(c) 2005 kuwata-lab all rights reserved.
 ###
 
@@ -338,6 +338,20 @@ rule-msg: |
 #  :range_undefined    : [/range] key 'mim:' undefined key.
 #
 ---
+name:   range_twomax
+desc:   range_twomax
+#
+schema: |
+  type:  float
+  range: { max: 10.0, max-ex: 1.0 }
+#
+meta-msg: |
+  :range_twomax       : [/range] both 'max' and 'max-ex' are not available at once.
+#
+rule-msg: |
+  :range_twomax       : [/range] both 'max' and 'max-ex' are not available at once.
+#
+---
 name:  length_notmap
 desc:  length_notmap
 #
@@ -396,6 +410,20 @@ rule-msg: |
 #  :length_undefined   : [/length] key 'maximum:' is undefined.
 #
 ---
+name:   length_twomax
+desc:   length_twomax
+#
+schema: |
+  type:  str
+  length: { max: 10, max-ex: 1 }
+#
+meta-msg: |
+  :length_twomax      : [/length] both 'max' and 'max-ex' are not available at once.
+#
+rule-msg: |
+  :length_twomax      : [/length] both 'max' and 'max-ex' are not available at once.
+#
+---
 name:  sequence_notseq
 desc:  sequence_notseq
 #
@@ -606,3 +634,145 @@ rule-msg: |
 # :enum_conflict      : [/] 'length:': not available with 'enum:'.
 # :enum_conflict      : [/] 'pattern:': not available with 'enum:'.
 #
+---
+name:  unique_notbool
+desc:  unique_notbool
+#
+schema: |
+  type: seq
+  sequence:
+  - type: map
+    mapping:
+     "id":
+        type:    int
+        unique:  'yes'
+     "name":
+        type:    str
+#
+meta-msg: |
+  :type_unmatch       : [/sequence/0/mapping/id/unique] 'yes': not a boolean.
+#
+rule-msg: |
+  :unique_notbool     : [/sequence/0/mapping/id/unique] 'yes': not a boolean.
+#
+---
+name:  unique_notscalar
+desc:  unique_notscalar
+#
+schema: |
+  type: seq
+  sequence:
+  - type: map
+    mapping:
+     "id":
+        type:    int
+        unique:  yes
+     "values":
+        type:    seq
+        unique:  yes
+        sequence:
+          - type: str
+#
+meta-msg: |
+  :unique_notscalar   : [/sequence/0/mapping/values] 'unique:': is available only with a scalar type.
+#
+rule-msg: |
+  :unique_notscalar   : [/sequence/0/mapping/values] 'unique:': is available only with a scalar type.
+#
+---
+name:  unique_root
+desc:  unique_root
+#
+schema: |
+  type: str
+  unique: yes
+#
+meta-msg: |
+  :unique_onroot      : [/] 'unique:': is not available on root element.
+#
+rule-msg: |
+  :unique_onroot      : [/] 'unique:': is not available on root element.
+#
+---
+name:  ident_notbool
+desc:  ident_notbool
+#
+schema: |
+  type: seq
+  sequence:
+  - type: map
+    mapping:
+     "id":
+        type:    int
+        ident:  'yes'
+     "name":
+        type:    str
+#
+meta-msg: |
+  :type_unmatch       : [/sequence/0/mapping/id/ident] 'yes': not a boolean.
+#
+rule-msg: |
+  :ident_notbool      : [/sequence/0/mapping/id/ident] 'yes': not a boolean.
+#
+---
+name:  ident_notscalar
+desc:  ident_notscalar
+#
+schema: |
+  type: seq
+  sequence:
+  - type: map
+    mapping:
+     "id":
+        type:    int
+        ident:  yes
+     "values":
+        type:    seq
+        ident:  yes
+        sequence:
+          - type: str
+#
+meta-msg: |
+  :ident_notscalar    : [/sequence/0/mapping/values] 'ident:': is available only with a scalar type.
+#
+rule-msg: |
+  :ident_notscalar    : [/sequence/0/mapping/values] 'ident:': is available only with a scalar type.
+#
+---
+name:  ident_root
+desc:  ident_root
+#
+schema: |
+  type: str
+  ident: yes
+#
+meta-msg: |
+  :ident_onroot       : [/] 'ident:': is not available on root element.
+#
+rule-msg: |
+  :ident_onroot       : [/] 'ident:': is not available on root element.
+#
+---
+name:  ident_notmap
+desc:  ident_notmap
+#
+schema: |
+  type: seq
+  sequence:
+  - type: map
+    mapping:
+     "id":
+        type:    int
+        ident:  yes
+     "values":
+        type:    seq
+        sequence:
+          - type: str
+            ident: yes
+#
+meta-msg: |
+  :ident_notmap       : [/sequence/0/mapping/values/sequence/0] 'ident:': is available only with an element of mapping.
+#
+rule-msg: |
+  :ident_notmap       : [/sequence/0/mapping/values/sequence/0] 'ident:': is available only with an element of mapping.
+#