kwalify 0.1.0 → 0.2.0

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

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

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

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

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

@@ -1,6 +1,6 @@
 ###
-### $Rev: 7 $
-### $Release: 0.1.0 $
+### $Rev: 10 $
+### $Release: 0.2.0 $
 ### copyright(c) 2005 kuwata-lab all rights reserved.
 ###
 
@@ -12,7 +12,7 @@ module YamlHelper
    ## expand tab character to spaces
    ##
    ## ex.
-   ##   untabified_str = YAML::Helper.untabify(tabbed_str)
+   ##   untabified_str = YamlHelper.untabify(tabbed_str)
    ##
    ## input:: String or IO
    ##
@@ -34,7 +34,7 @@ module YamlHelper
    ##     { "name"=>"Bar", "gender"=>"F", "age"=>25, },
    ##     { "name"=>"Baz", "gender"=>"M", "age"=>30, },
    ##   ]
-   ##   hashtable = YAML::Helper.create_hashtable(hashlist, "name")
+   ##   hashtable = YamlHelper.create_hashtable(hashlist, "name")
    ##   p hashtable
    ##       # => { "Foo" => { "name"=>"Foo", "gender"=>"M", "age"=>20, },
    ##              "Bar" => { "name"=>"Bar", "gender"=>"F", "age"=>25, },
@@ -60,7 +60,7 @@ module YamlHelper
    ## get nested value directly.
    ##
    ## ex.
-   ##   val = YAML::Helper.get_value(obj, ['aaa', 0, 'xxx'])
+   ##   val = YamlHelper.get_value(obj, ['aaa', 0, 'xxx'])
    ##
    ## This is equal to the following:
    ##   begin
@@ -72,8 +72,8 @@ module YamlHelper
    def self.get_value(obj, path)
       val = obj
       path.each do |key|
+         return nil unless val.is_a?(Hash) || val.is_a?(Array)
          val = val[key]
-         return val unless val
       end if path
       return val
    end

data/lib/kwalify/validator.rb

@@ -1,286 +1,179 @@
 ###
-### $Rev: 9 $
-### $Release: 0.1.0 $
+### $Rev: 18 $
+### $Release: 0.2.0 $
 ### copyright(c) 2005 kuwata-lab all rights reserved.
 ###
 
-require 'kwalify/error-msg'
+require 'kwalify/messages'
 require 'kwalify/errors'
 require 'kwalify/types'
-require 'pp'
+require 'kwalify/rule'
 
 module Kwalify
 
 
    ##
    ## ex.
-   ##   s = File.read('schema.yaml')
-   ##   validator = Kwalify::Validator.new(YAML.load(s))
-   ##   s = File.read('document.yaml')
-   ##   document = YAML.load(s)
+   ##   schema = YAML.load_file('schema.yaml')
+   ##   validator = Kwalify::Validator.new(schema)
+   ##   document = YAML.load_file('document.yaml')
    ##   error_list = validator.validate(document)
    ##   unless error_list.empty?
-   ##      error_list.each { |error| print error.message }
+   ##     error_list.each do |error|
+   ##       puts "- [#{error.path}] #{error.message}"
+   ##     end
    ##   end
    ##
    class Validator
+      include Kwalify::ErrorHelper
+
       def initialize(hash, &block)
-         raise KwalifyError.new("Validator#initalize(arg): arg is not a hash(==#{hash.class.name}).") unless hash.is_a?(Hash)
-         @schema = Schema.new(hash)
+         @rule  = Rule.new(hash)
          @block = block
       end
-      attr_reader :schema
+      attr_reader :rule
 
-      def validate(obj)
-         @schema.validate(obj, &@block)
-      end
 
-      def inspect
-         @schema.inspect
+      def _inspect
+         @rule._inspect
       end
