cim 0.2.7 → 0.3.0

data/Manifest.txt

@@ -7,14 +7,13 @@ lib/cim/association.rb
 lib/cim/class.rb
 lib/cim/indication.rb
 lib/cim/instance.rb
-lib/cim/meta/feature.rb
-lib/cim/meta/flavor.rb
-lib/cim/meta/named_element.rb
-lib/cim/meta/qualifier.rb
-lib/cim/meta/schema.rb
-lib/cim/meta/scope.rb
-lib/cim/meta/type.rb
-lib/cim/meta/variant.rb
+lib/cim/class_feature.rb
+lib/cim/qualifier_flavors.rb
+lib/cim/named_element.rb
+lib/cim/qualifier_declaration.rb
+lib/cim/qualifier_scope.rb
+lib/cim/type.rb
+lib/cim/variant.rb
 lib/cim/method.rb
 lib/cim/property.rb
 lib/cim/qualifier.rb

data/README.rdoc

@@ -8,8 +8,11 @@
 
   Instances of Cim classes are used to define a CIM schema, often
   represented as a .mof file.
+  See http://www.dmtf.org/standards/cim and http://www.dmtf.org/education/mof
+  for details
 
-  Hence the primary consumer of Cim is Mofparser, a Ruby based MOF parser.
+  https://rubygems.org/gems/mof is a parser for .mof files and the
+  primary consumer of the cim gem.
 
 == SYNOPSIS:
 
@@ -30,4 +33,4 @@
 
 Copyright (c) 2010 Klaus Kämpf <kkaempf@suse.de>
 
-See http://www.ruby-lang.org/en/LICENSE.txt for the full text
+See http://www.ruby-lang.org/en/LICENSE.txt for the full text

data/lib/cim.rb

@@ -8,17 +8,17 @@ $:.unshift(File.dirname(__FILE__)) unless
   $:.include?(File.dirname(__FILE__)) || $:.include?(File.expand_path(File.dirname(__FILE__)))
 
 module Cim
-  VERSION = '0.2.7'
+  VERSION = '0.3.0'
   cim_dir = File.join(File.dirname(__FILE__),"cim")
-  require cim_dir + '/meta/type'
-  require cim_dir + '/meta/variant'
-  require cim_dir + '/meta/flavor'
-  require cim_dir + '/meta/scope'
-  require cim_dir + '/meta/named_element'
-  require cim_dir + '/meta/qualifier'
+  require cim_dir + '/type'
+  require cim_dir + '/variant'
+  require cim_dir + '/qualifier_flavors'
+  require cim_dir + '/qualifier_scope'
+  require cim_dir + '/named_element'
+  require cim_dir + '/qualifier_declaration'
   require cim_dir + '/qualifier'
   require cim_dir + '/qualifiers'
-  require cim_dir + '/meta/feature'
+  require cim_dir + '/class_feature'
   require cim_dir + '/property'
   require cim_dir + '/reference'
   require cim_dir + '/method'

data/lib/cim/association.rb

@@ -1,4 +1,4 @@
-module Cim
+module CIM
   class Association < Class
     def initialize name, qualifiers, alias_name, superclass, features
       raise "Association needs 'association' qualifier" unless qualifiers.include?(:association, :bool)

data/lib/cim/class.rb

@@ -1,7 +1,7 @@
-module Cim
+module CIM
   require File.join(File.dirname(__FILE__),"qualifier")
-  class Class < Cim::Meta::NamedElement
-    attr_reader :qualifiers, :alias_name, :superclass, :features
+  class Class < CIM::NamedElement
+    attr_reader :alias_name, :qualifiers, :superclass, :features
     attr_accessor :parent
     def initialize name, qualifiers, alias_name, superclass, features
       @qualifiers = qualifiers
@@ -9,7 +9,7 @@ module Cim
       @superclass = superclass
       features = nil if features.is_a?(Array) && features.empty?
       @features = features
