mof 0.3.0

data/lib/mof/result.rb

@@ -0,0 +1,35 @@
+module MOF
+class Result
+  attr_reader :classes, :associations, :indications, :qualifiers, :instances
+    
+  def initialize
+    @qualifiers = []
+    @classes = []
+    @associations = []
+    @indications = []
+    @instances = []
+  end
+  
+  def is_qualifier? name
+    !qualifier(name).nil?
+  end
+  private
+  def join_to_s title, array
+    s = ""
+    if array.size > 0
+      s << "\n// #{title} [#{array.size}]\n"
+      s << array.join("\n")
+    end
+    s
+  end
+  public
+  def to_s
+    s = join_to_s( "Qualifiers", @qualifiers )
+    s << join_to_s( "Classes", @classes )
+    s << join_to_s( "Associations", @associations )
+    s << join_to_s( "Indications", @indications )
+    s << join_to_s( "Instances", @instances )
+    s
+  end
+end
+end

data/lib/mof/scanner.rb

@@ -0,0 +1,206 @@
+#
+# scanner.rb
+#
+# A scanner module for MOF files
+# to extend the Scanner class (via include)
+#
+# functions offered:
+#  parse( file ) : start parsing of file
+#  next_token    : return next [token,value] pair
+#  on_error      : report error
+#
+# Class variables:
+#
+# @file: file being scanned
+# @name: name of file
+# @lineno: current line number in file (for error reports)
+# @iconv: non-nil if iconv needed (i.e. Windows utf-16 mof files)
+# @fstack: stack of [ @file, @name, @lineno, @iconv ] for open files (to handle includes)
+# @q: Queue of [token,value] pairs, [false,false] denotes EOF
+#
+
+require 'iconv'
+
+module MOF
+module Scanner
+  def fill_queue
+    if @file.eof?
+#      $stderr.puts "eof ! #{@fstack.size}"
+      @file.close unless @file == $stdin
+      unless @fstack.empty?
+	@file, @name, @lineno, @iconv, $/, @result = @fstack.pop
+#	$stderr.puts "fill! #{@fstack.size}, #{@name}@#{@lineno}"
+        return fill_queue
+      end
+      @q.push [false, false]
+      return false
+    end
+    @line = @file.gets
+    return true unless @line
+    @lineno += 1
+
+#    $stderr.puts "fill_queue(#{@line.split('').inspect})"
+    @line.chomp!  # remove $/
+    @line = Iconv.conv( "ISO-8859-1", @iconv, @line ) if @iconv
+#    $stderr.puts "scan(#{@line})" unless @quiet
+    scanner = StringScanner.new(@line)
+
+    until scanner.eos?
+#      $stderr.puts "#{@q.size}:\"#{scanner.rest}\""
+      if @in_comment
+	if scanner.scan(%r{.*\*/})
+	  @in_comment = false
+	else
+	  break
+	end
+      end
+
+      case
+      when scanner.scan(/\s+/)
+	next        # ignore space
+	
+      when m = scanner.scan(/\n+/)
+	@lineno += m.size
+	next        # ignore newlines
+
+      when m = scanner.scan(%r{/\*})
+        @in_comment = true
+	
+      when m = scanner.scan(%r{//.*})
+	next        # c++ style comment
+	
+      when m = scanner.scan(%r{[(){}\[\],;\$#:=]})
+	@q.push [m, m]
+
+      # hexValue = [ "+" | "-" ] [ "0x" | "0X"] 1*hexDigit
+      #      hexDigit = decimalDigit | "a" | "A" | "b" | "B" | "c" | "C" | "d" | "D" | "e" | "E" | "f" | "F"
+      when m = scanner.scan(%r{(\+|-)?(0x|0X)([0123456789]|[abcdef]|[ABCDEF])+})
+	@q.push [:hexValue, m.to_i]
+
+      # octalValue = [ "+" | "-" ] "0" 1*octalDigit
+      when m = scanner.scan(%r{(\+|-)?0[01234567]+})
+	@q.push [:octalValue, m.to_i]
+
+      #	binaryValue = [ "+" | "-" ] 1*binaryDigit ( "b" | "B" )
+      when m = scanner.scan(%r{(\+|-)?(0|1)(b|B)})
+	@q.push [:binaryValue, m.to_i]
+	
+      #      realValue = [ "+" | "-" ] *decimalDigit "." 1*decimalDigit
+      #      [ ( "e" | "E" ) [ "+" | "-" ] 1*decimalDigit ]
+
+      when m = scanner.scan(%r{(\+|-)?\d*\.\d+})
+	@q.push [:realValue, m.to_f]
+
+      when m = scanner.scan(%r{[123456789]\d*})
+	@q.push [:positiveDecimalValue, m.to_i]
+     
+      # decimalValue = [ "+" | "-" ] ( positiveDecimalDigit *decimalDigit | "0" )
+      # decimalDigit = "0" | positiveDecimalDigit
+      when m = scanner.scan(%r{(\+|-)?\d+})
+	@q.push [:decimalValue, m.to_i]
+
+      #      charValue = // any single-quoted Unicode-character, except single quotes
+      
+      when m = scanner.scan(%r{\'([^\'])\'})
+	@q.push [:charValue, scanner[1]]
+
+      #      stringValue = 1*( """ *ucs2Character """ )
+      #      ucs2Character = // any valid UCS-2-character
+
+#      when m = scanner.scan(%r{\"([^\\\"]*)\"})
+#	@q.push [:stringValue, scanner[1]]
+
+      # string with embedded backslash
+      when m = scanner.scan(%r{\"(([^\\\"]|(\\[nrt\(\)/\"\'\\]))*)\"})
+#	$stderr.puts "scan(#{@line})" unless @quiet
+#	$stderr.puts ":string(#{scanner[1]})"
+	@q.push [:stringValue, scanner[1]]
+
+      when m = scanner.scan(%r{\w+})
+	case m.downcase
+	when "amended": @q.push [:AMENDED, CIM::QualifierFlavors.new(m)]
+	when "any": @q.push [:ANY, m]
+	when "as": @q.push [:AS, nil]
+	when "association": @q.push [:ASSOCIATION, CIM::QualifierDeclaration.new(m.downcase)]
+	when "class": @q.push( [:CLASS, m] )
+	when "disableoverride": @q.push [:DISABLEOVERRIDE, CIM::QualifierFlavors.new(m)]
+	when "void": @q.push [:DT_VOID, CIM::Type.new(:void)]
+	when "boolean": @q.push [:DT_BOOL, CIM::Type.new(:bool)]
+	when "char16": @q.push [:DT_CHAR16, CIM::Type.new(m)]
+	when "datetime": @q.push [:DT_DATETIME, CIM::Type.new(m)]
+	when "real32": @q.push [:DT_REAL32, CIM::Type.new(m)]
+	when "real64": @q.push [:DT_REAL64, CIM::Type.new(m)]
+	when "sint16": @q.push [:DT_SINT16, CIM::Type.new(m)]
+	when "sint32": @q.push [:DT_SINT32, CIM::Type.new(m)]
+	when "sint64": @q.push [:DT_SINT64, CIM::Type.new(m)]
+	when "sint8": @q.push [:DT_SINT8, CIM::Type.new(m)]
+	when "string": @q.push [:DT_STR, CIM::Type.new(m)]
+	when "uint16": @q.push [:DT_UINT16, CIM::Type.new(m)]
+	when "uint32": @q.push [:DT_UINT32, CIM::Type.new(m)]
+	when "uint64": @q.push [:DT_UINT64, CIM::Type.new(m)]
+	when "uint8": @q.push [:DT_UINT8, CIM::Type.new(m)]
+	when "enableoverride": @q.push [:ENABLEOVERRIDE, CIM::QualifierFlavors.new(m)]
+	when "false": @q.push [:booleanValue, false]
+	when "flavor": @q.push [:FLAVOR, nil]
+	when "include": @q.push [:INCLUDE, nil]
+	when "indication": @q.push [:INDICATION, CIM::QualifierDeclaration.new(m.downcase)]
+	when "instance": @q.push [:INSTANCE, m.to_sym]
+	when "method": @q.push [:METHOD, m]
+	when "null": @q.push [:nullValue, CIM::Variant.new(:null,nil)]
+	when "of": @q.push [:OF, nil]
+	when "parameter": @q.push [:PARAMETER, m]
+	when "pragma": @q.push [:PRAGMA, nil]
+	when "property": @q.push [:PROPERTY, m]
+	when "qualifier": @q.push [:QUALIFIER, m]
+	when "ref": @q.push [:REF, nil]
+	when "reference": @q.push [:REFERENCE, m]
+	when "restricted": @q.push [:RESTRICTED, CIM::QualifierFlavors.new(m)]
+	when "schema": @q.push [:SCHEMA, m]
+	when "scope": @q.push [:SCOPE, nil]
+	when "toinstance": @q.push [:TOINSTANCE, CIM::QualifierFlavors.new(m)]
+	when "tosubclass": @q.push [:TOSUBCLASS, CIM::QualifierFlavors.new(m)]
+	when "translatable": @q.push [:TRANSLATABLE, CIM::QualifierFlavors.new(m)]
+	when "true": @q.push [:booleanValue, true]
+	else
+	  @q.push( [:IDENTIFIER, m] )
+	end # case m.downcase
+      
+      else
+	require File.join(File.dirname(__FILE__), 'helper')
+	raise ParseHelper::ScannerError.new( @name, @lineno, @line, scanner.rest ) unless scanner.rest.empty?
+      end # case
+    end # until scanner.eos?
+#    $stderr.puts "scan done, @q #{@q.size} entries"
+    true
+  end
+
+  def parse files
+    return unless files
+    return if files.empty?
+    # open files in reverse order
+    #  open() will stack them and parse starts in right order
+    files.reverse_each do |file|
+      open file, :argv
+#      puts "Opened #{file} as #{@file} @ #{@fstack.size}"
+    end
+    @q = [] # init the token queue
+    do_parse
+  end
+
+  def next_token
+    while @q.empty?
+      break unless fill_queue 
+    end
+#    $stderr.puts "next_token #{@q.first.inspect}"
+    @q.shift
+  end
+  
+  # stack_size, last_token, value_stack
+  # stack[0] == Result
+  def on_error token, token_value, value_stack
+    require File.join(File.dirname(__FILE__), 'parse_helper')
+    raise ParseHelper::ParserError.new @name,@lineno, @line, token,token_value,value_stack
+  end
+
+end # module Scanner
+end # module MOF

data/test/test_loading.rb

@@ -0,0 +1,2 @@
+# test loading
+require File.join(File.dirname(__FILE__), "..", "lib", "mof")

data/test/test_qualifier.rb

@@ -0,0 +1,28 @@
+D = File.expand_path(File.dirname(__FILE__))
+require "test/unit"
+require File.join(D,'..','lib','mof')
+
+class TestQualifiers < Test::Unit::TestCase
+
+  def setup
+    @moffiles, @options = MOF::Parser.argv_handler "test_qualifier", ["qualifier.mof"]
+    @options[:style] ||= :cim
+    @options[:includes] ||= [ D, File.join(D,"mof")]
+
+    @parser = MOF::Parser.new @options
+  end
+  
+  def test_parse
+    result = @parser.parse @moffiles
+    assert result
+    # parsed one file
+    assert_equal 1, result.size
+
+    name,res = result.shift
+    assert !res.qualifiers.empty?
+    res.qualifiers.each do |q|
+      puts "#{q.class}"
+      assert q.is_a? CIM::QualifierDeclaration
+    end
+  end
+end

metadata

@@ -0,0 +1,133 @@
+--- !ruby/object:Gem::Specification 
+name: mof
+version: !ruby/object:Gem::Version 
+  hash: 19
+  prerelease: false
+  segments: 
+  - 0
+  - 3
+  - 0
+  version: 0.3.0
+platform: ruby
+authors: 
+- "Klaus K\xC3\xA4mpf"
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-10-04 00:00:00 +02:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: cim
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 25
+        segments: 
+        - 0
+        - 2
+        - 7
+        version: 0.2.7
+  type: :runtime
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: rubyforge
+  prerelease: false
+  requirement: &id002 !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: *id002
+- !ruby/object:Gem::Dependency 
+  name: hoe
+  prerelease: false
+  requirement: &id003 !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: *id003
+description: |-
+  A parser for the Managed Object Format (MOF) language used to describe
+  classes and instances of the Common Information Model (CIM)
+  
+  See http://www.dmtf.org/education/mof
+email: 
+- kkaempf@suse.de
+executables: 
+- moflint
+extensions: []
+
+extra_rdoc_files: 
+- History.txt
+- Manifest.txt
+files: 
+- History.txt
+- Manifest.txt
+- README.rdoc
+- Rakefile
+- bin/moflint
+- lib/mof.rb
+- lib/mof/helper.rb
+- lib/mof/parser.rb
+- lib/mof/result.rb
+- lib/mof/scanner.rb
+- test/test_qualifier.rb
+- test/test_loading.rb
+has_rdoc: true
+homepage: http://github.com/kkaempf/mof
+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: mof
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: A parser for the Managed Object Format (MOF) language used to describe classes and instances of the Common Information Model (CIM)  See http://www.dmtf.org/education/mof
+test_files: 
+- test/test_qualifier.rb
+- test/test_loading.rb