cim 0.3.0 → 0.5.0

data/lib/cim/qualifier_scopes.rb

@@ -0,0 +1,87 @@
+#
+# cim/qualifier_scopes.rb - class CIM::QualifierScopes, class CIM::QualifierScopesError
+#
+# 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
+    
+  class QualifierScopesError < ArgumentError
+    #
+    # Raised if wrong Scope passed
+    #
+    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 QualifierScopes
+    META_ELEMENTS = [ :schema, :class, :association, :indication, :qualifier, :property, :reference, :method, :parameter, :any ]
+    attr_reader :elements
+    #
+    # call-seq:
+    #   QualifierScopes.new => qualifier_scopes
+    #   QualifierScopes.new(:association) => qualifier_scopes
+    #   QualifierScopes.new("association") => qualifier_scopes
+    #   QualifierScopes.new("Association") => qualifier_scopes
+    #
+    # raises QualifierScopesError
+    #
+    def initialize *elements
+      @elements = []
+      elements.flatten.each do |element|
+	self << element
+      end
+    end
+    #
+    # call-seq:
+    #   qualifier_scopes << :association
+    #   qualifier_scopes << "association"
+    #   qualifier_scopes << "Association"
+    #
+    # raises QualifierScopesError
+    #
+    def << element
+      @elements << (normalize element)
+      self
+    end
+    #
+    # call-seq:
+    #   qualifier_scopes.has? :association
+    #   qualifier_scopes.has? "association"
+    #   qualifier_scopes.has? "Association"
+    #
+    # raises QualifierScopesError
+    #
+    def include? element
+      @elements.include?(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(', ')})"
+    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)
+      e
+    end
+  end
+end

data/lib/cim/qualifier_set.rb

@@ -0,0 +1,73 @@
+#
+# cim/qualifier_set.rb - class CIM::QualifierSet
+#
+# 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
+  #
+  # Set of Qualifier
+  #
+  class QualifierSet < ::Array
+    def initialize *args
+      super 0
+      args.flatten.each do |q|
+	case q
+	when QualifierDeclaration: q = Qualifier.new q
+	when Qualifier:
+	else
+	  q = Qualifier.new(QualifierDeclaration.new q)
+	end
+	self << q
+      end
+    end
+    #
+    # check if qualifier exists
+    #
+    # call-seq:
+    #   qualifier_set.includes?(qualifier) => bool
+    #   qualifier_set.includes?(qualifier_declaration) => bool
+    #   qualifier_set.includes?(:description) => bool
+    #   qualifier_set.includes?("description", :string) => bool
+    #
+    def includes? qualifier,type=nil
+      (self[qualifier,type]) ? true : false
+    end
+    alias include? includes?
+    #
+    # get qualifier by name and type
+    #
+    def [] qualifier,type=nil
+      self.each do |q|
+	unless type.nil?
+	  next unless q.type == type
+	end
+#	puts "#{q} == #{qualifier}<#{type}>"
+	return q if case qualifier
+                       when CIM::Qualifier
+			 q == qualifier.declaration
+		       when CIM::QualifierDeclaration
+			 q == qualifier
+		       when String
+			 q.declaration == qualifier
+		       when Symbol
+			 q.declaration == qualifier
+		       else
+			 raise "Unknown parameter in #{self.class}[]"
+		       end
+      end
+      nil
+    end
+    #
+    # returns a string representation in MOF syntax format
+    #
+    def to_s
+      return "" if self.empty?
+      q = self.join(", ")
+      return "[#{q}]"
+    end
+  end
+end

data/lib/cim/reference.rb

@@ -1,5 +1,23 @@
+#
+# cim/reference.rb - class CIM::Reference
+#
+# 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
+  #
+  # Reference is a pointer (reference) to a Class
+  #
+  # A Reference is a special type of Property reserved for
+  # use in Associations
+  #
   class Reference < CIM::Property
+    #
+    # Identifies a Property as a Reference
+    #
     def reference?
       true
     end

data/lib/cim/type.rb

@@ -1,4 +1,38 @@
+#
+# cim/type.rb - class CIM::Type, class CIM::Array, class CIM::ReferenceType
+#
+# 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
+  #
+  # Type represents a CIM basic type
+  # 
+  # The following basic types are known:
+  # uint8::     Unsigned 8-bit integer
+  # sint8::     Signed 8-bit integer
+  # uint16::    Unsigned 16-bit integer
+  # sint16::    Signed 16-bit integer
+  # uint32::    Unsigned 32-bit integer
+  # sint32::    Signed 32-bit integer
+  # uint64::    Unsigned 64-bit integer
+  # sint64::    Signed 64-bit integer
+  # string::    UCS-2 string
+  # bool::      Boolean
+  # real32::    IEEE 4-byte floating-point
+  # real64::    IEEE 8-byte floating-point
+  # 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]
     MATCHES = {
@@ -23,21 +57,36 @@ module CIM
       :array => [ :null ]
     }
     attr_reader :type
+    #
+    # Basic types are created by-symbol or by-name
+    #
+    # CIM::Type.new(:bool) == CIM::Type.new("bool")
+    #
     def initialize type
       type.downcase! if type.is_a? String
       @type = type.to_sym
       raise TypeError.new("#{type}") unless TYPES.include? @type
     end
