dc-kwalify 0.7.2

data/lib/kwalify/templates/genclass-java.eruby

@@ -0,0 +1,222 @@
+<%
+
+    ###
+    ### $Rev$
+    ### $Release: 0.7.2 $
+    ### copyright(c) 2005-2010 kuwata-lab all rights reserved.
+    ###
+
+    require 'fileutils'
+
+    if @describe
+      sb = []
+      sb << "  --package=name        :  package name\n"
+      sb << "  --extends=name        :  class name to extend\n"
+      sb << "  --implements=name,... :  interface names to implement\n"
+      sb << "  --dir=path            :  directory to locate output file\n"
+      sb << "  --basedir=path        :  base directory to locate output file\n"
+      sb << "  --constructor=false   :  not print initialize() method\n"
+      #sb << "  --ggap                :  use generation gap pattern\n"
+      return sb.join
+    end
+
+
+    def java_type(rulehash)
+      return rulehash['class'] if rulehash['class']
+      imports = []
+      case rulehash['type']
+      when nil                 ;  return 'String'
+      when 'str', 'text'       ;  return 'String'
+      when 'char'              ;  return 'char'
+      when 'int'               ;  return 'int'
+      when 'float'             ;  return 'float'
+      when 'bool'              ;  return 'boolean'
+      when 'date'              ;  return 'Date'
+      when 'timestamp'         ;  return 'Date'
+      when 'seq'               ;  return 'List'
+      when 'map'               ;  return 'Map'
+      when 'any'               ;  return 'Object'
+      else
+        raise "*** genclass-java.eruby: '#{rulehash['type']}': unknown type.\n"
+      end
+    end
+
+
+    #def primitive?(type)
+    #   @primitives ||= %w[int char float boolean double long byte]
+    #   return @primitives.include?(type)
+    #end
+
+
+    def camelize(str, all=true)
+      s = str.split(/[^\w]/).collect { |w| w.capitalize }.join()
+      s[0,1] = s[0].chr.lower unless all
+      return s
+    end
+
+
+    def write_file(classname, classdef)
+      if @properties[:dir]
+        dir = @properties[:dir]
+      else
+        basedir = @properties[:basedir] || '.'
+        dir = basedir.dup
+        dir << '/' << @properties[:package].gsub(/\./, '/') if @properties[:package]
+      end
+      FileUtils.mkdir_p(dir) unless test(?d, dir)
+      filename = "#{dir}/#{classname}.java"
+      print "generating #{filename}..."
+      File.open(filename, 'w') { |f| f.write(classdef) }
+      print "done.\n"
+    end
+
+
+    def generate_classdef(schema)
+      hash = Kwalify::Util::OrderedHash.new
+      Kwalify::Util.traverse_schema(schema) do |rulehash|
+        if rulehash['class']
+          classdef = _generate(rulehash)
+          classname = rulehash['class']
+          hash[classname] = classdef if !hash[classname] || classdef.length > hash[classname].length
+        end
+      end
+      hash.each do |classname, classdef|
+        write_file(classname, classdef)
+      end
+      print ""
+    end
+
+
+    def _generate(rulehash)
+      classname = rulehash['class']
+      return unless classname
+      assert unless rulehash['mapping']
+
+      ## preamble
+      schema_filename = @properties[:schema_filename]
+      sb = ''
+      sb       << "// generated by kwalify from #{schema_filename}\n"
+      sb       << "\n"
+
+      ## package and import classes
+      package = @properties[:package]
+      sb       << "package #{package};\n" if package
+      sb       << "import java.util.*;\n"
+      sb       << "\n"
+
+      ## start class declaration
+      extends = @properties[:extends] ? " extends #{@properties[:extends] % classname}" : nil
+      implements = @properties[:implements] ? " implements #{@properties[:implements]}" : nil
+      classname = classname + '_' if @properties[:ggap]
+      sb        << "/**\n"
+      sb        << " *  #{rulehash['desc']}\n"
+      sb        << " */\n"
+      sb        << "public class #{classname}#{extends}#{implements} {\n"
+      sb        << "\n"
+
+      ## instance variables
+      rulehash['mapping'].each do |name, map_rulehash|
+        next unless name =~ /\A[a-zA-Z_][-\w]*\z/
+        name2 = name.gsub(/-/, '_')
+        type = java_type(map_rulehash)
+        if map_rulehash['default'].nil?
+          sb    << "    private #{type} _#{name2};\n"
+        else
+          sb    << "    private #{type} _#{name2} = #{map_rulehash['default'].inspect};\n"
+        end
+      end
+      sb        << "\n"
+
+      ## constructors
+      if @properties[:constructor] != false
+        sb      << _generate_constructor(rulehash)
+        sb      << "\n"
+      end #if
+
+      ## setter/getter
+      rulehash['mapping'].each do |name, map_rulehash|
+        next unless name =~ /\A[a-zA-Z_][-\w]*\z/
+        name2 = name.gsub(/-/, '_')
+        type = java_type(map_rulehash)
+        get = type == 'boolean' ? 'is' : 'get'
+        sb      << "    public #{type} #{get}#{camelize(name)}() { return _#{name2}; }\n"
+        sb      << "    public void set#{camelize(name)}(#{type} #{name2}_) { _#{name2} = #{name2}_; }\n"
+      end
+
+      ## end of class declaration
+      if @properties[:ggap]
+        sb      << "}\n"
+        sb      << "public class #{rulehash['class']} < #{classname}\n"
+      end
+      sb        << "}\n"
+
+      ##
+      classdef = sb
+      return classdef
+    end
+
+
+    def _generate_constructor(rulehash)
+      classname = rulehash['class']
+      sb = ''
+      ## default constructor
+      sb        << "    public #{classname}() {}\n"
+      sb        << "\n"
+      ## constructor
+      sb        << "    public #{classname}(Map map) {\n"
+      objdecl   =  "        Object obj;\n"
+      seqdecl   =  "        List seq;\n"
+      rulehash['mapping'].each do |name, map_rulehash|
+        next unless name =~ /\A[a-zA-Z_][-\w]*\z/
+        name2 = name.gsub(/-/, '_')
+        if map_rulehash['class']
+          cname = map_rulehash['class']
+          type  = java_type(map_rulehash)
+          sb    << objdecl;  objdecl = ''
+          sb    << "        if ((obj = map.get(\"#{name}\")) != null && obj instanceof Map) {\n"
+          sb    << "            _%-8s = new #{cname}((Map)obj);\n" % name2
+          sb    << "        } else {\n"
+          sb    << "            _%-8s = (#{type})obj;\n" % name2
+          sb    << "        }\n"
+        elsif map_rulehash['sequence'] && map_rulehash['sequence'][0]['class']
+          item_rulehash = map_rulehash['sequence'][0]
+          cname = item_rulehash['class']
+          type  = java_type(item_rulehash)
+          sb    << seqdecl;  seqdecl = ''
+          sb    << objdecl;  objdecl = ''
+          sb    << "        if ((seq = (List)map.get(\"#{name}\")) != null) {\n"
+          sb    << "            for (int i = 0; i < seq.size(); i++) {\n"
+          sb    << "                if ((obj = seq.get(i)) instanceof Map) {\n"
+          sb    << "                    seq.set(i, new #{cname}((Map)obj));\n"
+          sb    << "                }\n"
+          sb    << "            }\n"
+          sb    << "        }\n"
+          sb    << "        _%-12s = seq;\n" % name2
+        else
+          type = java_type(map_rulehash)
+          @wrapper_classes ||= {
+            'int'   => 'Number',  'short'  => 'Number',
+            'float' => 'Number',  'double' => 'Number',
+            'long'  => 'Number',  'byte'   => 'Number',
+            'char'  => 'Character',
+            'boolean'  => 'Boolean',
+          }
+          if (wrapper = @wrapper_classes[type])
+            sb  << "        if (map.get(\"#{name}\") != null) {\n"
+            sb  << "            _%-8s = ((#{wrapper})map.get(\"#{name}\")).#{type}Value();\n" % name2
+            sb  << "        }\n"
+          elsif map_rulehash.key?('default')
+            sb  << "        if (map.get(\"#{name}\") != null)\n"
+            sb  << "            _%-8s = (#{type})map.get(\"#{name}\");\n" % name2
+          else
+            sb  << "        _%-12s = (#{type})map.get(\"#{name}\");\n" % name2
+          end
+        end #if
+      end #each
+      sb        << "    }\n"
+      return sb
+    end
+
+
+%>
+<%= generate_classdef(@schema) %>

