cim 0.5.0 → 1.3

data/History.txt

@@ -1,3 +1,16 @@
+=== 1.3 2011-11-16
+
+* Make QualifierScope and QualifierFlavor Array
+  (remove :elements and :flavors accessors)
+
+* Rename CIM::QualifierScopesError to CIM::QualifierScopeError
+
+=== 1.2.1 2011-11-08
+
+* Ruby 1.9 support
+
+=== 1.2.0
+
 === 0.5.0 2011-09-29
 
 * Clean up Rakefile, support Bundler

data/cim.gemspec

@@ -18,6 +18,9 @@ http://www.dmtf.org/education/mof for details}
   
   s.rubyforge_project = "cim"
 
+  s.add_development_dependency('rake')
+  s.add_development_dependency('bundler')
+
   s.files         = `git ls-files`.split("\n")
   s.files.reject! { |fn| fn == '.gitignore' }
   s.extra_rdoc_files    = Dir['README*', 'TODO*', 'CHANGELOG*', 'LICENSE']

data/lib/cim.rb

@@ -41,7 +41,7 @@ $:.unshift(File.dirname(__FILE__)) unless
 #
 
 module CIM
-  VERSION = '0.5.0'
+  VERSION = '1.3'
   require 'cim/type'
   require 'cim/variant'
   require 'cim/qualifier_flavors'
@@ -55,6 +55,4 @@ module CIM
   require 'cim/reference'
   require 'cim/method'
   require 'cim/class'
-  require 'cim/association'
-  require 'cim/indication'
 end

data/lib/cim/class.rb

@@ -18,7 +18,7 @@ module CIM
   # and contain features (properties or methods).
   #
   class Class < CIM::NamedElement
-    attr_reader :alias_name, :superclass, :features
+    attr_reader :alias_name, :superclass
     #
     # Creates a new Class with name (String), qualifiers, alias, superclass and features
     #
@@ -30,6 +30,23 @@ module CIM
     #   Class.new("MyClass", qualifiers, "my_class")
     #   Class.new("MyClass", qualifiers, "my_class", "SuperClass")
     #   Class.new("MyClass", qualifiers, "my_class", "SuperClass", features)
+#    	    if qualifiers and qualifiers.include?(:association, :boolean)
+	      # FIXME: 'association' must be first
+              # Context:
+	      #
+	      # The remaining qualifier list must not include
+	      # the ASSOCIATION qualifier again. If the
+	      # association has no super association, then at
+	      # least two references must be specified! The
+	      # ASSOCIATION qualifier may be omitted in
+	      # sub associations.
+#	      result = CIM::Association.new(val[2],qualifiers,val[3],val[4],features)
+#	    elsif qualifiers and qualifiers.include?(:indication, :boolean)
+	      # FIXME: 'indication' must be first
+	      # FIXME: features must not include references
+#	      result = CIM::Indication.new(val[2],qualifiers,val[3],val[4],features)
+#	    else
+
     #
     def initialize name, qualifiers = nil, alias_name = nil, superclass = nil, features = nil
       @alias_name = alias_name
@@ -39,11 +56,22 @@ module CIM
       #	puts "CIM::Class.new(#{@features})"
       super name, qualifiers
     end
+    
+    def method_missing name, *args
+      @qualifiers[name]
+    end
+
+    #
+    # Ensure features can be enumerated
+    #
+    def features
+      @features || []
+    end
     #
     # Iterate over features flagged as keys
     #
     def each_key
-      @features.each do |f|
+      features.each do |f|
 	yield f if f.key?
       end
     end
@@ -51,16 +79,19 @@ module CIM
     # true if class has instances (instance provider)
     #
     def instance?
-      @features.size > 0
+      features.each do |f|
+        next if f.reference?
+	next if f.method?
+	return true if f.property?
+      end
+      false
     end
     #
     # true if class has methods (method provider)
     #
     def method?
-      @features.each do |f|
-	case f
-	when CIM::Method: return true
-	end
+      features.each do |f|
+	return true if f.method?
       end
       false
     end
@@ -68,13 +99,13 @@ module CIM
     # true if class has associations (association provider)
     #
     def association?
-      false
+      include? :association
     end
     #
     # true if class has indications (indication provider)
     #
     def indication?
-      false
+      include? :indication
     end
     #
     # returns a string representation in MOF syntax format

