knut_tools 0.1.0

data/lib/knut_tools.rb

@@ -0,0 +1,45 @@
+=begin rdoc
+==knut_tools/file__END__.rb
+File-extensions for Ruby-scripts.
+
+This extensions of the File-class allows to open Files, starting at __END__.
+
+Details see file__END__.rb[link:files/lib/knut_tools/file__END___rb.html]
+
+==knut_tools/catch_output.rb
+Defines a function to catch outputs on stdout and stderr.
+
+Details see catch_output.rb[link:files/lib/knut_tools/catch_output_rb.html]
+
+==knut_tools/rot13.rb
+extend String by pseudo-encryption.
+
+Details see rot13.rb[link:files/lib/knut_tools/rot13_rb.html]
+
+==knut_tools/required_what.rb
+A little helper to detect file name conflicts between
+different gems.
+
+Details see required_what.rb[link:files/lib/knut_tools/required_what_rb.html]
+
+
+==knut_tools/rake/testtask.rb
+The knut_tools extends rake/testtask to run test in directories.
+This may be necessary, if you have to test, if files are created correct
+or test data can be find relative to your source.
+
+Details see testtask.rb[link:files/lib/knut_tools/rake/testtask_rb.html]
+
+==knut_tools/yaml.rb
+Add yaml-related feature:
+* sorted to_yaml for Hash with :SortKeys	=>	true
+* YAML.load_with_warning warns you about double Hash-keys.
+
+Details see yaml.rb[link:files/lib/knut_tools/yaml_rb.html]
+
+
+=end
+
+module Knut_tools
+VERSION = '0.1.0'
+end

data/lib/knut_tools/catch_output.rb

