cim 0.2.7

data/History.txt

@@ -0,0 +1,3 @@
+=== 0.2.7 2010-10-03
+
+* Initial release

data/Manifest.txt

@@ -0,0 +1,28 @@
+History.txt
+Manifest.txt
+README.rdoc
+Rakefile
+lib/cim.rb
+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/method.rb
+lib/cim/property.rb
+lib/cim/qualifier.rb
+lib/cim/qualifiers.rb
+lib/cim/reference.rb
+test/test_loading.rb
+test/test_method.rb
+test/test_property.rb
+test/test_qualifier.rb
+test/test_reference.rb
+test/test_type.rb

data/README.rdoc

@@ -0,0 +1,33 @@
+= cim
+
+* http://github.com/kkaempf/cim
+
+== DESCRIPTION:
+
+* Cim is a pure-Ruby implementation of the CIM meta model.
+
+  Instances of Cim classes are used to define a CIM schema, often
+  represented as a .mof file.
+
+  Hence the primary consumer of Cim is Mofparser, a Ruby based MOF parser.
+
+== SYNOPSIS:
+
+  require 'cim'
+
+== REQUIREMENTS:
+
+* - none -
+
+== INSTALL:
+
+* sudo gem install cim
+  (resp. rpm -Uhv rubygem-cim)
+
+== LICENSE:
+
+(The Ruby License)
+
+Copyright (c) 2010 Klaus Kämpf <kkaempf@suse.de>
+
+See http://www.ruby-lang.org/en/LICENSE.txt for the full text

data/Rakefile

@@ -0,0 +1,26 @@
+require 'rubygems'
+gem 'hoe', '>= 2.1.0'
+require 'hoe'
+require 'fileutils'
+require './lib/cim'
+
+Hoe.plugin :newgem
+# Hoe.plugin :website
+# Hoe.plugin :cucumberfeatures
+
+# Generate all the Rake tasks
+# Run 'rake -T' to see list of generated tasks (from gem root directory)
+$hoe = Hoe.spec 'cim' do
+  self.developer 'Klaus Kämpf', 'kkaempf@suse.de'
+
+  self.rubyforge_name       = self.name # TODO this is default value
+  # self.extra_deps         = [['activesupport','>= 2.0.2']]
+
+end
+
+require 'newgem/tasks'
+Dir['tasks/**/*.rake'].each { |t| load t }
+
+# TODO - want other tests/tasks run by default? Add them to the list
+# remove_task :default
+# task :default => [:spec, :features]

data/lib/cim.rb

@@ -0,0 +1,29 @@
+# cim
+# A pure-Ruby implementation of the CIM metamodel
+#
+# Written by Klaus Kaempf <kkaempf@suse.de>
+#
+
+$:.unshift(File.dirname(__FILE__)) unless
+  $:.include?(File.dirname(__FILE__)) || $:.include?(File.expand_path(File.dirname(__FILE__)))
+
+module Cim
+  VERSION = '0.2.7'
+  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 + '/qualifier'
+  require cim_dir + '/qualifiers'
+  require cim_dir + '/meta/feature'
+  require cim_dir + '/property'
+  require cim_dir + '/reference'
+  require cim_dir + '/method'
+  require cim_dir + '/class'
+  require cim_dir + '/association'
+  require cim_dir + '/instance'
+  require cim_dir + '/indication'
+end

data/lib/cim/association.rb

@@ -0,0 +1,12 @@
+module Cim
+  class Association < Class
+    def initialize name, qualifiers, alias_name, superclass, features
+      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/class.rb

@@ -0,0 +1,53 @@
+module Cim
+  require File.join(File.dirname(__FILE__),"qualifier")
+  class Class < Cim::Meta::NamedElement
+    attr_reader :qualifiers, :alias_name, :superclass, :features
+    attr_accessor :parent
+    def initialize name, qualifiers, alias_name, superclass, features
+      @qualifiers = qualifiers
+      @alias_name = alias_name
+      @superclass = superclass
+      features = nil if features.is_a?(Array) && features.empty?
+      @features = features
+      #	puts "Cim::Schema::Class.new(#{@features})"
+      super name
+    end
+    def add_type t
+      @ptype << t
+    end
+    # true if class has instances (instance provider)
+    def instance?
+      @features.size > 0
+    end
+    # true if class has methods (method provider)
+    def method?
+      @features.each do |f|
+	case f
+	when Cim::Schema::Method: return true
+	end
+      end
+      false
+    end
+    # true if class has associations (association provider)
+    def association?
+      false
+    end
+    # true if class has indications (indication provider)
+    def indication?
+      false
+    end
+    def to_s
+      s = ""
+      s << "[#{@qualifiers.join(', ')}]\n" if @qualifiers
+      s << "class #{@name}"
+      s << " AS #{@alias_name}" if @alias_name
+      s << " : #{@superclass}" if @superclass
+      s << " {"
+      if @features
+	f = @features.join(";\n  ")
+	s << "\n  #{f};\n" 
+      end
+      s << "}"
+    end
+  end
+end

