rkwalify 1.4.0.pre.beta

data/lib/kwalify/util/hashlike.rb

@@ -0,0 +1,51 @@
+###
+### $Rev$
+### $Release 1.4.0-beta $
+### copyright(c) 2005-2010 kuwata-lab all rights reserved.
+###
+
+module Kwalify
+
+  module Util
+
+    ##
+    ## add hash-like methods
+    ##
+    module HashLike
+
+      def [](key)
+        instance_variable_get("@#{key}")
+      end
+
+      def []=(key, val)
+        instance_variable_set("@#{key}", val)
+      end
+
+      #--
+      #def keys()
+      #  instance_variables().collect { |name| name[1, name.length-1] }
+      #end
+      #++
+
+      def key?(key)
+        instance_variables().include?("@#{key}")
+      end
+      if Object.method_defined?('instance_variable_defined?')
+        def key?(key)
+          instance_variable_defined?("@#{key}")
+        end
+      end
+
+      def each   # not necessary
+        instance_variables().each do |name|
+          key = name[1, name.length-1]
+          val = instance_variable_get(name)
+          yield(key, val)
+        end
+      end
+
+    end
+
+  end
+
+end

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

@@ -0,0 +1,220 @@
+###
+### $Rev$
+### $Release 1.4.0-beta $
+### copyright(c) 2005-2010 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/ordered-hash.rb

@@ -0,0 +1,57 @@
+###
+### $Rev$
+### Release 1.4.0-beta
+### $COPYRIGHT$
+###
+
+module Kwalify
+
+  module Util
+
+    class OrderedHash < Hash
+
+      def initialize(*args, &)
+        super
+        @_keys = []
+      end
+
+      alias __set__ []=
+
+      def put(key, val)
+        @_keys << key unless self.key?(key)
+        __set__(key, val)
+      end
+
+      def add(key, val)
+        @_keys.delete_at(@_keys.index(key)) if self.key?(key)
+        @_keys << key
+        __set__(key, val)
+      end
+
+      alias []= put
+      #alias []= add
+
+      def keys
+        return @_keys.dup
+      end
+
+      def values
+        return @_keys.collect {|key| self[key] }
+      end
+
+      def delete(key)
+        @_keys.delete_at(@_keys.index(key)) if self.key?(key)
+        super
+      end
+
+      def each
+        @_keys.each do |key|
+          yield key, self[key]
+        end
+      end
+
+    end
+
+  end
+
+end

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

