kwalify 0.6.1 → 0.7.0

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

@@ -1,84 +1,113 @@
 <%
 
+    ###
+    ### $Rev: 96 $
+    ### $Release: 0.7.0 $
+    ### copyright(c) 2005-2008 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
 
 
-    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
+    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(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
+    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(@rule) %>
+<%= generate_classdef(@schema) %>

data/lib/kwalify/types.rb

@@ -1,155 +1,156 @@
 ###
-### $Rev: 51 $
-### $Release: 0.6.1 $
-### copyright(c) 2005 kuwata-lab all rights reserved.
+### $Rev: 87 $
+### $Release: 0.7.0 $
+### copyright(c) 2005-2008 kuwata-lab all rights reserved.
 ###
 
 require 'date'
 
 
 module Kwalify
-   module Boolean   # :nodoc:
-   end
+  module Boolean  # :nodoc:
+  end
 end
 class TrueClass   # :nodoc:
-   include Kwalify::Boolean
+  include Kwalify::Boolean
 end
-class FalseClass   # :nodoc:
-   include Kwalify::Boolean
+class FalseClass  # :nodoc:
+  include Kwalify::Boolean
 end
 #module Boolean; end
 #class TrueClass
-#   include Boolean
+#  include Boolean
 #end
 #class FalseClass
-#   include Boolean
+#  include Boolean
 #end
 
 
 module Kwalify
-   module Text   # :nodoc:
-   end
+  module Text  # :nodoc:
+  end
 end
 class String   # :nodoc:
-   include Kwalify::Text
+  include Kwalify::Text
 end
-class Numeric   # :nodoc:
-   include Kwalify::Text
+class Numeric  # :nodoc:
+  include Kwalify::Text
 end
 #module Text; end
 #class String
-#   include Text
+#  include Text
 #end
 #class Numeric
-#   include Text
+#  include Text
 #end
 
 
 module Kwalify
-   module Scalar   # :nodoc:
-   end
+  module Scalar  # :nodoc:
+  end
 end
-class String   # :nodoc:
-   include Kwalify::Scalar
+class String     # :nodoc:
+  include Kwalify::Scalar
 end
-class Numeric   # :nodoc:
-   include Kwalify::Scalar
+class Numeric    # :nodoc:
+  include Kwalify::Scalar
 end
-class Date   # :nodoc:
-   include Kwalify::Scalar
+class Date       # :nodoc:
+  include Kwalify::Scalar
 end
-class Time   # :nodoc:
-   include Kwalify::Scalar
+class Time       # :nodoc:
+  include Kwalify::Scalar
 end
-class TrueClass   # :nodoc:
-   include Kwalify::Scalar
+class TrueClass  # :nodoc:
+  include Kwalify::Scalar
 end
-class FalseClass   # :nodoc:
-   include Kwalify::Scalar
+class FalseClass # :nodoc:
+  include Kwalify::Scalar
 end
 class NilClass   # :nodoc:
-   include Kwalify::Scalar
+  include Kwalify::Scalar
 end
 module Kwalify
-   module Text   # :nodoc:
-      include Kwalify::Scalar
-   end
+  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
-      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
+  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.rb

@@ -0,0 +1,157 @@
+###
+### $Rev: 88 $
+### $Release: 0.7.0 $
+### copyright(c) 2005-2008 kuwata-lab all rights reserved.
+###
+
+module Kwalify
+
+  module Util
+
+    module_function
+
+    ##
+    ## expand tab character to spaces
+    ##
+    ## ex.
+    ##   untabified_str = YamlHelper.untabify(tabbed_str)
+    ##
+    def untabify(str, width=8)
+      list = str.split(/\t/)
+      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, &block)  #:yield: rulehash
+      hash = schema
+      _done = {}
+      _traverse_schema(hash, _done, &block)
+    end
+
+    def _traverse_schema(hash, _done={}, &block)
+      return if _done.key?(hash.__id__)
+      _done[hash.__id__] = hash
+      yield hash
+      if hash['mapping']
+        hash['mapping'].each {|k, v| _traverse_schema(v, _done, &block) }
+      elsif hash['sequence']
+        _traverse_schema(hash['sequence'][0], _done, &block)
+      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, &block)  #:yield: rule
+      rule = validator.is_a?(Rule) ? validator : validator.rule
+      _done = {}
+      _traverse_rule(rule, _done, &block)
+    end
+
+    def _traverse_rule(rule, _done={}, &block)
+       return if _done.key?(rule.__id__)
+       _done[rule.__id__] = rule
+       yield rule
+       rule.sequence.each do |seq_rule|
+          _traverse_rule(seq_rule, _done, &block)
+       end if rule.sequence
+       rule.mapping.each do |name, map_rule|
+          _traverse_rule(map_rule, _done, &block)
+       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