kwalify 0.1.0 → 0.2.0

data/lib/kwalify/rule.rb

@@ -0,0 +1,326 @@
+###
+### $Rev: 18 $
+### $Release: 0.2.0 $
+### copyright(c) 2005 kuwata-lab all rights reserved.
+###
+
+require 'kwalify/messages'
+require 'kwalify/errors'
+require 'kwalify/types'
+
+module Kwalify
+
+   class Rule
+      include Kwalify::ErrorHelper
+
+      def initialize(hash=nil)
+         configure(hash, "", {}) if hash
+      end
+
+      def configure(hash, path="", rule_table={})
+         unless hash.is_a?(Hash)
+            #* key=:schema_notmap  msg="schema definition is not a mapping."
+            raise Kwalify.schema_error(:schema_notmap, nil, "/", nil)
+         end
+
+         rule = self
+         rule_table[hash.__id__] = rule
+
+         ## 'type:'
+         @type = hash['type']
+         @type = Kwalify::DEFAULT_TYPE if @type == nil
+         unless @type.is_a?(String)
+            #* key=:type_notstr  msg="not a string."
+            raise schema_error(:type_notstr, rule, "#{path}/type", @type.to_s)
+         end
+         @klass = Kwalify.get_type_class(@type)
+         #if @klass == nil
+         #   begin
+         #      @klass = Kernel.const_get(@type)
+         #   rescue NameError
+         #   end
+         #end
+         unless @klass
+            #* key=:type_unknown  msg="unknown type."
+            raise schema_error(:type_unknown, rule, "#{path}/type", @type.to_s)
+         end
+
+         ## other key
+         hash.each do |key, val|
+            curr_path = "#{path}/#{key}"
+            case key
+            #when "id"
+            #   @id       = val
+            when "name"
+               @name = val
+
+            when "desc"
+               @desc = val
+
+            when "type"
+               # done
+
+            when "required"
+               @required = val
+               unless val == nil || val.is_a?(Boolean)
+                  #* key=:required_notbool  msg="not a boolean."
+                  raise schema_error(:required_notbool, rule, curr_path, val)
+               end
+
+            when "pattern"
+               pat = (val =~ /\A\/(.*)\/([mi]?[mi]?)\z/ ? $1 : val)
+               begin
+                  @pattern = Regexp.compile(pat)
+               rescue RegexpError => ex
+                  #* key=:pattern_syntaxerr  msg="has regexp error."
+                  raise schema_error(:pattern_syntaxerr, rule, curr_path, val)
+               end
+
+            when "enum"
+               @enum = val
+               unless val.is_a?(Array)
+                  #* key=:enum_notseq  msg="not a sequence."
+                  raise schema_error(:enum_notseq, rule, curr_path, val)
+               end
+               if @type == 'seq' || @type == 'map'   # unless Kwalify.scalar_class?(@klass)
+                  #* key=:enum_notscalar  msg="not available with seq or map."
+                  raise schema_error(:enum_notscalar, rule, path, 'enum:')
+               end
+               elem_table = {}
+               @enum.each do |elem|
+                  unless !elem_table[elem]
+                     #* key=:enum_duplicate  msg="duplicated enum value."
+                     raise schema_error(:enum_duplicate, rule, curr_path, elem.to_s)
+                  end
+                  elem_table[elem] = true
+                  unless elem.is_a?(@klass)
+                     #* key=:enum_type_unmatch  msg="%s type expected."
+                     raise schema_error(:enum_type_unmatch, rule, curr_path, elem, [Kwalify.word(@type)])
+                  end
+               end
+
+            when "assert"   # or "cond-expr" ?
+               unless val.is_a?(String)
+                  #* key=:assert_notstr  msg="not a string."
+                  raise schema_error(:assert_notstr, rule, curr_path, val)
+               end
+               unless val =~ /\bval\b/
+                  #* key=:assert_noval  msg="'val' is not used."
+                  raise schema_error(:assert_noval, rule, curr_path, val)
+               end
+               begin
+                  @assert = val
+                  @assert_proc = eval "proc { |val| #{val} }"
+               rescue SyntaxError => ex
+                  #* key=:assert_syntaxerr  msg="expression syntax error."
+                  raise schema_error(:assert_syntaxerr, rule, curr_path, val)
+               end
+
+            when "range"
+               @range = val
+               unless val.is_a?(Hash)
+                  #* key=:range_notmap  msg="not a mapping."
+                  raise schema_error(:range_notmap, rule, curr_path, val)
+               end
+               if @type == 'map' || @type == 'seq' || @type == 'bool'
+                  #* key=:range_notscalar  msg="is available only with scalar type."
+                  raise schema_error(:range_notscalar, rule, path, 'range:')
+               end
+               val.each do |rkey, rval|
+                  case rkey
+                  when 'max', 'min'
+                     unless rval.is_a?(@klass)
+                        typename = Kwalify.word(@type) || @type
+                        #* key=:range_type_unmatch  msg="not a %s."
+                        raise schema_error(:range_type_unmatch, rule, "#{curr_path}/#{rkey}", rval, [typename])
+                     end
+                  else
+                     #* key=:range_undefined  msg="undefined key."
+                     raise schema_error(:range_undefined, rule, curr_path, "#{rkey}:")
+                  end
+               end
+
+            when "length"   # or "width"
+               @length = val
+               unless val.is_a?(Hash)
+                  #* key=:length_notmap  msg="not a mapping."
+                  raise schema_error(:length_notmap, rule, curr_path, val)
+               end
+               unless @type == 'str' || @type == 'text'
+                  #* key=:length_nottext  msg="is available only with string or text."
+                  raise schema_error(:length_nottext, rule, path, 'length:')
+               end
+               val.each do |lkey, lval|
+                  case lkey
+                  when 'max', 'min'
+                     unless lval.is_a?(Integer)
+                        #* key=:length_notint  msg="not an integer."
+                        raise schema_error(:length_notint, rule, "#{curr_path}/#{lkey}", lval)
+                     end
+                  else
+                     #* key=:length_undefined  msg="undefined key."
+                     raise schema_error(:length_undefined, rule, curr_path, "#{lkey}:")
+                  end
+               end
+
+            when "sequence"
+               if val != nil && !val.is_a?(Array)
+                  #* key=:sequence_notseq  msg="not a sequence."
+                  raise schema_error(:sequence_notseq, rule, curr_path, val)
+               elsif val == nil || val.empty?
+                  #* key=:sequence_noelem  msg="required one element."
+                  raise schema_error(:sequence_noelem, rule, curr_path, val)
+               elsif val.length > 1
+                  #* key=:sequence_toomany  msg="required just one element."
+                  raise schema_error(:sequence_toomany, rule, curr_path, val)
+               else
+                  elem = val[0]
+                  elem ||= {}
+                  i = 0   # or 1?  *index*
+                  rule = rule_table[elem.__id__]
+                  rule ||= Rule.new.configure(elem, "#{curr_path}/#{i}", rule_table)
+                  @sequence = [ rule ]
+               end
+
+            when "mapping"
+               if val != nil && !val.is_a?(Hash)
+                  #* key=:mapping_notmap  msg="not a mapping."
+                  raise schema_error(:mapping_notmap, rule, curr_path, val)
+               elsif val == nil || val.empty?
+                  #* key=:mapping_noelem  msg="required at least one element."
+                  raise schema_error(:mapping_noelem, rule, curr_path, val)
+               else
+                  @mapping = {}
+                  val.each do |key, elem|
+                     ##* key=:key_duplicate  msg="key duplicated."
+                     #raise schema_error(:key_duplicate, rule, curr_path, key) if @mapping.key?(key)
+                     elem ||= {}
+                     rule = rule_table[elem.__id__]
+                     rule ||= Rule.new.configure(elem, "#{curr_path}/#{key}", rule_table)
+                     if key == '*'
+                        @mapping.default = rule
+                     else
+                        @mapping[key] = rule
+                     end
+                  end
+               end
+
+            else
+               #* key=:key_unknown  msg="unknown key."
+               raise schema_error(:key_unknown, rule, path, "#{key}:")
+            end
+         end
+
+         if @type == 'seq'
+            #* key=:seq_nosequence  msg="type 'seq' requires 'sequence:'."
+            raise Kwalify.validate_error(:seq_nosequence, rule, path, nil) unless hash.key?('sequence')
+            #* key=:seq_conflict  msg="not available with sequence."
+            raise schema_error(:seq_conflict, rule, path, 'enum:')        if @enum
+            raise schema_error(:seq_conflict, rule, path, 'pattern:')     if @pattern
+            raise schema_error(:seq_conflict, rule, path, 'mapping:')     if @mapping
+            raise schema_error(:seq_conflict, rule, path, 'range:')       if @range
+            raise schema_error(:seq_conflict, rule, path, 'length:')      if @length
+         elsif @type == 'map'
+            #* key=:map_nomapping  msg="type 'map' requires 'mapping:'."
+            raise Kwalify.validate_error(:map_nomapping, rule, path, nil)  unless hash.key?('mapping')
+            #* key=:map_conflict  msg="not available with mapping."
+            raise schema_error(:map_conflict, rule, path, 'enum:')        if @enum
+            raise schema_error(:map_conflict, rule, path, 'pattern:')     if @pattern
+            raise schema_error(:map_conflict, rule, path, 'sequence:')    if @sequence
+            raise schema_error(:map_conflict, rule, path, 'range:')       if @range
+            raise schema_error(:map_conflict, rule, path, 'length:')      if @length
+         else
+            #* key=:scalar_conflict  msg="not available with scalar type."
+            raise schema_error(:scalar_conflict, rule, path, 'sequence:') if @sequence
+            raise schema_error(:scalar_conflict, rule, path, 'mapping:')  if @mapping
+            if @enum
+               #* key=:enum_conflict  msg="not available with 'enum:'."
+               raise schema_error(:enum_conflict, rule, path, 'range:')   if @range
+               raise schema_error(:enum_conflict, rule, path, 'length:')  if @length
+               raise schema_error(:enum_conflict, rule, path, 'pattern:') if @pattern
+            end
+         end
+
+         return self
+
+      end # end of def configure
+
+      #attr_reader   :id
+      attr_reader :name
+      attr_reader :desc
+      attr_reader :enum
+      attr_reader :required
+      attr_reader :type
+      attr_reader :klass
+      attr_reader :pattern
+      attr_reader :sequence
+      attr_reader :mapping
+      attr_reader :assert
+      attr_reader :assert_proc
+      attr_reader :range
+      attr_reader :length
+
+
+      #def inspect()
+      #   str = "";  level = 0;  done = {}
+      #   _inspect(str, level, done)
+      #   return str
+      #end
+
+
+      #protected
+
+
+      def _inspect(str="", level=0, done={})
+         done[self.__id__] = true
+         str << "  " * level << "name:      #{@name}\n"             if @name     != nil
+         str << "  " * level << "desc:      #{@desc}\n"             if @desc     != nil
+         str << "  " * level << "type:      #{@type}\n"             if @type     != nil
+         str << "  " * level << "klass:     #{@klass.name}\n"       if @klass    != nil
+         str << "  " * level << "required:  #{@required}\n"         if @required != nil
+         str << "  " * level << "pattern:   #{@pattern.inspect}\n"  if @pattern  != nil
+         str << "  " * level << "assert:    #{@assert}\n"           if @assert   != nil
+         if @enum != nil
+            str << "  " * level << "enum:\n"
+            @enum.each do |item|
+               str << "  " * (level+1) << "- #{item}\n"
+            end
+         end
+         if @range  != nil
+            str << "  " * level
+            str << "range:     { "
+            str << "max: #{@range['max'].inspect}"  if @range['max'] != nil
+            str << ", "  if @range['max'] != nil && @range['min'] != nil
+            str << "min: #{@range['min'].inspect}"  if @range['min'] != nil
+            str << "}\n"
+         end
+         if @length  != nil
+            str << "  " * level
+            str << "length:     { "
+            str << "max: #{@length['max'].inspect}"  if @length['max'] != nil
+            str << ", "  if @length['max'] != nil && @length['min'] != nil
+            str << "min: #{@length['min'].inspect}"  if @length['min'] != nil
+            str << "}\n"
+         end
+         @sequence.each do |rule|
+            if done[rule.__id__]
+               str << "  " * (level+1) << "- ...\n"
+            else
+               str << "  " * (level+1) << "- \n"
+               rule._inspect(str, level+2, done)
+            end
+         end if @sequence
+         @mapping.each do |key, rule|
+            if done[rule.__id__]
+               str << '  ' * (level+1) << '"' << key << "\": ...\n"
+            else
+               str << '  ' * (level+1) << '"' << key << "\":\n"
+               rule._inspect(str, level+2, done)
+            end
+         end if @mapping
+         return str
+      end
+
+   end
+
+end

