kwalify 0.1.0 → 0.2.0

data/lib/kwalify/main-program.rb

@@ -0,0 +1,214 @@
+###
+### $Rev: 18 $
+### $Release: 0.2.0 $
+### copyright(c) 2005 kuwata-lab all rights reserved.
+###
+
+require 'yaml'
+require 'kwalify'
+require 'kwalify/util/yaml-helper'
+require 'kwalify/util/option-parser'
+
+
+module Kwalify
+
+   ##
+   ## ex.
+   ##   command = File.basename($0)
+   ##   begin
+   ##      main = Kwalify::MainProgram.new(ARGV, command)
+   ##      s = main.execute
+   ##      print s if s
+   ##   rescue CommandOptionError => ex
+   ##      $stderr.puts "ERROR: #{ex.message}"
+   ##      exit 1
+   ##   rescue Kwalify::KwalifyError => ex
+   ##      $stderr.puts "ERROR: #{ex.message}"
+   ##      exit 1
+   ##   end
+   ##
+   class MainProgram
+
+      def initialize(argv=ARGV, command=nil)
+         @command = command || File.basename($0)
+         @options, @proerties = _parse_argv(argv)
+         @filenames = argv
+      end
+
+
+      def execute(filenames=@filenames)
+         if @options[:help] || @options[:version]
+            s = ''
+            s << _version() if @options[:version]
+            s << _usage()   if @options[:help]
+            return s
+         end
+         if @options[:meta] || @options[:meta2]
+            s = _meta_validate(filenames)
+         elsif @options[:schema]
+            if @options[:debug]
+               s = _inspect_schema(@options[:schema])
+            else
+               s = _validate(filenames)
+            end
+         else
+            #* key=:action_required  msg="command-line option '-f' or '-m' required."
+            raise CommandOptionError.new(nil, nil, Kwalify.msg(:action_required))
+         end
+         return s   # or return (s == nil || s.empty?) ? nil : s
+      end
+
+
+      private
+
+
+      def _meta_validate(filenames)
+         filenames = [ nil ] if filenames.empty?
+         meta_validator = @options[:meta2] ? nil : Kwalify.meta_validator()
+         flag_no_validate = @options[:meta2] == true
+         s = ''
+         filenames.each do |filename|
+            s << __meta_validate(meta_validator, filename)
+         end
+         return s
+      end
+
+
+      def __meta_validate(meta_validator, filename=nil)
+         str = filename ? File.open(filename) { |f| f.read() } : $stdin.read()
+         str = YamlHelper.untabify(tr) if @options[:untabify]
+         schema = YAML.load(str)
+         schema = schema.value if schema.is_a?(YAML::Syck::DomainType)
+         filename ||= "(stdin)"
+         if !schema || schema.empty?
+            #* key=:meta_schema_empty  msg="%s: empty.\n"
+            return Kwalify.msg(:meta_schema_emtpy) % filename
+         end
+         errors = nil
+         if meta_validator
+            errors = meta_validator.validate(schema)
+         else
+            begin
+               validator = Kwalify::Validator.new(schema)  # error raised when schema is wrong
+            rescue Kwalify::SchemaError => ex
+               errors = [ ex ]
+            end
+         end
+         s = ''
+         if !errors || errors.empty?
+            #* key=:meta_validation_valid  msg="%s: ok.\n"
+            s << (Kwalify.msg(:meta_validation_valid) % filename) unless @options[:silent]
+         else
+            #* key=:meta_validation_invalid  msg="%s: NG!\n"
+            s << (Kwalify.msg(:meta_validation_invalid) % filename)
+            errors.each { |error| s << "  - [#{error.path}] #{error.message}\n" }
+         end
+         return s
+      end
+
+
+      def _validate(filenames)
+         schema_filename = @options[:schema]
+         str = File.open(schema_filename) { |f| f.read() }
+         str = YamlHelper.untabify(str) if @options[:untabify]
+         schema = YAML.load(str)
+         schema = schema.value if schema.is_a?(YAML::Syck::DomainType)
+         validator = Kwalify::Validator.new(schema)
+         #
+         filenames = [ nil ] if filenames.empty?
+         s = ''
+         filenames.each do |filename|
+            s << __validate(validator, filename)
+         end
+         return s
+      end
+
+
+      def __validate(validator, filename=nil)
+         str = filename ? File.open(filename) { |f| f.read() } : $stdin.read()
+         str = YamlHelper.untabify(str) if @options[:untabify]
+         stream = YAML::load_stream(str)
+         filename ||= "(stdin)"
+         i = -1   # or 0?  *index*
+         s = ''
+         stream.documents.each do |document|
+            i += 1
+            document = document.value if document.is_a?(YAML::Syck::DomainType)
+            if !document || document.empty?
+               #* key=:schema_empty  msg="%s#%d: empty.\n"
+               s << (Kwalify.msg(:schema_empty) % i)
+               next
+            end
+            errors = validator.validate(document)
+            if errors.empty?
+               #* key=:validation_valid  msg="%s#%d: valid.\n"
+               s << (Kwalify.msg(:validation_valid) % [filename, i]) unless @options[:silent]
+            else
+               #* key=:validation_invalid  msg="%s#%d: INVALID\n"
+               s << (Kwalify.msg(:validation_invalid) % [filename, i])
+               errors.each { |error| s << "  - [#{error.path}] #{error.message}\n" }
+            end
+         end
+         return s
+      end
+
+
+      def _inspect_schema(schema_filename)
+         filename = schema_filename
+         str = filename ? File.open(filename) { |f| f.read() } : $stdin.read()
+         str = YamlHelper.untabify(tr) if @options[:untabify]
+         schema = YAML.load(str)
+         schema = schema.value if schema.is_a?(YAML::Syck::DomainType)
+         return nil if !schema || schema.empty?
+         validator = Kwalify::Validator.new(schema)  # error raised when schema is wrong
+         s = validator._inspect()
+         s << "\n" unless s[-1] == ?\n
+         return s
+      end
+
+
+      def _usage()
+         s = ''
+         s <<  "Usage1: #{@command} [-hvst] -f schema.yaml document.yaml [document2.yaml ...]\n"
+         s <<  "Usage2: #{@command} [-hvst] -m schema.yaml [schema2.yaml ...]\n"
+         s <<  "  -h, --help      :  help\n"
+         s <<  "  -v              :  version\n"
+         s <<  "  -s              :  silent\n"
+         s <<  "  -f schema.yaml  :  schema definition file\n"
+         s <<  "  -m              :  meta-validation mode\n"
+         s <<  "  -t              :  expand tab character automatically\n"
+         return s
+      end
+
+
+      def _version()
+         return "Kwalify: #{RELEASE}\n"
+      end
+
+
+      def _parse_argv(argv)
+         opt_parser = CommandOptionParser.new("hvstmMD", "f")
+         #opts, props = opt_parser.parse(argv)
+         #properties = {}
+         #props.each do |pname, pvalue|
+         #   key   = pname.gsub(/-/, '_').intern
+         #   value = value == nil ? true: CommandOptionParser.to_value(pvalue)
+         #   properties[key] = value
+         #end
+         auto_convert = true
+         opts, properties = opt_parser.parse(argv, auto_convert)
+         options = {}
+         options[:help]     = opts[?h] || properties[:help]
+         options[:version]  = opts[?v] || properties[:version]
+         options[:silent]   = opts[?s]
+         options[:schema]   = opts[?f]
+         options[:meta]     = opts[?m]
+         options[:meta2]    = opts[?M]
+         options[:untabify] = opts[?t]
+         options[:debug]    = opts[?D]
+         return options, properties
+      end
+
+   end
+
+end