-      #	puts "Cim::Schema::Class.new(#{@features})"
+      #	puts "CIM::Class.new(#{@features})"
       super name
     end
     def add_type t
@@ -23,7 +23,7 @@ module Cim
     def method?
       @features.each do |f|
 	case f
-	when Cim::Schema::Method: return true
+	when CIM::Method: return true
 	end
       end
       false

data/lib/cim/class_feature.rb

@@ -0,0 +1,43 @@
+module CIM
+  # Shared between Property and Method
+  class ClassFeature < NamedElement
+    attr_reader :type, :qualifiers
+    def initialize type, name, qualifiers = nil
+      @type = (type.is_a? CIM::Type) ? type : CIM::Type.new(type)
+      qualifiers = nil if qualifiers.is_a?(::Array) && qualifiers.empty?
+      @qualifiers = qualifiers
+      super name
+    end
+    # if has key qualifier
+    def key?
+      @qualifiers && @qualifiers.include?(:key,:bool)
+    end
+    # if static (class-level) feature
+    def static?
+      false
+    end
+    # if property
+    def property?
+      false
+    end
+    # if method
+    def method?
+      false
+    end
+    # if reference
+    def reference?
+      false
+    end
+    def to_s
+      s = ""
+      s << "#{@qualifiers}\n  " if @qualifiers
+      case @type
+      when CIM::Array
+	s << "#{@type.type} #{@name}[]"
+      else
+	s << "#{@type} #{@name}"
+      end
+      s
+    end
+  end
+end

data/lib/cim/indication.rb

@@ -1,4 +1,4 @@
-module Cim
+module CIM
   class Indication < Class
     # true if class has indications (indication provider)
     def indication?

data/lib/cim/method.rb

@@ -1,5 +1,5 @@
-module Cim
-  class Method < Cim::Meta::Feature
+module CIM
+  class Method < CIM::ClassFeature
     attr_reader :parameters
     def initialize type, name, qualifiers = nil, parameters = nil
       parameters = nil if parameters.kind_of?(::Enumerable) && parameters.empty?

data/lib/cim/named_element.rb

@@ -0,0 +1,17 @@
+module CIM
+  class NamedElement
+    attr_reader :name, :characteristics
+    def initialize name
+      raise "NamedElement must have a name" unless name
+      @name = name.to_s
+      @characteristics = []
+    end
+    def << qualifier
+      @characteristics << qualifier
+    end
+    def has? qualifier
+      @characteristics.include? qualifier
+    end
+  end
+end
+

data/lib/cim/property.rb

@@ -1,5 +1,5 @@
-module Cim
-  class Property < Cim::Meta::Feature
+module CIM
+  class Property < CIM::ClassFeature
     attr_reader :default
     def initialize type, name, qualifiers=nil, default=nil
       @default = default
@@ -8,6 +8,9 @@ module Cim
       end
       super type, name, qualifiers
     end
+    def property?
+      true
+    end
   end
 end
 

data/lib/cim/qualifier.rb

@@ -1,32 +1,32 @@
-module Cim
+module CIM
   class Qualifier
-    attr_reader :definition, :value, :flavor
-    def initialize definition, value = nil, flavor = nil
-      raise "Not a Cim::Meta::Qualifier definition: #{definition.inspect}" unless definition.is_a?(Cim::Meta::Qualifier)
-      @definition = definition
+    attr_reader :declaration, :value, :flavor
+    def initialize declaration, value = nil, flavor = nil
+      raise "Not a CIM::QualifierDeclaration: #{declaration.inspect}" unless declaration.is_a?(CIM::QualifierDeclaration)
+      @declaration = declaration
       @value = value
       @flavor = flavor
     end
     def == q
-      #	puts "Cim::Schema::Qualifier ->#{self} == #{q.inspect}"
+      #	puts "CIM::Qualifier ->#{self} == #{q.inspect}"
       case q
-      when Cim::Schema::Qualifier
-	(@definition == q.definition) &&
+      when CIM::Qualifier
+	(@declaration == q.declaration) &&
 	(@value == q.value) &&
 	(@flavor == q.flavor)