@@ -0,0 +1,173 @@
+=begin rdoc
+Catch screen output.
+Can be used to avoid messages from programms called by system
+
+Example:
+    require 'knut_tools/catch_output'
+    include Catch_output
+    stdout, stderr = catch_screen_output{ 
+      system('my_shell_application')
+    }
+
+If you want to avoid the _include Catch_output_ you can 
+* use the dummy class Frame_catch_output
+* make your own class
+
+Example Frame_catch_output:
+    require 'knut_tools/catch_output'
+    stdout, stderr = Frame_catch_output.catch_screen_output{ 
+      system('my_shell_application')
+    }
+
+Example own class:
+    require 'knut_tools/catch_output'
+    class MyCatch
+      include Catch_output
+    end
+    mycatch = MyCatch.new
+    
+    stdout, stderr = mycatch.catch_screen_output{ 
+      system('my_shell_application')
+    }
+
+
+Just to play a bit:
+  require 'knut_tools/catch_output'
+
+  puts 'Test 1'
+  a = Frame_catch_output.catch_stdout{
+    puts 'aa'
+  }
+  puts 'Test 1 durchgef�hrt, Ergebnis:'
+  puts a
+  puts '_'*50
+
+  puts 'Test 2'
+  a = Frame_catch_output.catch_stdout{
+    system('dir *')
+  }
+
+  puts 'Test 2 durchgef�hrt, Ergebnis:'
+  puts a
+  puts '_'*50
+=end
+
+#Class Tempfile for temporary redirection of stdout and stderr
+require "tempfile" 
+
+=begin rdoc
+Catch screen output.
+Can be used to avoid messages from programms called by system
+=end
+module Catch_output
+  STDOUT_ORIG	= STDOUT.clone()
+  STDERR_ORIG	= STDERR.clone()
+
+=begin rdoc
+Catch stdout for the given block, but print stderr.
+
+Example:
+    require 'knut_tools/catch_output'
+    include Catch_output
+    stdout = catch_stdout{ 
+      system('my_shell_application')
+    }
+=end
+  def catch_stdout( &block )
+    #~ raise 'no block' unless block_given? 
+    raise ArgumentError, 'no block' unless block.is_a?(Proc)
+    stdout, stderr = catch_screen_output( true, false, &block )
+    return stdout
+  end #catch_stdout()
+
+=begin rdoc
+Catch stderr for the given block, but print stdout.
+
+Example:
+    require 'knut_tools/catch_output'
+    include Catch_output
+    stderr = catch_stderr{ 
+      system('my_shell_application')
+    }
+    
+=end
+  def catch_stderr( &block )
+    #~ raise 'no block' unless block_given? 
+    raise ArgumentError, 'no block' unless block.is_a?(Proc)
+    stdout, stderr = catch_screen_output( false, true, &block )
+    return stderr
+  end #catch_stderr()
+=begin rdoc
+Catch the screen output (stdout and stderr) for the given block.
+You can set, which output you want to catch.
+
+Returnvalue is an array with the result of stdout and stderr.
+If any output wasn't catched, the return value in the array is nil.
+
+Example:
+    require 'knut_tools/catch_output'
+    include Catch_output
+    stdout, stderr = catch_screen_output{ 
+      system('my_shell_application')
+    }
+=end
+  def catch_screen_output(
+      catch_stdout = true,
+      catch_stderr = true,
+      stdout_orig	= STDOUT.clone(),
+      stderr_orig	= STDERR.clone()
+      )
+      
+    raise ArgumentError, 'no block' unless block_given? 
+       
+    if catch_stdout
+      #Create temporary file for stdout
+      tmpstdout = Tempfile.new( 'stdout')
+      #redirect stdout
+      STDOUT.reopen( tmpstdout ) 
+    end
+    if catch_stderr
+      #Create temporary file for stdout
+      tmpstderr = Tempfile.new( 'stderr')
+      #redirect stdout
+      STDERR.reopen( tmpstderr ) 
+    end
+
+    yield #Execute the block
+    
+    if catch_stdout
+      #stdout is coming again to the screen.
+      tmpstdout.close()    
+      STDOUT.reopen( stdout_orig)
+      
+      # Get the result of stdout
+      tmpstdout.open()
+      stdout = tmpstdout.readlines().join
+      tmpstdout.close()
+    end
+
+    if catch_stderr
+      #stderr is coming again to the screen.
+      tmpstderr.close()    
+      STDERR.reopen( stderr_orig)
+      
+      # Get the result of stderr
+      tmpstderr.open()
+      stderr = tmpstderr.readlines().join
+      tmpstderr.close()
+    end
+    return [ stdout, stderr ]
+  end
+end #Catch_output
+
+=begin rdoc
+Frame to use module Catch_output.
+
+Example:
+   Frame_catch_output.catch_stdout{ puts 11 }
+=end
+class Frame_catch_output
+  class << self 
+  include Catch_output
+  end
+end

data/lib/knut_tools/file__END__.rb

@@ -0,0 +1,88 @@
+=begin rdoc
+File-extensions for Ruby-scripts.
+
+Inside Ruby-scripts text after __END__ is used like a "internal files".
+
+Sometimes you want to use this data from other scripts.
+
+This extensions of the File-class allows to open Files, starting at __END__.
+
+Details see
+* File.open_after_END
+* File.readlines_after_END
+* File.each_line_after_END
+=end
+
+class File
+class << self
+=begin rdoc  
+This methods behave like File#open, but it starts after __END__
+
+Example:
+  filehandle = File.open_after_END('testdata/hello_world.rb')
+  filehandle.eachline{|line|
+    ... #text after __END__
+  }
+  filehandle.close
+
+or better:
+  File.open_after_END('testdata/hello_world.rb'){|filehandle|
+    filehandle.eachline{|line|
+      ... #text after __END__
+    }
+  }
+=end
+	def open_after_END( filename )
+		f = File.new(filename, 'r')
+		if filename =~ /\.rbw?\Z/
+			line = nil
+			while line !~ /^__END__\n/ and ! f.eof?
+				line = f.readline
+			end
+		end
+		
+    if block_given?
+      #~ f.each_line{|line| yield line }
+      yield f
+    else
+      return f      
+    end #block_given?
+	end
+=begin rdoc
+Return content of script after __END__
+
+Example:
+  File.readlines_after_END('testdata/hello_world.rb').each{|line|
+    #...
+  }
+=end
+	def readlines_after_END( filename )
+		f = open_after_END( filename )
+		txt = f.readlines.join
+		f.close
+		return txt
+	end
+=begin rdoc
+Get all lines after __END__.
+
+Example:
+  File.each_line_after_END('testdata/hello_world.rb'){|line|
+    #... lines after __END__
+  }
+or
+  textarray = File.each_line_after_END('testdata/hello_world.rb')
+=end
+  def each_line_after_END( filename )
+		f = open_after_END( filename )
+    res = true
+    if block_given?
+      res = f.each_line{|line| yield line }
+    else
+      res = f.readlines
+    end
+    f.close
+    return res
+	end
+  
+end #File
+end