-   end
-
-
-   class Schema
-      include Kwalify::Errors
-
-      def initialize(hash, path="", schema_table={})
-         schema_table[hash.__id__] = self
-         hash.each do |key, val|
-            case key
-            #when "id"
-            #   @id       = val
-            when "name"
-               @name = val.to_s
-            when "desc"
-               @desc = val.to_s
-            when "type"
-               @type  = val
-               @klass = Kwalify::type_table[val.downcase]
-               if @klass == nil
-                  begin
-                     @klass = Kernel.const_get(val)
-                  rescue NameError
-                     raise schema_error(:type_not_found, self, path)
-                  end
-               end
-            when "required"
-               unless val.is_a?(Boolean)
-                  raise schema_error(:required_not_boolean, self, path)
-               else
-                  @required = val
-               end
-            when "pattern"
-               pat = (val =~ /\A\/(.*)\/\z/ ? $1 : val)
-               begin
-                  @pattern = Regexp.compile(pat)
-               rescue RegexpError => ex
-                  raise schema_error(:regexp_error, self, path)
-               end
-            when "enum"
-               unless val.is_a?(Array)
-                  raise schema_error(:enum_not_seq, self, path)
-               else
-                  @enum = val
-               end
-            when "sequence"
-               if !val.is_a?(Array)
-                  raise schema_error(:sequence_not_seq, self, path)
-               elsif val.length == 0
-                  raise schema_error(:sequence_no_elem, self, path)
-               elsif val.length > 1
-                  raise schema_error(:sequence_too_many, self, path)
-               else
-                  elem = val[0]
-                  elem ||= {}
-                  schema = schema_table[elem.__id__]
-                  i = 1
-                  schema ||= Schema.new(elem, "#{path}/#{i}", schema_table)
-                  @sequence = [ schema ]
-               end
-            when "mapping"
-               if !val.is_a?(Hash)
-                  raise schema_error(:mapping_not_map, self, path)
-               elsif val.empty?
-                  raise schema_error(:mapping_no_elem, self, path)
-               else
-                  @mapping = {}
-                  val.each do |key, elem|
-                     raise schema_error(:duplicate_key, self, path, key) if @mapping.key?(key)
-                     elem ||= {}
-                     schema = schema_table[elem.__id__]
-                     schema ||= Schema.new(elem, "#{path}/#{key}", schema_table)
-                     if key == '*'
-                        @mapping.default = schema
-                     else
-                        @mapping[key] = schema
-                     end
-                  end
-               end
-            else
-               raise schema_error(:unexpected_key, self, path, key)
-            end
-         end
 
-         if @type == nil
-            if @sequence
-               @type = 'seq'
-            elsif @mapping
-               @type = 'map'
-            else
-               @type = Kwalify::DEFAULT_TYPE
-            end
-            @klass = Kwalify::type_table[@type]
-         end
-
-         if @klass == Array
-            raise schema_error(:seq_has_enum,      self, path) if @enum
-            raise schema_error(:seq_has_pattern,   self, path) if @pattern
-            raise schema_error(:seq_has_mapping,   self, path) if @mapping
-         elsif @klass == Hash
-            raise schema_error(:map_has_enum,      self, path) if @enum
-            raise schema_error(:map_has_pattern,   self, path) if @pattern
-            raise schema_error(:map_has_sequence,  self, path) if @sequence
-         else
-            raise schema_error(:scalar_has_sequence, self, path) if @sequence
-            raise schema_error(:scalar_has_mapping,  self, path) if @mapping
-         end
 
+      def validate(val)
+         path = "";  errors = [];  done = {}
+         _validate(val, @rule, path, errors, done)
+         return errors
       end
 
-      #attr_reader   :id
-      attr_accessor :name
-      attr_accessor :desc
-      attr_accessor :enum
-      attr_accessor :required
-      attr_accessor :type
-      attr_accessor :klass
-      attr_accessor :pattern
-      attr_accessor :elements
-      #attr_accessor :constraints
 
+      protected
 
-      def inspect()
-         str = "";  level = 0;  done = {}
-         _inspect(str, level, done)
-         return str
-      end
 