@@ -0,0 +1,112 @@
+###
+### $Rev$
+### $Release 1.4.0-beta $
+### copyright(c) 2005-2010 kuwata-lab all rights reserved.
+###
+
+require 'yaml'
+require 'test/unit/testcase'
+
+
+class Test::Unit::TestCase   # :nodoc:
+
+
+  def self._untabify(str, width=8)         # :nodoc:
+    sb = []
+    str.scan(/(.*?)\t/m) do |s, |
+      len = (n = s.rindex(?\n)) ? s.length - n - 1 : s.length
+      sb << s << (" " * (width - (len % width)))
+    end
+    str = (sb << $').join if $'
+    return str
+  end
+
+
+  def self.load_yaml_documents(filename, options={})   # :nodoc:
+    str = File.read(filename)
+    if filename =~ /\.rb$/
+      str =~ /^__END__$/   or raise "*** error: __END__ is not found in '#{filename}'."
+      str = $'
+    end
+    str = _untabify(str) unless options[:tabify] == false
+    #
+    identkey = options[:identkey] || 'name'
+    list = []
+    table = {}
+    YAML.load_stream(str) do |ydoc|
+      if ydoc.is_a?(Hash)
+        list << ydoc
+      elsif ydoc.is_a?(Array)
+        list += ydoc
+      else
+        raise "*** invalid ydoc: #{ydoc.inspect}"
+      end
+    end
+    #
+    list.each do |ydoc|
+      ident = ydoc[identkey]
+      ident         or  raise "*** #{identkey} is not found."
+      table[ident]  and raise "*** #{identkey} '#{ident}' is duplicated."
+      table[ident] = ydoc
+      yield(ydoc) if block_given?
+    end
+    #
+    return list
+  end
+
+
+  def self.load_yaml_testdata(filename, options={})   # :nodoc:
+    identkey   = options[:identkey]   || 'name'
+    testmethod = options[:testmethod] || '_test'
+    lang       = options[:lang]
+    load_yaml_documents(filename, options) do |ydoc|
+      ident = ydoc[identkey]
+      s  =   "def test_#{ident}\n"
+      ydoc.each do |key, val|
+        if key[-1] == ?*
+          key = key[0, key.length-1]
+          val = val[lang]
+        end
+        s << "  @#{key} = #{val.inspect}\n"
+      end
+      s  <<  "  #{testmethod}\n"
+      s  <<  "end\n"
+      #$stderr.puts "*** #{method_name()}(): eval_str=<<'END'\n#{s}END" if $DEBUG
+      module_eval s   # not eval!
+    end
+  end
+
+
+  def self.method_name   # :nodoc:
+    return (caller[0] =~ /in `(.*?)'/) && $1
+  end
+
+
+  def self.load_yaml_testdata_with_each_lang(filename, options={})   # :nodoc:
+    identkey   = options[:identkey]   || 'name'
+    testmethod = options[:testmethod] || '_test'
+    langs = defined?($lang) && $lang ? [ $lang ] : options[:langs]
+    langs or raise "*** #{method_name()}(): option ':langs' is required."
+    #
+    load_yaml_documents(filename, options) do |ydoc|
+      ident = ydoc[identkey]
+      langs.each do |lang|
+        s  =   "def test_#{ident}_#{lang}\n"
+        s  <<  "  @lang = #{lang.inspect}\n"
+        ydoc.each do |key, val|
+          if key[-1] == ?*
+            key = key[0, key.length-1]
+            val = val[lang]
+          end
+          s << "  @#{key} = #{val.inspect}\n"
+        end
+        s  <<  "  #{testmethod}\n"
+        s  <<  "end\n"
+        #$stderr.puts "*** #{method_name()}(): eval_str=<<'END'\n#{s}END" if $DEBUG
+        module_eval s   # not eval!
+      end
+    end
+  end
+
+
+end

data/lib/kwalify/util.rb

@@ -0,0 +1,159 @@
+###
+### $Rev$
+### $Release 1.4.0-beta $
+### copyright(c) 2005-2010 kuwata-lab all rights reserved.
+###
+# frozen_string_literal: false
+
+module Kwalify
+
+  module Util
+
+    module_function
+
+    ##
+    ## expand tab character to spaces
+    ##
+    ## ex.
+    ##   untabified_str = YamlHelper.untabify(tabbed_str)
+    ##
+    def untabify(str, width=8)
+      return str if str.nil?
+      list = str.split("\t", -1)   # if 2nd arg is negative then split() doesn't remove tailing empty strings
+      last = list.pop
+      sb = ''
+      list.each do |s|
+        column = (n = s.rindex(?\n)) ? s.length - n - 1 : s.length
+        n = width - (column % width)
+        sb << s << (' ' * n)
+      end
+      sb << last if last
+      return sb
+    end
+
+
+    ## traverse schema
+    ##
+    ## ex.
+    ##   schema = YAML.load_file('myschema.yaml')
+    ##   Kwalify::Util.traverse_schema(schema) do |rulehash|
+    ##     ## add module prefix to class name
+    ##     if rulehash['class']
+    ##       rulehash['class'] = 'MyModule::' + rulehash['class']
+    ##     end
+    ##   end
+    def traverse_schema(schema, &)  #:yield: rulehash
+      hash = schema
+      _done = {}
+      _traverse_schema(hash, _done, &)
+    end
+
+    def _traverse_schema(hash, _done={}, &)
+      return if _done.key?(hash.__id__)
+      _done[hash.__id__] = hash
+      yield hash
+      if hash['mapping']
+        hash['mapping'].each {|k, v| _traverse_schema(v, _done, &) }
+      elsif hash['sequence']
+        _traverse_schema(hash['sequence'][0], _done, &)
+      end
+    end
+    private :_traverse_schema
+
+
+    ## traverse rule
+    ##
+    ## ex.
+    ##   schema = YAML.load_file('myschema.yaml')
+    ##   validator = Kwalify::Validator.new(schema)
+    ##   Kwalify::Util.traverse_rule(validator) do |rule|
+    ##     p rule if rule.classname
+    ##   end
+    def traverse_rule(validator, &)  #:yield: rule
+      rule = validator.is_a?(Rule) ? validator : validator.rule
+      _done = {}
+      _traverse_rule(rule, _done, &)
+    end
+
+    def _traverse_rule(rule, _done={}, &)
+       return if _done.key?(rule.__id__)
+       _done[rule.__id__] = rule
+       yield rule
+       rule.sequence.each do |seq_rule|
+          _traverse_rule(seq_rule, _done, &)
+       end if rule.sequence
+       rule.mapping.each do |name, map_rule|
+          _traverse_rule(map_rule, _done, &)
+       end if rule.mapping
+    end
+    private :_traverse_rule
+
+
+    ##
+    ## get class object. if not found, NameError raised.
+    ##
+    def get_class(classname)
+      klass = Object
+      classname.split('::').each do |name|
+        klass = klass.const_get(name)
+      end
+      return klass
+    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 = YamlHelper.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 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 = YamlHelper.get_value(obj, ['aaa', 0, 'xxx'])
+    ##
+    ## This is equal to the following:
+    ##   begin
+    ##     val = obj['aaa'][0]['xxx']
+    ##   rescue NameError
+    ##     val = nil
+    ##   end
+    ##
+    def get_value(obj, path)
+      val = obj
+      path.each do |key|
+        return nil unless val.is_a?(Hash) || val.is_a?(Array)
+        val = val[key]
+      end if path
+      return val
+    end
+
+  end
+
+end