-      when Cim::Meta::Qualifier
-	@definition == q  
+      when CIM::QualifierDeclaration
+	@declaration == q  
       when Symbol
-	q.to_s.downcase == @definition.name.downcase && @value.nil? && @flavor.nil?
+	q.to_s.downcase == @declaration.name.downcase && @value.nil? && @flavor.nil?
       else
 	false
       end
     end
     def to_sym
-      @definition.downcase.to_sym
+      @declaration.downcase.to_sym
     end
     def to_s
-      s = "#{@definition.name.capitalize}"
+      s = "#{@declaration.name.capitalize}"
       case @value
       when nil:
       when Array:

data/lib/cim/qualifier_declaration.rb

@@ -0,0 +1,32 @@
+module CIM
+  class QualifierDeclaration < NamedElement
+
+    attr_reader :type, :default, :scope, :flavor
+
+    def initialize name, type = :bool, default = false, scope = nil, flavor = nil
+      @type = (type.kind_of? Type) ? type : Type.new(type)
+      @default = (default.nil? || default.is_a?(CIM::Variant)) ? default : CIM::Variant.new(@type, default)
+      @scope = scope
+      @flavor = flavor
+      super name
+    end
+      
+    def == q
+      #	puts "#{@name}:#{@type} == #{q.name}:#{q.type}"
+      (@name.downcase == q.name.downcase) &&
+        (@type.nil? || q.type.nil? || (@type == q.type))
+    end
+
+    def to_sym
+      @name.downcase.to_sym
+    end
+
+    def to_s
+      s = "Qualifier #{@name} : #{@type}"
+      s << " = #{@default}" if @default
+      s << ",\n\t#{@scope}" if @scope
+      s << ",\n\t#{@flavor}" if @flavor
+      s
+    end
+  end
+end

data/lib/cim/qualifier_flavors.rb

@@ -0,0 +1,33 @@
+module CIM
+
+  class QualifierFlavorError < ArgumentError
+    def initialize flavor
+      @flavor = flavor
+    end
+    def to_s
+      "#{@flavor} is not a valid qualifier flavor"
+    end
+  end
+
+  class QualifierFlavors
+    FLAVORS = [:amended, :enableoverride, :disableoverride, :restricted, :toinstance, :tosubclass, :translatable]
+    attr_reader :flavors
+    def initialize flavor
+      @flavors = []
+      self << flavor
+    end
+    def << flavor
+      flavor.downcase! if flavor.kind_of? String
+      f = flavor.to_sym
+      raise QualifierFlavorError.new("#{flavor}") unless FLAVORS.include? f
+      @flavors << f
+      self
+    end
+    def to_sym
+      @flavors.first
+    end
+    def to_s
+      "Flavor(#{@flavors.join(', ')})"
+    end
+  end
+end

data/lib/cim/qualifier_scope.rb

@@ -0,0 +1,37 @@
+module CIM
+    
+  class QualifierScopeError < ArgumentError
+    def initialize element, msg = nil
+      @element = element
+      super msg
+    end
+    def to_s
+      "#{@element} is not a valid meta element for scopes"
+    end
+  end
+
+  class QualifierScope
+    META_ELEMENTS = [ :schema, :class, :association, :indication, :qualifier, :property, :reference, :method, :parameter, :any ]
+    attr_reader :elements
+    def initialize element = :any
+      @elements = []
+      self << element
+    end
+    def << element
+      element.downcase! if element.is_a?(String)
+      e = element.to_sym
+      raise QualifierScopeError.new(element) unless META_ELEMENTS.include?(e)
+      @elements << e
+      self
+    end
+    def has? qualifier
+      @elements.include? qualifier
+    end
+    def to_s
+      "Scope(#{@elements.join(', ')})"
+    end
+    def to_sym
+      @elements.first
+    end
+  end
+end

data/lib/cim/qualifiers.rb