data/lib/kwalify/messages.rb

@@ -0,0 +1,91 @@
+###
+### $Rev: 18 $
+### $Release: 0.2.0 $
+### copyright(c) 2005 kuwata-lab all rights reserved.
+###
+
+module Kwalify
+
+   @@messages = {}
+
+   def self.msg(key)
+      return @@messages[key]
+   end
+
+   
+   ##----- 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_invalid] = "%s: NG!\n"
+   @@messages[:meta_validation_valid] = "%s: ok.\n"
+   @@messages[:meta_validation_invalid2] = "%s: NG! %s\n"
+   @@messages[:schema_empty]         = "%s#%d: empty.\n"
+   @@messages[:validation_valid]     = "%s#%d: valid.\n"
+   @@messages[:validation_invalid]   = "%s#%d: INVALID\n"
+   # --
+   # filename: lib/kwalify/rule.rb
+   @@messages[:schema_notmap]        = "schema definition is not a mapping."
+   @@messages[:type_notstr]          = "not a string."
+   @@messages[:type_unknown]         = "unknown type."
+   @@messages[:required_notbool]     = "not a boolean."
+   @@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[: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[: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[: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[: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:'."
+   @@messages[:map_conflict]         = "not available with mapping."
+   @@messages[:scalar_conflict]      = "not available with scalar type."
+   @@messages[:enum_conflict]        = "not available with 'enum:'."
+   # --
+   # filename: lib/kwalify/validator.rb
+   @@messages[:required_novalue]     = "value required but none."
+   @@messages[:type_unmatch]         = "not a %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[:length_toolong]       = "too long (length %d > max %d)."
+   @@messages[:length_tooshort]      = "too short (length %d < min %d)."
+   @@messages[:required_nokey]       = "key '%s:' is required."
+   @@messages[:key_undefined]        = "key '%s' is undefined."
+   # --
+   ##----- 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

@@ -1,137 +1,260 @@
 ###
-### $Rev: 9 $
-### $Release: 0.1.0 $
+### $Rev: 18 $
+### $Release: 0.2.0 $
 ### copyright(c) 2005 kuwata-lab all rights reserved.
 ###
 
 require 'kwalify/errors'
+require 'kwalify/rule'
 require 'kwalify/validator'
 require 'yaml'
 
 module Kwalify
 
-   META_SCHEMA_DEF = <<'END'
-
+   META_SCHEMA = <<'END'
 name:      MAIN
 type:      map
 required:  yes
-mapping:   &main-schema
+mapping:   &main-rule
  "name":
-    type:      string
+    type:      str
  "desc":
-    type:      text
+    type:      str
  "type":
-    type:      string
+    type:      str
+    #required:  yes
     enum:
       - seq
-      - sequence
+      #- sequence
       #- list
       - map
-      - mapping
+      #- mapping
       #- hash
-      - string
-      - integer
+      - str
+      #- string
+      - int
+      #- integer
       - float
       - number
-      - numeric
+      #- numeric
       - bool
-      - boolean
+      #- boolean
       - text
       - date
       - time
-      - object
+      - timestamp
+      #- object
       - any
+      - scalar
+      #- collection
  "required":
-    type:      boolean
+    type:      bool
  "enum":
     type:      seq
     sequence:
-      - type:     object
+      - type:     scalar
  "pattern":
-    type:      string
+    type:      str
+ "assert":
+    type:      str
+    pattern:   /\bval\b/
+ "range":
+    type:      map
+    mapping:
+     "max":
+        type:     scalar
+     "min":
+        type:     scalar
+ "length":
+    type:      map
+    mapping:
+     "max":
+        type:     int
+     "min":
+        type:     int
  "sequence":
     name:      SEQUENCE
     type:      seq
     sequence:
       - type:      map
-        mapping:   *main-schema
+        mapping:   *main-rule
         name:      MAIN
+        #required:  yes
  "mapping":
     name:      MAPPING
     type:      map
     mapping:
-      '*':
+     '*':
         type:      map
-        mapping:   *main-schema
+        mapping:   *main-rule
         name:      MAIN
-
+        #required:  yes
 END
 
 
-   def self.meta_validator()
-      yaml = YAML.load(META_SCHEMA_DEF)
-      validator = Kwalify::Validator.new(yaml)
-      return validator
-   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
 
-   def self.meta_validator2()
-      yaml = YAML.load(META_SCHEMA_DEF)
-      validator = Kwalify::Validator.new(yaml) { |schema, obj, errors, path|
-         next if obj == nil     ## realy?
-         if schema.name == "MAIN"
-            hash = obj
-            if hash.key?('pattern')
-               val = hash['pattern']
-               pat = (val =~ /\A\/(.*)\/\z/ ? $1 : val)
-               begin
-                  Regexp.compile(pat)
-               rescue RegexpError => ex
-                  errors << Kwalify::Errors.validate_error(:regexp_error, schema, path, obj)
+      def validate_hook(value, rule, path, errors)
+         return if value == nil     ## realy?
+         return unless rule.name == "MAIN"
+         #
+         hash = value
+         type = hash['type']
+         type = Kwalify::DEFAULT_TYPE if type == nil
+         unless type.is_a?(String)
+            errors << Kwalify.validate_error(:type_notstr, rule, "#{path}/type", type.to_s)
+         end
+         klass = Kwalify.get_type_class(type)
+         unless klass
+            errors << Kwalify.validate_error(:type_unknown, rule, "#{path}/type", type.to_s)
+         end
+         #
+         if hash.key?('pattern')
+            val = hash['pattern']
+            pat = (val =~ /\A\/(.*)\/([mi]?[mi]?)\z/ ? $1 : val)
+            begin
+               Regexp.compile(pat)
+            rescue RegexpError => ex
+               errors << Kwalify.validate_error(:pattern_syntaxerr, rule, "#{path}/pattern", val)
+            end
+         end
+         #
+         if hash.key?('enum')
+            if type == 'seq' || type == 'map'   # unless Kwalify.scalar_class?(klass)
+               errors << schema_error(:enum_notscalar, rule, path, 'enum:')
+            else
+               elem_table = {}
+               hash['enum'].each do |elem|
+                  if elem_table[elem]
+                     errors << Kwalify.validate_error(:enum_duplicate, rule, "#{path}/enum", elem.to_s)
+                  end
+                  elem_table[elem] = true
+                  unless elem.is_a?(klass)
+                     errors << schema_error(:enum_type_unmatch, rule, "#{path}/enum", elem, [Kwalify.word(type)])
+                  end
                end
             end
-            type = hash['type']
-            if type == nil
-               if hash.key?('sequence')
-                  type = 'seq'
-               elsif hash.key?('mapping')
-                  type = 'map'
+         end
+         #
+         if hash.key?('assert')
+            val =  hash['assert']
+            val =~ /\bval\b/ or errors << Kwalify.validate_error(:assert_noval, rule, "#{path}/assert", val)
+            begin
+               eval "proc { |val| #{val} }"
+            rescue SyntaxError => ex
+               errors << Kwalify.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 << Kwalify.validate_error(:range_notmap, rule, curr_path, val)
+            elsif type == 'seq' || type == 'map' || type == 'bool' || type == 'any'
+               errors << Kwalify.validate_error(:range_notscalar, rule, path, 'range:')
+            else
+               val.each do |rkey, rval|
+                  case rkey
+                  when 'max', 'min'
+                     unless rval.is_a?(klass)
+                        typename = Kwalify.word(type) || type
+                        errors << Kwalify.validate_error(:range_type_unmatch, rule, "#{curr_path}/#{rkey}", rval, [typename])
+                     end
+                  else
+                     errors << Kwalify.validate_error(:range_undefined, rule, curr_path, "#{rkey}:")
+                  end
+               end
+            end
+         end
+         #
+         if hash.key?('length')
+            val = hash['length']
+            curr_path = path + "/length"
+            val.is_a?(Hash) or errors << Kwalify.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'
+                  unless lval.is_a?(Integer)
+                     errors << Kwalify.validate_error(:length_notint, rule, "#{curr_path}/#{lkey}", lval)
+                  end
                else
-                  type = Kwalify::DEFAULT_TYPE
+                  errors << validate_error(:length_undefined, rule, curr_path, "#{lkey}:")
                end
             end
-            klass = Kwalify.type_table[type]
-            if klass == nil
-               errors << Kwalify::Errors.validate_error(:invalid_type, schema, path, obj)
-            elsif klass == Array
-               errors << Kwalify::Errors.validate_error(:seq_has_enum,     schema, path, obj) if hash.key?('enum')
-               errors << Kwalify::Errors.validate_error(:seq_has_pattern,  schema, path, obj) if hash.key?('pattern')
-               errors << Kwalify::Errors.validate_error(:seq_has_mapping,  schema, path, obj) if hash.key?('mapping')
-            elsif klass == Hash
-               errors << Kwalify::Errors.validate_error(:map_has_enum,     schema, path, obj) if hash.key?('enum')
-               errors << Kwalify::Errors.validate_error(:map_has_pattern,  schema, path, obj) if hash.key?('pattern')
-               errors << Kwalify::Errors.validate_error(:map_has_sequence, schema, path, obj) if hash.key?('sequence')
-            else
-               errors << Kwalify::Errors.validate_error(:scalar_has_sequence, schema, path, obj) if hash.key?('sequence')
-               errors << Kwalify::Errors.validate_error(:scalar_has_mapping,  schema, path, obj) if hash.key?('mapping')
+         end
+         #
+         if hash.key?('sequence')
+            val = hash['sequence']
+            if val != nil && !val.is_a?(Array)
+               errors << Kwalify.validate_error(:sequence_notseq,  rule, "#{path}/sequence", val)
+            elsif val == nil || val.empty?
+               errors << Kwalify.validate_error(:sequence_noelem,  rule, "#{path}/sequence", val)
+            elsif val.length > 1
+               errors << Kwalify.validate_error(:sequence_toomany, rule, "#{path}/sequence", val)
             end
-         elsif schema.name == "SEQUENCE"
-            if !obj.is_a?(Array)
-               errors << Kwalify::Errors.validate_error(:sequence_not_seq,  schema, path, obj)
-            else
-               errors << Kwalify::Errors.validate_error(:sequence_no_elem,  schema, path, obj) if obj.empty?
-               errors << Kwalify::Errors.validate_error(:sequence_too_many, schema, path, obj) if obj.length > 1
+         end
+         #
+         if hash.key?('mapping')
+            val = hash['mapping']
+            if val != nil && !val.is_a?(Hash)
+               errors << Kwalify.validate_error(:mapping_notmap,   rule, "#{path}/mapping", val)
+            elsif val == nil || val.empty?
+               errors << Kwalify.validate_error(:mapping_noelem,   rule, "#{path}/mapping", val)
             end
-         elsif schema.name == "MAPPING"
-            if !obj.is_a?(Hash)
-               errors << Kwalify::Errors.validate_error(:mapping_not_map,   schema, path, obj)
-            else
-               errors << Kwalify::Errors.validate_error(:mapping_no_elem,   schema, path, obj) if obj.empty?
+         end
+         #
+         if type == 'seq'
+            errors << Kwalify.validate_error(:seq_nosequence, rule, path, nil)      unless hash.key?('sequence')
+            #errors << Kwalify.validate_error(:seq_conflict, rule, path, 'enum:')        if hash.key?('enum')
+            errors << Kwalify.validate_error(:seq_conflict, rule, path, 'pattern:')     if hash.key?('pattern')
+            errors << Kwalify.validate_error(:seq_conflict, rule, path, 'mapping:')     if hash.key?('mapping')
+            #errors << Kwalify.validate_error(:seq_conflict, rule, path, 'range:')       if hash.key?('range')
+            errors << Kwalify.validate_error(:seq_conflict, rule, path, 'length:')      if hash.key?('length')
+         elsif type == 'map'
+            errors << Kwalify.validate_error(:map_nomapping, rule, path, nil)       unless hash.key?('mapping')
+            #errors << Kwalify.validate_error(:map_conflict, rule, path, 'enum:')        if hash.key?('enum')
+            errors << Kwalify.validate_error(:map_conflict, rule, path, 'pattern:')     if hash.key?('pattern')
+            errors << Kwalify.validate_error(:map_conflict, rule, path, 'sequence:')    if hash.key?('sequence')
+            #errors << Kwalify.validate_error(:map_conflict, rule, path, 'range:')       if hash.key?('range')
+            errors << Kwalify.validate_error(:map_conflict, rule, path, 'length:')      if hash.key?('length')
+         else
+            errors << Kwalify.validate_error(:scalar_conflict, rule, path, 'sequence:') if hash.key?('sequence')
+            errors << Kwalify.validate_error(:scalar_conflict, rule, path, 'mapping:')  if hash.key?('mapping')
+            if hash.key?('enum')
+               errors << Kwalify.validate_error(:enum_conflict, rule, path, 'range:')   if hash.key?('range')
+               errors << Kwalify.validate_error(:enum_conflict, rule, path, 'length:')  if hash.key?('length')
+               errors << Kwalify.validate_error(:enum_conflict, rule, path, 'pattern:') if hash.key?('pattern')
             end
          end
-      }
-      return validator
+
+      end  # end of def validate_hook()
+
+   end # end of class MetaValidator
+
+
+   schema = YAML.load(META_SCHEMA)
+   META_VALIDATOR = MetaValidator.new(schema)
+
+   def self.meta_validator
+      return META_VALIDATOR
    end
 
 end
-