data/lib/kwalify/templates/genclass-php.eruby

@@ -0,0 +1,104 @@
+<%
+
+    ###
+    ### $Rev$
+    ### $Release: 0.7.2 $
+    ### copyright(c) 2005-2010 kuwata-lab all rights reserved.
+    ###
+
+    if @describe
+       sb = []
+       sb << "  --namespace=name :  prefix name of class\n"
+       sb << "  --extends=name   :  parent class name\n"
+       sb << "  --inplements=name:  interface name\n"
+       sb << "  --constructor=false :  not print constructor\n"
+       #sb << "  --ggap          :  use generation gap pattern\n"
+       return sb.join
+    end
+
+
+    require 'kwalify/util/ordered-hash'
+
+    def generate_classdef(schema)
+      hash = Kwalify::Util::OrderedHash.new
+      #hash.instance_eval { alias []= add }
+      Kwalify::Util.traverse_schema(schema) do |rulehash|
+        if rulehash['class']
+          arr = _generate_classdef(rulehash)
+          key = rulehash['class']
+          classdef = arr.join()
+          #hash[key] = classdef if !hash.key?(key) || classdef != hash[key]
+          hash[key] = classdef if !hash.key?(key) || classdef.length > hash[key].length
+        end
+      end
+      sb = "<?php\n"
+      sb << "\n"
+      hash.each do |classname, classdef|
+        sb << classdef
+        sb << "\n"
+      end
+      sb << "?>\n"
+      return sb
+    end
+
+
+    def _generate_classdef(rulehash)
+      return nil unless rulehash['class']
+      assert unless rulehash['mapping']
+      classname = rulehash['class']
+      classname = classname + '_' if @properties[:ggap]
+      ns = @properties[:namespace]
+      ns = ns + '_' if ns
+      flag_init = @properties[:constructor] != false
+      v = nil
+      arr = ['']
+      arr     << "/// #{rulehash['desc']}\n"
+      arr     << "class #{ns}#{classname}"
+      arr     << " extends #{v}"     if v = @properties[:extends]
+      arr     << " implements #{v}"  if v = @properties[:implements]
+      arr     << " {\n"
+      arr2 = []   # assign into instance variables
+      rulehash['mapping'].each do |name, map_rulehash|
+        next unless name =~ /\A[a-zA-Z_][-\w]*\z/
+        name2 = name.gsub(/-/, '_')
+        var = "%-10s" % name2
+        len = 10 - name2.length
+        spc = ' ' * (len >= 0 ? len : 0)
+        if map_rulehash.key?('default')
+          arr << "    var $#{name2} = #{map_rulehash['default'].inspect}; // #{map_rulehash['type'] || 'str'}\n"
+        else
+          arr << "    var $#{name2}; #{spc}// #{map_rulehash['type'] || 'str'}\n"
+        end
+        if !flag_init
+          # pass
+        elsif map_rulehash['class']
+          cname = map_rulehash['class']
+          arr2 << "        $this->#{var} = is_array(@$arr['#{name}']) ? new #{cname}($arr['#{name}']) : @$arr['#{name}'];\n"
+        elsif map_rulehash['sequence'] && map_rulehash['sequence'][0]['class']
+          item_rulehash = map_rulehash['sequence'][0]
+          cname = item_rulehash['class']
+	  arr2 << "        if (is_array(@$arr['#{name}']))\n"
+	  arr2 << "            foreach ($arr['#{name}'] as $k=>$v)\n"
+	  arr2 << "                $this->#{name2}[$k] = is_array($v) ? new #{cname}($v) : $v;\n"
+	  arr2 << "        //else\n"
+	  arr2 << "        //    $this->#{var} = @$arr['#{name}'];\n"
+        elsif map_rulehash.key?('default')
+          arr2 << "        if (array_key_exists('#{name}', $arr)) $this->#{name2} = $arr['#{name}'];\n"
+        else
+          arr2 << "        $this->#{var} = @$arr['#{name}'];\n"
+        end
+      end
+      arr      << "    function __construct($arr=NULL) {\n"    if flag_init
+      arr      << "        if (! $arr) return;\n"            if flag_init
+      arr.concat(arr2)
+      arr      << "    }\n"   if flag_init
+      if @properties[:ggap]
+        arr   << "}\n"
+        arr   << "class #{ns}#{rulehash['class']} extends #{ns}#{classname}\n"
+      end
+      arr     << "}\n"
+      return arr
+    end
+
+%>
+<%= generate_classdef(@schema) %>