data/lib/cim/indication.rb

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

data/lib/cim/instance.rb

@@ -0,0 +1,3 @@
+class Instance
+  # FIXME
+end

data/lib/cim/meta/feature.rb

@@ -0,0 +1,41 @@
+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

@@ -0,0 +1,33 @@
+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

@@ -0,0 +1,18 @@
+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

@@ -0,0 +1,34 @@
+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

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

data/lib/cim/meta/scope.rb

@@ -0,0 +1,39 @@
+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

@@ -0,0 +1,124 @@
+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

@@ -0,0 +1,19 @@
+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

data/lib/cim/method.rb

@@ -0,0 +1,18 @@
+module Cim
+  class Method < Cim::Meta::Feature
+    attr_reader :parameters
+    def initialize type, name, qualifiers = nil, parameters = nil
+      parameters = nil if parameters.kind_of?(::Enumerable) && parameters.empty?
+      @parameters = parameters
+      qualifiers = [ qualifiers ] unless qualifiers.kind_of?(Enumerable)
+      super type,name,qualifiers
+    end
+    def method?
+      true
+    end
+    def to_s
+      p = @parameters.join(", ") if @parameters
+      "#{super}(#{p})"
+    end
+  end
+end

data/lib/cim/property.rb

@@ -0,0 +1,13 @@
+module Cim
+  class Property < Cim::Meta::Feature
+    attr_reader :default
+    def initialize type, name, qualifiers=nil, default=nil
+      @default = default
+      unless qualifiers.nil? || qualifiers.kind_of?(Enumerable)
+	qualifiers = [ qualifiers ]
+      end
+      super type, name, qualifiers
+    end
+  end
+end
+

data/lib/cim/qualifier.rb

@@ -0,0 +1,41 @@
+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
+      @value = value
+      @flavor = flavor
+    end
+    def == q
+      #	puts "Cim::Schema::Qualifier ->#{self} == #{q.inspect}"
+      case q
+      when Cim::Schema::Qualifier
+	(@definition == q.definition) &&
+	(@value == q.value) &&
+	(@flavor == q.flavor)
+      when Cim::Meta::Qualifier
+	@definition == q  
+      when Symbol
+	q.to_s.downcase == @definition.name.downcase && @value.nil? && @flavor.nil?
+      else
+	false
+      end
+    end
+    def to_sym
+      @definition.downcase.to_sym
+    end
+    def to_s
+      s = "#{@definition.name.capitalize}"
+      case @value
+      when nil:
+      when Array:
+	s << " {#{@value.join(', ')}}"
+      else
+	s << "(#{@value.inspect})"
+      end
+      s << " #{@flavor}" if @flavor
+      s
+    end
+  end
+end

data/lib/cim/qualifiers.rb

@@ -0,0 +1,53 @@
+module Cim
+  # Array of Cim::Schema::Qualifier
+  class Qualifiers < Array
+    #
+    # check if qualifier exists
+    #
+    alias array_include? include?
+    def include? q,type=:null
+      #	puts "#{self}.include? #{q}:#{type}"
+      case q
+      when Cim::Schema::Qualifier
+	q = q.definition
+      when Cim::Meta::Qualifier
+	# nothing
+      when String
+	q = Cim::Meta::Qualifier.new(q,type)
+      when Symbol
+	q = Cim::Meta::Qualifier.new(q,type)
+      else
+	raise "Unknown parameter in #{self.class}.include?"
+      end
+      self.array_include? q
+    end
+    #
+    # get qualifier by name and type
+    #
+    alias array_access []
+    def [] q,type=:null
+      case q
+      when Fixnum
+	return self.array_access[q]
+      when Cim::Schema::Qualifier
+	q = q.definition
+      when Cim::Meta::Qualifier
+	# nothing
+      when String
+	q = Cim::Meta::Qualifier.new(q,type)
+      when Symbol
+	q = Cim::Meta::Qualifier.new(q,type)
+      else
+	raise "Unknown parameter in #{self.class}.[]"
+      end
+      i = self.index(q)
+      return self.array_access(i) if i
+      i
+    end
+    def to_s
+      return "" if self.empty?
+      q = self.join(", ")
+      return "[#{q}]"
+    end
+  end
+end

