kwalify 0.5.1 → 0.6.0

data/lib/kwalify/messages.rb

@@ -1,6 +1,6 @@
 ###
-### $Rev: 44 $
-### $Release: 0.5.1 $
+### $Rev: 51 $
+### $Release: 0.6.0 $
 ### copyright(c) 2005 kuwata-lab all rights reserved.
 ###
 
@@ -15,33 +15,38 @@ module Kwalify
 
 
    @@messages[:command_help] = <<END
-Usage1: %s [-hvstlE] -f schema.yaml doc.yaml [doc2.yaml ...]
-Usage2: %s [-hvstlE] -m schema.yaml [schema2.yaml ...]
+kwalify - tiny schema validator for YAML and JSON
+Usage1: kwalify [..options..] -f schema.yaml doc.yaml [doc2.yaml ...]
+Usage2: kwalify [..options..] -m schema.yaml [schema2.yaml ...]
+Usage3: kwalify [..options..] -a action -f schema.yaml [schema2.yaml ...]
   -h, --help      :  help
   -v              :  version
   -s              :  silent
   -f schema.yaml  :  schema definition file
   -m              :  meta-validation mode
-  -t              :  expand tab character automatically
+  -t              :  expand tab characters
   -l              :  show linenumber when errored (experimental)
   -E              :  show errors in emacs-style (implies '-l')
+  -a action       :  action ('genclass-ruby' or 'genclass-java')
+                     (use '-ha action' option to show action properites)
 END
+#  -I path         :  path for template of action
 
 
 
    ##----- begin
    # filename: lib/kwalify/main.rb
+   @@messages[:command_option_actionnoschema] = "schema filename is not specified."
    @@messages[:command_option_noaction] = "command-line option '-f' or '-m' required."
-   @@messages[:meta_empty]           = "%s: empty.\n"
-   @@messages[:meta_valid]           = "%s: ok.\n"
-   @@messages[:meta_invalid]         = "%s: NG!\n"
-   @@messages[:schema_empty]         = "%s#%d: empty schema.\n"
+   @@messages[:command_option_notemplate] = "%s: invalid action (template not found).\n"
+   @@messages[:schema_empty]         = "%s: empty schema.\n"
    @@messages[:validation_empty]     = "%s#%d: empty.\n"
    @@messages[:validation_valid]     = "%s#%d: valid.\n"
    @@messages[:validation_invalid]   = "%s#%d: INVALID\n"
-   @@messages[:command_property_invalid] = "%s: invalid property."
-   @@messages[:command_option_noarg] = "-%s: argument required."
    @@messages[:command_option_noschema] = "-%s: schema filename required."
+   @@messages[:command_option_noaction] = "-%s: action required."
+   @@messages[:command_option_notpath] = "-%s: template path required."
+   @@messages[:command_property_invalid] = "%s: invalid property."
    @@messages[:command_option_invalid] = "-%s: invalid command option."
    # --
    # filename: lib/kwalify/rule.rb
@@ -49,6 +54,7 @@ END
    @@messages[:key_unknown]          = "unknown key."
    @@messages[:type_notstr]          = "not a string."
    @@messages[:type_unknown]         = "unknown type."
+   @@messages[:classname_notmap]     = "available only with map type."
    @@messages[:required_notbool]     = "not a boolean."
    @@messages[:pattern_notstr]       = "not a string (or regexp)"
    @@messages[:pattern_notmatch]     = "should be '/..../'."

data/lib/kwalify/meta-validator.rb

@@ -1,6 +1,6 @@
 ###
-### $Rev: 42 $
-### $Release: 0.5.1 $
+### $Rev: 51 $
+### $Release: 0.6.0 $
 ### copyright(c) 2005 kuwata-lab all rights reserved.
 ###
 
@@ -34,6 +34,8 @@ mapping:   &main-rule
     type:      str
  "desc":
     type:      str