data/lib/cim/class_feature.rb

@@ -22,7 +22,7 @@ module CIM
     # if has key qualifier
     #
     def key?
-      @qualifiers && @qualifiers.include?(:key,:bool)
+      @qualifiers && @qualifiers.include?(:key,:boolean)
     end
     #
     # if static (class-level) feature
@@ -51,7 +51,7 @@ module CIM
     protected
     def initialize type, name, qualifiers = nil
     # :notnew:
-      @type = (type.is_a? CIM::Type) ? type : CIM::Type.new(type)
+      @type = CIM::Type.normalize type
       super name, qualifiers
     end
     #

data/lib/cim/method.rb

@@ -14,21 +14,25 @@ module CIM
   # For data members, see Property.
   #
   class Method < CIM::ClassFeature
-    attr_reader :parameters
     #
     # Create a Method with return type (Type) and name (String), optional Qualifiers and parameters (Property)
     #
     # call-seq:
-    #   Method.new(:bool, "do_something")
-    #   Method.new(:bool, "do_something", qualifiers)
-    #   Method.new(:bool, "do_something", qualifiers, parameters)
+    #   Method.new(:boolean, "do_something")
+    #   Method.new(:boolean, "do_something", qualifiers)
+    #   Method.new(:boolean, "do_something", qualifiers, parameters)
     #
     def initialize type, name, qualifiers = nil, parameters = nil
-      parameters = nil if parameters.kind_of?(::Enumerable) && parameters.empty?
       @parameters = parameters
       super type,name,qualifiers
     end
     #
+    # parameters accessor
+    #
+    def parameters
+      @parameters || []
+    end
+    #
     # Makes a Method recognizable in the set of Class features.
     #
     def method?
@@ -38,7 +42,7 @@ module CIM
     # returns a string representation in MOF syntax format
     #
     def to_s
-      p = @parameters.join(", ") if @parameters
+      p = parameters.join(", ")
       "#{super}(#{p})"
     end
   end

data/lib/cim/named_element.rb

@@ -7,6 +7,7 @@
 #
 # Licensed under the Ruby license
 #
+
 module CIM
   #
   # The NamedElement is a basic building block for the CIM schema, acting as a base class
@@ -22,28 +23,19 @@ module CIM
     def initialize name, qualifiers = nil
       raise "NamedElement must have a name" unless name
       @name = name.to_s
-      unless qualifiers.nil?
-	unless qualifiers.is_a?(QualifierSet)
-	  if qualifiers.kind_of?(::Enumerable) && qualifiers.empty?
-	    qualifiers = nil 
-	  else
-	    qualifiers = QualifierSet.new qualifiers
-	  end
-	end
-      end
-      @qualifiers = qualifiers
+      @qualifiers = (qualifiers) ? CIM::QualifierSet.normalize(qualifiers) : CIM::QualifierSet.new
     end
     #
     # Add a Qualifier to the NamedElements qualifiers
     #
     def << qualifier
-      @qualifiers << (normalize qualifier)
+      @qualifiers << CIM::Qualifier.normalize(qualifier)
     end
     #
     # Check if a Qualifier is included 
     #
     def include? qualifier
-      @qualifiers.include?(normalize qualifier)
+      @qualifiers.include? qualifier
     end
     alias includes? include?
     #
@@ -54,12 +46,5 @@ module CIM
       s << "[#{@qualifiers.join(', ')}]\n " if @qualifiers
       s << "#{@name}"
     end
-    private
-    def normalize qualifier
-      unless qualifier.is_a?(CIM::Qualifier)
-	qualifier = Qualifier.new(qualifier)
-      end
-      qualifier
-    end
   end
 end

data/lib/cim/property.rb

@@ -19,9 +19,9 @@ module CIM
     # Create a Property with type (Type) and name (String), optional QualifierSet and default value
     #
     # call-seq:
-    #   Property.new(:bool, "flag")
-    #   Property.new(:bool, "flag", qualifier_set)
-    #   Property.new(:bool, "flag", qualifier_set, true)
+    #   Property.new(:boolean, "flag")
+    #   Property.new(:boolean, "flag", qualifier_set)
+    #   Property.new(:boolean, "flag", qualifier_set, true)
     #
     def initialize type, name, qualifier_set=nil, default=nil
       @default = default

data/lib/cim/qualifier.rb