data/lib/knut_tools/file_winlink.rb

@@ -0,0 +1,52 @@
+=begin rdoc
+shortcut to define a link under windows.
+=end
+
+#~ fixme:
+#~ genauer �berlegen
+#~ interface mit hash (target bleibt, rest ist ableitbar)
+#~ daten pr�fen.
+
+require "win32/shortcut"
+
+=begin rdoc
+Usage:
+  mk_link( target, linkname )
+  mk_link( target, linkname, descr, workdir )
+  mk_link( 'readme.txt', 'readme.lnk', "Link to <#{target}>", "C:\\")
+Builds a link, named linkname, to target.
+Throws an error, if target does not exist.
+=end
+def mk_link( target, linkname, 
+    descr="Link to <#{target}>", 
+    workdir = "C:\\"
+  )
+  if File.exist?(target)
+    s = Win32::Shortcut.new(linkname)
+    s.description = descr
+    s.path = File.expand_path(target)
+    s.show_cmd = Win32::Shortcut::SHOWNORMAL
+    s.working_directory = workdir
+    s.save
+    #~ puts "Build link to #{target}"
+  else
+    raise Errno::ENOENT, "No link created to #{target}"
+  end
+end
+
+
+=begin
+Quicktest.
+See also unittest
+=end
+#~ mk_link( 'yaml.rb', 
+              #~ "mylink.lnk",
+              #~ "This is a longer description of a link to yaml.rb"
+            #~ )
+            
+            
+  #~ mk_link( File.join( gemdir, 'gems', spec.full_name ), 
+              #~ "dir_#{spec.full_name}.dir.lnk",
+              #~ "#{spec.name} version #{spec.version}"
+            #~ )
+

data/lib/knut_tools/rake/gempackager.rb

