ddao-kwalify 0.7.1

data/examples/tapkit/tapkit.yaml

@@ -0,0 +1,85 @@
+##
+## original:
+##   http://www.spice-of-life.net/tapkit/ja/TapKitUserGuide_J_c5_s6.html#doc7_1532
+##
+
+adapter_name: DBI
+
+connection:
+  url:      dbi:Mysql:examples
+  user:     mysql
+  password: mysql
+
+entities:
+  -
+    name:          Employee
+    external_name: EMPLOYEE
+
+    attributes:
+      -
+        name:          employee_id
+        column_name:   EMPLOYEE_ID
+        external_type: int
+        class_name:    Integer
+      -
+        name:          name
+        column_name:   NAME
+        external_type: char
+        class_name:    String
+        width:         64
+      -
+        name:          company_id
+        column_name:   COMPANY_ID
+        external_type: int
+        class_name:    Integer
+
+    relationships:
+      -
+        name:          company
+        destination:   Company
+        to_many:       false
+        joins:
+          -
+             source:      company_id
+             destination: company_id
+
+    primary_key_attributes:
+      - employee_id
+
+    class_properties:
+      - name
+      - company
+
+  -
+    name:          Company
+    external_name: COMPANY
+
+    attributes:
+      -
+        name:          company_id
+        column_name:   COMPANY_ID
+        external_type: int
+        class_name:    Integer
+      -
+        name:          name
+        column_name:   NAME
+        external_type: char
+        class_name:    String
+        width:         64
+
+    relationships:
+      -
+        name:          employees
+        destination:   Employee
+        to_many:       true
+        joins:
+          -
+             source:      company_id
+             destination: company_id
+
+    primary_key_attributes:
+      - company_id
+
+    class_properties:
+      - name
+      - employees

data/lib/kwalify.rb

@@ -0,0 +1,67 @@
+###
+### $Rev: 99 $
+### $Release: 0.7.1 $
+### copyright(c) 2006 kuwata-lab.com all rights reserved.
+###
+
+
+module Kwalify
+
+  RELEASE = ("$Release: 0.7.1 $" =~ /[.\d]+/) && $&
+
+end
+
+require 'kwalify/types'
+require 'kwalify/messages'
+require 'kwalify/errors'
+require 'kwalify/rule'
+require 'kwalify/validator'
+require 'kwalify/meta-validator'
+require 'kwalify/yaml-parser'
+#require 'kwalify/parser/base'
+#require 'kwalify/parser/yaml'
+
+
+module Kwalify
+
+  module Util
+
+    autoload :HashLike, 'kwalify/util/hashlike'
+
+  end
+
+  module Yaml
+
+    autoload :Parser, 'kwalify/parser/yaml'
+
+    ## read yaml_str, parse it, and return yaml document.
+    ##
+    ## opts:
+    ## ::validator:        Kwalify::Validator object
+    ## ::preceding_aliass: allow preceding alias if true
+    ## ::data_binding:     enable data binding if true
+    ## ::untabify:         expand tab chars if true
+    ## ::filename:         filename
+    def self.load(yaml_str, opts={})
+      #require 'kwalify/parser/yaml'
+      parser = Kwalify::Yaml::Parser.new(opts[:validator])
+      parser.preceding_alias = true if opts[:preceding_alias]
+      parser.data_binding    = true if opts[:data_binding]
+      yaml_str = Kwalify::Util.untabify(yaml_str) if opts[:untabify]
+      ydoc = parser.parse(yaml_str, :filename=>opts[:filename])
+      return ydoc
+    end
+
+    ## read file, parse it, and return yaml document.
+    ## see Kwalify::Yaml::Parser.load()
+    def self.load_file(filename, opts={})
+      opts[:filename] = filename
+      return self.load(File.read(filename), opts)
+    end
+
+  end
+
+  module Json
+  end
+
+end

data/lib/kwalify/errors.rb