data/lib/kwalify/templates/genclass-ruby.eruby

@@ -0,0 +1,113 @@
+<%
+
+    ###
+    ### $Rev$
+    ### $Release: 0.7.2 $
+    ### copyright(c) 2005-2010 kuwata-lab all rights reserved.
+    ###
+
+    if @describe
+       sb = []
+       sb << "  --module=name   :  module name in which class defined\n"
+       sb << "  --parent=name   :  parent class name\n"
+       sb << "  --include=name  :  module name which all classes include\n"
+       sb << "  --initialize=false :  not print initialize() method\n"
+       sb << "  --hashlike      :  include Kwalify::Util::HashLike module\n"
+       #sb << "  --ggap          :  use generation gap pattern\n"
+       return sb.join
+    end
+
+
+    require 'kwalify/util/ordered-hash'
+
+    def generate_classdef(schema)
+      hash = Kwalify::Util::OrderedHash.new
+      #hash.instance_eval { alias []= add }
+      modname = @properties[:module]
+      Kwalify::Util.traverse_schema(schema) do |rulehash|
+        if rulehash['class']
+          arr = _generate_classdef(rulehash)
+          key = rulehash['class']
+          classdef = modname ? arr.join('  ') : arr.join()
+          #hash[key] = classdef if !hash.key?(key) || classdef != hash[key]
+          hash[key] = classdef if !hash.key?(key) || classdef.length > hash[key].length
+        end
+      end
+      sb = ''
+      sb   << "require 'kwalify/util/hashlike'\n" if @properties[:hashlike]
+      sb   << "\n"                                if @properties[:hashlike]
+      sb   << "module #{@properties[:module]}\n"  if modname
+      sb   << "\n"                                if modname
+      hash.each do |classname, classdef|
+        sb << classdef
+        sb << "\n"
+      end
+      sb   << "end\n"                             if modname
+      sb   << "\n"                                if modname
+      return sb.chomp
+    end
+
+
+    def _generate_classdef(rulehash)
+      return nil unless rulehash['class']
+      assert unless rulehash['mapping']
+      classname = rulehash['class']
+      classname = classname + '_' if @properties[:ggap]
+      extend = @properties[:parent] ? " < #{@properties[:parent]}" : nil
+      flag_init = @properties[:initialize] != false
+      arr = ['']
+      arr      << "## #{rulehash['desc']}\n"
+      arr      << "class #{classname}#{extend}\n"
+      arr      << "  include Kwalify::Util::HashLike\n"  if @properties[:hashlike]
+      arr      << "  include #{@properties[:include]}\n" if @properties[:include]
+      arr1 = []
+      arr2 = []   # accessors
+      arr3 = []   # boolean accessors
+      arr4 = []   # default values
+      v = nil
+      rulehash['mapping'].each do |name, map_rulehash|
+        next unless name =~ /\A[a-zA-Z_][-\w]*\z/
+        name2 = name.gsub(/-/, '_')
+        var = "%-16s" % name2
+        len = 13 - name2.length
+        len = 0 if len < 0
+        spc = ' ' * len
+        arr2   << "  attr_accessor :#{var} # #{map_rulehash['type'] || 'str'}\n"
+        flag_bool = (t = map_rulehash['type']) == 'bool' || t == 'boolean'
+        arr3   << "  def #{name2}?#{spc};  @#{name2}#{spc}; end\n" if flag_bool
+        arr4   << "      @#{var} = #{v.inspect}\n" unless (v=map_rulehash['default']).nil?
+        if !flag_init
+          # pass
+        elsif map_rulehash['class']
+          cname = map_rulehash['class']
+          arr1 << "    @#{var} = (v=hash['#{name}']) && v.is_a?(Hash) ? #{cname}.new(v) : v\n"
+        elsif map_rulehash['sequence'] && map_rulehash['sequence'][0]['class']
+          item_rulehash = map_rulehash['sequence'][0]
+          cname = item_rulehash['class']
+          arr1 << "    @#{var} = (v=hash['#{name}']) ? v.map!{|e| e.is_a?(#{cname}) ? e : #{cname}.new(e)} : v\n"
+        elsif map_rulehash.key?('default')
+          #arr << "    @#{var} = hash.key?('#{name}') ? hash['#{name}'] : #{map_rulehash['default'].inspect}\n"
+          arr1 << "    @#{var} = (v=hash['#{name}']).nil? ? #{map_rulehash['default'].inspect} : v\n"
+        else
+          arr1 << "    @#{var} = hash['#{name}']\n"
+        end
+      end
+      arr      << "  def initialize(hash=nil)\n" if flag_init
+      arr      << "    if hash.nil?\n"           if flag_init
+      arr.concat arr4                            if flag_init
+      arr      << "      return\n"               if flag_init
+      arr      << "    end\n"                    if flag_init
+      arr.concat arr1                            if flag_init
+      arr      << "  end\n"                      if flag_init
+      arr.concat(arr2)
+      arr.concat(arr3)
+      if @properties[:ggap]
+        arr    << "end\n"
+        arr    << "class #{rulehash['class']} < #{classname}\n"
+      end
+      arr      << "end\n"
+      return arr
+    end
+
+%>
+<%= generate_classdef(@schema) %>

