cim 0.3.0 → 0.5.0

data/Gemfile

@@ -0,0 +1,4 @@
+source "http://rubygems.org"
+
+# Specify your gem's dependencies in cim.gemspec
+gemspec

data/History.txt

@@ -1,3 +1,22 @@
+=== 0.5.0 2011-09-29
+
+* Clean up Rakefile, support Bundler
+* Add QualifierSet[] access function
+* Make check functions like key?, etc. public
+
+=== 0.4.1 2010-10-14
+
+* More tests
+* Refactor Qualifiers to QualifierSet, QualifierSet includes Qualifiers
+
+=== 0.3.1 2010-10-05
+
+* Extend API for mof
+
+=== 0.3.0 2010-10-04
+
+* Refactoring for mof
+
 === 0.2.7 2010-10-03
 
 * Initial release

data/LICENSE

@@ -0,0 +1,58 @@
+Ruby is copyrighted free software by Yukihiro Matsumoto <matz@netlab.co.jp>.
+You can redistribute it and/or modify it under either the terms of the GPL
+(see COPYING.txt file), or the conditions below:
+
+  1. You may make and give away verbatim copies of the source form of the
+     software without restriction, provided that you duplicate all of the
+     original copyright notices and associated disclaimers.
+
+  2. You may modify your copy of the software in any way, provided that
+     you do at least ONE of the following:
+
+       a) place your modifications in the Public Domain or otherwise
+          make them Freely Available, such as by posting said
+	  modifications to Usenet or an equivalent medium, or by allowing
+	  the author to include your modifications in the software.
+
+       b) use the modified software only within your corporation or
+          organization.
+
+       c) rename any non-standard executables so the names do not conflict
+	  with standard executables, which must also be provided.
+
+       d) make other distribution arrangements with the author.
+
+  3. You may distribute the software in object code or executable
+     form, provided that you do at least ONE of the following:
+
+       a) distribute the executables and library files of the software,
+	  together with instructions (in the manual page or equivalent)
+	  on where to get the original distribution.
+
+       b) accompany the distribution with the machine-readable source of
+	  the software.
+
+       c) give non-standard executables non-standard names, with
+          instructions on where to get the original software distribution.
+
+       d) make other distribution arrangements with the author.
+
+  4. You may modify and include the part of the software into any other
+     software (possibly commercial).  But some files in the distribution
+     are not written by the author, so that they are not under this terms.
+
+     They are gc.c(partly), utils.c(partly), regex.[ch], st.[ch] and some
+     files under the ./missing directory.  See each file for the copying
+     condition.
+
+  5. The scripts and library files supplied as input to or produced as 
+     output from the software do not automatically fall under the
+     copyright of the software, but belong to whomever generated them, 
+     and may be sold commercially, and may be aggregated with this
+     software.
+
+  6. THIS SOFTWARE IS PROVIDED "AS IS" AND WITHOUT ANY EXPRESS OR
+     IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
+     WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+     PURPOSE.
+

data/README.rdoc

@@ -1,18 +1,25 @@
-= cim
+= About Cim
 
 * http://github.com/kkaempf/cim
 
+* http://rubygems.org/gems/cim
+
+* http://rdoc.info/github/kkaempf/cim/master/frames
+
+* https://build.opensuse.org/package/show?package=rubygem-cim&project=devel:languages:ruby:extensions
+
 == DESCRIPTION:
 
-* Cim is a pure-Ruby implementation of the CIM meta model.
+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.
 
-  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
+See http://www.dmtf.org/standards/cim and http://www.dmtf.org/education/mof
+for details
 
-  https://rubygems.org/gems/mof is a parser for .mof files and the
-  primary consumer of the cim gem.
+https://rubygems.org/gems/mof is a parser for .mof files and the
+primary consumer of the cim gem.
 
 == SYNOPSIS:
 
@@ -27,6 +34,15 @@
 * sudo gem install cim
   (resp. rpm -Uhv rubygem-cim)
 