data/lib/kwalify/types.rb

@@ -1,6 +1,6 @@
 ###
-### $Rev: 7 $
-### $Release: 0.1.0 $
+### $Rev: 18 $
+### $Release: 0.2.0 $
 ### copyright(c) 2005 kuwata-lab all rights reserved.
 ###
 
@@ -11,60 +11,126 @@ module Kwalify
    module Boolean
    end
 end
-#module Boolean; end
 class TrueClass
    include Kwalify::Boolean
-   #include Boolean
 end
 class FalseClass
    include Kwalify::Boolean
-   #include Boolean
 end
+#module Boolean; end
+#class TrueClass
+#   include Boolean
+#end
+#class FalseClass
+#   include Boolean
+#end
 
 
 module Kwalify
    module Text
    end
 end
-#module Text; end
 class String
    include Kwalify::Text
-   #include Text
 end
 class Numeric
    include Kwalify::Text
-   #include Text
+end
+#module Text; end
+#class String
+#   include Text
+#end
+#class Numeric
+#   include Text
+#end
+
+
+module Kwalify
+   module Scalar
+   end
+end
+class String
+   include Kwalify::Scalar
+end
+class Numeric
+   include Kwalify::Scalar
+end
+class Date
+   include Kwalify::Scalar
+end
+class Time
+   include Kwalify::Scalar
+end
+class TrueClass
+   include Kwalify::Scalar
+end
+class FalseClass
+   include Kwalify::Scalar
+end
+class NilClass
+   include Kwalify::Scalar
+end
+module Kwalify
+   module Text
+      include Kwalify::Scalar
+   end
 end
 
 
 module Kwalify
 