@@ -1,6 +1,6 @@
-module Cim
-  # Array of Cim::Schema::Qualifier
-  class Qualifiers < Array
+module CIM
+  # Array of CIM::Qualifier
+  class Qualifiers < ::Array
     #
     # check if qualifier exists
     #
@@ -8,14 +8,14 @@ module Cim
     def include? q,type=:null
       #	puts "#{self}.include? #{q}:#{type}"
       case q
-      when Cim::Schema::Qualifier
+      when CIM::Qualifier
 	q = q.definition
-      when Cim::Meta::Qualifier
+      when CIM::QualifierDeclaration
 	# nothing
       when String
-	q = Cim::Meta::Qualifier.new(q,type)
+	q = CIM::QualifierDeclaration.new(q,type)
       when Symbol
-	q = Cim::Meta::Qualifier.new(q,type)
+	q = CIM::QualifierDeclaration.new(q,type)
       else
 	raise "Unknown parameter in #{self.class}.include?"
       end
@@ -29,14 +29,14 @@ module Cim
       case q
       when Fixnum
 	return self.array_access[q]
-      when Cim::Schema::Qualifier
+      when CIM::Qualifier
 	q = q.definition
-      when Cim::Meta::Qualifier
+      when CIM::QualifierDeclaration
 	# nothing
       when String
-	q = Cim::Meta::Qualifier.new(q,type)
+	q = CIM::QualifierDeclaration.new(q,type)
       when Symbol
-	q = Cim::Meta::Qualifier.new(q,type)
+	q = CIM::QualifierDeclaration.new(q,type)
       else
 	raise "Unknown parameter in #{self.class}.[]"
       end

data/lib/cim/reference.rb

@@ -1,5 +1,5 @@
-module Cim
-  class Reference < Property
+module CIM
+  class Reference < CIM::Property
     def reference?
       true
     end

data/lib/cim/type.rb

@@ -0,0 +1,122 @@
+module CIM
+  class Type
+    TYPES = [:null,:void,:bool,:char16,:string,:uint8,:sint8,:uint16,:sint16,:uint32,:sint32,:uint64,:sint64,:real32,:real64,:datetime,:class,:reference,:array]
+    MATCHES = {
+      :null => [],
+      :void => [], # WMI
+      :bool => [],
+      :char16 => [ :null, :string ],
+      :string => [ :null ],
+      :uint8 => [ :null ],
+      :sint8 => [ :null ],
+      :uint16 => [ :null, :uint8 ],
+      :sint16 => [ :null, :sint8 ],
+      :uint32 => [ :null, :uint8, :uint16 ],
+      :sint32 => [ :null, :sint8, :sint16 ],
+      :uint64 => [ :null, :uint8, :uint16, :sint32 ],
+      :sint64 => [ :null, :sint8, :sint16, :sint32 ],
+      :real32 => [ :null ],
+      :real64 => [ :null, :real32 ],
+      :datetime => [ :null ],
+      :class => [ :null ],
+      :reference => [ :null ],
+      :array => [ :null ]
+    }
+    attr_reader :type
+    def initialize type
+      type.downcase! if type.is_a? String
+      @type = type.to_sym
+      raise TypeError.new("#{type}") unless TYPES.include? @type
+    end
+    def to_s
+      @type.to_s
+    end
+    def to_sym
+      @type
+    end
+    def == t
+      case t
+      when Type: t.type == @type
+      when Symbol: t == @type
+      else
+	false
+      end
+    end
+    private
+    def matches_value type,value
+      #	puts ">#{type}<{#{type.class}}.matches_value?>#{value.inspect}<{#{value.class}}"
+      case value
+      when NilClass
+	true
+      when FalseClass, TrueClass
+	type == :bool
+      when Integer
+	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
+	else
+	  false
+	end
+      when Float
+	case type
+	when :real32: value.to_i.size == 4
+	when :real64: true
+	else
+	  false
+	end
+      when String
+	type == :string
+      else
+	false
+      end
+    end
+    public
+    def matches? x
+      #	puts ">#{self}<{#{self.class}}.matches?>#{x.inspect}<{#{x.class}}"
+      case x
+      when CIM::Type, CIM::Variant
+	return true if x.type == @type
+	return true if MATCHES[@type].include? x.type
+	false
+      when ::Array
+	return false unless self.is_a? CIM::Array
+	x.each do |v|
+	  return false unless matches_value @type,v
+	end
+	true
+      else
+	matches_value @type, x
+      end
+    end
+  end
+  class Array < Type
+    attr_reader :size
+    def initialize size, type
+      @size = size
+      super type
+    end
+    def to_s
+      if @size > 0
+	"#{super}[#{@size}]"
+      else
+	"#{super}[]"
+      end
+    end
+  end
+  class ReferenceType < Type
+    attr_reader :name
+    def initialize name
+      @name = name
+      super :class
+    end
+    def to_s
+      "#{@name} ref"
+    end
+  end
+end