data/lib/kwalify/types.rb

@@ -0,0 +1,156 @@
+###
+### $Rev$
+### $Release: 0.7.2 $
+### copyright(c) 2005-2010 kuwata-lab all rights reserved.
+###
+
+require 'date'
+
+
+module Kwalify
+  module Boolean  # :nodoc:
+  end
+end
+class TrueClass   # :nodoc:
+  include Kwalify::Boolean
+end
+class FalseClass  # :nodoc:
+  include Kwalify::Boolean
+end
+#module Boolean; end
+#class TrueClass
+#  include Boolean
+#end
+#class FalseClass
+#  include Boolean
+#end
+
+
+module Kwalify
+  module Text  # :nodoc:
+  end
+end
+class String   # :nodoc:
+  include Kwalify::Text
+end
+class Numeric  # :nodoc:
+  include Kwalify::Text
+end
+#module Text; end
+#class String
+#  include Text
+#end
+#class Numeric
+#  include Text
+#end
+
+
+module Kwalify
+  module Scalar  # :nodoc:
+  end
+end
+class String     # :nodoc:
+  include Kwalify::Scalar
+end
+class Numeric    # :nodoc:
+  include Kwalify::Scalar
+end
+class Date       # :nodoc:
+  include Kwalify::Scalar
+end
+class Time       # :nodoc:
+  include Kwalify::Scalar
+end
+class TrueClass  # :nodoc:
+  include Kwalify::Scalar
+end
+class FalseClass # :nodoc:
+  include Kwalify::Scalar
+end
+class NilClass   # :nodoc:
+  include Kwalify::Scalar
+end
+module Kwalify
+  module Text    # :nodoc:
+    include Kwalify::Scalar
+  end
+end
+
+
+module Kwalify
+
+
+  module Types
+
+
+    DEFAULT_TYPE = "str"        ## use "str" as default of @type
+
+    @@type_table = {
+      "seq"     => Array,
+      "map"     => Hash,
+      "str"     => String,
+      #"string"   => String,
+      "text"    => Text,
+      "int"     => Integer,
+      #"integer"  => Integer,
+      "float"    => Float,
+      "number"   => Numeric,
+      #"numeric"  => Numeric,
+      "date"    => Date,
+      "time"    => Time,
+      "timestamp" => Time,
+      "bool"    => Boolean,
+      #"boolean"  => Boolean,
+      #"object"   => Object,
+      "any"     => Object,
+      "scalar"   => Scalar,
+    }
+
+    def self.type_table
+      return @@type_table
+    end
+
+    def self.type_class(type)
+      klass = @@type_table[type]
+      #assert_error('type=#{type.inspect}') unless klass
+      return klass
+    end
+
+    def self.get_type_class(type)
+      return type_class(type)
+    end
+
+
+
+    #--
+    #def collection_class?(klass)
+    #  return klass.is_a?(Array) || klass.is_a?(Hash)
+    #end
+    #
+    #def scalar_class?(klass)
+    #  return !klass.is_a?(Array) && !klass.is_a?(Hash) && klass != Object
+    #end
+
+    def collection?(val)
+      return val.is_a?(Array) || val.is_a?(Hash)
+    end
+
+    def scalar?(val)
+      #return !val.is_a?(Array) && !val.is_a?(Hash) && val.class != Object
+      return val.is_a?(Kwalify::Scalar)  #&& val.class != Object
+    end
+
+    def collection_type?(type)
+      return type == 'seq' || type == 'map'
+    end
+
+    def scalar_type?(type)
+      return type != 'seq' && type != 'map' && type == 'any'
+    end
+
+    module_function 'collection?', 'scalar?', 'collection_type?', 'scalar_type?'
+  end
+
+  extend Types
+
+end