@@ -0,0 +1,128 @@
+###
+### $Rev: 99 $
+### $Release: 0.7.1 $
+### copyright(c) 2005-2008 kuwata-lab all rights reserved.
+###
+
+require 'kwalify/messages'
+
+module Kwalify
+
+  class KwalifyError < StandardError
+  end
+
+
+  class AssertionError < KwalifyError
+    def initialize(msg)
+      super("*** assertion error: " + msg)
+    end
+  end
+
+
+  class BaseError < KwalifyError
+    def initialize(message="", path=nil, value=nil, rule=nil, error_symbol=nil)
+      super(message)
+      @path  = path.is_a?(Array) ? '/'+path.join('/') : path
+      @rule  = rule
+      @value = value
+      @error_symbol = error_symbol
+      @filename = @linenum = nil
+    end
+    attr_accessor :error_symbol, :rule, :path, :value
+    attr_accessor :filename, :linenum, :column
+
+    def to_path
+      return @path == '' ? "/" : @path
+    end
+
+    alias _to_s to_s
+    alias message to_s
+
+    def to_s
+      s = ''
+      s << @filename << ":" if @filename
+      s << "#{@linenum}:#{@column} " if @linenum
+      s << "[#{to_path()}] " if @path
+      s << _to_s()
+      return s
+    end
+
+    def <=>(ex)
+      #return @linenum <=> ex.linenum
+      v = 0
+      v = @linenum <=> ex.linenum if @linenum && ex.linenum
+      v = @column  <=> ex.column  if v == 0 && @column && ex.column
+      v = @path    <=> ex.path    if v == 0
+      return v
+    end
+  end
+
+
+  class SchemaError < BaseError
+    def initialize(message="", path=nil, rule=nil, value=nil, error_symbol=nil)
+      super(message, path, rule, value, error_symbol)
+    end
+  end
+
+
+  class ValidationError < BaseError
+    def initialize(message="", path=nil, rule=nil, value=nil, error_symbol=nil)
+      super(message, path, rule, value, error_symbol)
+    end
+  end
+
+
+  ## syntax error for YAML and JSON
+  class SyntaxError < BaseError  #KwalifyError
+    def initialize(msg, linenum=nil, error_symbol=nil)
+      super(linenum ? "line #{linenum}: #{msg}" : msg)
+      @linenum = linenum
+      @error_symbol = error_symbol
+    end
+    #attr_accessor :linenum, :error_symbol
+    def message
+      "file: #{@filename}, line #{@linenum}: #{super}"
+    end
+  end
+
+
+  ## (obsolete) use Kwalify::SyntaxError instead
+  class YamlSyntaxError < SyntaxError
+  end
+
+
+  module ErrorHelper
+
+    #module_function
+
+    def assert_error(message="")
+      raise AssertionError.new(message)
+    end
+
+    def validate_error(error_symbol, rule, path, val, args=nil)
+      msg = _build_message(error_symbol, val, args);
+      path = '/'+path.join('/') if path.is_a?(Array)
+      return ValidationError.new(msg, path, val, rule, error_symbol)
+    end
+    module_function :validate_error
+
+    def schema_error(error_symbol, rule, path, val, args=nil)
+      msg = _build_message(error_symbol, val, args);
+      path = '/'+path.join('/') if path.is_a?(Array)
+      return SchemaError.new(msg, path, val, rule, error_symbol)
+    end
+
+    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? && Types.scalar?(val)
+      return msg;
+    end
+    module_function :_build_message
+
+  end
+
+  extend ErrorHelper
+
+end

data/lib/kwalify/kwalify.schema.yaml