+ "classname":
+    type:      str
  "type":
     type:      str
     #required:  yes
@@ -135,6 +137,13 @@ END
          #   errors << validate_error(:type_unknown, rule, "#{path}/type", type)
          #end
          #
+         if hash.key?('classname')
+            val = hash['classname']
+            unless val.nil? || type == 'map'
+               errors << validate_error(:classname_notmap, rule, "#{path}/classname", 'classname:')
+            end
+         end
+         #
          if hash.key?('pattern')
             val = hash['pattern']
             pat = (val =~ /\A\/(.*)\/([mi]?[mi]?)\z/ ? $1 : val)

data/lib/kwalify/rule.rb

@@ -1,6 +1,6 @@
 ###
-### $Rev: 42 $
-### $Release: 0.5.1 $
+### $Rev: 51 $
+### $Release: 0.6.0 $
 ### copyright(c) 2005 kuwata-lab all rights reserved.
 ###
 
@@ -36,7 +36,7 @@ module Kwalify
       attr_reader :length
       attr_reader :ident
       attr_reader :unique
-
+      attr_reader :classname
 
       def init(hash, path="", rule_table={})
          unless hash.is_a?(Hash)
@@ -67,6 +67,7 @@ module Kwalify
             when :unique    ;  _init_unique_value(  val, rule, path)
             when :sequence  ;  _init_sequence_value(val, rule, path, rule_table)
             when :mapping   ;  _init_mapping_value( val, rule, path, rule_table)
+            when :classname ;  _init_classname_value(val, rule, path)
             else
                #* key=:key_unknown  msg="unknown key."
                raise schema_error(:key_unknown, rule, curr_path, "#{key}:")
@@ -101,6 +102,15 @@ module Kwalify
       end
 
 
+      def _init_classname_value(val, rule, path)
+         @classname = val
+         unless @type == 'map'
+            #* key=:classname_notmap  msg="available only with map type."
+            raise schema_error(:classname_notmap, rule, "#{path}/classname", 'classname:')
+         end
+      end
+
+
       def _init_name_value(val, rule, path)
          @name = val
       end

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

