ddao-kwalify 0.7.1

data/lib/kwalify/messages.rb

@@ -0,0 +1,173 @@
+###
+### $Rev: 95 $
+### $Release: 0.7.1 $
+### copyright(c) 2005-2008 kuwata-lab all rights reserved.
+###
+
+module Kwalify
+
+   @@messages = {}
+
+   def self.msg(key)
+      return @@messages[key]
+   end
+
+
+
+   @@messages[:command_help] = <<END
+kwalify - schema validator and data binding tool for YAML and JSON
+## Usage1: validate yaml document
+kwalify [..options..] -f schema.yaml doc.yaml [doc2.yaml ...]
+## Usage2: validate schema definition
+kwalify [..options..] -m schema.yaml [schema2.yaml ...]
+## Usage3: do action
+kwalify [..options..] -a action -f schema.yaml [schema2.yaml ...]
+  -h, --help     : help
+  -v             : version
+  -q             : quiet
+  -s             : silent (obsolete, use '-q' instead)
+  -f schema.yaml : schema definition file
+  -m             : meta-validation mode
+  -t             : expand tab characters
+  -l             : show linenumber when errored (experimental)
+  -E             : show errors in emacs-style (experimental, implies '-l')
+  -a action      : action ('genclass-ruby', 'genclass-php', 'genclass-java')
+                   (try '-ha genclass-ruby' for details)
+  -I path        : template path (for '-a')
+  -P             : allow preceding alias
+END
+#  -z              :  syntax checking of schema file
+#  -I path         :  path for template of action
+
+
+
+   ##----- begin
+   # filename: lib/kwalify/main.rb
+   @@messages[:command_option_actionnoschema] = "schema filename is not specified."
+   @@messages[:command_option_noaction] = "command-line option '-f' or '-m' required."
+   @@messages[:command_option_notemplate] = "%s: invalid action (template not found).\n"
+   @@messages[:schema_empty]         = "%s: empty schema.\n"
+   @@messages[:validation_empty]     = "%s#%d: empty."
+   @@messages[:validation_empty]     = "%s#%d: empty.\n"
+   @@messages[:validation_valid]     = "%s#%d: valid."
+   @@messages[:command_option_schema_required] = "-%s: schema filename required."
+   @@messages[:command_option_action_required] = "-%s: action required."
+   @@messages[:command_option_tpath_required] = "-%s: template path required."
+   @@messages[:command_property_invalid] = "%s: invalid property."
+   @@messages[:command_option_invalid] = "-%s: invalid command option."
+   # --
+   # 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[:class_notmap]         = "available only with map type."
+   @@messages[:required_notbool]     = "not a boolean."
+   @@messages[:pattern_notstr]       = "not a string (or regexp)"
+   @@messages[:pattern_notmatch]     = "should be '/..../'."
+   @@messages[:pattern_syntaxerr]    = "has regexp error."
+   @@messages[:enum_notseq]          = "not a sequence."
+   @@messages[:enum_notscalar]       = "not available with seq or map."
+   @@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."
+   @@messages[:range_notmap]         = "not a mapping."
+   @@messages[:range_notscalar]      = "is available only with scalar type."
+   @@messages[:range_type_unmatch]   = "not a %s."
+   @@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."
+   @@messages[:ident_notmap]         = "is available only with an element of mapping."
+   @@messages[:unique_notbool]       = "not a boolean."
+   @@messages[:unique_notscalar]     = "is available only with a scalar type."
+   @@messages[:unique_onroot]        = "is not available on root element."
+   @@messages[:default_nonscalarval] = "not a scalar."
+   @@messages[:default_notscalar]    = "is available only with a scalar type."
+   @@messages[:default_unmatch]      = "not a %s."
+   @@messages[:sequence_notseq]      = "not a sequence."
+   @@messages[:sequence_noelem]      = "required one element."
+   @@messages[:sequence_toomany]     = "required just one element."
+   @@messages[:mapping_notmap]       = "not a mapping."
+   @@messages[:mapping_noelem]       = "required at least one element."
+   @@messages[:seq_nosequence]       = "type 'seq' requires 'sequence:'."
+   @@messages[:seq_conflict]         = "not available with sequence."
+   @@messages[:map_nomapping]        = "type 'map' requires 'mapping:'."
+   @@messages[:map_conflict]         = "not available with mapping."
+   @@messages[:scalar_conflict]      = "not available with scalar type."
+   @@messages[:enum_conflict]        = "not available with 'enum:'."
+   @@messages[:default_conflict]     = "not available when 'required:' is true."
+   # --
+   # filename: lib/kwalify/validator.rb
+   @@messages[:required_novalue]     = "value required but none."
+   @@messages[:type_unmatch]         = "not a %s."
+   @@messages[:key_undefined]        = "key '%s' is undefined."
+   @@messages[:required_nokey]       = "key '%s:' is required."
+   @@messages[:value_notunique]      = "is already used at '%s'."
+   @@messages[:assert_failed]        = "assertion expression failed (%s)."
+   @@messages[:enum_notexist]        = "invalid %s value."
+   @@messages[:pattern_unmatch]      = "not matched to pattern %s."
+   @@messages[:range_toolarge]       = "too large (> max %s)."
+   @@messages[:range_toosmall]       = "too small (< min %s)."
+   @@messages[:range_toolargeex]     = "too large (>= max %s)."
+   @@messages[:range_toosmallex]     = "too small (<= min %s)."
+   @@messages[:length_toolong]       = "too long (length %d > max %d)."
+   @@messages[:length_tooshort]      = "too short (length %d < min %d)."
+   @@messages[:length_toolongex]     = "too long (length %d >= max %d)."
+   @@messages[:length_tooshortex]    = "too short (length %d <= min %d)."
+   # --
+   # filename: lib/kwalify/yaml-parser.rb
+   @@messages[:flow_hastail]         = "flow style sequence is closed but got '%s'."
+   @@messages[:flow_eof]             = "found EOF when parsing flow style."
+   @@messages[:flow_alias_label]     = "alias name expected."
+   @@messages[:flow_anchor_label]    = "anchor name expected."
+   @@messages[:flow_noseqitem]       = "sequence item required (or last comma is extra)."
+   @@messages[:flow_seqnotclosed]    = "flow style sequence requires ']'."
+   @@messages[:flow_mapnoitem]       = "mapping item required (or last comma is extra)."
+   @@messages[:flow_mapnotclosed]    = "flow style mapping requires '}'."
+   @@messages[:flow_nocolon]         = "':' expected but got %s."
+   @@messages[:flow_str_notclosed]   = "%s: string not closed."
+   @@messages[:anchor_duplicated]    = "anchor '%s' is already used."
+   @@messages[:alias_extradata]      = "alias cannot take any data."
+   @@messages[:anchor_notfound]      = "anchor '%s' not found"
+   @@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
+
+
+
+
+   @@words = {}
+
+   def self.word(key)
+      return @@words[key] || key
+   end
+
+   @@words['str']  = 'string'
+   @@words['int']  = 'integer'
+   @@words['bool'] = 'boolean'
+   @@words['seq']  = 'sequence'
+   @@words['map']  = 'mapping'
+
+end

