kwalify 0.4.1 → 0.5.0

data/examples/address-book/address-book.schema.yaml

@@ -1,7 +1,7 @@
 ##
 ## Kwalify schema example for address book
 ##
-## $Release: 0.4.1 $
+## $Release: 0.5.0 $
 ## copyright(c) 2005 kuwata-lab all rights reserved.
 ##
 ##

data/examples/invoice/invoice.schema.yaml

@@ -1,8 +1,8 @@
 ###
 ### Kwalify schema example for invoice
 ###
-### $Rev: 20 $
-### $Release: 0.4.1 $
+### $Rev: 41 $
+### $Release: 0.5.0 $
 ### copyright(c) 2005 kuwata-lab all rights reserved.
 ###
 

data/examples/tapkit/tapkit.schema.yaml

@@ -1,7 +1,7 @@
 ##
 ## Kwalify schema example for TapKit
 ##
-## $Release: 0.4.1 $
+## $Release: 0.5.0 $
 ## copyright(c) 2005 kuwata-lab all rights reserved.
 ##
 
@@ -62,44 +62,44 @@ mapping:
             sequence:
               - type: map
                 mapping:
-                  "name":
-                     type: str
-                     required: yes
-                     unique: yes
-                  "column_name":
-                     type: text
-                     required: yes
-                  "class_name":
-                     type: str
-                     enum:
-                       - String
-                       - Integer
-                       - Float
-                       - Date
-                       - Time
-                       - Timestamp
-                       - Boolean
-                  "external_type":
-                     type: str
-                     required: yes
-                     enum:   [
-                        char, character, varchar, char varying, character varying,
-                        nchar, national char, national character,
-                        national character varying, bit, bit varying, 
-                        int, integer, smallint, interval,
-                        numeric, decimal, dec, float, real, double presicion,
-                        date, time, timestamp
-                       ]
-                  "allow_null":
-                     type: bool
-                  "read_only":
-                     type: bool
-                  "width":
-                     type: int
-                  "factory_method":
-                     type: str
-                  "convertion_method":
-                     type: str
+                 "name":
+                    type: str
+                    required: yes
+                    unique: yes
+                 "column_name":
+                    type: str
+                    required: yes
+                 "class_name":
+                    type: str
+                    enum:
+                      - String
+                      - Integer
+                      - Float
+                      - Date
+                      - Time
+                      - Timestamp
+                      - Boolean
+                 "external_type":
+                    type: str
+                    required: yes
+                    enum:   [
+                      char, character, varchar, char varying, character varying,
+                      nchar, national char, national character,
+                      national character varying, bit, bit varying, 
+                      int, integer, smallint, interval,
+                      numeric, decimal, dec, float, real, double presicion,
+                      date, time, timestamp
+                      ]
+                 "allow_null":
+                    type: bool
+                 "read_only":
+                    type: bool
+                 "width":
+                    type: int
+                 "factory_method":
+                    type: str
+                 "convertion_method":
+                    type: str
          "relationships":
             type: seq
             sequence:

data/lib/kwalify.rb

@@ -1,13 +1,13 @@
 ###
-### $Rev: 26 $
-### $Release: 0.4.1 $
+### $Rev: 42 $
+### $Release: 0.5.0 $
 ### copyright(c) 2005 kuwata-lab all rights reserved.
 ###
 
 
 module Kwalify
 
-   RELEASE = ("$Release: 0.4.1 $" =~ /[.\d]+/) && $&
+   RELEASE = ("$Release: 0.5.0 $" =~ /[.\d]+/) && $&
 
 end
 
@@ -17,4 +17,4 @@ require 'kwalify/errors'
 require 'kwalify/rule'
 require 'kwalify/validator'
 require 'kwalify/meta-validator'
-require 'kwalify/parser'
+require 'kwalify/yaml-parser'

data/lib/kwalify/errors.rb

@@ -1,6 +1,6 @@
 ###