data/lib/cim/reference.rb

@@ -0,0 +1,7 @@
+module Cim
+  class Reference < Property
+    def reference?
+      true
+    end
+  end
+end

data/test/test_loading.rb

@@ -0,0 +1,2 @@
+$: << File.join(File.dirname(__FILE__),"..","lib")
+require "cim"

data/test/test_method.rb

@@ -0,0 +1,28 @@
+$: << File.join(File.dirname(__FILE__),"..","lib")
+
+require "test/unit"
+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)
+    assert m
+    assert_equal "Foo", m.name
+    assert m.qualifiers.size > 0
+#    assert m.qualifiers.include?( :description, :string )
+#    assert_equal "This is a foo method", m.description
+    assert_equal false, m.to_s.empty?
+  end
+  def test_nodesc
+    m = Cim::Method.new :bool, "Foo"
+    assert m
+    assert_equal "Foo", m.name
+    assert_equal m.type, :bool
+#    assert_equal nil, m.description
+  end
+  def test_raise
+    assert_raise TypeError do
+      m = Cim::Method.new :foo, "Foo"
+    end
+  end
+end

data/test/test_property.rb

@@ -0,0 +1,23 @@
+$: << File.join(File.dirname(__FILE__),"..","lib")
+
+require "test/unit"
+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)
+    assert p
+    assert p.is_a? Cim::Property
+    assert_equal "String", p.name
+#    assert p.key?
+  end
+  def test_name
+    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"
+    end
+  end
+end

data/test/test_qualifier.rb

@@ -0,0 +1,16 @@
+$: << File.join(File.dirname(__FILE__),"..","lib")
+
+require "test/unit"
+require "cim"
+
+class QualifierTest < Test::Unit::TestCase
+  def test_key
+    q = Cim::Meta::Qualifier.new :key, :bool
+    assert q
+  end
+  def test_raise
+    assert_raise RuntimeError do
+      Cim::Qualifier.new(:unknown)
+    end  
+  end
+end

data/test/test_reference.rb

@@ -0,0 +1,13 @@
+$: << File.join(File.dirname(__FILE__),"..","lib")
+
+require "test/unit"
+require "cim"
+
+class ReferenceTest < Test::Unit::TestCase
+  def test_init
+    r = Cim::Reference.new :string, "String"
+    assert r
+    assert r.is_a? Cim::Reference
+    assert r.kind_of? Cim::Property
+  end
+end

data/test/test_type.rb

@@ -0,0 +1,17 @@
+$: << File.join(File.dirname(__FILE__),"..","lib")
+
+require "test/unit"
+require "cim"
+
+class TypeTest < Test::Unit::TestCase
+  def test_init
+    t = Cim::Meta::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
+    end
+  end
+end

metadata

@@ -0,0 +1,139 @@
+--- !ruby/object:Gem::Specification 
+name: cim
+version: !ruby/object:Gem::Version 
+  hash: 25
+  prerelease: false
+  segments: 
+  - 0
+  - 2
+  - 7
+  version: 0.2.7
+platform: ruby
+authors: 
+- "Klaus K\xC3\xA4mpf"
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-10-03 00:00:00 +02:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: rubyforge
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 7
+        segments: 
+        - 2
+        - 0
+        - 4
+        version: 2.0.4
+  type: :development
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: hoe
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 21
+        segments: 
+        - 2
+        - 6
+        - 1
+        version: 2.6.1
+  type: :development
+  version_requirements: *id002
+description: |-
+  * Cim is a pure-Ruby implementation of the CIM meta model.
+  
+    Instances of Cim classes are used to define a CIM schema, often
+    represented as a .mof file.
+  
+    Hence the primary consumer of Cim is Mofparser, a Ruby based MOF parser.
+email: 
+- kkaempf@suse.de
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- History.txt
+- Manifest.txt
+files: 
+- History.txt
+- Manifest.txt
+- README.rdoc
+- Rakefile
+- lib/cim.rb
+- 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/method.rb
+- lib/cim/property.rb
+- lib/cim/qualifier.rb
+- lib/cim/qualifiers.rb
+- lib/cim/reference.rb
+- test/test_loading.rb
+- test/test_method.rb
+- test/test_property.rb
+- test/test_qualifier.rb
+- test/test_reference.rb
+- test/test_type.rb
+has_rdoc: true
+homepage: http://github.com/kkaempf/cim
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --main
+- README.rdoc
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: cim
+rubygems_version: 1.3.7
+signing_key: 
+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_property.rb
+- test/test_type.rb
+- test/test_loading.rb
+- test/test_reference.rb