@@ -15,6 +15,10 @@ module CIM
   # Qualifier can be seen as an instance of QualifierDeclaration
   #
   class Qualifier
+    def self.normalize type
+      (type.is_a? self) ? type : self.new(type)
+    end
+    
     attr_reader :declaration, :value, :flavor
     #
     # call-seq:
@@ -73,8 +77,8 @@ module CIM
     def to_s
       s = "#{@declaration.name.capitalize}"
       case @value
-      when nil:
-      when Array:
+      when nil
+      when Array
 	s << " {#{@value.join(', ')}}"
       else
 	s << "(#{@value.inspect})"

data/lib/cim/qualifier_declaration.rb

@@ -22,7 +22,7 @@ module CIM
   #
   # A QualifierDeclaration declares a qualifier by
   # name:: (String)
-  # type:: (Type) (defaults to bool)
+  # type:: (Type) (defaults to boolean)
   # default value:: (Variant) (defaults to false)
   # scopes:: (QualifierScopes) (where the qualifier can be used)
   # flavor:: (QualifierFlavors) (how the qualifier is applied)
@@ -34,7 +34,7 @@ module CIM
     #
     # Create a new QualifierDeclaration
     #
-    def initialize name, type = :bool, default = false, scopes = nil, flavors = nil
+    def initialize name, type = :boolean, default = false, scopes = nil, flavors = nil
       @type = (type.kind_of? Type) ? type : Type.new(type)
       @default = (default.nil? || default.is_a?(CIM::Variant)) ? default : CIM::Variant.new(@type, default)
       @scopes = scopes

data/lib/cim/qualifier_flavors.rb

@@ -32,9 +32,8 @@ module CIM
   # tosubclass:: The qualifier is inherited by any subclass (default: true)
   # translatable:: Marks a qualifier value for localization (default: false)
   #
-  class QualifierFlavors
+  class QualifierFlavors < ::Array
     FLAVORS = [:amended, :enableoverride, :disableoverride, :restricted, :toinstance, :tosubclass, :translatable]
-    attr_reader :flavors
     #
     # Create QualifierFlavors with an initial flavor. More flavors can be added through the << method.
     #
@@ -46,7 +45,6 @@ module CIM
     # The flavor can be named as a string or a symbol.
     #
     def initialize *flavors
-      @flavors = []
       flavors.flatten.each do |flavor|
 	self << flavor
       end
@@ -63,16 +61,10 @@ module CIM
     # Raises QualifierFlavorError if its not an allowed flavor
     #
     def << flavor
-      @flavors << normalize(flavor)
+      super(normalize flavor)
       self
     end
     #
-    # Number of flavors in the set
-    #
-    def size
-      @flavors.size
-    end
-    #
     # Check if a specific flavor is included in the set
     #
     # call-seq:
@@ -83,14 +75,14 @@ module CIM
     # Raises QualifierFlavorError if its not an allowed flavor
     #
     def include? flavor
-      @flavors.include?(normalize flavor)
+      super(normalize flavor)
     end
     alias includes? include?
     #
     # returns a string representation in MOF syntax format
     #
     def to_s
-      "Flavor(#{@flavors.join(', ')})"
+      "Flavor(#{self.join(', ')})"
     end
     private
     #

data/lib/cim/qualifier_scopes.rb

@@ -9,7 +9,7 @@
 #
 module CIM
     
-  class QualifierScopesError < ArgumentError
+  class QualifierScopeError < ArgumentError
     #
     # Raised if wrong Scope passed
     #
@@ -22,9 +22,8 @@ module CIM
     end
   end
 
-  class QualifierScopes
+  class QualifierScopes < ::Array
     META_ELEMENTS = [ :schema, :class, :association, :indication, :qualifier, :property, :reference, :method, :parameter, :any ]
-    attr_reader :elements
     #
     # call-seq:
     #   QualifierScopes.new => qualifier_scopes
@@ -35,7 +34,6 @@ module CIM
     # raises QualifierScopesError
     #
     def initialize *elements
-      @elements = []
       elements.flatten.each do |element|
 	self << element
       end
@@ -49,7 +47,7 @@ module CIM
     # raises QualifierScopesError
     #
     def << element
-      @elements << (normalize element)
+      self.push(normalize element)
       self
     end
     #
@@ -61,26 +59,21 @@ module CIM
     # raises QualifierScopesError
     #
     def include? element
