genprovider 0.2.0

data/features/step_definitions/genprovider.rb

@@ -0,0 +1,52 @@
+Then /^I should see a short usage explanation$/ do
+  @output =~ /Usage:/
+end
+
+Then /^I should see an "([^"]*)" file$/ do |arg1| #"
+  File.exists? arg1
+end
+
+Then /^I should see an error message$/ do
+  File.stat(File.join(TMPDIR,"std.err")).size > 0
+end
+
+Then /^comment lines should not exceed (\d+) characters$/ do |arg1| #"
+  maxcolumn = arg1.to_i
+  @output.scan(/^\s*\#.*$/).each do |l|
+    return false if l.chomp.size > maxcolumn
+  end
+  true
+end
+
+Then /^its output should be accepted by Ruby$/ do
+  Dir.foreach($sfcb.providers_dir) do |f|
+    next unless f =~ /.rb$/
+    res = system "ruby", File.join($sfcb.providers_dir, f)
+    raise unless res && $? == 0
+  end
+end
+
+When /^I run genprovider with no arguments$/ do
+  @output = `ruby -I #{LIBDIR} #{GENPROVIDER} 2> #{TMPDIR}/std.err`
+  raise if $? == 0
+end
+
+def generate_provider_for mof
+  cmd = "ruby -I #{LIBDIR} #{GENPROVIDER} -f -n #{NAMESPACE} -o #{$sfcb.providers_dir} #{TOPLEVEL}/samples/mof/qualifiers.mof #{File.join(TOPLEVEL, mof)} 2> #{TMPDIR}/std.err"
+#  STDERR.puts "Run #{cmd}"
+  @output = `#{cmd}`
+  raise unless $? == 0
+end
+
+When /^I pass "([^"]*)" to genprovider$/ do |arg1| #"
+  generate_provider_for arg1
+end
+
+Given /^a generated provider for "(.*?)"$/ do |arg1|
+  raise unless File.exists?(File.join(TOPLEVEL,arg1))
+end
+
+When /^I run genprovider with "([^"]*)"$/ do |arg1| #"
+  @output = `ruby -I #{LIBDIR} #{GENPROVIDER} #{arg1} 2> #{TMPDIR}/std.err`
+  raise unless $? == 0
+end

data/features/step_definitions/mof.rb

@@ -0,0 +1,3 @@
+Given /^I have a mof file called "([^"]*)"$/ do |arg1|
+  File.exists?("mof/#{arg1}")
+end

data/features/step_definitions/registration.rb