+    #
+    # returns a string representation in MOF syntax format
+    #
     def to_s
       @type.to_s
     end
+    #
+    # returns a symbol representation of the type
+    #
     def to_sym
       @type
     end
+    #
+    # type equality
+    #
     def == t
       case t
       when Type: t.type == @type
       when Symbol: t == @type
+      when String: t.downcase == @type.to_s
       else
 	false
       end
@@ -77,6 +126,9 @@ module CIM
       end
     end
     public
+    #
+    # check if another Type or Variant matches
+    #
     def matches? x
       #	puts ">#{self}<{#{self.class}}.matches?>#{x.inspect}<{#{x.class}}"
       case x
@@ -95,12 +147,30 @@ module CIM
       end
     end
   end
+  
+  #
+  # Array represents an array of identical typed value
+  # 
+  #  
   class Array < Type
     attr_reader :size
+    #
+    # Arrays are initialized by size and type
+    # Passing 0 (zero) as the size creates an unlimited array
+    #
     def initialize size, type
       @size = size
       super type
     end
+    #
+    # An array is equal to any other array, regardless of the enclosed type
+    #
+    def == t
+      t == :array
+    end
+    #
+    # returns a string representation of the array type
+    #
     def to_s
       if @size > 0
 	"#{super}[#{@size}]"
@@ -109,12 +179,23 @@ module CIM
       end
     end
   end
+  
+  #
+  # ReferenceType is a strongly typed reference to a class
+  # 
+  #
   class ReferenceType < Type
     attr_reader :name
+    #
+    # Creates a strongly typed reference to class +name+
+    #
     def initialize name
       @name = name
-      super :class
+      super "class"
     end
+    #
+    # returns a string representation of the reference type
+    #
     def to_s
       "#{@name} ref"
     end

data/lib/cim/variant.rb

@@ -1,11 +1,50 @@
+#
+# cim/variant.rb - class CIM::Variant
+#
+# 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
+  #
   # A Variant is a typed value
+  #
   class Variant
     attr_reader :type, :value
+    #
+    # Creates a typed value
+    #
+    # +type+: See CIM::Type
+    # +value+: A Ruby value
+    #
+    # No attempt is made to check if the type matches the value.
+    #
     def initialize type = :null, value = nil
       @type = (type.kind_of? CIM::Type) ? type : CIM::Type.new(type)
       @value = value unless value == :null
     end
+    #
+    # Checks equality of the Variant with a Ruby value or another Variant
+    #
+    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
+      else
+	false
+      end			
+    end
+    #
+    # returns a string representation in MOF syntax format
+    #
     def to_s
       if @type == :null
 	"null"

data/tasks/clean.rake

@@ -0,0 +1,9 @@
+task :clean do
+  `rm -rf *~`
+  `rm -rf */*~`
+  `rm -rf */*/*~`
+  `rm -f Gemfile.lock`
+  `rm -rf doc`
+  `rm -rf .yardoc`
+  `rm -rf pkg`
+end

data/tasks/doc.rake

@@ -0,0 +1,14 @@
+begin
+ require 'yard'
+  YARD::Rake::YardocTask.new(:doc) do |t|
+    t.files   = ['lib/**/*.rb']
+    t.options = ['--no-private']
+  end
+rescue LoadError
+  STDERR.puts "Install yard if you want prettier docs"
+  require 'rdoc/task'
+  Rake::RDocTask.new(:doc) do |rdoc|
+    rdoc.rdoc_dir = "doc"
+    rdoc.title = "dm-keeper-adapter #{CIM::VERSION}"
+  end
+end

data/tasks/test.rake

@@ -0,0 +1,6 @@
+Rake::TestTask.new do |t|
+  t.libs << File.expand_path('../test', __FILE__)
+  t.libs << File.expand_path('../', __FILE__)
+  t.test_files = FileList['test/test*.rb']
+  t.verbose = true
+end

data/test/test_method.rb

@@ -9,7 +9,8 @@ class MethodTest < Test::Unit::TestCase
     assert m
     assert_equal "Foo", m.name
     assert m.qualifiers.size > 0
-#    assert m.qualifiers.include?( :description, :string )
+    assert m.qualifiers.include?( :description )
+    assert m.qualifiers.include?( :description, :string )
 #    assert_equal "This is a foo method", m.description
     assert_equal false, m.to_s.empty?
   end

data/test/test_qualifier_set.rb

@@ -0,0 +1,39 @@
+$: << File.join(File.dirname(__FILE__),"..","lib")
+
+require "test/unit"
+require "cim"
+
+class QualifierSetTest < Test::Unit::TestCase
+  def setup
+    qbool    = 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(qint)
+    @qualifiers << CIM::Qualifier.new(qstring)
+  end
+  def test_key
+    assert_equal 3, @qualifiers.size
+  end
+  def test_prefill
+    q = CIM::QualifierSet.new "a", :b
+    assert 2, q.size
+    assert q.include?( "a" )
+    assert q.include?( "b", :bool )
+  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", :string )
+  end
+  def test_access
+    assert @qualifiers[:flag]
+    assert @qualifiers["flag"]
+    assert @qualifiers["flag", :bool]
+    assert @qualifiers["flag", "bool"]
+    assert !@qualifiers["flag", :string]
+  end
+end