-      @elements.include?(normalize element)
+      super(normalize element)
     end
     alias includes? include?
-    #
-    # Number of scopes
-    #
-    def size
-      @elements.size
-    end
+
     #
     # returns a string representation in MOF syntax format
     #
     def to_s
-      "Scope(#{@elements.join(', ')})"
+      "Scope(#{self.join(', ')})"
     end
   private
     def normalize element
       element.downcase! if element.is_a?(String)
       e = element.to_sym
-      raise QualifierScopesError.new(element) unless META_ELEMENTS.include?(e)
+      raise QualifierScopeError.new(element) unless META_ELEMENTS.include?(e)
       e
     end
   end

data/lib/cim/qualifier_set.rb

@@ -12,17 +12,24 @@ module CIM
   # Set of Qualifier
   #
   class QualifierSet < ::Array
+    def self.normalize type
+      (type.is_a? self) ? type : self.new(type)
+    end
+
+
     def initialize *args
       super 0
       args.flatten.each do |q|
 	case q
-	when QualifierDeclaration: q = Qualifier.new q
-	when Qualifier:
+	when QualifierDeclaration
+	  q = Qualifier.new q
+	when Qualifier
+	  # nothing
 	else
 	  q = Qualifier.new(QualifierDeclaration.new q)
 	end
 	self << q
-      end
+      end if args
     end
     #
     # check if qualifier exists
@@ -51,9 +58,7 @@ module CIM
 			 q == qualifier.declaration
 		       when CIM::QualifierDeclaration
 			 q == qualifier
-		       when String
-			 q.declaration == qualifier
-		       when Symbol
+		       when String, Symbol
 			 q.declaration == qualifier
 		       else
 			 raise "Unknown parameter in #{self.class}[]"

data/lib/cim/type.rb

@@ -23,22 +23,29 @@ module CIM
   # uint64::    Unsigned 64-bit integer
   # sint64::    Signed 64-bit integer
   # string::    UCS-2 string
-  # bool::      Boolean
+  # boolean::   Boolean
   # real32::    IEEE 4-byte floating-point
   # real64::    IEEE 8-byte floating-point
-  # datetime::  A string containing a date-time
+  # dateTime::  A string containing a date-time
   # reference:: Strongly typed reference
   # char16::    16-bit UCS-2 character
-  # datetime::  Timestamp
   # void::      -- allowed for WMI only
   #
   #
   class Type