-      def _inspect(str, level, done)
-         done[self.__id__] = true
-         str << "  " * level << "name:      #{@name}\n"             if @name     != nil
-         str << "  " * level << "type:      #{@type}\n"             if @type     != nil
-         str << "  " * level << "klass:     #{@klass.name}\n"       if @klass    != nil
-         str << "  " * level << "required:  #{@required}\n"         if @required != nil
-         str << "  " * level << "pattern:   #{@pattern.inspect}\n"  if @pattern  != nil
-         if @enum != nil
-            str << "  " * level << "enum:\n"
-            @enum.each do |item|
-               str << "  " * (level+1) << "- #{item}\n"
-            end
-         end
-         @sequence.each do |schema|
-            if done[schema.__id__]
-               str << "  " * (level+1) << "- ...\n"
-            else
-               str << "  " * (level+1) << "- \n"
-               schema._inspect(str, level+2, done)
-            end
-         end if @sequence
-         @mapping.each do |key, schema|
-            if done[schema.__id__]
-               str << "  " * (level+1) << key << ": ...\n"
-            else
-               str << "  " * (level+1) << key << ":\n"
-               schema._inspect(str, level+2, done)
-            end
-         end if @mapping
+      def validate_hook(val, rule, path, errors)
       end
-      protected :_inspect
 
 
-      def validate(obj, &block)
-         errors = [];  path = "";  done = {}
-         _validate(obj, errors, path, done, &block)
-         return errors
-      end
-
-
-      def _validate(obj, errors=[], path="", done={}, &block)
-         return true if done[obj.__id__]
-         done[obj.__id__] = true
-         if @required && obj == nil
-            errors << validate_error(:missing_value, self, path, obj)
+      def _validate(val, rule, path, errors, done)
+         if Kwalify.collection_class?(val.class)
+            return true if done[val.__id__]     # avoid infinite loop
+            done[val.__id__] = true
+         end
+         if rule.required && val == nil
+            #* key=:required_novalue  msg="value required but none."
+            errors << validate_error(:required_novalue, rule, path, val)
             return
          end
-         if @klass && obj != nil && !obj.is_a?(@klass)
-            errors << validate_error(:invalid_type, self, path, obj)
+         if rule.klass && val != nil && !val.is_a?(rule.klass)
+            #* key=:type_unmatch  msg="not a %s."
+            errors << validate_error(:type_unmatch, rule, path, val, [Kwalify.word(rule.type)])
             return
          end
          #
          n = errors.length
-         if @sequence
-            _validate_sequence(obj, errors, path, done, &block)
-         elsif @mapping
-            _validate_mapping(obj, errors, path, done, &block)
+         if rule.sequence
+            _validate_sequence(val, rule, path, errors, done)
+         elsif rule.mapping
+            _validate_mapping(val, rule, path, errors, done)
          else
-            _validate_scalar(obj, errors, path, done, &block)
+            _validate_scalar(val, rule, path, errors, done)
          end
          return unless errors.length == n
          #
-         yield(self, obj, errors, path) if block
+         validate_hook(val, rule, path, errors)
+         @block.call(val, rule, path, errors) if @block
       end
-      protected :_validate
 
 
-      def _validate_scalar(obj, errors, path, done, &block)
-         assert_error("@sequence.class==#{@sequence.class.name} (expected NilClass)") if @sequence
-         assert_error("@mapping.class==#{@mapping.class.name} (expected NilClass)") if @mapping
-         return if obj == nil
-         if @enum && !@enum.include?(obj)
-            errors << validate_error(:invalid_enum, self, path, obj)
+      private
+
+
+      def _validate_scalar(val, rule, path, errors, done)
+         assert_error("rule.sequence.class==#{rule.sequence.class.name} (expected NilClass)") if rule.sequence
+         assert_error("rule.mapping.class==#{rule.mapping.class.name} (expected NilClass)") if rule.mapping
+         if rule.assert_proc
+            unless rule.assert_proc.call(val)
+               #* key=:assert_failed  msg="assertion expression failed (%s)."
+               errors << validate_error(:assert_failed, rule, path, val, [rule.assert])
+            end
+         end
+         if rule.enum
+            unless rule.enum.include?(val)
+               keyname = File.basename(path)
+               keyname = 'enum' if keyname =~ /\A\d+\z/
+               #* key=:enum_notexist  msg="invalid %s value."
+               errors << validate_error(:enum_notexist, rule, path, val, [keyname])
+            end
+         end
+         #
+         return if val == nil
+         #
+         if rule.pattern
+            unless val.to_s =~ rule.pattern
+               #* key=:pattern_unmatch  msg="not matched to pattern %s."
+               errors << validate_error(:pattern_unmatch, rule, path, val, [rule.pattern.inspect])
+            end
          end