data/lib/cim/variant.rb

@@ -0,0 +1,17 @@
+module CIM
+  # A Variant is a typed value
+  class Variant
+    attr_reader :type, :value
+    def initialize type = :null, value = nil
+      @type = (type.kind_of? CIM::Type) ? type : CIM::Type.new(type)
+      @value = value unless value == :null
+    end
+    def to_s
+      if @type == :null
+	"null"
+      else
+	"#{@value.inspect}"
+      end
+    end
+  end
+end

data/test/test_method.rb

@@ -5,7 +5,7 @@ require "cim"
 
 class MethodTest < Test::Unit::TestCase
   def test_init
-    m = Cim::Method.new :real32, "Foo", Cim::Meta::Qualifier.new(:description, :string, "This is a foo method", :class)
+    m = CIM::Method.new :real32, "Foo", CIM::QualifierDeclaration.new(:description, :string, "This is a foo method", :class)
     assert m
     assert_equal "Foo", m.name
     assert m.qualifiers.size > 0
@@ -14,7 +14,7 @@ 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 :bool, "Foo"
     assert m
     assert_equal "Foo", m.name
     assert_equal m.type, :bool
@@ -22,7 +22,7 @@ class MethodTest < Test::Unit::TestCase
   end
   def test_raise
     assert_raise TypeError do
-      m = Cim::Method.new :foo, "Foo"
+      m = CIM::Method.new :foo, "Foo"
     end
   end
 end

data/test/test_property.rb

@@ -5,19 +5,19 @@ require "cim"
 
 class PropertyTest < Test::Unit::TestCase
   def test_init
-    p = Cim::Property.new :string, "String", Cim::Meta::Qualifier.new(:key, :bool), Cim::Meta::Qualifier.new(:description, :string, "This is a string", :class)
+    p = CIM::Property.new :string, "String", CIM::QualifierDeclaration.new(:key, :bool), CIM::QualifierDeclaration.new(:description, :string, "This is a string", :class)
     assert p
-    assert p.is_a? Cim::Property
+    assert p.is_a? CIM::Property
     assert_equal "String", p.name
 #    assert p.key?
   end
   def test_name
-    p = Cim::Property.new :uint32, "foo"
+    p = CIM::Property.new :uint32, "foo"
     assert_equal "foo", p.name
   end
   def test_raise
     assert_raise TypeError do
-      p = Cim::Property.new :foo, "foo"
+      p = CIM::Property.new :foo, "foo"
     end
   end
 end

data/test/test_qualifier.rb

@@ -5,12 +5,12 @@ require "cim"
 
 class QualifierTest < Test::Unit::TestCase
   def test_key
-    q = Cim::Meta::Qualifier.new :key, :bool
+    q = CIM::QualifierDeclaration.new :key, :bool
     assert q
   end
   def test_raise
     assert_raise RuntimeError do
-      Cim::Qualifier.new(:unknown)
+      CIM::Qualifier.new(:unknown)
     end  
   end
 end

data/test/test_reference.rb