@@ -0,0 +1,58 @@
+## $Rev: 95 $
+## $Date: 2008-01-27 22:49:22 +0900 (Sun, 27 Jan 2008) $
+## copyright(c) 2005-2008 kuwata-lab all rights reserved.
+
+name:      MAIN
+type:      map
+required:  yes
+mapping:   &main-rule
+ "name":   { type: str }
+ "desc":   { type: str }
+ "class":  { type: str }
+ "type":
+    type:      str
+    #required:  yes
+    enum: [ seq, map, str, int, float, number, bool, text,
+            date, time, timestamp, any, scalar ]
+ "required":  { type: bool }    # equivarent to 'not-null'
+ "enum":
+    type:      seq
+    sequence:
+      - type:     scalar
+        unique:   yes
+ "pattern":  { type: str }
+ "assert":   { type: str, pattern: /\bval\b/ }
+ "range":
+    type:      map
+    mapping:
+     "max":    { type: scalar }
+     "min":    { type: scalar }
+     "max-ex": { type: scalar }
+     "min-ex": { type: scalar }
+ "length":
+    type:      map
+    mapping:
+     "max":    { type: int }
+     "min":    { type: int }
+     "max-ex": { type: int }
+     "min-ex": { type: int }
+ "ident":   { type: bool }      # equivarent to 'primary-key' (undocumented)
+ "unique":  { type: bool }
+ "default": { type: scalar }    # used only in action's template
+ "sequence":
+    name:      SEQUENCE
+    type:      seq
+    sequence:
+      - type:      map
+        mapping:   *main-rule
+        name:      MAIN
+        #required:  yes
+ "mapping":
+    name:      MAPPING
+    type:      map
+    mapping:
+      =:
+        type:      map
+        mapping:   *main-rule
+        name:      MAIN
+        #required:  yes

data/lib/kwalify/main.rb

