Hello community, here is the log from the commit of package cmpi-bindings for openSUSE:Factory checked in at 2013-12-22 19:31:18 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ Comparing /work/SRC/openSUSE:Factory/cmpi-bindings (Old) and /work/SRC/openSUSE:Factory/.cmpi-bindings.new (New) ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Package is "cmpi-bindings" Changes: -------- --- /work/SRC/openSUSE:Factory/cmpi-bindings/cmpi-bindings.changes 2013-10-19 11:14:35.000000000 +0200 +++ /work/SRC/openSUSE:Factory/.cmpi-bindings.new/cmpi-bindings.changes 2013-12-22 19:31:19.000000000 +0100 @@ -1,0 +2,8 @@ +Thu Dec 12 12:47:52 UTC 2013 - [email protected] + +- Update to 0.9.8 + - Create Ruby documentation + - Split off package cmpi-bindings-ruby-docs + - Fix Fedora 19 build + +------------------------------------------------------------------- Old: ---- cmpi-bindings-0.9.7.tar.bz2 New: ---- cmpi-bindings-0.9.8.tar.bz2 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ Other differences: ------------------ ++++++ cmpi-bindings.spec ++++++ --- /var/tmp/diff_new_pack.UOwsdk/_old 2013-12-22 19:31:19.000000000 +0100 +++ /var/tmp/diff_new_pack.UOwsdk/_new 2013-12-22 19:31:19.000000000 +0100 @@ -20,7 +20,7 @@ Url: http://github.com/kkaempf/cmpi-bindings Name: cmpi-bindings -Version: 0.9.7 +Version: 0.9.8 Release: 0 Summary: Adapter to write and run CMPI-type CIM providers License: BSD-3-Clause and CPL-1.0 @@ -46,9 +46,7 @@ BuildRequires: curl-devel BuildRequires: pkgconfig BuildRequires: ruby -%if 0%{?rhel_version} < 600 BuildRequires: ruby-devel -%endif BuildRequires: ruby-libs %if 0%{?rhel_version} < 500 @@ -61,6 +59,10 @@ BuildRequires: ruby-rdoc %endif +%if 0%{?fedora} == 19 +BuildRequires: rubypick +%endif + %if 0%{?fedora} || 0%{?rhel_version} >= 600 || 0%{?centos_version} >= 600 BuildRequires: perl-devel %endif @@ -100,6 +102,13 @@ %setup -q %build + +# enforce installed FindRuby + +if [ -f /usr/share/cmake/Modules/FindRuby.cmake ]; then + rm -f cmake/modules/FindRuby.cmake +fi + mkdir build cd build cmake -DCMAKE_INSTALL_PREFIX=%_prefix \ @@ -117,8 +126,9 @@ cd build mkdir -p $RPM_BUILD_ROOT%{_datadir}/cmpi make install DESTDIR=$RPM_BUILD_ROOT +mkdir -p $RPM_BUILD_ROOT%{_docdir} +cp -a swig/ruby/html $RPM_BUILD_ROOT%{_docdir}/cmpi-bindings-ruby-docs -%if 0%{?rhel_version} < 600 %package -n cmpi-bindings-ruby Summary: Adapter to write and run CMPI-type CIM providers in Ruby Group: Development/Languages/Ruby @@ -130,7 +140,7 @@ %endif %description -n cmpi-bindings-ruby -- +Adapter to write and run CMPI-type CIM providers in Ruby %files -n cmpi-bindings-ruby %defattr(-,root,root,-) @@ -141,7 +151,17 @@ %dir %{ruby_sitelib}/cmpi/providers %{ruby_sitelib}/cmpi/provider.rb -%endif #!RHEL6 +%package -n cmpi-bindings-ruby-doc +Summary: RDoc-style documentation for cmpi-bindings-ruby +Group: Documentation/HTML + +%description -n cmpi-bindings-ruby-doc +RDoc-style documentation for cmpi-bindings-ruby + +%files -n cmpi-bindings-ruby-doc +%defattr(-,root,root,-) +%dir %{_docdir}/cmpi-bindings-ruby-docs +%{_docdir}/cmpi-bindings-ruby-docs %package -n cmpi-bindings-pywbem Summary: Adapter to write and run CMPI-type CIM providers in Python ++++++ cmpi-bindings-0.9.7.tar.bz2 -> cmpi-bindings-0.9.8.tar.bz2 ++++++ diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/cmpi-bindings-0.9.7/VERSION.cmake new/cmpi-bindings-0.9.8/VERSION.cmake --- old/cmpi-bindings-0.9.7/VERSION.cmake 2013-10-09 13:56:42.000000000 +0200 +++ new/cmpi-bindings-0.9.8/VERSION.cmake 2013-12-12 11:39:43.000000000 +0100 @@ -1,3 +1,3 @@ SET(VERSION_MAJOR "0") SET(VERSION_MINOR "9") -SET(VERSION_PATCH "7") +SET(VERSION_PATCH "8") diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/cmpi-bindings-0.9.7/package/cmpi-bindings.changes new/cmpi-bindings-0.9.8/package/cmpi-bindings.changes --- old/cmpi-bindings-0.9.7/package/cmpi-bindings.changes 2013-10-09 13:57:55.000000000 +0200 +++ new/cmpi-bindings-0.9.8/package/cmpi-bindings.changes 2013-12-12 13:49:12.000000000 +0100 @@ -1,4 +1,12 @@ ------------------------------------------------------------------- +Thu Dec 12 12:47:52 UTC 2013 - [email protected] + +- Update to 0.9.8 + - Create Ruby documentation + - Split off package cmpi-bindings-ruby-docs + - Fix Fedora 19 build + +------------------------------------------------------------------- Wed Oct 9 11:56:48 UTC 2013 - [email protected] - Update to 0.9.7 diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/cmpi-bindings-0.9.7/package/cmpi-bindings.spec.in new/cmpi-bindings-0.9.8/package/cmpi-bindings.spec.in --- old/cmpi-bindings-0.9.7/package/cmpi-bindings.spec.in 2013-10-09 11:39:26.000000000 +0200 +++ new/cmpi-bindings-0.9.8/package/cmpi-bindings.spec.in 2013-12-12 14:14:33.000000000 +0100 @@ -46,9 +46,7 @@ BuildRequires: curl-devel BuildRequires: pkgconfig BuildRequires: ruby -%if 0%{?rhel_version} < 600 BuildRequires: ruby-devel -%endif BuildRequires: ruby-libs %if 0%{?rhel_version} < 500 @@ -61,6 +59,10 @@ BuildRequires: ruby-rdoc %endif +%if 0%{?fedora} == 19 +BuildRequires: rubypick +%endif + %if 0%{?fedora} || 0%{?rhel_version} >= 600 || 0%{?centos_version} >= 600 BuildRequires: perl-devel %endif @@ -100,6 +102,13 @@ %setup -q %build + +# enforce installed FindRuby + +if [ -f /usr/share/cmake/Modules/FindRuby.cmake ]; then + rm -f cmake/modules/FindRuby.cmake +fi + mkdir build cd build cmake -DCMAKE_INSTALL_PREFIX=%_prefix \ @@ -117,8 +126,9 @@ cd build mkdir -p $RPM_BUILD_ROOT%{_datadir}/cmpi make install DESTDIR=$RPM_BUILD_ROOT +mkdir -p $RPM_BUILD_ROOT%{_docdir} +cp -a swig/ruby/html $RPM_BUILD_ROOT%{_docdir}/cmpi-bindings-ruby-docs -%if 0%{?rhel_version} < 600 %package -n cmpi-bindings-ruby Summary: Adapter to write and run CMPI-type CIM providers in Ruby Group: Development/Languages/Ruby @@ -130,7 +140,7 @@ %endif %description -n cmpi-bindings-ruby -- +Adapter to write and run CMPI-type CIM providers in Ruby %files -n cmpi-bindings-ruby %defattr(-,root,root,-) @@ -141,7 +151,19 @@ %dir %{ruby_sitelib}/cmpi/providers %{ruby_sitelib}/cmpi/provider.rb -%endif #!RHEL6 + +%package -n cmpi-bindings-ruby-doc +Summary: RDoc-style documentation for cmpi-bindings-ruby +Group: Documentation/HTML + +%description -n cmpi-bindings-ruby-doc +RDoc-style documentation for cmpi-bindings-ruby + +%files -n cmpi-bindings-ruby-doc +%defattr(-,root,root,-) +%dir %{_docdir}/cmpi-bindings-ruby-docs +%{_docdir}/cmpi-bindings-ruby-docs + %package -n cmpi-bindings-pywbem Summary: Adapter to write and run CMPI-type CIM providers in Python diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/cmpi-bindings-0.9.7/swig/ruby/CMakeLists.txt new/cmpi-bindings-0.9.8/swig/ruby/CMakeLists.txt --- old/cmpi-bindings-0.9.7/swig/ruby/CMakeLists.txt 2013-09-26 09:10:23.000000000 +0200 +++ new/cmpi-bindings-0.9.8/swig/ruby/CMakeLists.txt 2013-12-12 14:27:05.000000000 +0100 @@ -5,10 +5,23 @@ enable_testing() ADD_SUBDIRECTORY(tests) -EXECUTE_PROCESS(COMMAND ${RUBY_EXECUTABLE} -r rbconfig -e "print RbConfig::CONFIG['ruby_version']" OUTPUT_VARIABLE RUBY_VERSION) - -EXECUTE_PROCESS(COMMAND ${RUBY_EXECUTABLE} -r rbconfig -e "print RbConfig::CONFIG['vendorarchdir']" OUTPUT_VARIABLE RUBY_ARCH_DIR) -EXECUTE_PROCESS(COMMAND ${RUBY_EXECUTABLE} -r rbconfig -e "print RbConfig::CONFIG['vendorlibdir']" OUTPUT_VARIABLE RUBY_LIB_DIR) +IF(NOT RUBY_ARCH_DIR) + EXECUTE_PROCESS(COMMAND ${RUBY_EXECUTABLE} -r rbconfig -e "print RbConfig::CONFIG['vendorarchdir']" OUTPUT_VARIABLE RUBY_ARCH_DIR) +ENDIF(NOT RUBY_ARCH_DIR) + +IF(NOT RUBY_LIB_DIR) + EXECUTE_PROCESS(COMMAND ${RUBY_EXECUTABLE} -r rbconfig -e "print RbConfig::CONFIG['vendorlibdir']" OUTPUT_VARIABLE RUBY_LIB_DIR) +ENDIF(NOT RUBY_LIB_DIR) + +IF(NOT RUBY_VERSION_MAJOR) + EXECUTE_PROCESS(COMMAND ${RUBY_EXECUTABLE} -r rbconfig -e "print RbConfig::CONFIG['MAJOR']" OUTPUT_VARIABLE RUBY_VERSION_MAJOR) + EXECUTE_PROCESS(COMMAND ${RUBY_EXECUTABLE} -r rbconfig -e "print RbConfig::CONFIG['MINOR']" OUTPUT_VARIABLE RUBY_VERSION_MINOR) + EXECUTE_PROCESS(COMMAND ${RUBY_EXECUTABLE} -r rbconfig -e "print RbConfig::CONFIG['TEENY']" OUTPUT_VARIABLE RUBY_VERSION_TEENY) +ENDIF(NOT RUBY_VERSION_MAJOR) + +IF(NOT RUBY_VERSION) + set(RUBY_VERSION "${RUBY_VERSION_MAJOR}.${RUBY_VERSION_MINOR}.${RUBY_VERSION_TEENY}") +ENDIF(NOT RUBY_VERSION) IF( "${RUBY_ARCH_DIR}" STREQUAL "nil" OR "${RUBY_LIB_DIR}" STREQUAL "nil") MESSAGE(STATUS "Ruby too old, no vendor_dir, going for site_dir") @@ -71,20 +84,20 @@ PATTERN "*~" EXCLUDE) # rdoc -IF(RUBY_VERSION VERSION_LESS "1.9.1") SET(rdoc_dir "${CMAKE_CURRENT_BINARY_DIR}/html") ADD_CUSTOM_COMMAND ( OUTPUT ${rdoc_dir} COMMAND ${CMAKE_COMMAND} -E echo_append "Creating rdoc documentation ..." COMMAND rm -rf ${rdoc_dir} - COMMAND ${CMAKE_CURRENT_SOURCE_DIR}/rdoc -o ${rdoc_dir} cmpi.i *.i ruby/cmpi.rb ruby/cmpi/*.rb + COMMAND ./ruby/rdoc${RUBY_VERSION_MAJOR}.${RUBY_VERSION_MINOR} -o ${rdoc_dir} -t "cmpi-bindings - writing CIM providers in Ruby" -m cmpi.i *.i ruby/cmpi.rb ruby/cmpi/*.rb COMMAND ${CMAKE_COMMAND} -E echo "Done." WORKING_DIRECTORY ${CMAKE_SOURCE_DIR}/swig - DEPENDS ${CMAKE_SOURCE_DIR}/swig/*.i ${CMAKE_SOURCE_DIR}/swig/ruby/*.rb ${CMAKE_SOURCE_DIR}/swig/ruby/cmpi/*.rb + DEPENDS ${CMAKE_SOURCE_DIR}/swig/*.i + DEPENDS ${CMAKE_SOURCE_DIR}/swig/ruby/*.rb + DEPENDS ${CMAKE_SOURCE_DIR}/swig/ruby/cmpi/*.rb ) + ADD_CUSTOM_TARGET(ruby_rdoc ALL DEPENDS "${rdoc_dir}") -ADD_DEPENDENCIES(ruby_rdoc ${NAME}) -ENDIF(RUBY_VERSION VERSION_LESS "1.9.1") IF( BUILD_RUBY_GEM ) # diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/cmpi-bindings-0.9.7/swig/ruby/README.rdoc new/cmpi-bindings-0.9.8/swig/ruby/README.rdoc --- old/cmpi-bindings-0.9.7/swig/ruby/README.rdoc 1970-01-01 01:00:00.000000000 +0100 +++ new/cmpi-bindings-0.9.8/swig/ruby/README.rdoc 2013-12-12 11:35:27.000000000 +0100 @@ -0,0 +1,60 @@ += \Openwsman - WS-Management for all + +home :: http://openwsman.github.io +wiki :: https://github.com/Openwsman/openwsman/wiki +mailing list :: [email protected] +source :: https://github.com/Openwsman/openwsman +rdoc :: http://www.suse.de/~kkaempf/openwsman +bugs :: https://github.com/Openwsman/openwsman/issues +code climate :: {<img src="https://codeclimate.com/github/Openwsman/openwsman.png";>}[https://codeclimate.com/github/Openwsman/openwsman] + +== Description + +Openwsman is an open source implementation of WS-Management; enabling +the in-band management of Linux/uni*/Windows platforms. +Openwsman supports the generic WS-Management protocol as well as +specific protocol extensions for the +{Common Information Model}[http://www.dmtf.org/standards/cim] (CIM) + +Openwsman provides 'C' language API by default and a 'C++' API in an +'alpha' state. For other languages, see the bindings. + +== About the bindings + +The bindings provide the simplest way to perform WS-Management +operations with Openwsman. + +Bindings exist for +{Ruby}[https://github.com/Openwsman/openwsman/tree/master/bindings/ruby], +{Python}[https://github.com/Openwsman/openwsman/tree/master/bindings/python], +{Perl}[https://github.com/Openwsman/openwsman/tree/master/bindings/perl], and +{Java}[https://github.com/Openwsman/openwsman/tree/master/bindings/java]. +with plenty of examples in the respective 'tests' directories. + +The Ruby bindings are fully maintained an considered 'production' +quality. + +== Bugs + +If you have problems using Openwsman, report to the +{mailing list}[mailto:[email protected]] +first. + +If you are sure to have found a bug, please report it via the +{Github issue tracker}[https://github.com/Openwsman/openwsman/issues] + +== License + +Openwsman is copyright (C) 2004-2006 by Intel Corp, 2006-2013 by SUSE +Linux Products GmbH. + +Openwsman is free software, and may be redistributed under the terms +of the +{BSD-3-Clause}[https://github.com/Openwsman/openwsman/blob/master/COPYING] +license. + +== Warranty + +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. diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/cmpi-bindings-0.9.7/swig/ruby/parse_swig.rb new/cmpi-bindings-0.9.8/swig/ruby/parse_swig.rb --- old/cmpi-bindings-0.9.7/swig/ruby/parse_swig.rb 2013-04-11 16:06:06.000000000 +0200 +++ new/cmpi-bindings-0.9.8/swig/ruby/parse_swig.rb 2013-12-12 11:35:32.000000000 +0100 @@ -78,8 +78,7 @@ @@module_name = nil # prepare to parse a SWIG file - # RHEL4 has Ruby 1.8.1 which does not provide stats - def initialize(top_level, file_name, body, options, stats = nil) + def initialize(top_level, file_name, body, options, stats) @known_classes = KNOWN_CLASSES.dup @body = handle_tab_width(handle_ifdefs_in(body)) @options = options @@ -162,16 +161,12 @@ enclosure = @top_level end - if RUBY_VERSION == "1.8.1" - return nil unless enclosure # workaround for RHEL4 - end - if class_mod == "class" cm = enclosure.add_class(NormalClass, class_name, parent_name) - @stats.num_classes += 1 if @stats + @stats.num_classes += 1 else cm = enclosure.add_module(NormalModule, class_name) - @stats.num_modules += 1 if @stats + @stats.num_modules += 1 end cm.record_location(enclosure.toplevel) cm.body = options[:content] @@ -180,6 +175,7 @@ find_class_comment(class_name, cm) @classes[class_name] = cm @known_classes[class_name] = cm.full_name + cm end ## @@ -255,7 +251,7 @@ extends[name] = true cn = class_name.to_s cn.capitalize! unless cn[0,1] =~ /[A-Z_]/ - handle_class_module("class", cn, :parent => "rb_cObject", :content => content.to_s, :extend_name => name) + swig_class = handle_class_module("class", cn, :parent => "rb_cObject", :content => content.to_s, :extend_name => name) end end @body.scan(/^%extend\s*(\w+)\s*\{(.*)\}/mx) do |class_name,content| @@ -263,7 +259,7 @@ unless extends[cn] # puts "Class #{cn}" cn.capitalize! unless cn[0,1] =~ /[A-Z_]/ - handle_class_module("class", cn, :parent => "rb_cObject", :content => content) + swig_class = handle_class_module("class", cn, :parent => "rb_cObject", :content => content) extends[cn] = true end end @@ -353,7 +349,7 @@ c = find_class class_name c.body.scan(%r{%alias\s+(\w+)\s+"([^"]+)"\s*;}m) do #" |old_name, new_name| - @stats.num_methods += 1 if @stats + @stats.num_methods += 1 raise "Unknown class '#{class_name}'" unless @known_classes[class_name] class_obj = find_class(class_name) @@ -478,7 +474,7 @@ seen_before = class_obj.method_list.find { |meth| meth.name == meth_name } return nil if seen_before - @stats.num_methods += 1 if @stats + @stats.num_methods += 1 if meth_name == "initialize" meth_name = "new" type = "singleton_method" diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/cmpi-bindings-0.9.7/swig/ruby/rdoc1.8 new/cmpi-bindings-0.9.8/swig/ruby/rdoc1.8 --- old/cmpi-bindings-0.9.7/swig/ruby/rdoc1.8 1970-01-01 01:00:00.000000000 +0100 +++ new/cmpi-bindings-0.9.8/swig/ruby/rdoc1.8 2013-12-12 11:35:27.000000000 +0100 @@ -0,0 +1,19 @@ +#!/usr/bin/ruby + +# This is ./rdoc +# + +home = File.dirname __FILE__ +$:.unshift(home) +new_rdoc = home+"/rdoc.rb" + +# Symlink ./rdoc.rb to /usr/bin/rdoc +# +File.symlink("/usr/bin/rdoc", new_rdoc) unless File.symlink?(new_rdoc) + +begin + require 'parse_swig.rb' # load the swig parser + require 'rdoc' # load the original rdoc +ensure + File.delete new_rdoc # Discard the symlink +end diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/cmpi-bindings-0.9.7/swig/ruby/rdoc1.9 new/cmpi-bindings-0.9.8/swig/ruby/rdoc1.9 --- old/cmpi-bindings-0.9.7/swig/ruby/rdoc1.9 1970-01-01 01:00:00.000000000 +0100 +++ new/cmpi-bindings-0.9.8/swig/ruby/rdoc1.9 2013-12-12 11:35:27.000000000 +0100 @@ -0,0 +1,10 @@ +#!/usr/bin/env ruby +require 'rdoc' + +require 'rdoc/encoding' +require 'rdoc/parser' + +# Simple must come first +require 'rdoc/parser/simple' +require File.join(File.dirname(__FILE__),'rdoc_parser_swig') +require File.join(File.dirname(__FILE__),'rdoc1_9') diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/cmpi-bindings-0.9.7/swig/ruby/rdoc1_9.rb new/cmpi-bindings-0.9.8/swig/ruby/rdoc1_9.rb --- old/cmpi-bindings-0.9.7/swig/ruby/rdoc1_9.rb 1970-01-01 01:00:00.000000000 +0100 +++ new/cmpi-bindings-0.9.8/swig/ruby/rdoc1_9.rb 2013-12-12 11:35:27.000000000 +0100 @@ -0,0 +1,40 @@ +#!/usr/bin/ruby1.9 +# +# RDoc: Documentation tool for source code +# (see lib/rdoc/rdoc.rb for more information) +# +# Copyright (c) 2003 Dave Thomas +# Released under the same terms as Ruby + +begin + gem 'rdoc' +rescue NameError => e # --disable-gems + raise unless e.name == :gem +rescue Gem::LoadError +end + +require 'rdoc/rdoc' + +begin + r = RDoc::RDoc.new + r.document ARGV +rescue SystemExit + raise +rescue Exception => e + if $DEBUG_RDOC then + $stderr.puts e.message + $stderr.puts "#{e.backtrace.join "\n\t"}" + $stderr.puts + elsif Interrupt === e then + $stderr.puts + $stderr.puts 'Interrupted' + else + $stderr.puts "uh-oh! RDoc had a problem:" + $stderr.puts e.message + $stderr.puts + $stderr.puts "run with --debug for full backtrace" + end + + exit 1 +end + diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/cmpi-bindings-0.9.7/swig/ruby/rdoc2.0 new/cmpi-bindings-0.9.8/swig/ruby/rdoc2.0 --- old/cmpi-bindings-0.9.7/swig/ruby/rdoc2.0 1970-01-01 01:00:00.000000000 +0100 +++ new/cmpi-bindings-0.9.8/swig/ruby/rdoc2.0 2013-12-12 11:35:27.000000000 +0100 @@ -0,0 +1,10 @@ +#!/usr/bin/env ruby +require 'rdoc' + +require 'rdoc/encoding' +require 'rdoc/parser' + +# Simple must come first +require 'rdoc/parser/simple' +require File.join(File.dirname(__FILE__),'rdoc_parser_swig') +require File.join(File.dirname(__FILE__),'rdoc2_0') diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/cmpi-bindings-0.9.7/swig/ruby/rdoc2_0.rb new/cmpi-bindings-0.9.8/swig/ruby/rdoc2_0.rb --- old/cmpi-bindings-0.9.7/swig/ruby/rdoc2_0.rb 1970-01-01 01:00:00.000000000 +0100 +++ new/cmpi-bindings-0.9.8/swig/ruby/rdoc2_0.rb 2013-12-12 11:35:27.000000000 +0100 @@ -0,0 +1,40 @@ +#!/usr/bin/ruby1.9 +# +# RDoc: Documentation tool for source code +# (see lib/rdoc/rdoc.rb for more information) +# +# Copyright (c) 2003 Dave Thomas +# Released under the same terms as Ruby + +begin + gem 'rdoc' +rescue NameError => e # --disable-gems + raise unless e.name == :gem +rescue Gem::LoadError +end + +require 'rdoc/rdoc' + +begin + r = RDoc::RDoc.new + r.document ARGV +rescue SystemExit + raise +rescue Exception => e + if $DEBUG_RDOC then + $stderr.puts e.message + $stderr.puts "#{e.backtrace.join "\n\t"}" + $stderr.puts + elsif Interrupt === e then + $stderr.puts + $stderr.puts 'Interrupted' + else + $stderr.puts "uh-oh! RDoc had a problem:" + $stderr.puts e.message + $stderr.puts + $stderr.puts "run with --debug for full backtrace" + end + + exit 1 +end + diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/cmpi-bindings-0.9.7/swig/ruby/rdoc_parser_swig.rb new/cmpi-bindings-0.9.8/swig/ruby/rdoc_parser_swig.rb --- old/cmpi-bindings-0.9.7/swig/ruby/rdoc_parser_swig.rb 1970-01-01 01:00:00.000000000 +0100 +++ new/cmpi-bindings-0.9.8/swig/ruby/rdoc_parser_swig.rb 2013-12-12 11:35:33.000000000 +0100 @@ -0,0 +1,918 @@ + +require 'rdoc/parser/ruby' +require 'rdoc/known_classes' + +## +# RDoc::Parser::SWIG attempts to parse SWIG extension files. It looks for +# the standard patterns that you find in extensions: <tt>%extend, %define, +# %rename, %alias</tt> and so on. It tries to find the corresponding +# C source for the methods and extract comments, but if we fail +# we don't worry too much. +# +# The comments associated with a Ruby method are extracted from the SWIG +# comment block associated with the routine that _implements_ that +# method +# +# The comment blocks may include special directives: +# +# [Document-class: +name+] +# Documentation for the named class. +# +# [Document-module: +name+] +# Documentation for the named module. +# +# [Document-const: +name+] +# Documentation for the named +rb_define_const+. +# +# [Document-global: +name+] +# Documentation for the named +rb_define_global_const+ +# +# [Document-variable: +name+] +# Documentation for the named +rb_define_variable+ +# +# [Document-method: +method_name+] +# Documentation for the named method. Use this when the method name is +# unambiguous. +# +# [Document-method: <tt>ClassName::method_name<tt>] +# Documentation for a singleton method in the given class. Use this when +# the method name alone is ambiguous. +# +# [Document-method: <tt>ClassName#method_name<tt>] +# Documentation for a instance method in the given class. Use this when the +# method name alone is ambiguous. +# +# [Document-attr: +name+] +# Documentation for the named attribute. +# +# [call-seq: <i>text up to an empty line</i>] +# Because C source doesn't give descriptive names to Ruby-level parameters, +# you need to document the calling sequence explicitly +# +# +# As an example, we might have an extension that defines multiple classes +# in its Init_xxx method. We could document them using +# +# /* +# * Document-class: MyClass +# * +# * Encapsulate the writing and reading of the configuration +# * file. ... +# */ +# +# /* +# * Document-method: read_value +# * +# * call-seq: +# * cfg.read_value(key) -> value +# * cfg.read_value(key} { |key| } -> value +# * +# * Return the value corresponding to +key+ from the configuration. +# * In the second form, if the key isn't found, invoke the +# * block and return its value. +# */ + +class RDoc::Parser::SWIG < RDoc::Parser + + parse_files_matching(/\.i\z/) + + include RDoc::Text + + ## + # SWIG file the parser is parsing + + attr_accessor :content + + + ## + # Maps C type names to names of ruby classes (andsingleton classes) + + attr_reader :known_classes + + ## + # Maps C type names to names of ruby singleton classes + + attr_reader :singleton_classes + + ## + # Resets cross-file state. Call when parsing different projects that need + # separate documentation. + + def self.reset + @@enclosure_classes = {} + @@known_bodies = {} + end + + reset + + ## + # Prepare to parse a SWIG file + + def initialize(top_level, file_name, content, options, stats) + super + + @known_classes = RDoc::KNOWN_CLASSES.dup + @content = handle_tab_width handle_ifdefs_in(@content) + @renames = {} # maps old_name => [ new_name, args ] + @aliases = {} # maps name => [ alias_name, args ] + @classes = {} + @singleton_classes = {} + @file_dir = File.dirname(@file_name) + end + + ## + # Scans #content for %alias + + def do_aliases + @content.scan(/%alias\s+(\w+)\s+"([^"]+)";/) do |old_name, new_name| # " +# class_name = @known_classes[var_name] +# +# unless class_name then +# warn "Enclosing class/module %p for alias %s %s not known" % [ +# var_name, new_name, old_name] +# next +# end +# +# class_obj = find_class var_name, class_name + + al = RDoc::Alias.new '', old_name, new_name, '' +# al.singleton = @singleton_classes.key? var_name + +# comment = find_alias_comment var_name, new_name, old_name +# comment = strip_stars comment +# al.comment = comment + + al.record_location @top_level + +# class_obj.add_alias al + @stats.add_alias al + end + end + + ## + # Scans #content for rb_attr and rb_define_attr + + def do_attrs + @content.scan(/rb_attr\s*\( + \s*(\w+), + \s*([\w"()]+), + \s*([01]), + \s*([01]), + \s*\w+\);/xm) do |var_name, attr_name, read, write| + handle_attr var_name, attr_name, read, write + end + + @content.scan(%r%rb_define_attr\( + \s*([\w\.]+), + \s*"([^"]+)", + \s*(\d+), + \s*(\d+)\s*\); + %xm) do |var_name, attr_name, read, write| + handle_attr var_name, attr_name, read, write + end + end + + ## + # Scans #content for %rename + + def do_renames + @content.scan(/\s*%rename\s*\(\s*"?([\w_=]+)"?\s*\)\s*([\w_]+)\s*\(?([\w_,\*\s]+)?\s*\)?;/) do + |new_name, old_name, args| + @renames[old_name] = [new_name, args] + end + end + + ## + # Scans #content for first(!) %module + + def do_modules + @content.scan(/%module\s+(\w+)/) do |match_data| + module_name = match_data[0] + @module = handle_class_module(nil, "module", module_name, @toplevel) + break # first %module only + end + @@module ||= @module + @module = @@module + end + + ## + # Scans #content for %extend + + def do_classes content + found = false +# puts "do_classes #{content.inspect}" + content.scan(/%extend\s+([\w_]+)(.*)/m) do |class_name, content| + real_name = @renames[class_name][0] rescue nil + klass = handle_class_module(class_name, "class", real_name, @module) + # now check if we have multiple %extend, the regexp above is greedy and will match all of them + while content =~ /%extend/ + do_classes $& + $' # ' add the %extend back in + content = $` # real content is everything before the embedded %extend + end +# puts "%extend #{class_name}: #{content.inspect}" + do_methods klass, class_name, content + found = true + end + found + end + + ## + # Scans #content for #define and %constant + + def do_constants + # %constant <type>[*] <name> = <c-constant>; + + @content.scan(/(\/\*.*?\*\/)?\s*%constant\s+([\w_]+)([\s\*]+)([\w_]+)\s*=\s*([\w_]+);/) do |comment, type, pointer, const_name, definition| +# puts "\nConst #{const_name} : #{comment.inspect}" + handle_constants comment, const_name, definition + end + end + + ## + # Scans #content for %mixin + + def do_includes + @content.scan(/%mixin/) do |c,m| + if cls = @classes[c] + m = @known_classes[m] || m + incl = cls.add_include RDoc::Include.new(m, "") + incl.record_location @top_level + end + end + end + + ## + # Scans content for methods + # klass is a RDoc::NormalClass + # name is the 'C' (type) name + # content is what's enclosed in %extend <name> { ... } + + def do_methods klass, name, content + # Find class constructor as 'new' + content.scan(/^\s+#{name}\s*\(([^\)]*)\)\s*\{/m) do |args| + handle_method("method", klass.name, "initialize", name, (args.to_s.split(",")||[]).size, content) + end + content.scan(%r{static\s+((const\s+)?\w+)([\s\*]+)(\w+)\s*\(([^\)]*)\)\s*;}) do + |const,type,pointer,meth_name,args| + handle_method("method", klass.name, meth_name, nil, (args.split(",")||[]).size, content) + end + content.scan(/((const\s+)?\w+) # <const>? <type> + ([ \t\*]+) # <pointer>? + (\w+) # <meth> + \s*\(([^\)]*)\) # args + \s*\{/xm) do # function def start + |const,type,pointer,meth_name,args| +# puts "do_methods klass #{klass}, name #{name}: const #{const.inspect}, type #{type.inspect}, pointer #{pointer.inspect}, meth_name #{meth_name.inspect}" + next unless meth_name + next if meth_name =~ /~/ + type = "string" if type =~ /char/ && pointer =~ /\*/ + handle_method("method", klass.name, meth_name, nil, (args.split(",")||[]).size, content) + end + end + + ## + # Finds the comment for an alias on +class_name+ from +new_name+ to + # +old_name+ + + def find_alias_comment class_name, new_name, old_name + content =~ %r%((?>/\*.*?\*/\s+)) + rb_define_alias\(\s*#{Regexp.escape class_name}\s*, + \s*"#{Regexp.escape new_name}"\s*, + \s*"#{Regexp.escape old_name}"\s*\);%xm + + $1 || '' + end + + ## + # Finds a comment for rb_define_attr, rb_attr or Document-attr. + # + # +var_name+ is the C class variable the attribute is defined on. + # +attr_name+ is the attribute's name. + # + # +read+ and +write+ are the read/write flags ('1' or '0'). Either both or + # neither must be provided. + + def find_attr_comment var_name, attr_name, read = nil, write = nil + attr_name = Regexp.escape attr_name + + rw = if read and write then + /\s*#{read}\s*,\s*#{write}\s*/xm + else + /.*?/m + end + + if @content =~ %r%((?>/\*.*?\*/\s+)) + rb_define_attr\((?:\s*#{var_name},)?\s* + "#{attr_name}"\s*, + #{rw}\)\s*;%xm then + $1 + elsif @content =~ %r%((?>/\*.*?\*/\s+)) + rb_attr\(\s*#{var_name}\s*, + \s*#{attr_name}\s*, + #{rw},.*?\)\s*;%xm then + $1 + elsif @content =~ %r%Document-attr:\s#{attr_name}\s*?\n + ((?>.*?\*/))%xm then + $1 + else + '' + end + end + + ## + # Find the C code corresponding to a Ruby method + + def find_body class_name, meth_name, meth_obj, file_content, quiet = false +# puts "\n\tfind_body #{meth_obj.c_function.inspect}[#{meth_name.inspect}]" if meth_obj.name == "new" +# puts "\n\tfind_body #{meth_name}[#{meth_obj.name}] ?" +# puts "\n\t#{file_content}" + case file_content +# when %r%(/\*.*\*/\s*#{meth_obj.c_function})%xm + when %r%((?>/\*.*?\*/\s+)?) + ((?:(?:static\s*)?(?:\s*const)?(?:\s*unsigned)?(?:\s*struct)?\s+)? + (VALUE|[\w_]+)(\s+\*|\*\s+|\s+)#{meth_name} + \s*(\([^)]*\))([^;]|$))%xm, + %r%(/\*.*?\*/\s+) + #{meth_name} + \s*(\([^)]*\))([^;]|$)%xm then +# puts "\n found! [1:#{$1.inspect},2:#{$2.inspect},3:#{$3.inspect},#{$4.inspect},#{$5.inspect},#{$6.inspect}]" if meth_obj.name == "detail" + + comment = $1 + body = $2 + # type = $3 + return false if $3 == "define" # filter out SWIG_Exception + return false if $3.nil? && meth_name != "initialize" # constructor has no type + # ptr = $4 + offset = $~.offset(2).first + + remove_private_comments comment if comment + + # try to find the whole body + body = $& if /#{Regexp.escape body}[^(]*?\{.*?^\}/m =~ file_content + +# puts "\n\tfind_body #{meth_name} -> #{body}" + # The comment block may have been overridden with a 'Document-method' + # block. This happens in the interpreter when multiple methods are + # vectored through to the same C method but those methods are logically + # distinct (for example Kernel.hash and Kernel.object_id share the same + # implementation + + override_comment = find_override_comment class_name, meth_obj + comment = override_comment if override_comment + + find_modifiers comment, meth_obj if comment + + #meth_obj.params = params + meth_obj.start_collecting_tokens + tk = RDoc::RubyToken::Token.new nil, 1, 1 + tk.set_text body + meth_obj.add_token tk + meth_obj.comment = strip_stars comment + meth_obj.offset = offset + meth_obj.line = file_content[0, offset].count("\n") + 1 + + body + when %r%((?>/\*.*?\*/\s*))^\s*(\#\s*define\s+#{meth_name}\s+(\w+))%m then + comment = $1 + body = $2 + offset = $~.offset(2).first + + find_body class_name, $3, meth_obj, file_content, true + find_modifiers comment, meth_obj + + meth_obj.start_collecting_tokens + tk = RDoc::RubyToken::Token.new nil, 1, 1 + tk.set_text body + meth_obj.add_token tk + meth_obj.comment = strip_stars(comment) + meth_obj.comment.to_s + meth_obj.offset = offset + meth_obj.line = file_content[0, offset].count("\n") + 1 + + body + when %r%^\s*\#\s*define\s+#{meth_name}\s+(\w+)%m then + # with no comment we hope the aliased definition has it and use it's + # definition + + body = find_body(class_name, $1, meth_obj, file_content, true) + + return body if body + + warn "No definition for #{meth_name}" if @options.verbosity > 1 + false + else # No body, but might still have an override comment + comment = find_override_comment class_name, meth_obj + + if comment then + find_modifiers comment, meth_obj + meth_obj.comment = strip_stars comment + + '' + else + warn "No definition for #{meth_name}" if @options.verbosity > 1 + false + end + end + end + + ## + # Finds a RDoc::NormalClass or RDoc::NormalModule for +raw_name+ + + def find_class(raw_name, name) + unless @classes[raw_name] + if raw_name =~ /^rb_m/ + container = @top_level.add_module RDoc::NormalModule, name + else + container = @top_level.add_class RDoc::NormalClass, name + end + + container.record_location @top_level + @classes[raw_name] = container + end + @classes[raw_name] + end + + ## + # Look for class or module documentation above Init_+class_name+(void), + # in a Document-class +class_name+ (or module) comment or above an + # rb_define_class (or module). If a comment is supplied above a matching + # Init_ and a rb_define_class the Init_ comment is used. + # + # /* + # * This is a comment for Foo + # */ + # Init_Foo(void) { + # VALUE cFoo = rb_define_class("Foo", rb_cObject); + # } + # + # /* + # * Document-class: Foo + # * This is a comment for Foo + # */ + # Init_foo(void) { + # VALUE cFoo = rb_define_class("Foo", rb_cObject); + # } + # + # /* + # * This is a comment for Foo + # */ + # VALUE cFoo = rb_define_class("Foo", rb_cObject); + + def find_class_comment(class_name, class_mod) + comment = nil + + if @content =~ %r%Document-(?:class|module):\s+#{class_name}\s*? + (?:<\s+[:,\w]+)?\n((?>.*?\*/))%xm then + comment = $1 + elsif @content =~ %r% + ((?>/\*.*?\*/\s+)) + (static\s+)? + void\s+ + Init_#{class_name}\s*(?:_\(\s*)?\(\s*(?:void\s*)?\)%xmi then + comment = $1.sub(%r%Document-(?:class|module):\s+#{class_name}%, '') + end + + return unless comment + + comment = strip_stars comment + + comment = look_for_directives_in class_mod, comment + + class_mod.add_comment comment, @top_level + end + + ## + # Handles modifiers in +comment+ and updates +meth_obj+ as appropriate. + # + # If <tt>:nodoc:</tt> is found, documentation on +meth_obj+ is suppressed. + # + # If <tt>:yields:</tt> is followed by an argument list it is used for the + # #block_params of +meth_obj+. + # + # If the comment block contains a <tt>call-seq:</tt> section like: + # + # call-seq: + # ARGF.readlines(sep=$/) -> array + # ARGF.readlines(limit) -> array + # ARGF.readlines(sep, limit) -> array + # + # ARGF.to_a(sep=$/) -> array + # ARGF.to_a(limit) -> array + # ARGF.to_a(sep, limit) -> array + # + # it is used for the parameters of +meth_obj+. + + def find_modifiers comment, meth_obj + # we must handle situations like the above followed by an unindented first + # comment. The difficulty is to make sure not to match lines starting + # with ARGF at the same indent, but that are after the first description + # paragraph. + + if comment =~ /call-seq:(.*?(?:\S|\*\/?).*?)^\s*(?:\*\/?)?\s*$/m then + all_start, all_stop = $~.offset(0) + seq_start, seq_stop = $~.offset(1) + + # we get the following lines that start with the leading word at the + # same indent, even if they have blank lines before + if $1 =~ /(^\s*\*?\s*\n)+^(\s*\*?\s*\w+)/m then + leading = $2 # ' * ARGF' in the example above + re = %r% + \A( + (^\s*\*?\s*\n)+ + (^#{Regexp.escape leading}.*?\n)+ + )+ + ^\s*\*?\s*$ + %xm + if comment[seq_stop..-1] =~ re then + all_stop = seq_stop + $~.offset(0).last + seq_stop = seq_stop + $~.offset(1).last + end + end + + seq = comment[seq_start..seq_stop] + seq.gsub!(/^(\s*\*?\s*?)(\S|\n)/m, '\2') + comment.slice! all_start...all_stop + meth_obj.call_seq = seq + elsif comment.sub!(/\A\/\*\s*call-seq:(.*?)\*\/\Z/, '') then + meth_obj.call_seq = $1.strip + end + + look_for_directives_in meth_obj, comment + end + + ## + # Finds a <tt>Document-method</tt> override for +meth_obj+ on +class_name+ + + def find_override_comment class_name, meth_obj + name = Regexp.escape meth_obj.name + prefix = Regexp.escape meth_obj.name_prefix + + if @content =~ %r%Document-method:\s+#{class_name}#{prefix}#{name}\s*?\n((?>.*?\*/))%m then + $1 + elsif @content =~ %r%Document-method:\s#{name}\s*?\n((?>.*?\*/))%m then + $1 + end + end + + ## + # Creates a new RDoc::Attr +attr_name+ on class +var_name+ that is either + # +read+, +write+ or both + + def handle_attr(var_name, attr_name, read, write) + rw = '' + rw << 'R' if '1' == read + rw << 'W' if '1' == write + + class_name = @known_classes[var_name] + + return unless class_name + + class_obj = find_class var_name, class_name + + return unless class_obj + + comment = find_attr_comment var_name, attr_name + comment = strip_stars comment + + name = attr_name.gsub(/rb_intern\("([^"]+)"\)/, '\1') # " + + attr = RDoc::Attr.new '', name, rw, comment + + attr.record_location @top_level + class_obj.add_attribute attr + @stats.add_attribute attr + end + + ## + # Creates a new RDoc::NormalClass or RDoc::NormalModule based on +type+ + # named +class_name+ in +parent+ which was assigned to the C +var_name+. + + def handle_class_module(type_name, type, class_name, enclosure) + enclosure ||= @top_level + + if type == "class" then + full_name = if RDoc::ClassModule === enclosure then + enclosure.full_name + "::#{class_name}" + else + class_name + end + + if @content =~ %r%Document-class:\s+#{full_name}\s*<\s+([:,\w]+)% then + parent_name = $1 + end + + cm = enclosure.add_class RDoc::NormalClass, class_name, parent_name + else + cm = enclosure.add_module RDoc::NormalModule, class_name + end + + cm.record_location enclosure.top_level + + find_class_comment class_name, cm + + case cm + when RDoc::NormalClass + @stats.add_class cm + when RDoc::NormalModule + @stats.add_module cm + end + + @classes[type_name] = cm + @@enclosure_classes[class_name] = cm + @known_classes[class_name] = cm.full_name + cm + end + + ## + # Adds constants. + # + + def handle_constants(comment, const_name, definition) + class_obj = @module + + unless class_obj then + warn "Enclosing class/module #{const_name.inspect} not known" + return + end + + class_name = class_obj.name + + if comment + comment = strip_stars comment + comment = normalize_comment comment + else + comment = "" + end + + con = RDoc::Constant.new const_name, definition, comment + con.record_location @top_level + @stats.add_constant con + class_obj.add_constant con + end + + ## + # Removes #ifdefs that would otherwise confuse us + + def handle_ifdefs_in(body) + result = "" + loop do + body.match(/^#if ((\s*\|\|\s*)?defined\(SWIG([\w]+)\))+/) do + result << $` # copy everything before #if + after = $' #' + if $1 =~ /RUBY/ # if defined(SWIGRUBY) + raise "Unmatched #if SWIGRUBY\n#{after}" unless after.match /^#(if|else|endif)/ + result << $` # copy everything between SWIGRUBY and #if/else/endif + case $1 + when "if" + result << handle_ifdefs_in($& + $') #' + when "else" + after = $' #' + raise "Unclosed #else" unless after.match /^#endif/ + result << handle_ifdefs_in($') #' + when "endif" + result << handle_ifdefs_in($') #' + end + else # if defined(SWIG...) + # throw away everything between SIWG... and #if/else/endif + raise "Unmatched #if" unless after.match /^#(if|else|endif)/ + case $1 + when "if" + result << handle_ifdefs_in($& + $') #' + when "else" + after = $' #' + raise "Unclosed #else" unless after.match /^#endif/ + result << $` # copy everything between #else and #endif + result << handle_ifdefs_in($') #' + when "endif" + result << handle_ifdefs_in($') #' + end + end + end + break + end + result.empty? ? body : result + end + + ## + # Adds an RDoc::AnyMethod +meth_name+ defined on a class or module assigned + # to +var_name+. +type+ is the type of method definition function used. + # +singleton_method+ and +module_function+ create a singleton method. + + def handle_method(type, klass_name, meth_name, function, param_count, content = nil, + source_file = nil) + ruby_name = (@renames[meth_name][0] rescue nil) || meth_name +# puts "\n\thandle_method #{type},#{klass_name},#{meth_name}[#{ruby_name}],#{function},#{param_count} args" # if meth_name == "initialize" + class_name = @known_classes[klass_name] + singleton = @singleton_classes.key? klass_name + + return unless class_name + + class_obj = find_class klass_name, class_name +# puts "\n\tclass_obj #{class_obj.inspect}" #if meth_name == "initialize" + + if class_obj then + if meth_name == "initialize" then + ruby_name = 'new' + singleton = true + type = 'method' # force public + end + + function ||= meth_name + meth_obj = RDoc::AnyMethod.new '', ruby_name + meth_obj.c_function = function + meth_obj.singleton = singleton + + p_count = Integer(param_count) rescue -1 + + if source_file then + file_name = File.join @file_dir, source_file + + if File.exist? file_name then + file_content = (@@known_bodies[file_name] ||= File.read(file_name)) + else + warn "unknown source #{source_file} for #{meth_name} in #{@file_name}" + end + else + file_content = content || @content + end + + body = find_body class_name, function, meth_obj, file_content +# puts "find_body #{class_name}##{function} -> #{body}" + if body and meth_obj.document_self then + meth_obj.params = if p_count < -1 then # -2 is Array + '(*args)' + elsif p_count == -1 then # argc, argv + rb_scan_args body + else + "(#{(1..p_count).map { |i| "p#{i}" }.join ', '})" + end + + + meth_obj.record_location @top_level + class_obj.add_method meth_obj + @stats.add_method meth_obj + meth_obj.visibility = :private if 'private_method' == type + end + end + end + + ## + # Registers a singleton class +sclass_var+ as a singleton of +class_var+ + + def handle_singleton sclass_var, class_var + class_name = @known_classes[class_var] + + @known_classes[sclass_var] = class_name + @singleton_classes[sclass_var] = class_name + end + + ## + # Normalizes tabs in +body+ + + def handle_tab_width(body) + if /\t/ =~ body + tab_width = @options.tab_width + body.split(/\n/).map do |line| + 1 while line.gsub!(/\t+/) do + ' ' * (tab_width * $&.length - $`.length % tab_width) + end && $~ + line + end.join "\n" + else + body + end + end + + ## + # Look for directives in a normal comment block: + # + # /* + # * :title: My Awesome Project + # */ + # + # This method modifies the +comment+ + + def look_for_directives_in context, comment + @preprocess.handle comment, context do |directive, param| + case directive + when 'main' then + @options.main_page = param + '' + when 'title' then + @options.default_title = param if @options.respond_to? :default_title= + '' + end + end + + comment + end + + ## + # Extracts parameters from the +method_body+ and returns a method + # parameter string. Follows 1.9.3dev's scan-arg-spec, see README.EXT + + def rb_scan_args method_body + method_body =~ /rb_scan_args\((.*?)\)/m + return '(*args)' unless $1 + + $1.split(/,/)[2] =~ /"(.*?)"/ # format argument + format = $1.split(//) + + lead = opt = trail = 0 + + if format.first =~ /\d/ then + lead = $&.to_i + format.shift + if format.first =~ /\d/ then + opt = $&.to_i + format.shift + if format.first =~ /\d/ then + trail = $&.to_i + format.shift + block_arg = true + end + end + end + + if format.first == '*' and not block_arg then + var = true + format.shift + if format.first =~ /\d/ then + trail = $&.to_i + format.shift + end + end + + if format.first == ':' then + hash = true + format.shift + end + + if format.first == '&' then + block = true + format.shift + end + + # if the format string is not empty there's a bug in the C code, ignore it + + args = [] + position = 1 + + (1...(position + lead)).each do |index| + args << "p#{index}" + end + + position += lead + + (position...(position + opt)).each do |index| + args << "p#{index} = v#{index}" + end + + position += opt + + if var then + args << '*args' + position += 1 + end + + (position...(position + trail)).each do |index| + args << "p#{index}" + end + + position += trail + + if hash then + args << "p#{position} = {}" + position += 1 + end + + args << '&block' if block + + "(#{args.join ', '})" + end + + ## + # Removes private comments from +comment+ + + def remove_private_comments(comment) + comment.gsub!(/\/?\*--\n(.*?)\/?\*\+\+/m, '') + comment.sub!(/\/?\*--\n.*/m, '') + end + + ## + # Extracts the classes, modules, methods, attributes, constants and aliases + # from a SWIG file and returns an RDoc::TopLevel for this file + + def scan + do_modules + do_renames + do_aliases + do_constants + have_classes = do_classes @content # -> do_methods + do_methods @module, @module.name, @content unless have_classes # file without %extend +# do_includes +# do_attrs + @top_level + end + +end + -- To unsubscribe, e-mail: [email protected] For additional commands, e-mail: [email protected]
![https://codeclimate.com/github/Openwsman/openwsman.png"](https://codeclimate.com/github/Openwsman/openwsman.png"){kind=link}