-### $Rev: 27 $
-### $Release: 0.4.1 $
+### $Rev: 42 $
+### $Release: 0.5.0 $
 ### copyright(c) 2005 kuwata-lab all rights reserved.
 ###
 
@@ -22,10 +22,10 @@ module Kwalify
    class BaseError < KwalifyError
       def initialize(message="", path=nil, value=nil, rule=nil, error_symbol=nil)
          super(message)
-         @error_symbol = error_symbol
+         @path        = path
          @rule         = rule
-         @path         = path
          @value        = value
+         @error_symbol = error_symbol
       end
       attr_reader :error_symbol, :rule, :path, :value
       attr_accessor :linenum
@@ -43,6 +43,10 @@ module Kwalify
       def to_s
          return "[#{path()}] #{message()}"
       end
+
+      def <=>(ex)
+        return @linenum <=> ex.linenum
+      end
    end
 
 
@@ -60,12 +64,13 @@ module Kwalify
    end
 
 
-   class ParseError < KwalifyError
-      def initialize(msg, linenum)
+   class YamlSyntaxError < KwalifyError
+      def initialize(msg, linenum, error_symbol)
          super("line #{linenum}: #{msg}")
          @linenum = linenum
+         @error_symbol
       end
-      attr_accessor :linenum
+      attr_accessor :linenum, :error_symbol
    end
 
 
@@ -76,19 +81,21 @@ module Kwalify
       end
 
       def validate_error(error_symbol, rule, path, val, args=nil)
-         return _create_error(ValidationError, error_symbol, rule, path, val, args)
+         msg = _build_message(error_symbol, val, args);
+         return ValidationError.new(msg, path, val, rule, error_symbol)
       end
 
       def schema_error(error_symbol, rule, path, val, args=nil)
-         return _create_error(SchemaError, error_symbol, rule, path, val, args)
+         msg = _build_message(error_symbol, val, args);
+         return SchemaError.new(msg, path, val, rule, error_symbol)
       end
 
-      def _create_error(error_klass, error_symbol, rule, path, val, args)
-         msg = Kwalify.msg(error_symbol)
-         assert_error("error_symbol=#{error_symbol.inspect}") unless msg
+      def _build_message(message_key, val, args)
+         msg = Kwalify.msg(message_key)
+         assert_error("message_key=#{message_key.inspect}") unless msg
          msg = msg % args if args
-         msg = "'#{val.to_s.gsub(/\n/, '\n')}': #{msg}" if val != nil && Kwalify.scalar?(val)
-         return error_klass.new(msg, path, val, rule, error_symbol)
+         msg = "'#{val.to_s.gsub(/\n/, '\n')}': #{msg}" if val != nil && Types.scalar?(val)
+         return msg;
       end
 
    end

data/lib/kwalify/main.rb

