kwalify 0.1.0

data/lib/kwalify/types.rb

@@ -0,0 +1,70 @@
+###
+### $Rev: 7 $
+### $Release: 0.1.0 $
+### copyright(c) 2005 kuwata-lab all rights reserved.
+###
+
+require 'date'
+
+
+module Kwalify
+   module Boolean
+   end
+end
+#module Boolean; end
+class TrueClass
+   include Kwalify::Boolean
+   #include Boolean
+end
+class FalseClass
+   include Kwalify::Boolean
+   #include Boolean
+end
+
+
+module Kwalify
+   module Text
+   end
+end
+#module Text; end
+class String
+   include Kwalify::Text
+   #include Text
+end
+class Numeric
+   include Kwalify::Text
+   #include Text
+end
+
+
+module Kwalify
+
+   DEFAULT_TYPE = "string"           ## use "string" as default of @type
+
+   @@type_table = {
+      "seq"       => Array,
+      "sequence"  => Array,
+      #"list"      => Array,
+      #"array"     => Array,
+      "map"       => Hash,
+      "mapping"   => Hash,
+      #"hash"      => Hash,
+      "text"      => Text,
+      "string"    => String,
+      "integer"   => Integer,
+      "float"     => Float,
+      "number"    => Numeric,
+      #"numeric"   => Numeric,
+      "date"      => Date,
+      "time"      => Time,
+      "boolean"   => Boolean,
+      #"bool"      => Boolean,
+      "object"    => Object,
+      "any"       => Object,
+   }
+   
+   def self.type_table
+      return @@type_table
+   end
+
+end

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

@@ -0,0 +1,44 @@
+###
+### $Rev: 5 $
+### $Release: 0.1.0 $
+### copyright(c) 2005 kuwata-lab all rights reserved.
+###
+
+require 'test/unit'
+require 'tempfile'
+
+module Test
+   module Unit
+      class TestCase
+         def assert_equal_with_diff(expected, actual, message=nil, diffopt='-u', flag_cut=true)
+            if expected == actual
+               assert(true)
+               return
+            end
+
+            if expected[-1] != ?\n || actual[-1] != ?\n
+               expected += "\n"
+               actual   += "\n"
+            end
+            begin
+               expfile = Tempfile.new(".expected.")
+               expfile.write(expected); expfile.flush()
+               actfile = Tempfile.new(".actual.")
+               actfile.write(actual);   actfile.flush()
+               diff = `diff #{diffopt} #{expfile.path} #{actfile.path}`
+            ensure
+               expfile.close(true) if expfile
+               actfile.close(true) if actfile
+            end
+
+            # cut 1st & 2nd lines
+            message = (flag_cut ? diff.gsub(/\A.*\n.*\n/, '') : diff) unless message
+            #raise Test::Unit::AssertionFailedError.new(message)
+            assert_block(message) { false }  # or assert(false, message)
+         end
+         #def assert_equal(expected, actual, message=nil)
+         #   return assert_equal_with_diff(expected, actual, message)
+         #end
+      end
+   end
+end

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