-   DEFAULT_TYPE = "string"           ## use "string" as default of @type
+   DEFAULT_TYPE = "str"           ## use "str" as default of @type
 
    @@type_table = {
       "seq"       => Array,
-      "sequence"  => Array,
-      #"list"      => Array,
-      #"array"     => Array,
       "map"       => Hash,
-      "mapping"   => Hash,
-      #"hash"      => Hash,
+      "str"       => String,
+      #"string"    => String,
       "text"      => Text,
-      "string"    => String,
-      "integer"   => Integer,
+      "int"       => Integer,
+      #"integer"   => Integer,
       "float"     => Float,
       "number"    => Numeric,
       #"numeric"   => Numeric,
       "date"      => Date,
       "time"      => Time,
-      "boolean"   => Boolean,
-      #"bool"      => Boolean,
-      "object"    => Object,
+      "timestamp" => Time,
+      "bool"      => Boolean,
+      #"boolean"   => Boolean,
+      #"object"    => Object,
       "any"       => Object,
+      "scalar"    => Scalar,
    }
-   
+
    def self.type_table
       return @@type_table
    end
 
+   def self.get_type_class(type)
+      klass = @@type_table[type]
+      #assert_error('type=#{type.inspect}') unless klass
+      return klass
+   end
+
+
+   module TypeHelper
+      def collection_class?(klass)
+         return klass == Array || klass == Hash
+      end
+
+      def scalar_class?(klass)
+         return klass != Array && klass != Hash && klass != Object
+      end
+
+      def collection?(val)
+         return collection_class?(val.class)
+      end
+
+      def scalar?(val)
+         return scalar_class?(val.class)
+      end
+   end
+
+   extend TypeHelper
+
 end