+== DEVELOPERS:
+
+After checking out the source, run:
+
+  $ rake newb
+
+This task will install any missing dependencies, run the tests/specs,
+and generate the RDoc.
+
 == LICENSE:
 
 (The Ruby License)

data/Rakefile

@@ -1,26 +1,6 @@
-require 'rubygems'
-gem 'hoe', '>= 2.1.0'
-require 'hoe'
-require 'fileutils'
-require './lib/cim'
+require 'bundler/gem_tasks'
+require 'rake/testtask'
 
-Hoe.plugin :newgem
-# Hoe.plugin :website
-# Hoe.plugin :cucumberfeatures
+task :default => [:test]
 
-# 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/cim.gemspec

@@ -0,0 +1,27 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "cim"
+
+Gem::Specification.new do |s|
+  s.name        = "cim"
+  s.version     = CIM::VERSION
+
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = ["Klaus Kämpf"]
+  s.email       = ["kkaempf@suse.de"]
+  s.homepage    = "https://github.com/kkaempf/cim"
+  s.summary     = %q{A pure-Ruby implementation of the CIM meta model}
+  s.description = %q{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}
+  
+  s.rubyforge_project = "cim"
+
+  s.files         = `git ls-files`.split("\n")
+  s.files.reject! { |fn| fn == '.gitignore' }
+  s.extra_rdoc_files    = Dir['README*', 'TODO*', 'CHANGELOG*', 'LICENSE']
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+end

data/lib/cim.rb

@@ -1,29 +1,60 @@
-# cim
-# A pure-Ruby implementation of the CIM metamodel
 #
-# Written by Klaus Kaempf <kkaempf@suse.de>
+# cim.rb
+#
+# A pure-Ruby implementation of the CIM meta schema.
+#
+# Copyright (c) 2010 Klaus Kämpf <kkaempf@suse.de>
+#
+# Licensed under the Ruby license
 #
-
 $:.unshift(File.dirname(__FILE__)) unless
   $:.include?(File.dirname(__FILE__)) || $:.include?(File.expand_path(File.dirname(__FILE__)))
 
-module Cim
-  VERSION = '0.3.0'
-  cim_dir = File.join(File.dirname(__FILE__),"cim")
-  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 + '/class_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'
+#
+# The CIM Ruby gem is an implementation of the Common Information Model (CIM) meta schema[1]
+#
+# = About
+#
+# The Common Information Model provides a common definition of management
+# information for systems, networks, applications and services.[2]
+#
+# The CIM meta schema is used to describe elements of the CIM model, like
+# types (CIM::Type), properties (CIM::Property), methods (CIM::Method)
+# and classes (CIM::Class).
+#
+# Elements of the CIM model can be defined as text files using the Managed
+# Object Format (MOF)[3] or by inspection on a running CIM Object Manager (CIMOM)[4]
+# 
+# Primary users of the CIM gem are the MOF gem [5], a parser for MOF files,
+# and ruby-sfcc[6], a Ruby CIM client api.
+#
+# = Usage
+#   require 'cim'
+#
+# = Links
+# 1. http://www.wbemsolutions.com/tutorials/CIM/metaschema.html
+# 2. http://www.dmtf.org/standards/cim
+# 3. http://www.wbemsolutions.com/tutorials/CIM/cim-mof.html
+# 4. http://www.wbemsolutions.com/tutorials/CIM/glossary.html#c-gloss
+# 5. http://github.com/kkaempf/mof
+# 6. http://github.com/dmacvicar/ruby-sfcc
+#
+
+module CIM
+  VERSION = '0.5.0'
+  require 'cim/type'
+  require 'cim/variant'
+  require 'cim/qualifier_flavors'
+  require 'cim/qualifier_scopes'
+  require 'cim/named_element'
+  require 'cim/qualifier_declaration'
+  require 'cim/qualifier'
+  require 'cim/qualifier_set'
+  require 'cim/class_feature'
+  require 'cim/property'
+  require 'cim/reference'
+  require 'cim/method'
+  require 'cim/class'
+  require 'cim/association'
+  require 'cim/indication'
 end

