kwalify 0.6.1 → 0.7.0

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

@@ -1,32 +1,44 @@
 <%
 
+    ###
+    ### $Rev: 95 $
+    ### $Release: 0.7.0 $
+    ### copyright(c) 2005-2008 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"
-       return sb.join
+      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(rule)
-       return rule.classname if rule.classname
-       imports = []
-       case rule.type
-       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'    
-       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
 
 
@@ -37,159 +49,174 @@
 
 
     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
+      s = str.split(/[^\w]/).collect { |w| w.capitalize }.join()
+      s[0,1] = s[0].chr.lower unless all
+      return s
     end
 
 
-    def write_file(classdef_info)
-       classname, classdef = classdef_info
-       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"
-       $stdout.print "generating #{filename}..."
-       File.open(filename, 'w') { |f| f.write(classdef) }
-       $stdout.print "done.\n"
+    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(rule)
-       classdef_list = []
-       done = {}
-       _generate(rule, classdef_list, done)
-       classdef_list.each do |classdef_info|
-         write_file(classdef_info)
-       end
-       return nil
+    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(rule, classdef_list=[], done={})
-       return if done.key?(rule.__id__)
-       done[rule.__id__] = rule
-       #
-       sb = []
-       if rule.classname
-          unless rule.type == 'map'
-             raise "*** assertion error: rule.type==#{rule.type.inspect}"
-          end
-          assert unless rule.mapping
-
-	  ## preamble
-	  sb   <<    "// generated by kwalify from #{@properties[:schema_filename]}\n"
-	  sb   <<    "\n"
-
-          ## package and import classes
-          sb   <<    "package #{@properties[:package]};\n" if @properties[:package]
-          sb   <<    "import java.util.*;\n"
-          sb   <<    "\n"
-
-          ## start class declaration
-          classname = rule.classname
-          extends = @properties[:extends] ? " extends #{@properties[:extends] % classname}" : nil
-          implements = @properties[:implements] ? " implements #{@properties[:implements]}" : nil
-          classname = classname + '_' if @properties[:ggap]
-          sb   <<     "/**\n"
-          sb   <<     " *  #{rule.desc}\n"
-          sb   <<     " */\n"
-          sb   <<     "public class #{classname}#{extends}#{implements} {\n"
-          sb   <<     "\n"
-
-          ## instance variables
-          rule.mapping.each do |name, map_rule|
-             type = java_type(map_rule)
-             sb <<    "    private #{type} _#{name};\n"
-          end
-          sb   <<     "\n"
-
-          ## default constructor
-          sb   <<     "    public #{classname}() {}\n"
-          sb   <<     "\n"
-
-          ## constructor
-          sb   <<     "    public #{classname}(Map map) {\n"
-          objdecl  =  "        Object obj;\n"
-	  seqdecl  =  "        List seq;\n"
-          rule.mapping.each do |name, map_rule|
-             next unless name =~ /\A[a-zA-Z_]\w*\z/
-             if map_rule.classname
-                cname = map_rule.classname
-                type  = java_type(map_rule)
-                sb << objdecl;  objdecl = ''
-                sb << "        if ((obj = map.get(\"#{name}\")) != null && obj instanceof Map) {\n"
-                sb << "            _%-8s = new #{cname}((Map)obj);\n" % name
-                sb << "        } else {\n"
-                sb << "            _%-8s = (#{type})obj;\n" % name
-                sb << "        }\n"
-             elsif map_rule.sequence && map_rule.sequence[0].classname
-                item_rule = map_rule.sequence[0]
-                cname = item_rule.classname
-                type  = java_type(item_rule)
-                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" % name
-             else
-                type = java_type(map_rule)
-                @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" % name
-		   sb << "        }\n"
-                else
-                   sb << "        _%-12s = (#{type})map.get(\"#{name}\");\n" % name
-                end
-             end #if
-          end #each
-          sb   <<     "    }\n"
-          sb   <<     "\n"
-
-          ## setter/getter
-          rule.mapping.each do |name, map_rule|
-             next unless name =~ /\A[a-zA-Z_]\w*\z/
-             type = java_type(map_rule)
-             sb <<       "    public #{type} get#{camelize(name)}() { return _#{name}; }\n"
-             sb <<       "    public void set#{camelize(name)}(#{type} #{name}_) { _#{name} = #{name}_; }\n"
-          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
+
 
-          ## end of class declaration
-          if @properties[:ggap]
-             sb <<       "}\n"
-             sb <<       "public class #{rule.classname} < #{classname}\n"
+    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
-          sb   <<       "}\n"
-
-	  ##
-	  classdef_list << [classname, sb.join]
-       end #if
-       #
-       rule.sequence.each do |seq_rule|
-          _generate(seq_rule, classdef_list, done)
-       end if rule.sequence
-       rule.mapping.each do |name, map_rule|
-          _generate(map_rule, classdef_list, done)
-       end if rule.mapping
+        end #if
+      end #each
+      sb        << "    }\n"
+      return sb
     end
 
 
 %>
-<%= generate_classdef(@rule) %>
+<%= generate_classdef(@schema) %>

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

@@ -0,0 +1,104 @@
+<%
+
+    ###
+    ### $Rev$
+    ### $Release: 0.7.0 $
+    ### copyright(c) 2005-2008 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) %>