@@ -5,9 +5,9 @@ require "cim"
 
 class ReferenceTest < Test::Unit::TestCase
   def test_init
-    r = Cim::Reference.new :string, "String"
+    r = CIM::Reference.new :string, "String"
     assert r
-    assert r.is_a? Cim::Reference
-    assert r.kind_of? Cim::Property
+    assert r.is_a? CIM::Reference
+    assert r.kind_of? CIM::ClassFeature
   end
 end

data/test/test_type.rb

@@ -5,13 +5,13 @@ require "cim"
 
 class TypeTest < Test::Unit::TestCase
   def test_init
-    t = Cim::Meta::Type.new :null
+    t = CIM::Type.new :null
     assert t
     assert_equal "null", t.to_s
   end
   def test_raise
     assert_raise TypeError do
-      t = Cim::Meta::Type.new :foo
+      t = CIM::Type.new :foo
     end
   end
 end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: cim
 version: !ruby/object:Gem::Version 
-  hash: 25
+  hash: 19
   prerelease: false
   segments: 
   - 0
-  - 2
-  - 7
-  version: 0.2.7
+  - 3
+  - 0
+  version: 0.3.0
 platform: ruby
 authors: 
 - "Klaus K\xC3\xA4mpf"
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-10-03 00:00:00 +02:00
+date: 2010-10-04 00:00:00 +02:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -55,8 +55,11 @@ description: |-
   
     Instances of Cim classes are used to define a CIM schema, often
     represented as a .mof file.
+    See http://www.dmtf.org/standards/cim and http://www.dmtf.org/education/mof
+    for details
   
-    Hence the primary consumer of Cim is Mofparser, a Ruby based MOF parser.
+    https://rubygems.org/gems/mof is a parser for .mof files and the
+    primary consumer of the cim gem.
 email: 
 - kkaempf@suse.de
 executables: []
@@ -76,14 +79,13 @@ files:
 - lib/cim/class.rb
 - lib/cim/indication.rb
 - lib/cim/instance.rb
-- lib/cim/meta/feature.rb
-- lib/cim/meta/flavor.rb
-- lib/cim/meta/named_element.rb
-- lib/cim/meta/qualifier.rb
-- lib/cim/meta/schema.rb
-- lib/cim/meta/scope.rb
-- lib/cim/meta/type.rb
-- lib/cim/meta/variant.rb
+- lib/cim/class_feature.rb
+- lib/cim/qualifier_flavors.rb
+- lib/cim/named_element.rb
+- lib/cim/qualifier_declaration.rb
+- lib/cim/qualifier_scope.rb
+- lib/cim/type.rb
+- lib/cim/variant.rb
 - lib/cim/method.rb
 - lib/cim/property.rb
 - lib/cim/qualifier.rb
@@ -132,8 +134,8 @@ specification_version: 3
 summary: "* Cim is a pure-Ruby implementation of the CIM meta model"
 test_files: 
 - test/test_qualifier.rb
-- test/test_method.rb
+- test/test_loading.rb
 - test/test_property.rb
 - test/test_type.rb
-- test/test_loading.rb
+- test/test_method.rb
 - test/test_reference.rb

data/lib/cim/meta/feature.rb

@@ -1,41 +0,0 @@
-module Cim
-  module Meta
-    # Shared between Property and Method
-    class Feature < NamedElement
-      attr_reader :type, :qualifiers
-      def initialize type, name, qualifiers
-	@type = (type.is_a? Cim::Meta::Type) ? type : Cim::Meta::Type.new(type)
-	qualifiers = nil if qualifiers.is_a?(::Array) && qualifiers.empty?
-	@qualifiers = qualifiers
-	super name
-      end
-      # if has key qualifier
-      def key?
-	@qualifiers && @qualifiers.include?(:key,:bool)
-      end
-      # if static (class-level) feature
-      def static?
-	false
-      end
-      # if method
-      def method?
-	false
-      end
-      # if reference
-      def reference?
-	false
-      end
-      def to_s
-	s = ""
-	s << "#{@qualifiers}\n  " if @qualifiers
-	case @type
-	when Cim::Meta::Array
-	  s << "#{@type.type} #{@name}[]"
-        else
-	  s << "#{@type} #{@name}"
-        end
-	s
-      end
-    end
-  end
-end