data/lib/cim/association.rb

@@ -1,10 +1,36 @@
+#
+# 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
-    def initialize name, qualifiers, alias_name, superclass, features
+    #
+    # 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

data/lib/cim/class.rb

@@ -1,25 +1,61 @@
+#
+# cim/class.rb - class CIM::Class
+#
+# 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
   require File.join(File.dirname(__FILE__),"qualifier")
+  #
+  # A Class is a central element in the object-oriented CIM schema
+  #
+  # Classes can be derived from other classes, creating a hierachical model.
+  #
+  # Classes have qualifiers to describe the class characteristics
+  # and contain features (properties or methods).
+  #
   class Class < CIM::NamedElement
-    attr_reader :alias_name, :qualifiers, :superclass, :features
-    attr_accessor :parent
-    def initialize name, qualifiers, alias_name, superclass, features
-      @qualifiers = qualifiers
+    attr_reader :alias_name, :superclass, :features
+    #
+    # Creates a new Class with name (String), qualifiers, alias, superclass and features
+    #
+    # Features are class attributes, namely Property, Method, or Reference
+    #
+    # call-seq:
+    #   Class.new("MyClass")
+    #   Class.new("MyClass", qualifiers)
+    #   Class.new("MyClass", qualifiers, "my_class")
+    #   Class.new("MyClass", qualifiers, "my_class", "SuperClass")
+    #   Class.new("MyClass", qualifiers, "my_class", "SuperClass", features)
+    #
+    def initialize name, qualifiers = nil, alias_name = nil, superclass = nil, features = nil
       @alias_name = alias_name
       @superclass = superclass
-      features = nil if features.is_a?(Array) && features.empty?
+      features = nil if features.kind_of?(::Enumerable) && features.empty?
       @features = features
       #	puts "CIM::Class.new(#{@features})"
-      super name
+      super name, qualifiers
     end
-    def add_type t
-      @ptype << t
+    #
+    # Iterate over features flagged as keys
+    #
+    def each_key
+      @features.each do |f|
+	yield f if f.key?
+      end
     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
@@ -28,14 +64,21 @@ module CIM
       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
+    #
+    # returns a string representation in MOF syntax format
+    #
     def to_s
       s = ""
       s << "[#{@qualifiers.join(', ')}]\n" if @qualifiers

data/lib/cim/class_feature.rb

@@ -1,33 +1,62 @@
+#
+# cim/class_feature.rb - class CIM::ClassFeature
+#
+# 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
-  # Shared between Property and Method
+  #
+  # ClassFeature is the base class for Class Property and Method
+  #
+  # A ClassFeature has a type (Type), name (String), and optional Qualifiers
+  #
+  # Access to ClassFeature attributes is *protected*, use the derived
+  # classes Property, Method and Reference
+  #
   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
+    attr_reader :type
+    #
     # if has key qualifier
+    #
     def key?
       @qualifiers && @qualifiers.include?(:key,:bool)
     end
+    #
     # if static (class-level) feature
+    #
     def static?
       false
     end
-    # if property
+    #
+    # if Property
+    #
     def property?
       false
     end
-    # if method
+    #
+    # if Method
+    #
     def method?
       false
     end
-    # if reference
+    #
+    # if Reference
+    #
     def reference?
       false
     end
+    protected
+    def initialize type, name, qualifiers = nil
+    # :notnew:
+      @type = (type.is_a? CIM::Type) ? type : CIM::Type.new(type)
+      super name, qualifiers
+    end
+    #
+    # returns a string representation in MOF syntax format
+    #
     def to_s
       s = ""
       s << "#{@qualifiers}\n  " if @qualifiers