@@ -0,0 +1,195 @@
+<%
+
+    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
+    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
+    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(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"
+    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
+    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
+
+          ## end of class declaration
+          if @properties[:ggap]
+             sb <<       "}\n"
+             sb <<       "public class #{rule.classname} < #{classname}\n"
+          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
+
+
+%>
+<%= generate_classdef(@rule) %>

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

@@ -0,0 +1,84 @@
+<%
+
+    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 << "  --ggap          :  use generation gap pattern\n"
+       return sb.join
+    end
+
+
+    def generate_classdef(rule)
+       sb = []
+       sb << "module #{@properties[:module]}\n\n" if @properties[:module]
+       done = {}
+       _generate(rule, sb, done)
+       if @properties[:module]
+          code = sb.join("  ")
+          code << "end\n"
+       else
+          code = sb.join
+       end
+       return code
+    end
+
+
+    def _generate(rule, sb=[], done={})
+       return if done.key?(rule.__id__)
+       done[rule.__id__] = rule
+       #
+       if rule.classname
+          unless rule.type == 'map'
+             raise "*** assertion error: rule.type==#{rule.type.inspect}"
+          end
+          assert unless rule.mapping
+       	  classname = rule.classname
+       	  classname = classname + '_' if @properties[:ggap]
+          extend = @properties[:parent] ? " < #{@properties[:parent]}" : nil
+          sb   <<     "## #{rule.desc}\n"
+          sb   <<     "class #{classname}#{extend}\n"
+          sb   <<     "  include #{@properties[:include]}\n" if @properties[:include]
+          sb   <<     "  def initialize(hash)\n"
+          rule.mapping.each do |name, map_rule|
+             next unless name =~ /\A[a-zA-Z_]\w*\z/
+             #if map_rule.sequence && map_rule.sequence[0].classname
+             #  item_rule = map_rule.sequence[0]
+             #  cname = item_rule.classname
+       	     #  sb << "    hash['#{name}'].map!{|e| #{cname}.new(e)} if hash.key?('#{name}') && !hash['#{name}'][0].is_a?(#{cname})\n"
+             #end
+       	     if map_rule.classname
+       	        cname = map_rule.classname
+       	        sb << "    @%-10s = (v=hash['#{name}']) && v.is_a?(Hash) ? #{cname}.new(v) : v\n" % name
+       	     elsif map_rule.sequence && map_rule.sequence[0].classname
+                item_rule = map_rule.sequence[0]
+                cname = item_rule.classname
+       	        sb << "    @%-10s = (v=hash['#{name}']) ? v.map!{|e| e.is_a?(#{cname}) ? e : #{cname}.new(e)} : v\n" % name
+             else
+       	        sb << "    @%-10s = hash['#{name}']\n" % name
+       	    end
+          end
+          sb   <<    "  end\n"
+	  rule.mapping.each do |name, map_rule|
+             next unless name =~ /\A[a-zA-Z_]\w*\z/
+             sb <<   "  attr_accessor :%-10s # %s\n" % [name, rule.mapping[name].type]
+          end
+       	  if @properties[:ggap]
+       	     sb <<   "end\n"
+       	     sb <<   "class #{rule.classname} < #{classname}\n"
+       	  end
+          sb   <<    "end\n\n"
+       end
+       #
+       rule.sequence.each do |seq_rule|
+          _generate(seq_rule, sb, done)
+       end if rule.sequence
+       rule.mapping.each do |name, map_rule|
+          _generate(map_rule, sb, done)
+       end if rule.mapping
+    end
+
+
+%>
+<%= generate_classdef(@rule) %>

data/lib/kwalify/types.rb

@@ -1,6 +1,6 @@
 ###
-### $Rev: 42 $
-### $Release: 0.5.1 $
+### $Rev: 51 $
+### $Release: 0.6.0 $
 ### copyright(c) 2005 kuwata-lab all rights reserved.
 ###
 
@@ -8,13 +8,13 @@ require 'date'
 
 
 module Kwalify
-   module Boolean
+   module Boolean   # :nodoc:
    end
 end
-class TrueClass
+class TrueClass   # :nodoc:
    include Kwalify::Boolean
 end
-class FalseClass
+class FalseClass   # :nodoc:
    include Kwalify::Boolean
 end
 #module Boolean; end
@@ -27,13 +27,13 @@ end
 
 
 module Kwalify
-   module Text
+   module Text   # :nodoc:
    end
 end
-class String
+class String   # :nodoc:
    include Kwalify::Text
 end
-class Numeric
+class Numeric   # :nodoc:
    include Kwalify::Text
 end
 #module Text; end
@@ -46,32 +46,32 @@ end
 
 
 module Kwalify
-   module Scalar
+   module Scalar   # :nodoc:
    end
 end
-class String
+class String   # :nodoc:
    include Kwalify::Scalar
 end
-class Numeric
+class Numeric   # :nodoc:
    include Kwalify::Scalar
 end
-class Date
+class Date   # :nodoc:
    include Kwalify::Scalar
 end
-class Time
+class Time   # :nodoc:
    include Kwalify::Scalar
 end
-class TrueClass
+class TrueClass   # :nodoc:
    include Kwalify::Scalar
 end
-class FalseClass
+class FalseClass   # :nodoc:
    include Kwalify::Scalar
 end
-class NilClass
+class NilClass   # :nodoc:
    include Kwalify::Scalar
 end
 module Kwalify
-   module Text
+   module Text   # :nodoc:
       include Kwalify::Scalar
    end
 end
@@ -115,7 +115,7 @@ module Kwalify
          #assert_error('type=#{type.inspect}') unless klass
          return klass
       end
-      
+
       def self.get_type_class(type)
          return type_class(type)
       end