data/lib/cim/meta/flavor.rb

@@ -1,33 +0,0 @@
-module Cim
-  module Meta
-    class FlavorError < ArgumentError
-      def initialize flavor
-	@flavor = flavor
-      end
-      def to_s
-	"#{@flavor} is not a valid Flavor"
-      end
-    end
-    class Flavors
-      FLAVORS = [:amended, :enableoverride, :disableoverride, :restricted, :toinstance, :tosubclass, :translatable]
-      attr_reader :flavors
-      def initialize flavor
-	@flavors = []
-	self << flavor
-      end
-      def << flavor
-	flavor.downcase! if flavor.kind_of? String
-	f = flavor.to_sym
-	raise FlavorError.new("#{flavor}") unless FLAVORS.include? f
-	@flavors << f
-	self
-      end
-      def to_sym
-	@flavors.first
-      end
-      def to_s
-	"Flavor(#{@flavors.join(', ')})"
-      end
-    end
-  end
-end

data/lib/cim/meta/named_element.rb

@@ -1,18 +0,0 @@
-module Cim
-  module Meta
-    class NamedElement
-      attr_reader :name, :characteristics
-      def initialize name
-	raise "NamedElement must have a name" unless name
-	@name = name.to_s
-	@characteristics = []
-      end
-      def << qualifier
-	@characteristics << qualifier
-      end
-      def has? qualifier
-	@characteristics.include? qualifier
-      end
-    end
-  end
-end

data/lib/cim/meta/qualifier.rb

@@ -1,34 +0,0 @@
-module Cim
-  module Meta
-    class Qualifier < NamedElement
-      
-      attr_reader :type, :default, :scope, :flavor
-      
-      def initialize name, type = :bool, default = false, scope = nil, flavor = nil
-	@type = (type.kind_of? Type) ? type : Type.new(type)
-	@default = (default.nil? || default.is_a?(Cim::Meta::Variant)) ? default : Cim::Meta::Variant.new(@type, default)
-	@scope = scope
-	@flavor = flavor
-	super name
-      end
-
-      def == q
-#	puts "#{@name}:#{@type} == #{q.name}:#{q.type}"
-	(@name.downcase == q.name.downcase) &&
-	  (@type.nil? || q.type.nil? || (@type == q.type))
-      end
-
-      def to_sym
-	@name.downcase.to_sym
-      end
-
-      def to_s
-	s = "Qualifier #{@name} : #{@type}"
-	s << " = #{@default}" if @default
-	s << ",\n\t#{@scope}" if @scope
-	s << ",\n\t#{@flavor}" if @flavor
-	s
-      end
-    end
-  end
-end

data/lib/cim/meta/schema.rb

@@ -1,7 +0,0 @@
-module Cim
-  module Meta
-    class Schema < NamedElement
-      # Class schema
-    end
-  end
-end

data/lib/cim/meta/scope.rb

@@ -1,39 +0,0 @@
-module Cim
-  module Meta
-    
-    class MetaElementError < ArgumentError
-      def initialize element, msg = nil
-	@element = element
-	super msg
-      end
-      def to_s
-	"#{@element} is not a valid meta element for scopes"
-      end
-    end
-    
-    class Scope
-      META_ELEMENTS = [ :schema, :class, :association, :indication, :qualifier, :property, :reference, :method, :parameter, :any ]
-      attr_reader :elements
-      def initialize element = :any
-	@elements = []
-	self << element
-      end
-      def << element
-	element.downcase! if element.is_a?(String)
-	e = element.to_sym
-	raise MetaElementError.new(element) unless META_ELEMENTS.include?(e)
-	@elements << e
-	self
-      end
-      def has? qualifier
-	@elements.include? qualifier
-      end
-      def to_s
-	"Scope(#{@elements.join(', ')})"
-      end
-      def to_sym
-	@elements.first
-      end
-    end
-  end
-end