@@ -0,0 +1,220 @@
+###
+### $Rev: 6 $
+### $Release: 0.1.0 $
+### copyright(c) 2005 kuwata-lab all rights reserved.
+###
+
+class CommandOptionError < StandardError
+   def initialize(option, error_symbol, message=nil)
+      if !message
+         case error_symbol
+         when :no_argument
+            message = "-%s: argument required." % option
+         when :unknown_option
+            message = "-%s: unknown option." % option
+         when :invalid_property
+            message = "-%s: invalid property." % option
+         else
+            message = "*** internal error(optchar=#{option}, error_symbol=#{error_symbol}) ***"
+         end
+      end
+      super(message)
+      @option = option
+      @error_symbol = error_symbol
+   end
+
+   attr_reader :option, :error_symbol
+end
+
+
+##
+##  ex.
+##    ## create parser
+##    arg_none     = "hv"      # ex. -h -v
+##    arg_required = "xf"      # ex. -x suffix -f filename
+##    arg_optional = "i"       # ex. -i  (or -i10)
+##    parser = CommandOptionParser.new(arg_none, arg_required, arg_optional)
+##
+##    ## parse options
+##    argv = %w[-h -v -f filename -i 10 aaa bbb]
+##    options, properties = parser.parse(argv)
+##    p options   #=> { ?h=>true, ?v=>true, ?f=>"filename", ?i=>true }
+##    p argv      #=> ["10", "aaa", "bbb"]
+##
+##    ## parse options #2
+##    argv = %w[-hvx.txt -ffilename -i10 aaa bbb]
+##    options, properties = parser.parse(argv)
+##    p options   #=> { ?h=>true, ?v=>true, ?x=>".txt", ?f=>"filename", ?i=>10 }
+##    p argv      #=> ["aaa", "bbb"]
+##
+##    ## parse properties
+##    argv = %w[-hi --index=10 --user-name=foo --help]
+##    options, properties = parser.parse(argv)
+##    p options     #=> {?h=>true, ?i=>true}
+##    p properties  #=> {"index"=>"10", "user-name"=>"foo", "help"=>nil}
+##
+##    ## parse properties with auto-convert
+##    argv = %w[-hi --index=10 --user-name=foo --help]
+##    options, properties = parser.parse(argv, true)
+##    p options     #=> {?h=>true, ?i=>true}
+##    p properties  #=> {:index=>10, :user_name=>foo, :help=>true}
+##
+##    ## -a: unknown option.
+##    argv = %w[-abc]
+##    begin
+##       options, properties = parser.parse(argv)
+##    rescue CommandOptionError => ex
+##       $stderr.puts ex.message     # -a: unknown option.
+##    end
+##
+##    ## -f: argument required.
+##    argv = %w[-f]
+##    begin
+##       options, properties = parser.parse(argv)
+##    rescue CommandOptionError => ex
+##       $stderr.puts ex.message     # -f: argument required.
+##    end
+##
+##    ## --@prop=10: invalid property.
+##    argv = %w[--@prop=10]
+##    begin
+##       options, properties = parser.parse(argv)
+##    rescue CommandOptionError => ex
+##       $stderr.puts ex.message     # --@prop=10: invalid property.
+##    end
+##
+
+class CommandOptionParser
+
+   ## arg_none:      option string which takes no argument
+   ## arg_required:  option string which takes argument
+   ## arg_otpional:  option string which may takes argument optionally
+   def initialize(arg_none=nil, arg_required=nil, arg_optional=nil)
+      @arg_none      = arg_none     || ""
+      @arg_required  = arg_required || ""
+      @arg_optional  = arg_optional || ""
+   end
+
+
+   def self.to_value(str)
+      case str
+      when nil, "null", "nil"         ;   return nil
+      when "true", "yes"              ;   return true
+      when "false", "no"              ;   return false
+      when /\A\d+\z/                  ;   return str.to_i
+      when /\A\d+\.\d+\z/             ;   return str.to_f
+      when /\/(.*)\//                 ;   return Regexp.new($1)
+      when /\A'.*'\z/, /\A".*"\z/     ;   return eval(str)
+      else                            ;   return str
+      end
+   end
+
+
+   ## argv:: array of string
+   ## auto_convert::  if true, convert properties value to int, boolean, string, regexp, ... (default false)
+   def parse(argv, auto_convert=false)
+      options = {}
+      properties = {}
+      while argv[0] && argv[0][0] == ?-
+         optstr = argv.shift
+         optstr = optstr[1, optstr.length-1]
+         #
+         if optstr[0] == ?-    ## property
+            unless optstr =~ /\A\-([-\w]+)(?:=(.*))?/
+               raise CommandOptionError.new(optstr, :invalid_property)
+            end
+            prop_name = $1;  prop_value = $2
+            if auto_convert
+               key   = prop_name.gsub(/-/, '_').intern
+               value = prop_value == nil ? true : CommandOptionParser.to_value(prop_value)
+               properties[key] = value
+            else
+               properties[prop_name] = prop_value
+            end
+         #
+         else                  ## options
+            while optstr && !optstr.empty?
+               optchar = optstr[0]
+               optstr[0,1] = ""
+               #puts "*** debug: optchar=#{optchar.chr}, optstr=#{optstr.inspect}"
+               if @arg_none.include?(optchar)
+                  options[optchar] = true
+               elsif @arg_required.include?(optchar)
+                  arg = optstr.empty? ? argv.shift : optstr
+                  raise CommandOptionError.new(optchar.chr, :no_argument) unless arg
+                  options[optchar] = arg
+                  optstr = nil
+               elsif @arg_optional.include?(optchar)
+                  arg = optstr.empty? ? true : optstr
+                  options[optchar] = arg
+                  optstr = nil
+               else
+                  raise CommandOptionError.new(optchar.chr, :unknown_option)
+               end
+            end
+         end
+         #
+      end  # end of while
+
+      return options, properties
+   end
+
+end
+
+
+if __FILE__ == $0
+   ## create parser
+   arg_none     = "hv"      # ex. -h -v
+   arg_required = "xf"      # ex. -x suffix -f filename
+   arg_optional = "i"       # ex. -i  (or -i10)
+   parser = CommandOptionParser.new(arg_none, arg_required, arg_optional)
+
+   ## parse options
+   argv = %w[-h -v -f filename -i 10 aaa bbb]
+   options, properties = parser.parse(argv)
+   p options   #=> { ?h=>true, ?v=>true, ?f=>"filename", ?i=>true }
+   p argv      #=> ["10", "aaa", "bbb"]
+
+   ## parse options #2
+   argv = %w[-hvx.txt -ffilename -i10 aaa bbb]
+   options, properties = parser.parse(argv)
+   p options   #=> { ?h=>true, ?v=>true, ?x=>".txt", ?f=>"filename", ?i=>"10" }
+   p argv      #=> ["aaa", "bbb"]
+
+   ## parse properties
+   argv = %w[-hi --index=10 --user-name=foo --help]
+   options, properties = parser.parse(argv)
+   p options     #=> {?h=>true, ?i=>true}
+   p properties  #=> {"index"=>"10", "user-name"=>"foo", "help"=>nil}
+
+   ## parse properties with auto-convert
+   argv = %w[-hi --index=10 --user-name=foo --help]
+   options, properties = parser.parse(argv, true)
+   p options     #=> {?h=>true, ?i=>true}
+   p properties  #=> {:index=>10, :user_name=>foo, :help=>true}
+
+   ## -a: unknown option.
+   argv = %w[-abc]
+   begin
+      options, properties = parser.parse(argv)
+   rescue CommandOptionError => ex
+      $stderr.puts ex.message     # -a: unknown option.
+   end
+
+   ## -f: argument required.
+   argv = %w[-f]
+   begin
+      options, properties = parser.parse(argv)
+   rescue CommandOptionError => ex
+      $stderr.puts ex.message     # -f: argument required.
+   end
+
+   ## --@prop=10: invalid property.
+   argv = %w[--@prop=10]
+   begin
+      options, properties = parser.parse(argv)
+   rescue CommandOptionError => ex
+      $stderr.puts ex.message     # --@prop=10: invalid property.
+   end
+
+end

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