data/lib/kwalify/util/assert-text-equal.rb

@@ -0,0 +1,46 @@
+###
+### $Rev$
+### $Release: 0.7.2 $
+### copyright(c) 2005-2010 kuwata-lab all rights reserved.
+###
+
+require 'test/unit/testcase'
+require 'tempfile'
+
+
+class Test::Unit::TestCase  # :nodoc:
+
+  def assert_text_equal(expected, actual, message=nil, options={}) # :nodoc:
+    expected = expected.to_s
+    actual   = actual.to_s
+    diffopt  = options[:diffopt] || '-u'
+    flag_cut = options.key?(:cut) ? options[:key] : true
+
+    if expected == actual
+      assert(true)
+      return
+    end
+    if expected[-1] != ?\n || actual[-1] != ?\n
+      expected += "\n"
+      actual   += "\n"
+    end
+    begin
+      expfile = Tempfile.new(".expected.")
+      expfile.write(expected); expfile.flush()
+      actfile = Tempfile.new(".actual.")
+      actfile.write(actual);   actfile.flush()
+      diff = `diff #{diffopt} #{expfile.path} #{actfile.path}`
+    ensure
+      expfile.close(true) if expfile
+      actfile.close(true) if actfile
+    end
+    # cut 1st & 2nd lines
+    message = (flag_cut ? diff.gsub(/\A.*\n.*\n/, '') : diff) unless message
+    #raise Test::Unit::AssertionFailedError.new(message)
+    assert_block(message) { false }  # or assert(false, message)
+  end
+
+  alias assert_equal_with_diff assert_text_equal    # for compatibility
+  alias assert_text_equals     assert_text_equal    # for typo
+
+end

data/lib/kwalify/util/hash-interface.rb

@@ -0,0 +1,18 @@
+###
+### $Rev$$
+### $Release: 0.7.2 $
+### copyright(c) 2005-2010 kuwata-lab all rights reserved.
+###
+
+require 'kwalify/util/hashlike'
+
+module Kwalify
+
+  ##
+  ## OBSOLETE: use Hash::Util::HashLike instead.
+  ##
+  module HashInterface
+    include Kwalify::Util::HashLike
+  end
+
+end