@@ -0,0 +1,357 @@
+###
+### $Rev: 42 $
+### $Release: 0.5.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
+
+   class CommandOptionError < KwalifyError
+      def initialize(message, option, error_symbol)
+         super(message)
+         @option = option
+         @error_symbol = error_symbol
+      end
+      attr_reader :option, :error_symbol
+   end
+
+
+   ##
+   ## ex.
+   ##   command = File.basename($0)
+   ##   begin
+   ##      main = Kwalify::Main.new(command)
+   ##      s = main.execute
+   ##      print s if s
+   ##   rescue Kwalify::CommandOptionError => ex
+   ##      $stderr.puts "ERROR: #{ex.message}"
+   ##      exit 1
+   ##   rescue Kwalify::KwalifyError => ex
+   ##      $stderr.puts "ERROR: #{ex.message}"
+   ##      exit 1
+   ##   end
+   ##
+   class Main
+
+      def initialize(command=nil)
+         @command = command || File.basename($0)
+         @flag_help     = false
+         @flag_version  = false
+         @flag_silent   = false
+         @flag_meta     = false
+         @flag_untabify = false
+         @flag_linenum  = false
+         @flag_debug    = false
+         @schema_filename = nil
+         @properties    = {}
+      end
+
+      def _inspect()
+         s =     ""
+         s <<    "command       : #{@command}\n"
+         s <<    "flag_help     : #{@flag_help}\n"
+         s <<    "flag_version  : #{@flag_version}\n"
+         s <<    "flag_silent   : #{@flag_silent}\n"
+         s <<    "flag_meta     : #{@flag_meta}\n"
+         s <<    "flag_untabify : #{@flag_untabify}\n"
+         s <<    "flag_linenum  : #{@flag_linenum}\n"
+         s <<    "flag_debug    : #{@flag_debug}\n"
+         s <<    "schema_filename : #{@schema_filename != nil ? @schema_filename : 'null'}\n"
+         s <<    "properties:\n"
+         @properties.each do |key, val|
+            s << "  #{key}: #{val}\n"
+         end
+         return s
+      end
+
+
+      def execute(argv=ARGV)
+         filenames = _parse_argv(argv)
+
+         s = ''
+         s << _version() << "\n" if @flag_version
+         s << _usage()           if @flag_help
+         return s unless s.empty?
+
+         if @flag_meta || @flag_meta2
+            s = _meta_validate(filenames)
+         elsif @schema_filename
+            if @flag_debug
+               s = _inspect_schema(@flag_schema)
+            else
+               s = _validate(filenames)
+            end
+         else
+            #* key=:command_option_noaction  msg="command-line option '-f' or '-m' required."
+            raise option_error(:command_option_noaction, @command)
+         end
+         return s   # or return (s == nil || s.empty?) ? nil : s
+      end
+
+
+      def self.main(command, argv=ARGV)
+         begin
+            main = Kwalify::Main.new(command)
+            s = main.execute(ARGV)
+            print s if s
+            #rescue Kwalify::CommandOptionError => ex
+            #   $stderr.puts ex.message
+            #   exit 1
+            #rescue Kwalify::KwalifyError => ex
+            #   $stderr.puts "ERROR: #{ex.message}"
+            #   exit 1
+         rescue => ex
+            $stderr.puts ex.message
+            exit 1
+         end
+      end
+
+
+      private
+
+
+      def option_error(error_symbol, arg)
+         msg = Kwalify.msg(error_symbol) % arg
+         return CommandOptionError.new(msg, arg, error_symbol)
+      end
+
+
+      def _load_yaml(str)
+         str = YamlHelper.untabify(str) if @flag_untabify
+         if @flag_linenum
+            @parser = Kwalify::YamlParser.new(str)
+            doc = @parser.parse()
+         else
+            doc = YAML.load(str)
+            doc = doc.value if _domain_type?(doc)
+         end
+         return doc
+      end
+
+
+      def _meta_validate(filenames)
+         filenames = [ nil ] if filenames.empty?
+         meta_validator = @flag_meta2 ? nil : Kwalify::MetaValidator.instance()
+         flag_no_validate = @flag_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()
+         schema = _load_yaml(str)
+         filename ||= "(stdin)"
+         if !schema || schema.empty?
+            #* key=:meta_empty  msg="%s: empty.\n"
+            return Kwalify.msg(:meta_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_valid  msg="%s: ok.\n"
+            s << (Kwalify.msg(:meta_valid) % filename) unless @flag_silent
+         else
+            #* key=:meta_invalid  msg="%s: NG!\n"
+            s << (Kwalify.msg(:meta_invalid) % filename)
+            s << _errors_to_str(errors)
+         end
+         return s
+      end
+
+
+      def _errors_to_str(errors)
+         s = ''
+         flag_linenum = @flag_linenum
+         if flag_linenum
+            @parser.set_errors_linenum(errors)
+            errors = errors.sort
+         end
+         errors.each do |error|
+            if flag_linenum
+               s << "  - (line #{error.linenum}) [#{error.path}] #{error.message}\n"
+            else
+               s << "  - [#{error.path}] #{error.message}\n"
+            end
+         end
+         return s
+      end
+
+
+      def _validate(filenames)
+         str = File.open(@schema_filename) { |f| f.read() }
+         schema = _load_yaml(str)
+         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()
+         filename ||= "(stdin)"
+         s = ''
+         i = -1
+         _each_yaml_documents(str) do |document|
+            i += 1
+            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 @flag_silent
+            else
+               #* key=:validation_invalid  msg="%s#%d: INVALID\n"
+               s << (Kwalify.msg(:validation_invalid) % [filename, i])
+               s << _errors_to_str(errors)
+            end
+         end
+         return s
+      end
+
+
+      def _each_yaml_documents(str, &block)
+         str = YamlHelper.untabify(str) if @flag_untabify
+         if @flag_linenum
+            @parser = Kwalify::YamlParser.new(str)
+            while @parser.has_next()
+               doc = @parser.parse()
+               yield(doc)
+            end
+         else
+            YAML::load_documents(str) do |doc|
+               doc = doc.value if _domain_type?(doc)
+               yield(doc)
+            end
+         end
+      end
+
+
+      def _inspect_schema(schema_filename)
+         filename = schema_filename
+         str = filename ? File.open(filename) { |f| f.read() } : $stdin.read()
+         schema = _load_yaml(str)
+         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} [-hvstl] -f schema.yaml document.yaml [document2.yaml ...]\n"
+         s <<  "Usage2: #{@command} [-hvstl] -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"
+         s <<  "  -l              :  show linenumber when errored (experimental)\n"
+         return s
+      end
+
+
+      def _version()
+         return RELEASE
+      end
+
+      def _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
+
+      def _parse_argv(argv)
+         while argv[0] && argv[0][0] == ?-
+            optstr = argv.shift
+            optstr = optstr[1, optstr.length-1]
+            # property
+            if optstr[0] == ?-
+               unless optstr =~ /\A\-([-\w]+)(?:=(.*))?\z/
+                  #* key=:command_property_invalid  msg="%s: invalid property."
+                  raise option_error(:command_property_invalid, optstr)
+               end
+               prop_name = $1;  prop_value = $2
+               key   = prop_name.gsub(/-/, '_').intern
+               value = prop_value == nil ? true : _to_value(prop_value)
+               @properties[key] = value
+            # option
+            else
+               while optstr && !optstr.empty?
+                  optchar = optstr[0]
+                  optstr[0,1] = ""
+                  case optchar
+                  when ?h  ;  @flag_help     = true
+                  when ?v  ;  @flag_version  = true
+                  when ?s  ;  @flag_silent   = true
+                  when ?t  ;  @flag_untabify = true
+                  when ?l  ;  @flag_linenum  = true
+                  when ?m  ;  @flag_meta     = true
+                  when ?M  ;  @flag_meta2    = true
+                  when ?D  ;  @flag_debug    = true
+                  when ?f  ;
+                     arg = optstr.empty? ? argv.shift : optstr
+                     #* key=:command_option_noarg  msg="-%s: argument required."
+                     #* key=:command_option_noschema  msg="-%s: schema filename required."
+                     raise option_error(:command_option_noschema, "f") unless arg
+                     @schema_filename = arg
+                     optstr = nil
+                  else
+                     #* key=:command_option_invalid  msg="-%s: invalid command option."
+                     raise option_error(:command_option_invalid, optchar.chr)
+                  end
+               end
+            end
+         end  # end of while
+         #
+         @flag_help    = true if @properties[:help]
+         @flag_version = true if @properties[:version]
+         filenames = argv
+         return filenames
+      end
+
+
+      def _domain_type?(doc)
+         klass = defined?(YAML::DomainType) ? YAML::DomainType : YAML::Syck::DomainType
+         return doc.is_a?(klass)
+      end
+
+   end
+
+end