@@ -0,0 +1,82 @@
+###
+### $Rev: 7 $
+### $Release: 0.1.0 $
+### copyright(c) 2005 kuwata-lab all rights reserved.
+###
+
+require 'yaml'
+
+module YamlHelper
+
+   ##
+   ## expand tab character to spaces
+   ##
+   ## ex.
+   ##   untabified_str = YAML::Helper.untabify(tabbed_str)
+   ##
+   ## input:: String or IO
+   ##
+   def self.untabify(input)
+      s = ''
+      input.each_line do |line|
+         s << line.gsub(/([^\t]{8})|([^\t]*)\t/n) { [$+].pack("A8") }
+      end
+      return s
+   end
+
+
+   ##
+   ## create a hash table from list of hash with primary key.
+   ##
+   ## ex.
+   ##   hashlist = [
+   ##     { "name"=>"Foo", "gender"=>"M", "age"=>20, },
+   ##     { "name"=>"Bar", "gender"=>"F", "age"=>25, },
+   ##     { "name"=>"Baz", "gender"=>"M", "age"=>30, },
+   ##   ]
+   ##   hashtable = YAML::Helper.create_hashtable(hashlist, "name")
+   ##   p hashtable
+   ##       # => { "Foo" => { "name"=>"Foo", "gender"=>"M", "age"=>20, },
+   ##              "Bar" => { "name"=>"Bar", "gender"=>"F", "age"=>25, },
+   ##              "Baz" => { "name"=>"Baz", "gender"=>"M", "age"=>30, }, }
+   ##
+   def self.create_hashtable(hashlist, primarykey, flag_duplicate_check=true)
+      hashtable = {}
+      hashlist.each do |hash|
+         key = hash[primarykey]
+         unless key
+            riase "primary key '#{key}' not found."
+         end
+         if flag_duplicate_check && hashtable.key?(key)
+            raise "primary key '#{key}' duplicated (value '#{hashtable[key]}')"
+         end
+         hashtable[key] = hash
+      end if hashlist
+      return hashtable
+   end
+
+
+   ##
+   ## get nested value directly.
+   ##
+   ## ex.
+   ##   val = YAML::Helper.get_value(obj, ['aaa', 0, 'xxx'])
+   ##
+   ## This is equal to the following:
+   ##   begin
+   ##     val = obj['aaa'][0]['xxx']
+   ##   rescue NameError
+   ##     val = nil
+   ##   end
+   ##
+   def self.get_value(obj, path)
+      val = obj
+      path.each do |key|
+         val = val[key]
+         return val unless val
+      end if path
+      return val
+   end
+
+end
+