@@ -0,0 +1,21 @@
+When /^I register "([^"]*)" using "([^"]*)" with sfcb$/ do |mofpath,regname|
+  return if ENV['NO_REGISTER']
+  $sfcb.stop
+  tmpregname = File.join(TMPDIR, File.basename(regname, ".registration") + ".reg")
+  sfcb_transform_to tmpregname, File.join("#{TOPLEVEL}/samples/registration", regname)
+  cmd = "sfcbstage -s #{$sfcb.stage_dir} -n #{NAMESPACE} -r #{tmpregname} #{File.join(TOPLEVEL, mofpath)}"
+#  STDERR.puts cmd
+  res = `#{cmd} 2> #{TMPDIR}/sfcbstage.err`
+  raise unless $? == 0
+  cmd = "sfcbrepos -f -s #{$sfcb.stage_dir} -r #{$sfcb.registration_dir}"
+#  STDERR.puts cmd
+  res = `#{cmd} 2> #{TMPDIR}/sfcbrepos.err`
+  raise unless $? == 0
+  $sfcb.start
+end
+
+When /^"([^"]*)" is registered in namespace "([^"]*)"$/ do |arg1,arg2| #"
+  out = `wbemecn #{$sfcb.url}/#{arg2} 2> #{TMPDIR}/wbemecn.err`
+#  STDERR.puts "wbemecn expects '#{arg1}', returns '#{out}'"
+  raise unless out =~ Regexp.new(arg1)
+end

data/features/step_definitions/wbemcli.rb

@@ -0,0 +1,58 @@
+Given /^an instance of "([^"]*)" with property "([^"]*)" set to "([^"]*)"$/ do |arg1, arg2, arg3| #"
+  url = $sfcb.url
+  cmd = "wbemein #{url}/test/test:#{arg1}"
+#  STDERR.puts "Calling #{cmd}"
+  out = `#{cmd}`
+#  STDERR.puts "Enum instance names returned '#{out}'"
+  raise unless out =~ Regexp.new(arg1)
+  @instance = out.chomp
+  out = `wbemgi http://#{out}`
+#  STDERR.puts "Get instance returned '#{out}'"
+  raise unless out.include? "#{arg2}=\"#{arg3}\""
+end
+
+Then /^I should see "([^"]*)" in enumerated class names$/ do |arg1| #"
+  url = $sfcb.url
+  out = `wbemecn #{url}`
+  raise unless out =~ Regexp.new(arg1)
+end
+
+Then /^I should see "([^"]*)" in namespace "([^"]*)"$/ do |arg1, arg2|
+  url = $sfcb.url
+  out = `wbemecn #{url}/#{arg2}`
+  raise unless out =~ Regexp.new(arg1)
+end
+  
+Then /^I should see "([^"]*)" in enumerated instance names$/ do |arg1| #"
+  url = $sfcb.url
+  cmd = "wbemein #{url}/test/test:#{arg1}"
+#  STDERR.puts "Calling #{cmd}"
+  out = `#{cmd}`
+  raise unless out =~ Regexp.new(arg1)
+end
+
+Then /^the instance of "([^"]*)" should have property "([^"]*)" set to "([^"]*)"$/ do |arg1, arg2, arg3| #"
+  url = $sfcb.url
+  cmd = "wbemein #{url}/test/test:#{arg1}"
+#  STDERR.puts "Calling #{cmd}"
+  out = `#{cmd}`
+#  STDERR.puts "-> '#{out}'"
+  out = `wbemgi http://#{out}`
+#  STDERR.puts "-> '#{out}'"
+  raise unless out.include? "#{arg2}=\"#{arg3}\""
+end
+
+When /^I create an instance of "([^"]*)" with "([^"]*)" set to "([^"]*)"$/ do |arg1, arg2, arg3| #"
+  url = $sfcb.url
+  cmd = "wbemci '#{url}/test/test:#{arg1}.#{arg2}=\"#{arg3}\"' '#{arg2}=\"#{arg3}\"'"
+#  $stderr.puts "Calling #{cmd}"
+  out = `#{cmd}`
+  raise unless $? == 0
+end
+
+When /^I change the property "([^"]*)" to "([^"]*)"$/ do |arg1, arg2|
+  cmd = "wbemmi http://#{@instance} #{arg1}=\"#{arg2}\""
+#  $stderr.puts "Calling #{cmd}"
+  out = `#{cmd}`
+#  STDERR.puts "Modify instance returned '#{out}'"
+end

data/features/support/env.rb

@@ -0,0 +1,20 @@
+#
+# features/support/env.rb
+#
+
+require 'rubygems'
+require "test/unit"
+
+require_relative "../../test/env"
+
+require_relative "./sfcb"
+
+# directory with test .mof files
+MOFDIR = File.join(TOPLEVEL,"features","mof")
+
+$sfcb = Sfcb.new :tmpdir => TMPDIR,
+                 :provider => "#{TOPLEVEL}/samples/provider"
+$sfcb.start
+at_exit do
+  $sfcb.stop
+end

data/genprovider.gemspec

@@ -0,0 +1,36 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "genprovider/version"
+
+Gem::Specification.new do |s|
+  s.name        = "genprovider"
+  s.version     = Genprovider::VERSION
+
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = ["Klaus Kämpf"]
+  s.email       = ["kkaempf@suse.de"]
+  s.homepage    = "https://github.com/kkaempf/genprovider"
+  s.summary     = %q{A generator for Ruby based CIM providers}
+  s.description = %q{Generates Ruby provider templates for use with cmpi-bindings}
+
+  s.requirements << %q{sblim-cmpi-base (for provider-register.sh)}
+  s.requirements << %q{sblim-sfcb for testing}
+
+  s.add_dependency("cim", ["~> 1.0"])
+  s.add_dependency("mof", ["~> 1.0"])
+  s.add_dependency("rdoc")
+
+  s.add_development_dependency('rake')
+  s.add_development_dependency('sfcc')
+  s.add_development_dependency('bundler')
+  s.add_development_dependency('cucumber')
+  
+  s.rubyforge_project = "genprovider"
+
+  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/genprovider/class.rb

@@ -0,0 +1,200 @@
+#
+# Genprovider::Class
+#
+
+#
+# make element description
+#
+
+module Genprovider
+  class Class
+    def self.mkdescription out, element
+      p = element.qualifiers["description", :string]
+      out.comment
+      out.comment(p.value).comment if p
+    end
+
+    def self.keyargs c, out, first = true
+      keyargs c.parent, first, out if c.parent
+      c.each_key do |k|
+	if first
+	  first = false
+	else
+	  out.write ", "
+	end
+	out.write(k.name.decamelize)
+      end
+    end
+
+    #
+    # make initializer
+    #
+
+    def mkinitialize c, out
+
+      out.def "initialize", "reference", "properties"
+      if c.parent
+	out.puts "super reference,properties"
+      end
+      out.end
+    end
+
+    #
+    # make static methods
+    #
+
+    def mkstatic c, out
+      out.comment "each: yield CMPIObjectPath references"
+      out.comment "  full => false: set only key properties (instance name)"
+      out.comment "          true:  with full information to create instances"
+      out.def "self.each", "reference", "properties", "full = false"
+      out.comment "Retrieve names, adapt reference, and yield CMPIObjectPath"
+      out.comment
+      out.comment "YOUR CODE HERE"
+      out.comment
+      out.end
+      out.def "self.delete", "reference", "properties = nil"
+      out.comment "Remove by reference"
+      out.comment
+      out.comment "YOUR CODE HERE"
+      out.comment
+      out.end
+    end
+
+    #
+    # make feature definition
+    #
+
+    def mkdef out, feature
+      Genprovider::Class.mkdescription out, feature
+      case feature
+      when CIM::Property
+      # skip
+      when CIM::Reference then out.comment "Reference"
+      when CIM::Method then out.comment "Method"
+      else
+	raise "Unknown feature class #{feature.class}"
+      end
+      out.comment feature.type.to_s + " : " + feature.name
+      out.comment "*Key*" if feature.key?
+      out.comment
+      
+      args = nil      
+      if feature.method?
+	feature.parameters.each do |p|
+	  args ||= []
+	  if p.qualifiers.include?(:out,:bool)
+	    args << "#{p.name.decamelize}_out"
+	  else
+	    args << p.name.decamelize
+	  end
+	end
+      end
+      n = feature.name.decamelize
+      out.def n, args
+        out.puts "@#{n}"
+      out.end
+      if feature.property? && feature.qualifiers.include?(:write)
+	out.def "#{n}=", "_arg" 
+          out.puts "@#{n} = _arg"
+	out.end
+      end
+    end
+      
+    #
+    # generate code for property
+    #
+      
+    def mkproperty property, out
+      mkdef out, property
+    end
+
+    #
+    # generate code for reference
+    #
+      
+    def mkreference reference, out
+      mkdef out, reference
+    end
+    
+    #
+    # generate code for method
+    #
+    
+    def mkmethod method, out
+      mkdef out, method
+    end
+    
+    #
+    # generate provider code for features matching match
+    #
+    
+    def mkfeatures features, out, match
+      features.each do |f|
+	next unless f.instance_of? match
+	case f
+	when CIM::Property then mkproperty f, out
+	when CIM::Reference then mkreference f, out
+	when CIM::Method then mkmethod f, out
+	else
+	  raise "Unknown feature class #{f.class}"
+	end
+      end
+    end
+    
+    #
+    # yield class features recursively
+    #   which => nil     : all
+    #            :keys   : keys only
+    #            :nokeys : nokeys only
+    #    
+    def all_features(klass, option)
+      while klass
+	klass.features.each do |f|
+	  next if option == :nokeys && f.key?
+	  next if option == :keys && !f.key?
+	  yield "- #{f.type} #{f.name} (-> #{klass.name})"
+	end
+	klass = klass.parent
+      end
+    end
+    #
+    # generate provider code for class 'c'
+    #
+    
+    def initialize c, out
+      out.comment
+      out.comment "Generated by genprovider"
+      out.comment
+      out.puts("require 'cmpi'").puts
+      out.puts("module Cmpi").inc
+      
+      Genprovider::Class.mkdescription out, c
+      
+      if c.superclass
+	out.puts "d = File.dirname(__FILE__)"
+	out.puts "$: << d unless $:.include? d"
+	out.puts "require '#{c.superclass.decamelize}'"
+      end
+      out.comment.comment "Properties:"
+      all_features(c, :keys) { |comment| out.comment "[key] #{comment}" }
+      all_features(c, :nokeys) { |comment| out.comment comment }
+      out.comment
+      out.printf("class #{c.name}")
+      out.write(" < #{c.superclass}") if c.superclass
+      out.puts.inc
+      # class functions
+      mkstatic c, out
+      # initializer
+      mkinitialize c, out
+      # normal properties
+      mkfeatures c.features, out, CIM::Property
+      # reference properties
+      mkfeatures c.features, out, CIM::Reference
+      # methods
+      mkfeatures c.features, out, CIM::Method
+      out.end # class
+      out.end # module
+    end
+  end
+end

data/lib/genprovider/classinfo.rb

@@ -0,0 +1,88 @@
+#
+# classinfo.rb
+#
+# Generate class information (esp method invocation) for clients
+#
+
+module Genprovider
+  class ClassInfo
+    
+    def initialize c, out
+      out.comment.comment "Class information for #{c.name}"
+      out.comment.comment "Generated by 'genprovider' for use with ruby-sfcc"
+      out.puts
+      out.puts "require 'rubygems'"
+      out.puts "require 'cim'"
+      s = c
+      while s.parent
+        s = s.parent
+        out.puts "require 'mof/#{s.name}'"
+      end
+      out.puts
+      s = c.superclass ? " < #{c.superclass}" : ""
+      
+      # module MOF
+      out.puts "module MOF"
+      out.inc
+      
+      # class <Class>
+      out.puts "class #{c.name}#{s}"
+      out.inc
+      
+      # methods
+      method_count = 0
+      s = nil
+      c.features.each do |f|
+        next unless f.method?
+        if method_count == 0
+          out.puts "METHODS = {"
+          out.inc
+        end
+        if method_count > 0
+          out.puts "#{s}," if s
+          s = nil
+        end
+        s = "#{f.name.inspect} => { :type => #{f.type.to_sym.inspect}"
+        unless f.parameters.empty?
+          s << ", :parameters => {"
+          
+          have_in = 0          
+          f.parameters.each do |p|
+            next if p.out? # non-out parameters are input
+            if have_in == 0
+              s << ":in => ["
+            else
+              s << ", "
+            end
+            s << "#{p.name.inspect}, #{p.type.to_sym.inspect}"
+            have_in += 1
+          end
+          s << "]" if have_in > 0
+
+          have_out = 0
+          f.parameters.each do |p|
+            next unless p.out? # output parameters must have explicit qualifier
+            if have_out == 0
+              s << ", " if have_in > 0
+              s << ":out => ["
+            else
+              s << ", "
+            end
+            s << "#{p.name.inspect}, #{p.type.to_sym.inspect}"
+            have_out += 1
+          end
+          s << "]" if have_out > 0
+          s << "}"
+        end
+        s << " }"
+        method_count += 1
+      end
+      if method_count > 0
+        out.puts s
+        out.dec.puts "}"
+      end
+      out.end # class
+      out.end # module
+    end
+  end
+end

data/lib/genprovider/output.rb

@@ -0,0 +1,104 @@
+#
+# Output - a class to output generated code with indendation
+#
+module Genprovider
+class Output
+ private
+  def indent
+    @file.write( " " * @depth * @indent ) if @newline
+  end
+ public
+  attr_reader :name, :dir
+  def initialize file, force=false
+    if file.kind_of?(IO)
+      @file = file
+      @name = nil
+    else
+      if File.exist?(file) && !force
+	STDERR.puts "Not overwriting existing #{file}"
+	return
+      end
+      @file = File.open(file, "w+")
+      @name = File.basename file
+      @dir = File.expand_path(File.dirname file)
+    end
+    raise "Cannot create file at #{file}" unless @file
+    @newline = true
+    @indent = 0
+    @wrap = 75 # wrap at this column
+    @depth = 2 # indent depth
+    yield self if block_given?
+  end
+  def inc
+    @indent += 1
+    self
+  end
+  def dec
+    @indent -= 1
+    @indent = 0 if @indent < 0
+    self
+  end
+  def write str
+    @file.write str
+    @newline = false
+    self
+  end
+  def puts str=""
+    indent
+    @file.puts str
+    @newline = true
+    self
+  end
+  def def name, *args
+    if args.nil? || args.empty? || args[0].nil?
+      self.puts "def #{name}"
+    else
+      self.puts "def #{name}( #{args.join(', ')} )"
+    end
+    self.inc
+  end
+  def end
+    self.dec
+    self.puts "end"
+  end
+  def comment str=nil, lmargin = nil
+    if str =~ /\\n/
+      comment $`, lmargin
+      comment $', lmargin  #' <- colorize helper
+      return self
+    end
+    wrap = @wrap - (@depth * @indent + 2) - ((lmargin)?lmargin:0)
+    if str && str.size > wrap # must wrap
+#      STDERR.puts "#{str.size} > #{wrap}"
+      pivot = wrap
+      while pivot > 0 && str[pivot,1] != " " # search space left of wrap
+        pivot -= 1
+      end
+      if pivot == 0 # no space left of wrap
+        pivot = wrap
+        while pivot < str.size && str[pivot,1] != " " # search space right of wrap
+          pivot += 1
+        end
+      end
+      if 0 < pivot && pivot < str.size
+#        puts "-wrap @ #{pivot}-"
+        comment str[0,pivot], lmargin
+	comment str[pivot+1..-1], lmargin
+	return self
+      end
+    end
+    indent
+    @file.write "#"
+    @file.write(" " * lmargin) if lmargin
+    @file.write " #{str}" if str
+    @file.puts
+    self
+  end
+  def printf format, *args
+    indent
+    Kernel.printf @file, format, *args
+    @newline = false
+    self
+  end
+end
+end