@@ -0,0 +1,442 @@
+###
+### $Rev: 95 $
+### $Release: 0.7.1 $
+### copyright(c) 2005-2008 kuwata-lab all rights reserved.
+###
+
+require 'yaml'
+require 'erb'
+require 'kwalify'
+require 'kwalify/util'
+require 'kwalify/util/ordered-hash'
+
+
+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)
+      @options = {}
+      @properties   = {}
+      @template_path  = []
+      $:.each do |path|
+        tpath = "#{path}/kwalify/templates"
+        @template_path << tpath if test(?d, tpath)
+      end
+    end
+
+
+    def debug?
+      @options[:debug]
+    end
+
+
+    def _inspect()
+      sb = []
+      sb <<   "command: #{@command}\n"
+      sb <<   "options:\n"
+      @options.keys.sort {|k1,k2| k1.to_s<=>k2.to_s }.each do |key|
+        sb << "  - #{key}: #{@options[key]}\n"
+      end
+      sb <<   "properties:\n"
+      @properties.keys.sort_by {|k| k.to_s}.each do |key|
+        sb << "  - #{key}: #{@properties[key]}\n"
+      end
+      #sb <<   "template_path:\n"
+      #@template_path.each do |path|
+      #  sb << "  - #{path}\n"
+      #end
+      return sb.join
+    end
+
+
+    def execute(argv=ARGV)
+      ## parse command-line options
+      filenames = _parse_argv(argv)
+
+      ## help or version
+      if @options[:help] || @options[:version]
+        action = @options[:action]
+        s = ''
+        s << _version() << "\n"           if @options[:version]
+        s << _usage()                     if @options[:help] && !action
+        s << _describe_properties(action) if @options[:help] && action
+        puts s
+        return
+      end
+
+      # validation
+      if @options[:meta2]
+        validate_schemafiles2(filenames)
+      elsif @options[:meta]
+        validate_schemafiles(filenames)
+      elsif @options[:action]
+        unless @options[:schema]
+          #* key=:command_option_actionnoschema  msg="schema filename is not specified."
+          raise option_error(:command_option_actionnoschema, @options[:action])
+        end
+        perform_action(@options[:action], @options[:schema])
+      elsif @options[:schema]
+        if @options[:debug]
+          inspect_schema(@options[:schema])
+        else
+          validate_files(filenames, @options[:schema])
+        end
+      else
+        #* key=:command_option_noaction  msg="command-line option '-f' or '-m' required."
+        raise option_error(:command_option_noaction, @command)
+      end
+      return
+    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
+        raise ex if main.debug?
+        $stderr.puts ex.message
+        exit 1
+      rescue Kwalify::KwalifyError => ex
+        raise ex if main.debug?
+        $stderr.puts "ERROR: #{ex.to_s}"
+        exit 1
+      #rescue => ex
+      #  if main.debug?
+      #    raise ex
+      #  else
+      #    $stderr.puts ex.message
+      #    exit 1
+      #  end
+      end
+    end
+
+
+    private
+
+
+    def option_error(error_symbol, arg)
+      msg = Kwalify.msg(error_symbol) % arg
+      return CommandOptionError.new(msg, arg, error_symbol)
+    end
+
+
+    def _find_template(action)
+      template_filename = action + '.eruby'
+      unless test(?f, template_filename)
+        pathlist = []
+        pathlist.concat(@options[:tpath].split(/,/)) if @options[:tpath]
+        pathlist.concat(@template_path)
+        tpath = pathlist.find {|path| test(?f, "#{path}/#{template_filename}") }
+        #* key=:command_option_notemplate  msg="%s: invalid action (template not found).\n"
+        raise option_error(:command_option_notemplate, action) unless tpath
+        template_filename = "#{tpath}/#{action}.eruby"
+      end
+      return template_filename
+    end
+
+
+    def apply_template(template_filename, hash)
+      template = File.read(template_filename)
+      trim_mode = 1
+      erb = ERB.new(template, nil, trim_mode)
+      context = Object.new
+      hash.each do |key, val|
+        context.instance_variable_set("@#{key}", val)
+      end
+      s = context.instance_eval(erb.src, template_filename)
+      return s
+    end
+
+
+    def _describe_properties(action)
+      template_filename = _find_template(action)
+      s = apply_template(template_filename, :describe=>true)
+      return s
+    end
+
+
+    def perform_action(action, schema_filename, describe=false)
+      template_filename = _find_template(action)
+      schema = _load_schemafile(schema_filename, ordered=true)
+      validator = Kwalify::Validator.new(schema)
+      @properties[:schema_filename] = schema_filename
+      hash = { :validator=>validator, :schema=>schema, :properties=>@properties }
+      s = apply_template(template_filename, hash)
+      puts s if s && !s.empty?
+    end
+
+
+    def inspect_schema(schema_filename)
+      schema = _load_schemafile(schema_filename)
+      if schema.nil?
+        puts "nil"
+      else
+        validator = Kwalify::Validator.new(schema)  # error raised when schema is wrong
+        puts validator._inspect()
+      end
+    end
+
+
+    ## -f schemafile datafile
+    def validate_files(filenames, schema_filename)
+      schema = _load_schemafile(schema_filename)
+      validator = Kwalify::Validator.new(schema)
+      _validate_files(validator, filenames)
+    end
+
+
+    def _load_schemafile(schema_filename, ordered=false)
+      str = File.read(schema_filename)
+      if str.empty?
+        #* key=:schema_empty  msg="%s: empty schema.\n"
+        msg = Kwalify.msg(:schema_emtpy) % filename
+        raise CommandOptionError.new(msg)
+      end
+      str = Util.untabify(str) if @options[:untabify]
+      parser = Kwalify::Yaml::Parser.new()
+      parser.preceding_alias = true if @options[:preceding]
+      parser.mapping_class = Kwalify::Util::OrderedHash if ordered
+      schema = parser.parse(str, :filename=>schema_filename) # or YAML.load(str)
+      return schema
+    end
+
+
+    ## -m schemafile
+    def validate_schemafiles(schema_filenames)
+      meta_validator = Kwalify::MetaValidator.instance()
+      _validate_files(meta_validator, schema_filenames)
+    end
+
+
+    ## -M schemafile
+    def validate_schemafiles2(schema_filenames)
+      parser = Kwalify::Yaml::Parser.new()
+      parser.preceding_alias = true if @options[:preceding]
+      for schema_filename in schema_filenames
+        str = File.read(schema_filename)
+        str = Util.untabify(str) if @options[:untabify]
+        schema = parser.parse(str, :filename=>schema_filename)
+        Kwalify::Validator.new(schema)   # exception raised when schema has errors
+      end
+    end
+
+
+    def _validate_files(validator, filenames)
+      ## parser
+      if @options[:linenum] || @options[:preceding]
+        parser = Kwalify::Yaml::Parser.new(validator)
+        parser.preceding_alias = true if @options[:preceding]
+      else
+        parser = nil
+      end
+      ## filenames
+      if filenames.empty?
+        filenames = [ $stdin ]
+      end
+      for filename in filenames
+        ## read input
+        if filename.is_a?(IO)
+          input = filename.read()
+          filename = '(stdin)'
+        else
+          input = File.read(filename)
+        end
+        if input.empty?
+          #* key=:validation_empty  msg="%s#%d: empty."
+          puts kwalify.msg(:validation_empty) % [filename, i]
+          #puts "#{filename}##{i}: empty."
+          next
+        end
+        input = Util.untabify(input) if @options[:untabify]
+        ## parse input
+        if parser
+          #i = 0
+          #ydoc = parser.parse(input, :filename=>filename)
+          #_show_errors(filename, i, ydoc, parser.errors)
+          #while parser.has_next?
+          #  i += 1
+          #  ydoc = parser.parse_next()
+          #  _show_errors(filename, i, ydoc, parser.errors)
+          #end
+          i = 0
+          parser.parse_stream(input, :filename=>filename) do |ydoc|
+            _show_errors(filename, i, ydoc, parser.errors)
+            i += 1
+          end
+        else
+          i = 0
+          YAML.load_documents(input) do |ydoc|
+            errors = validator.validate(ydoc)
+            _show_errors(filename, i, ydoc, errors)
+            i += 1
+          end
+        end
+      end
+    end
+
+
+    def _show_errors(filename, i, ydoc, errors, ok_label="valid.", ng_label="INVALID")
+      if errors && !errors.empty?
+        puts "#{filename}##{i}: #{ng_label}"
+        errors.sort!
+        for error in errors
+          e = error
+          if @options[:emacs]
+            raise unless @options[:linenum]
+            puts "#{filename}:#{e.linenum}:#{e.column} [#{e.path}] #{e.message}\n"
+          elsif @options[:linenum]
+            puts "  - (line #{e.linenum}) [#{e.path}] #{e.message}\n"
+          else
+            puts "  - [#{e.path}] #{e.message}\n"
+          end
+        end
+      elsif ydoc.nil?
+        #* key=:validation_empty  msg="%s#%d: empty.\n"
+        puts kwalify.msg(:validation_empty) % [filename, i]
+      else
+        #* key=:validation_valid  msg="%s#%d: valid."
+        puts Kwalify.msg(:validation_valid) % [filename, i] unless @options[:quiet]
+        #puts "#{filename}##{i} - #{ok_label}" unless @options[:quiet]
+      end
+    end
+
+
+    def _usage()
+      #msg = Kwalify.msg(:command_help) % [@command, @command, @command]
+      msg = Kwalify.msg(:command_help)
+      return msg
+    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)
+      option_table = {
+        ?h => :help,
+        ?v => :version,
+        ?q => :quiet,
+        ?s => :quiet,
+        ?t => :untabify,
+        #?z => :meta,
+        ?m => :meta,
+        ?M => :meta2,
+        ?E => :emacs,
+        ?l => :linenum,
+        ?f => :schema,
+        ?D => :debug,
+        ?a => :action,
+        ?I => :tpath,
+        ?P => :preceding,
+      }
+
+      errcode_table = {
+        #* key=:command_option_schema_required  msg="-%s: schema filename required."
+        ?f => :command_option_schema_required,
+        #* key=:command_option_action_required  msg="-%s: action required."
+        ?a => :command_option_action_required,
+        #* key=:command_option_tpath_required  msg="-%s: template path required."
+        ?I => :command_option_tpath_required,
+      }
+
+      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] = ""
+            unless option_table.key?(optchar)
+              #* key=:command_option_invalid  msg="-%s: invalid command option."
+              raise option_error(:command_option_invalid, optchar.chr)
+            end
+            optkey = option_table[optchar]
+            case optchar
+            when ?f, ?a, ?I
+              arg = optstr.empty? ? argv.shift : optstr
+              raise option_error(errcode_table[optchar], optchar.chr) unless arg
+              @options[optkey] = arg
+              optstr = ''
+            else
+              @options[optkey] = true
+            end
+          end
+        end
+      end  # end of while
+      #
+      @options[:linenum] = true if @options[:emacs]
+      @options[:help]    = true if @properties[:help]
+      @options[: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