data/lib/kwalify/validator.rb

@@ -0,0 +1,286 @@
+###
+### $Rev: 9 $
+### $Release: 0.1.0 $
+### copyright(c) 2005 kuwata-lab all rights reserved.
+###
+
+require 'kwalify/error-msg'
+require 'kwalify/errors'
+require 'kwalify/types'
+require 'pp'
+
+module Kwalify
+
+
+   ##
+   ## ex.
+   ##   s = File.read('schema.yaml')
+   ##   validator = Kwalify::Validator.new(YAML.load(s))
+   ##   s = File.read('document.yaml')
+   ##   document = YAML.load(s)
+   ##   error_list = validator.validate(document)
+   ##   unless error_list.empty?
+   ##      error_list.each { |error| print error.message }
+   ##   end
+   ##
+   class Validator
+      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)
+         @block = block
+      end
+      attr_reader :schema
+
+      def validate(obj)
+         @schema.validate(obj, &@block)
+      end
+
+      def inspect
+         @schema.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
+
+      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
+
+
+      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
+      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)
+            return
+         end
+         if @klass && obj != nil && !obj.is_a?(@klass)
+            errors << validate_error(:invalid_type, self, path, obj)
+            return
+         end
+         #
+         n = errors.length
+         if @sequence
+            _validate_sequence(obj, errors, path, done, &block)
+         elsif @mapping
+            _validate_mapping(obj, errors, path, done, &block)
+         else
+            _validate_scalar(obj, errors, path, done, &block)
+         end
+         return unless errors.length == n
+         #
+         yield(self, obj, errors, path) 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)
+         end
+         if @pattern && obj.to_s !~ @pattern
+            errors << validate_error(:invalid_pattern, self, path, obj)
+         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
+         return if list == nil
+         schema = @sequence[0]
+         i = 0
+         list.each do |obj|
+            i += 1
+            schema._validate(obj, errors, "#{path}/#{i}", done, &block)   ## 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)
+         return if hash == nil
+         @mapping.each do |key, schema|
+            if schema.required && !hash.key?(key)
+               errors << validate_error(:missing_key, schema, 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
+            else
+               errors << validate_error(:invalid_key, schema, path, hash, key)
+            end
+         end
+      end
+      private :_validate_mapping
+
+
+   end
+end
+