@@ -0,0 +1,551 @@
+=begin rdoc
+
+Usage:
+  require 'knut_tools/rake/gempackager.rb'
+  puts Gem_packer::Template
+
+Take the result and start to add your data.
+
+
+=Other packaging tools
+There are different other packaging tools.
+
+- hoe 
+- newgem 
+- bones 
+- gemhub 
+- echoe 
+- jeweler
+
+(Source and discussion (German):
+http://forum.ruby-portal.de/viewtopic.php?f=6&t=9517
+)
+
+==Short analyse of other tools
+By some reasons the other tools doesn't fit my needs.
+
+===hoe
+* http://seattlerb.rubyforge.org/hoe/
+* http://blog.emson.co.uk/2008/06/an-almost-fix-for-creating-rubygems-on-windows/
+* http://nubyonrails.com/articles/tutorial-publishing-rubygems-with-hoe
+
+Disadvantage:
+* hoe becomes a dependecy in all gems.
+* Problems with windows support
+** http://blog.emson.co.uk/2008/06/an-almost-fix-for-creating-rubygems-on-windows/
+** Seems to be solved, but you need some 
+
+
+===echoe
+* http://blog.evanweaver.com/articles/2007/01/10/if-you-dont-want-to-hoe-echoe/
+* http://gemcutter.org/gems/echoe
+* http://blog.evanweaver.com/files/doc/fauna/echoe/files/README.html
+
+Disadvantage:
+* Manifest is build from scratch with tasks manifest and build
+  (Danger of overwritting your data)
+* gemspec contains the test data files under "files"
+
+
+=end
+
+require 'rake'
+require 'rubygems'
+require "knut_tools/file_winlink.rb"
+require 'knut_tools/rake/testtask.rb'
+require 'rake/contrib/ftptools.rb'
+
+=begin rdoc
+Class to define an "extended" gemspec.
+
+Defines all tasks to admin the gem (build, install, push to gemcutter...)
+Details see #build_tasks.
+=end
+class Gem_packer
+  #Template for a new gem.
+  Template = <<-TEMPLATE
+    require 'knut_tools/rake/#{File.basename(__FILE__)}'
+    require 'knut_tools/rake/testtask.rb'
+  
+    Gem_packer.new('my_gem', '0.1.0', {
+          :verbose => nil,
+          :versions => [],
+          :public => false,
+        }){|gemdef, spec|
+      #http://docs.rubygems.org/read/chapter/20
+      spec.author = "Knut Lickert"
+      spec.email = "knut@lickert.net"
+      spec.homepage = "http://www.rubypla.net/"
+      #~ spec.rubyforge_project = ''
+      spec.platform = Gem::Platform::RUBY
+      spec.summary = ""
+      spec.description = spec.summary
+      #~ spec.require_path = "lib"
+      spec.files = %w{
+      }
+      spec.test_files  = %w{
+      }
+      #~ spec.test_files   << Dir['unittest/expected/*']
+      spec.test_files.flatten!
+
+      spec.has_rdoc	= true  
+      #~ spec.rdoc_options << '--main' << 'lib/???'
+      
+      #~ spec.add_dependency()
+      #~ spec.add_development_dependency('more_unit_test', '> 0.0.2')  #assert_equal_filecontent
+      #~ spec.requirements << 'A (La)TeX-system'
+      
+      #~ gemdef.versions << ??
+      #Define the tests (parameter: directory, test files)
+      #~ gemdef.define_test( 'unittest', FileList['test*.rb'])
+
+      #~ gemdef.public = true
+      #~ gemdef.add_ftp_connection(host, account, passwort, directory)
+      
+    }
+
+    require 'creole/creole2doc'  #needed for readme.html, readme.txt
+    #Build the html-readme from creole-source
+    rule '.html' => '.creole' do |t|
+      doc = Creole_document.new()
+      File.open(t.source){|f| doc << f }
+      doc.save(t.name)
+    end
+    #Build the text-readme from creole-source
+    rule '.txt' => '.creole' do |t|
+      doc = Creole_document.new()
+      File.open(t.source){|f| doc << f }
+      doc.save(t.name)
+    end
+    #~ task :default => 'readme.html'
+    #~ task :default => 'readme.txt'
+    
+    desc "Copy the created gems to archive"
+    task :archive do
+      Dir["*-#{$version}.gem"].each{|gem_file|
+        FileUtils.copy(gem_file, "archive/File.basename(gem_file)")
+      }
+    end
+    
+    #~ task :default => 'mygem:check'
+    task :default => :check
+    #~ task :default => :test
+    #~ task :default => :gem
+    #~ task :default => :install
+    #~ task :default => :ftp_rdoc
+    #~ task :default => 
+    #~ task :default => 
+    
+    
+    if $0 == __FILE__
+      app = Rake.application
+      app[:default].invoke
+    end
+
+  TEMPLATE
+  Template.gsub!(/^    /,'')
+
+  #Error thrown, if version conflict is detected.
+  class VersionError < RuntimeError; end
+  #Thrown, if a blocked task is called.
+  class BlockError < RuntimeError; end
+  #Struct with :host, :account, :password, :target_dir. Used in ftp_rdoc
+  FTP_DATA = Struct.new('FTP', :host, :account, :password, :target_dir)
+  
+=begin rdoc
+Create a new gem definition.
+
+Usage: 
+  Gem_packer.new('test', '0.1.0', { ...options... })   do |gem_packer, spec|
+    spec.email = 'xx@testdomain.org'
+    # ...
+  end
+Options may be:
+* verbose
+* public  - allow push, ftp...
+* versions - variables, which should be same as version.
+
+Effects:
+* Defines the tasks inside a namespace (see Gem_packer#build_tasks )
+* Add the 'namespaced'-tasks to standard tasks.
+=end
+  def initialize( name, version, options = {} )
+    @name = name
+    @version = version
+    @spec = Gem::Specification.new{ |spec|
+      spec.name = name
+      spec.version = version
+    }
+    
+    @ftp_connections = []
+    
+    raise ArgumentError unless options.is_a?(Hash)
+    #Copy all options to class settings.
+    @versions = options.delete(:versions)
+    @versions ||= [] 
+    @verbose = options.delete(:verbose)
+    @public = options.delete(:public)
+      #~ gemdef.add_ftp_connection(host, account, passwort, directory)
+
+    raise ArgumentError unless options.empty?
+    
+    yield self, @spec if block_given?
+    
+    puts "Build the tasks for #{@name}" if @verbose    
+    build_tasks()
+  end
+  
+=begin rdoc
+Tasks defined by this class. See #build_tasks().
+
+Test tasks are defined with #define_test.
+=end
+  TASKLIST = [ :default, 
+                      :check, :check_version, :check_gemspec,
+                      :gem,
+                      :install, :ftp_rdoc, :push,
+                      :links,
+                    ]
+=begin fixme
+:check
+  :check_manifest: manifest lesen, vergliechen mit gemspec
+
+* build_manifest  (aus gemspec?
+=end
+  
+  #Spec-definition
+  attr_reader :spec
+  #Name of the gem
+  attr_reader :name
+  #Version of the gem
+  attr_reader :version
+  #Collection (Array) of version-elements. Have to be identic with version.
+  #Example: mygem_def.versions << Knut_tools::VERSION
+  attr_reader :versions
+  #Flag, if the gem is public (block "push" if false)
+  attr_accessor :public
+
+=begin rdoc
+Add a ftp-connection to copy the documentation.
+
+The complete content of the rdoc-directory will be copied to the ftp-destination.
+=end
+  def add_ftp_connection(host, account, passwort, directory)
+    puts "Add ftp-connection to #{host} for ftp_doc" if @verbose
+    @ftp_connections << FTP_DATA.new(host, account, passwort, directory)
+  end
+
+=begin rdoc
+Build all the tasks from TASKLIST inside a namespace.
+
+Tasks outside the namespace get the "namespaced" tasks as prerequisite.
+
+Test tasks are defined with #define_test.
+
+=The tasks
+
+
+==default
+Includes:
+* check
+
+==check
+Includes:
+* check_version
+* check_gemspec
+
+===check_version
+The gem has a defined version.
+
+Inside your code you have VERSION-definition you can add with Gem_packer#versions
+
+This tasks checks, if all VERSION fit to the gem-version.
+
+Example: 
+  mygem_def = Gem_packer.new('mygem', '1.0.0')
+  mygem_def.versions << Mygem::VERSION
+  mygem_def.versions << Mygem::Firstclass::VERSION
+  mygem_def.versions << Mygem::Secondclass::VERSION
+
+===check_gemspec
+Makes some tests on the gemspec-definition.
+* File existence (files, test files, executables
+
+==gem
+Build the gem.
+
+==ftp_rdoc
+Copy the rdoc-files to a ftp-destination.
+The destionations must be defined with
+Gem_packer#add_ftp_connection.
+
+You can block this task with Gem_packer#public = false.
+
+==push 
+Push the gem to gemcutter.
+
+You can block this task with Gem_packer#public = false.
+=end
+  def build_tasks()
+    
+    #Define the namespace for the gem.
+    namespace @name do
+      desc "Run default tasks for #{name}"
+      task :default => :check do
+        #empty, only prerequisites needed
+      end
+
+      desc "Run check tasks for #{name}"
+      task :check => [:check_version, :check_gemspec ] do |t|
+        #empty, only prerequisites needed
+        #~ puts t.comment if @verbose
+      end
+
+      desc "Check version for #{@name}"
+      task :check_version do |t|
+        puts t.comment if @verbose
+        check_version()
+      end
+
+      desc "Check gemspec for #{@name}"
+      task :check_gemspec do |t|
+        puts t.comment if @verbose
+        check_gemspec()
+      end
+
+      desc "Build #{@name}-#{@version}.gem"
+      task :gem do |t|
+        puts t.comment if @verbose
+        Gem::Builder.new(@spec).build
+      end
+
+=begin
+Remark 2010-07-20:
+gem uses ruby 1.9-branch 
+-> Use pik to update all branches
+=end
+      desc "Install #{@name}-#{@version}.gem"
+      task :install => [:check, :gem ] do |t|
+        puts t.comment if @verbose
+        puts `call gem install #{@name}-#{@version}.gem -l`
+        #~ puts `call pik gem install #{@name}-#{@version}.gem -l`
+      end
+
+      desc "Push documentation to gems.rubypla.net"
+      task :ftp_rdoc do |t|
+        raise BlockError, "Task ftp_rdoc blocked for #{@spec.full_name}" unless @public
+        
+        puts t.comment if @verbose
+        gemdir = %x{call gem environment gemdir}.strip
+        
+        source = File.join( gemdir, 'doc', @spec.full_name, 'rdoc' )
+        
+        raise "#{source} not found" unless File.exist?(source)
+        raise "#{source} no directory " unless File.directory?(source)
+
+        raise "No ftp-connection defined" if @ftp_connections.empty?
+          
+        Dir.chdir(source){
+          @ftp_connections.each{|ftp|
+            puts "Upload rdoc to #{ftp.host}/#{ftp.target_dir}"
+            #Copy the data into target dir 
+            #The target directory is created if it doesn't exist.
+            Rake::FtpUploader.connect(ftp.target_dir, ftp.host, ftp.account, ftp.password){|uploader|
+              uploader.upload_files('**/*')
+            }
+          }
+        }
+      end  #ftp_rdoc
+
+      desc "Push #{@name} gem to gemcutter"
+      task :push => :gem do |t|
+        raise BlockError, "Task push blocked for #{@spec.full_name}" unless @public
+        
+        puts t.comment if @verbose
+        puts `call gem push #{@name}-#{@version}.gem`
+      end #push
+
+      desc "Create Links to directory and rdoc for #{@name}"
+      task :links do |t|
+        # Klappt leider nicht auf dir --> 
+        gemdir = %x{call gem environment gemdir}.strip
+          mk_link( File.join( gemdir, 'gems', @spec.full_name ), 
+                      "dir_#{@spec.full_name}.dir.lnk",
+                      "#{@name} version #{@version}"
+                    )
+          mk_link(File.join( gemdir, 'doc', @spec.full_name, 'rdoc', 'index.html' ), 
+                      "rdoc_#{@spec.full_name}.lnk",
+                      "rdoc #{@spec.name} version #{@spec.version}"
+                    )
+      end
+
+    end
+    
+    #Tasks outside the namespace
+    task :default => @name
+    task @name => "#{@name}:default"
+    #Add prerequisites
+    TASKLIST.each{|task|
+      task task => "#{@name}:#{task}"
+    }
+    
+  end #build_tasks()
+=begin rdoc
+Check the version.
+
+Each value from #versions must be equal to #version.
+=end
+  def check_version()
+    raise VersionError, "Gemspec#version != Gem_packer#version" unless @spec.version.to_s == @version
+    @versions.each{|version|
+    #fixme --> Name rauszubekommen?
+    #~ puts version.object_id
+      raise VersionError, "#{@version} != #{version}" unless version == @version
+    }
+  end
+  
+=begin rdoc
+Check the gemspec.
+=end
+  def check_gemspec()
+    #~ check obligatory fields?
+    files = []
+    
+    #Check file existence
+    #spec.files includes testfiles.
+    @spec.files.each{|file|
+      puts "\t#{file} missing" unless File.exist?(file)
+      files << file
+    }
+    @spec.test_files.each{|file|
+      puts "\t#{file} missing" unless File.exist?(file)
+      files << file
+    }
+    @spec.executables.each{|file|
+      puts "\t#{file} missing" unless File.exist?(File.join(@spec.bindir, file))
+      files << File.join(@spec.bindir, file)
+    }
+    files.sort!
+    files.uniq!
+    
+    #~ fixme: compare files with manifest.
+    #~ puts files.to_yaml
+  end
+
+=begin rdoc
+Define tests.
+=end
+  def define_test( testdir = "unittest", glob = FileList['test*.rb'] )
+    
+    raise ArgumentError, "Testdirectory #{testdir} missing" unless File.exist?(testdir)
+    raise ArgumentError, "Testdirectory #{testdir} missing" unless File.directory?(testdir)
+    
+    lib = ("../" * (testdir.count('/') + 1) ) + @spec.require_path
+    raise ArgumentError, "Require path #{@spec.require_path} missing from #{testdir}" unless File.exist?("#{testdir}/#{lib}")
+    raise ArgumentError, "Require path #{@spec.require_path} missing from #{testdir}" unless File.directory?("#{testdir}/#{lib}")
+    
+    #Check if test files exist
+    Dir.chdir(testdir){
+      raise ArgumentError, "Test files missing in #{testdir}" unless glob.existing.size > 0
+    }
+    
+    #Define the test tasks
+    testcase = Rake::TestTask.new("#{@name}:test") do |t|
+      t.dir = testdir #possible with 'knut_tools/rake/testtask.rb'
+      #Get 'lib' directory relative to test directory.
+      t.libs << lib
+      t.test_files = glob
+      t.verbose = true
+    end
+    
+    task :test => "#{@name}:test"
+    
+    testcase
+  end #define_test
+
+end
+
+=begin rdoc
+Tasks outside the namespace.
+Define the titles.
+=end
+desc "Run default tasks for all gem-definitions"
+task :default
+desc "Check all versions"
+task :check_version
+desc "Check all gemspecs"
+task :check_gemspec
+
+=begin
+Helper tasks to build the readmes.
+=end
+begin
+require 'creole/creole2doc'  #needed for readme.html, readme.txt
+rescue
+  #define dummy class
+  class Creole_document
+    def save(filename)
+      puts "Error: Use of Creole_document without docgenerator-gem"
+    end
+  end
+end
+#Build the html-readme from creole-source
+rule '.html' => '.creole' do |t|
+  doc = Creole_document.new()
+  File.open(t.source){|f| doc << f }
+  doc.save(t.name)
+end
+#Build the text-readme from creole-source
+rule '.txt' => '.creole' do |t|
+  doc = Creole_document.new()
+  File.open(t.source){|f| doc << f }
+  doc.save(t.name)
+end
+
+
+if $0 == __FILE__
+  #~ puts Gem_packer::Template
+  
+  app = Rake.application
+  #~ app[:check_version].invoke
+  #~ app['test'].invoke
+  #~ app[:default].invoke
+end
+
+__END__
+
+require "win32/shortcut"
+def mk_link( target, linkname, descr )
+  if File.exist?(target)
+    s = Win32::Shortcut.new(linkname)
+    s.description = descr
+    s.path = target
+    s.show_cmd = Win32::Shortcut::SHOWNORMAL
+    s.working_directory = "C:\\"
+    s.save
+    puts "Build link to #{s.path}"
+  else
+    puts "No link created to #{target}"
+  end
+end
+
+desc "Prepare the readmes"
+task :readme => [] do
+  puts "Build readmes"
+  readme = Creole_document.new
+  readme << DESCRIPTION
+  readme.save('readme.txt')
+  readme.save('readme.html')
+end
+
+
+
+#
+#gem fr�gt bei uninstall gerne nach (abh�ngigkeiten, welche version....)
+#rake-prozess wartet dann auf user-eingabe.
+#
+#~ #desc "Uninstall the gem first"
+#~ task :uninstall do
+  #~ puts "Vorsicht vor R�ckfragen"
+  #~ puts `call gem uninstall #{SPEC.name} --version #{SPEC.version}`
+#~ end