data/lib/cim/meta/type.rb

@@ -1,124 +0,0 @@
-module Cim
-  module Meta
-    class Type
-      TYPES = [:null,:void,:bool,:char16,:string,:uint8,:sint8,:uint16,:sint16,:uint32,:sint32,:uint64,:sint64,:real32,:real64,:datetime,:class,:reference,:array]
-      MATCHES = {
-	:null => [],
-	:void => [], # WMI
-	:bool => [],
-	:char16 => [ :null, :string ],
-	:string => [ :null ],
-	:uint8 => [ :null ],
-	:sint8 => [ :null ],
-	:uint16 => [ :null, :uint8 ],
-	:sint16 => [ :null, :sint8 ],
-	:uint32 => [ :null, :uint8, :uint16 ],
-	:sint32 => [ :null, :sint8, :sint16 ],
-	:uint64 => [ :null, :uint8, :uint16, :sint32 ],
-	:sint64 => [ :null, :sint8, :sint16, :sint32 ],
-	:real32 => [ :null ],
-	:real64 => [ :null, :real32 ],
-	:datetime => [ :null ],
-	:class => [ :null ],
-	:reference => [ :null ],
-	:array => [ :null ]
-      }
-      attr_reader :type
-      def initialize type
-	type.downcase! if type.is_a? String
-	@type = type.to_sym
-	raise TypeError.new("#{type}") unless TYPES.include? @type
-      end
-      def to_s
-	@type.to_s
-      end
-      def to_sym
-	@type
-      end
-      def == t
-	case t
-	when Type: t.type == @type
-	when Symbol: t == @type
-	else
-	  false
-	end
-      end
-      private
-      def matches_value type,value
-#	puts ">#{type}<{#{type.class}}.matches_value?>#{value.inspect}<{#{value.class}}"
-	case value
-	when NilClass
-	  true
-	when FalseClass, TrueClass
-	  type == :bool
-	when Integer
-	  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
-	  else
-	    false
-	  end
-	when Float
-	  case type
-	  when :real32: value.to_i.size == 4
-	  when :real64: true
-	  else
-	    false
-	  end
-	when String
-	  type == :string
-	else
-	  false
-	end
-      end
-      public
-      def matches? x
-#	puts ">#{self}<{#{self.class}}.matches?>#{x.inspect}<{#{x.class}}"
-	case x
-	when Cim::Meta::Type, Cim::Meta::Variant
-	  return true if x.type == @type
-	  return true if MATCHES[@type].include? x.type
-	  false
-	when ::Array
-	  return false unless self.is_a? Cim::Meta::Array
-	  x.each do |v|
-	    return false unless matches_value @type,v
-	  end
-	  true
-	else
-	  matches_value @type, x
-	end
-      end
-    end
-    class Array < Type
-      attr_reader :size
-      def initialize size, type
-	@size = size
-	super type
-      end
-      def to_s
-	if @size > 0
-	  "#{super}[#{@size}]"
-	else
-	  "#{super}[]"
-	end
-      end
-    end
-    class Reference < Type
-      attr_reader :name
-      def initialize name
-	@name = name
-	super :class
-      end
-      def to_s
-	"#{@name} ref"
-      end
-    end
-  end
-end

data/lib/cim/meta/variant.rb

@@ -1,19 +0,0 @@
-module Cim
-  module Meta
-    # A Variant is a typed value
-    class Variant
-      attr_reader :type, :value
-      def initialize type = :null, value = nil
-	@type = (type.kind_of? Cim::Meta::Type) ? type : Cim::Meta::Type.new(type)
-	@value = value unless value == :null
-      end
-      def to_s
-	if @type == :null
-	  "null"
-	else
-	  "#{@value.inspect}"
-	end
-      end
-    end
-  end
-end