-    TYPES = [:null,:void,:bool,:char16,:string,:uint8,:sint8,:uint16,:sint16,:uint32,:sint32,:uint64,:sint64,:real32,:real64,:datetime,:class,:reference,:array]
+    def self.normalize type
+      (type.is_a? self) ? type : self.new(type)
+    end
+    
+    TYPES = [:null,:void,:boolean,:char16,:string,:uint8,:sint8,:uint16,:sint16,:uint32,:sint32,:uint64,:sint64,:real32,:real64,:dateTime,:class,:reference,:array]
+    NORMALIZE = {
+      :bool => :boolean,
+      :datetime => :dateTime
+    }
     MATCHES = {
       :null => [],
       :void => [], # WMI
-      :bool => [],
+      :boolean => [],
       :char16 => [ :null, :string ],
       :string => [ :null ],
       :uint8 => [ :null ],
@@ -51,7 +58,7 @@ module CIM
       :sint64 => [ :null, :sint8, :sint16, :sint32 ],
       :real32 => [ :null ],
       :real64 => [ :null, :real32 ],
-      :datetime => [ :null ],
+      :dateTime => [ :null ],
       :class => [ :null ],
       :reference => [ :null ],
       :array => [ :null ]
@@ -60,13 +67,17 @@ module CIM
     #
     # Basic types are created by-symbol or by-name
     #
-    # CIM::Type.new(:bool) == CIM::Type.new("bool")
+    # CIM::Type.new(:boolean) == CIM::Type.new("boolean")
     #
     def initialize type
       type.downcase! if type.is_a? String
       @type = type.to_sym
+      @type = NORMALIZE[@type] || @type
       raise TypeError.new("#{type}") unless TYPES.include? @type
     end
+    def array?
+      false
+    end
     #
     # returns a string representation in MOF syntax format
     #
@@ -84,38 +95,49 @@ module CIM
     #
     def == t
       case t
-      when Type: t.type == @type
-      when Symbol: t == @type
-      when String: t.downcase == @type.to_s
+      when Type then t.type == @type
+      when Symbol then t == @type
+      when String then t.downcase == @type.to_s
       else
 	false
       end
     end
     private
     def matches_value type,value
-      #	puts ">#{type}<{#{type.class}}.matches_value?>#{value.inspect}<{#{value.class}}"
+#      puts "matches_value >#{type}<{#{type.class}}.matches_value?>#{value.inspect}<{#{value.class}}"
+      if value.class === Class
+	return case value.to_s
+          when "NilClass" then type == :null
+	  when "FalseClass", "TrueClass" then type == :boolean
+	  when "Integer", "Fixnum" then [:uint8,:sint8,:uint16,:sint16,:uint32,:sint32,:uint64,:sint64].include? type
+	  when "Float" then [:real32, :real64].include? type
+	  when "String" then type == :string
+	  when "Array" then type.array?
+	  else
+	    false
+	  end
+      end
       case value
       when NilClass
 	true
       when FalseClass, TrueClass
-	type == :bool
-      when Integer
+	type == :boolean
+      when Integer, Fixnum
 	case type
-	when :uint8: (0..255) === value
-	when :sint8: (-128..127) === value
-	when :uint16: (0..65535) === value
-	when :sint16: (-32768..32767) === value
-	when :uint32: (0..4294967295) === value
-	when :sint32: (-2147483648..2147483647) === value
-	when :uint64: (0..18446744073709551615) === value
-	when :sint64: (-9223372036854775808..9223372036854775807) === value
+	when :uint8 then (0..255) === value
+	when :sint8 then (-128..127) === value
+	when :uint16 then (0..65535) === value
+	when :sint16 then (-32768..32767) === value
+	when :uint32 then (0..4294967295) === value
+	when :sint32 then (-2147483648..2147483647) === value
+	when :uint64 then (0..18446744073709551615) === value
+	when :sint64 then (-9223372036854775808..9223372036854775807) === value
 	else
 	  false
 	end
       when Float
 	case type
-	when :real32: value.to_i.size == 4
-	when :real64: true
+	when :real32, :real64 then true
 	else
 	  false
 	end
@@ -162,6 +184,9 @@ module CIM
       @size = size
       super type
     end
+    def array?
+      true
+    end
     #
     # An array is equal to any other array, regardless of the enclosed type
     #

data/lib/cim/variant.rb

@@ -31,13 +31,13 @@ module CIM
     def == v
 #      $stderr.puts "<#{@type}>#{self} == #{v.class}"
       case v
-      when NilClass:   @type == :null && @value.nil?
-      when FalseClass: @type == :bool && !@value
-      when TrueClass:  @type == :bool && @value
-      when String:     @type == :string && @value == v
-      when Integer:    @type == :int && @value == v
-      when Float:      @type == :real && @value == v
-      when CIM::Variant: @type == v.type && @value == v.value
+      when NilClass then     @type == :null && @value.nil?
+      when FalseClass then   @type == :boolean && !@value
+      when TrueClass then    @type == :boolean && @value
+      when String then       @type == :string && @value == v
+      when Integer then      @type == :int && @value == v
+      when Float then        @type == :real && @value == v
+      when CIM::Variant then @type == v.type && @value == v.value
       else
 	false
       end			

data/test/test_method.rb

@@ -15,10 +15,10 @@ class MethodTest < Test::Unit::TestCase
     assert_equal false, m.to_s.empty?
   end
   def test_nodesc
-    m = CIM::Method.new :bool, "Foo"
+    m = CIM::Method.new :boolean, "Foo"
     assert m
     assert_equal "Foo", m.name
-    assert_equal m.type, :bool
+    assert_equal m.type, :boolean
 #    assert_equal nil, m.description
   end
   def test_raise

data/test/test_property.rb

@@ -5,7 +5,7 @@ require "cim"
 
 class PropertyTest < Test::Unit::TestCase
   def test_init
-    p = CIM::Property.new :string, "String", CIM::QualifierDeclaration.new(:key, :bool), CIM::QualifierDeclaration.new(:description, :string, "This is a string", :class)
+    p = CIM::Property.new :string, "String", CIM::QualifierDeclaration.new(:key, :boolean), CIM::QualifierDeclaration.new(:description, :string, "This is a string", :class)
     assert p
     assert p.is_a? CIM::Property
     assert_equal "String", p.name

data/test/test_qualifier.rb

@@ -5,7 +5,7 @@ require "cim"
 
 class QualifierTest < Test::Unit::TestCase
   def test_key
-    q = CIM::QualifierDeclaration.new :key, :bool
+    q = CIM::QualifierDeclaration.new :key, :boolean
     assert q
   end
   def test_raise

data/test/test_qualifier_flavors.rb

@@ -0,0 +1,19 @@
+$: << File.join(File.dirname(__FILE__),"..","lib")
+
+require "test/unit"
+require "cim"
+
+class QualifierFlavorsTest < Test::Unit::TestCase
+  def test_new
+    assert CIM::QualifierFlavors.new
+    f = CIM::QualifierFlavors.new(:enableoverride)
+    assert f
+    assert_equal 1,f.size
+    assert f.include? :enableoverride
+  end
+  def test_raise
+    assert_raise CIM::QualifierFlavorError do
+      CIM::QualifierFlavors.new(:unknown)
+    end
+  end
+end

data/test/test_qualifier_scopes.rb

@@ -0,0 +1,19 @@
+$: << File.join(File.dirname(__FILE__),"..","lib")
+
+require "test/unit"
+require "cim"
+
+class QualifierScopesTest < Test::Unit::TestCase
+  def test_new
+    assert CIM::QualifierScopes.new
+    s = CIM::QualifierScopes.new(:association)
+    assert s
+    assert_equal 1,s.size
+    assert s.include? :association
+  end
+  def test_raise
+    assert_raise CIM::QualifierScopeError do
+      CIM::QualifierScopes.new(:unknown)
+    end
+  end
+end

data/test/test_qualifier_set.rb

@@ -5,11 +5,11 @@ require "cim"
 
 class QualifierSetTest < Test::Unit::TestCase
   def setup
-    qbool    = CIM::QualifierDeclaration.new("flag")
+    qboolean = CIM::QualifierDeclaration.new("flag")
     qint     = CIM::QualifierDeclaration.new("value", :uint32)
     qstring  = CIM::QualifierDeclaration.new("description", :string, "This is a description")
     @qualifiers = CIM::QualifierSet.new
-    @qualifiers << CIM::Qualifier.new(qbool)
+    @qualifiers << CIM::Qualifier.new(qboolean)
     @qualifiers << CIM::Qualifier.new(qint)
     @qualifiers << CIM::Qualifier.new(qstring)
   end
@@ -18,22 +18,22 @@ class QualifierSetTest < Test::Unit::TestCase
   end
   def test_prefill
     q = CIM::QualifierSet.new "a", :b
-    assert 2, q.size
+    assert_equal 2, q.size
     assert q.include?( "a" )
-    assert q.include?( "b", :bool )
+    assert q.include?( "b", :boolean )
   end
   def test_include
     assert @qualifiers.include?( :flag )
     assert @qualifiers.include?( "flag" )
-    assert @qualifiers.include?( "flag", :bool )
-    assert @qualifiers.include?( "flag", "bool" )
+    assert @qualifiers.include?( "flag", :boolean )
+    assert @qualifiers.include?( "flag", "boolean" )
     assert !@qualifiers.include?( "flag", :string )
   end
   def test_access
     assert @qualifiers[:flag]
     assert @qualifiers["flag"]
-    assert @qualifiers["flag", :bool]
-    assert @qualifiers["flag", "bool"]
+    assert @qualifiers["flag", :boolean]
+    assert @qualifiers["flag", "boolean"]
     assert !@qualifiers["flag", :string]
   end
 end

data/test/test_type.rb

@@ -8,10 +8,26 @@ class TypeTest < Test::Unit::TestCase
     t = CIM::Type.new :null
     assert t
     assert_equal "null", t.to_s
+    assert !t.array?
   end
   def test_raise
     assert_raise TypeError do
       t = CIM::Type.new :foo
     end
   end
+  def test_alias
+    assert_equal CIM::Type.new(:bool), CIM::Type.new(:boolean)
+    assert_equal CIM::Type.new(:datetime), CIM::Type.new(:dateTime)
+  end
+  def test_normalize
+    assert_equal CIM::Type.new(:null), CIM::Type.normalize(:null)
+    assert_equal CIM::Type.normalize(:null), CIM::Type.normalize(CIM::Type.new(:null))
+  end
+  def test_matches
+    assert CIM::Type.new(:null).matches? nil
+    assert CIM::Type.new(:uint64).matches? 1
+    assert CIM::Type.new(:uint64).matches? Integer
+    assert CIM::Type.new(:real32).matches? 3.1415
+    assert CIM::Type.new(:string).matches? String
+  end
 end

metadata

@@ -1,13 +1,12 @@
 --- !ruby/object:Gem::Specification 
 name: cim
 version: !ruby/object:Gem::Version 
-  hash: 11
+  hash: 9
   prerelease: 
   segments: 
-  - 0
-  - 5
-  - 0
-  version: 0.5.0
+  - 1
+  - 3
+  version: "1.3"
 platform: ruby
 authors: 
 - "Klaus K\xC3\xA4mpf"
@@ -15,10 +14,37 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-09-29 00:00:00 +02:00
+date: 2012-03-13 00:00:00 +01:00
 default_executable: 
-dependencies: []
-
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: rake
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: bundler
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id002
 description: |-
   Instances of Cim classes are used to define a CIM
   schema, often represented as a .mof file. See
@@ -41,10 +67,8 @@ files:
 - Rakefile
 - cim.gemspec
 - lib/cim.rb
-- lib/cim/association.rb
 - lib/cim/class.rb
 - lib/cim/class_feature.rb
-- lib/cim/indication.rb
 - lib/cim/instance.rb
 - lib/cim/method.rb
 - lib/cim/named_element.rb
@@ -64,6 +88,8 @@ files:
 - test/test_method.rb
 - test/test_property.rb
 - test/test_qualifier.rb
+- test/test_qualifier_flavors.rb
+- test/test_qualifier_scopes.rb
 - test/test_qualifier_set.rb
 - test/test_reference.rb
 - test/test_type.rb
@@ -97,7 +123,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
 requirements: []
 
 rubyforge_project: cim
-rubygems_version: 1.5.2
+rubygems_version: 1.5.0
 signing_key: 
 specification_version: 3
 summary: A pure-Ruby implementation of the CIM meta model
@@ -106,6 +132,8 @@ test_files:
 - test/test_method.rb
 - test/test_property.rb
 - test/test_qualifier.rb
+- test/test_qualifier_flavors.rb
+- test/test_qualifier_scopes.rb
 - test/test_qualifier_set.rb
 - test/test_reference.rb
 - test/test_type.rb

data/lib/cim/association.rb

@@ -1,38 +0,0 @@
-#
-# cim/association.rb - class CIM::Association
-#
-# A pure-Ruby implementation of the CIM meta model.
-#
-# Copyright (c) 2010 Klaus Kämpf <kkaempf@suse.de>
-#
-# Licensed under the Ruby license
-#
-module CIM
-  #
-  # An Association is a Class with the :association Qualifier
-  #
-  # Only such a class can have Reference properties
-  #
-  class Association < Class
-    #
-    # Create Association class
-    #
-    # call-seq:
-    #   Association.new("AssocClass")
-    #   Association.new("AssocClass", qualifiers)
-    #   Association.new("AssocClass", qualifiers, "assoc_class")
-    #   Association.new("AssocClass", qualifiers, "assoc_class", "SuperClass")
-    #   Association.new("AssocClass", qualifiers, "assoc_class", "SuperClass", features)
-    #
-    def initialize name, qualifiers = nil, alias_name = nil, superclass = nil, features = nil
-      raise "Association needs 'association' qualifier" unless qualifiers.include?(:association, :bool)
-      super name, qualifiers, alias_name, superclass, features
-    end
-    #
-    # true if class has associations (association provider)
-    #
-    def association?
-      true
-    end
-  end
-end

data/lib/cim/indication.rb

@@ -1,22 +0,0 @@
-#
-# cim/indication.rb - class CIM::Indication
-#
-# A pure-Ruby implementation of the CIM meta model.
-#
-# Copyright (c) 2010 Klaus Kämpf <kkaempf@suse.de>
-#
-# Licensed under the Ruby license
-#
-module CIM
-  #
-  # Indication is a Class whose Instances are sending asynchronous notifications
-  #
-  class Indication < Class
-    #
-    # true if class has indications (indication provider)
-    #
-    def indication?
-      true
-    end
-  end
-end