-         if @pattern && obj.to_s !~ @pattern
-            errors << validate_error(:invalid_pattern, self, path, obj)
+         if rule.range
+            assert_error("val.class=#{val.class.name}") unless Kwalify.scalar?(val)
+            if rule.range['max'] && rule.range['max'] < val
+               #* key=:range_toolarge  msg="too large (> max %s)."
+               errors << validate_error(:range_toolarge, rule, path, val, [rule.range['max'].to_s])
+            end
+            if rule.range['min'] && rule.range['min'] > val
+               #* key=:range_toosmall  msg="too small (< min %s)."
+               errors << validate_error(:range_toosmall, rule, path, val, [rule.range['min'].to_s])
+            end
+         end
+         if rule.length
+            assert_error("val.class=#{val.class.name}") unless val.is_a?(String) || val.is_a?(Text)
+            len = val.to_s.length
+            if rule.length['max'] && rule.length['max'] < len
+               #* key=:length_toolong  msg="too long (length %d > max %d)."
+               errors << validate_error(:length_toolong, rule, path, val, [len, rule.length['max']])
+            end
+            if rule.length['min'] && rule.length['min'] > len
+               #* key=:length_tooshort  msg="too short (length %d < min %d)."
+               errors << validate_error(:length_tooshort, rule, path, val, [len, rule.length['min']])
+            end
          end
       end
-      private :_validate_scalar
 
 
-      def _validate_sequence(list, errors, path, done, &block)
-         assert_error("@sequence.class==#{@sequence.class.name} (expected Array)") unless @sequence.is_a?(Array)
-         assert_error("@sequence.length==#{@sequence.length} (expected 1)") unless @sequence.length == 1
+      def _validate_sequence(list, seq_rule, path, errors, done)
+         assert_error("seq_rule.sequence.class==#{seq_rule.sequence.class.name} (expected Array)") unless seq_rule.sequence.is_a?(Array)
+         assert_error("seq_rule.sequence.length==#{seq_rule.sequence.length} (expected 1)") unless seq_rule.sequence.length == 1
          return if list == nil
-         schema = @sequence[0]
-         i = 0
-         list.each do |obj|
+         rule = seq_rule.sequence[0]
+         i = -1  # or 0?  *index*
+         list.each do |val|
             i += 1
-            schema._validate(obj, errors, "#{path}/#{i}", done, &block)   ## validate recursively
+            _validate(val, rule, "#{path}/#{i}", errors, done)   ## validate recursively
          end
       end
-      private :_validate_sequence
 
 
-      def _validate_mapping(hash, errors, path, done, &block)
-         assert_error("@mapping.class==#{@mapping.class.name} (expected Hash)") unless @mapping.is_a?(Hash)
+      def _validate_mapping(hash, map_rule, path, errors, done)
+         assert_error("map_rule.mapping.class==#{map_rule.mapping.class.name} (expected Hash)") unless map_rule.mapping.is_a?(Hash)
          return if hash == nil
-         @mapping.each do |key, schema|
-            if schema.required && !hash.key?(key)
-               errors << validate_error(:missing_key, schema, path, hash, key)
+         map_rule.mapping.each do |key, rule|
+            if rule.required && !hash.key?(key)
+               #* key=:required_nokey  msg="key '%s:' is required."
+               errors << validate_error(:required_nokey, rule, path, hash, [key])
             end
          end
          hash.each do |key, value|
-            schema = @mapping[key]
-            if schema
-               ret = schema._validate(value, errors, "#{path}/#{key}", done, &block)   ## validate recursively
+            rule = map_rule.mapping[key]
+            if rule
+               _validate(value, rule, "#{path}/#{key}", errors, done)   ## validate recursively
             else
-               errors << validate_error(:invalid_key, schema, path, hash, key)
+               #* key=:key_undefined  msg="key '%s' is undefined."
+               errors << validate_error(:key_undefined, rule, path, nil, ["#{key}:"])
+               ##* key=:key_undefined  msg="undefined key."
+               #errors << validate_error(:key_undefined, rule, path, "#{key}:")
             end
          end
       end
-      private :_validate_mapping
-
 
    end
-end
 
+end