Class Kwalify::Rule
In: kwalify/rule.rb
Parent: Object

Methods

_inspect   init   new  

Included Modules

Kwalify::ErrorHelper

Attributes

assert  [R] 
assert_proc  [R] 
classname  [R] 
desc  [R] 
enum  [R] 
ident  [R] 
length  [R] 
mapping  [R] 
name  [R]  attr_reader :id
parent  [RW] 
pattern  [R] 
range  [R] 
regexp  [R] 
required  [R] 
sequence  [R] 
type  [R] 
type_class  [R] 
unique  [R] 

Public Class methods

[Source]

# File kwalify/rule.rb, line 16
      def initialize(hash=nil, parent=nil)
         init(hash, "", {}) if hash
         @parent = parent
      end

Public Instance methods

[Source]

# File kwalify/rule.rb, line 41
      def init(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, (!path || path.empty? ? "/" : path), nil)
         end
         rule = self
         rule_table[hash.__id__] = rule
         ## 'type:' entry
         _init_type_value(hash['type'], rule, path)
         ## other entries
         hash.each do |key, val|
            code = key.intern
            curr_path = "#{path}/#{key}"
            case code
            #when "id"
            #   @id       = val
            when :type      ;  # done
            when :name      ;  _init_name_value(    val, rule, path)
            when :desc      ;  _init_desc_value(    val, rule, path)
            when :required  ;  _init_required_value(val, rule, path)
            when :pattern   ;  _init_pattern_value( val, rule, path)
            when :enum      ;  _init_enum_value(    val, rule, path)
            when :assert    ;  _init_assert_value(  val, rule, path)
            when :range     ;  _init_range_value(   val, rule, path)
            when :length    ;  _init_length_value(  val, rule, path)
            when :ident     ;  _init_ident_value(   val, rule, path)
            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}:")
            end
         end
         check_confliction(hash, rule, path)
         return self
      end

Protected Instance methods

def inspect()

   str = "";  level = 0;  done = {}
   _inspect(str, level, done)
   return str

end

[Source]

# File kwalify/rule.rb, line 437
      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:     #{@type_class.name}\n"  if @type_class    != nil
         str << "  " * level << "required:  #{@required}\n"         if @required != nil
         str << "  " * level << "pattern:   #{@regexp.inspect}\n"   if @pattern  != nil
         str << "  " * level << "assert:    #{@assert}\n"           if @assert   != nil
         str << "  " * level << "ident:     #{@ident}\n"            if @ident    != nil
         str << "  " * level << "unique:    #{@unique}\n"           if @unique   != 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:     { "
            colon = ""
            %w[max max-ex min min-ex].each do |key|
               val = @range[key]
               if val != nil
                  str << colon << "#{key}: #{val.inspect}"
                  colon = ", "
               end
            end
            str << " }\n"
         end
         if @length != nil
            str << "  " * level
            str << "length:     { "
            colon = ""
            %w[max max-ex min min-ex].each do |key|
               val = @length[key]
               if val != nil
                  str << colon << "#{key}: #{val.inspect}"
                  colon = ", "
               end
            end
            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

[Validate]