data/lib/kwalify/meta-validator.rb

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

data/lib/kwalify/parser/base.rb

@@ -0,0 +1,127 @@
+###
+### $Rev: 92 $
+### $Release: 0.7.1 $
+### copyright(c) 2005-2008 kuwata-lab all rights reserved.
+###
+
+require 'strscan'
+require 'kwalify/errors'
+require 'kwalify/util'
+
+
+##
+## base class for Yaml::Parser
+##
+class Kwalify::BaseParser
+
+
+  def reset(input, filename=nil, untabify=false)
+    input = Kwalify::Util.untabify(input) if untabify
+    @scanner = StringScanner.new(input)
+    @filename = filename
+    @linenum = 1
+    @column  = 1
+  end
+  attr_reader :filename, :linenum, :column
+
+
+  def scan(regexp)
+    ret = @scanner.scan(regexp)
+    return nil if ret.nil?
+    _set_column_and_linenum(ret)
+    return ret
+  end
+
+
+  def _set_column_and_linenum(s)
+    pos = s.rindex(?\n)
+    if pos
+      @column = s.length - pos
+      @linenum += s.count("\n")
+    else
+      @column += s.length
+    end
+  end
+
+
+  def match?(regexp)
+    return @scanner.match?(regexp)
+  end
+
+
+  def group(n)
+    return @scanner[n]
+  end
+
+
+  def eos?
+    return @scanner.eos?
+  end
+
+
+  def peep(n=1)
+    return @scanner.peek(n)
+  end
+
+
+  def _getch
+    ch = @scanner.getch()
+    if ch == "\n"
+      @linenum += 1
+      @column = 0
+    else
+      @column += 1
+    end
+    return ch
+  end
+
+
+  CHAR_TABLE = { "\""=>"\"", "\\"=>"\\", "n"=>"\n", "r"=>"\r", "t"=>"\t", "b"=>"\b" }
+
+  def scan_string
+    ch = _getch()
+    ch == '"' || ch == "'" or raise "assertion error"
+    endch = ch
+    s = ''
+    while !(ch = _getch()).nil? && ch != endch
+      if ch != '\\'
+        s << ch
+      elsif (ch = _getch()).nil?
+        raise _syntax_error("%s: string is not closed." % (endch == '"' ? "'\"'" : '"\'"'))
+      elsif endch == '"'
+        if CHAR_TABLE.key?(ch)
+          s << CHAR_TABLE[ch]
+        elsif ch == 'u'
+          ch2 = scan(/(?:[0-9a-f][0-9a-f]){1,4}/)
+          unless ch2
+            raise _syntax_error("\\x: invalid unicode format.")
+          end
+          s << [ch2.hex].pack('U*')
+        elsif ch == 'x'
+          ch2 = scan(/[0-9a-zA-Z][0-9a-zA-Z]/)
+          unless ch2
+            raise _syntax_error("\\x: invalid binary format.")
+          end
+          s << [ch2].pack('H2')
+        else
+          s << "\\" << ch
+        end
+      elsif endch == "'"
+        ch == '\'' || ch == '\\' ? s << ch : s << '\\' << ch
+      else
+        raise "unreachable"
+      end
+    end
+    #_getch()
+    return s
+  end
+
+
+  def _syntax_error(message, path=nil, linenum=@linenum, column=@column)
+    #message = _build_message(message_key)
+    return _error(Kwalify::SyntaxError, message.to_s, path, linenum, column)
+  end
+  protected :_syntax_error
+
+
+end