bee 0.4.0 → 0.5.0

data/lib/bee_task_default.rb

@@ -1,4 +1,4 @@
-# Copyright 2006-2007 Michel Casabianca <michel.casabianca@gmail.com>
+# Copyright 2006-2008 Michel Casabianca <michel.casabianca@gmail.com>
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
@@ -15,6 +15,8 @@
 require 'bee'
 require 'bee_task'
 require 'bee_util'
+require 'erb'
+require 'fileutils'
 
 module Bee
   
@@ -23,18 +25,19 @@ module Bee
     # Package for default tasks (tasks with no package).
     class Default < Package
     
-      include Bee::Util::FileSelector
-      
-      # Print a message on console. If message is a string, it is printed
-      # on standard output, if message is another Ruby object, this task
-      # outputs its inspected value instead.
+      ######################################################################
+      #                        MISCELLANEOUS TASKS                         #
+      ######################################################################
+    
+      # Print a message on console. If message is not a string, this task
+      # outputs the inspected value of the object.
       # 
       # - message: message to print.
       # 
       # Example
       # 
-      #  - print: "Hello World!"
-      def print(message)
+      #  - echo: "Hello World!"
+      def echo(message)
         case message
         when String
           puts message
@@ -42,7 +45,138 @@ module Bee
           puts message.inspect
         end
       end
-      
+
+      # Alias for echo.
+      alias :print :echo
+
+      # Wait for a given amount of time.
+      # 
+      # - time: time to wait, in seconds, as an integer or float.
+      # 
+      # Example
+      # 
+      #  - sleep: 3.5
+      def sleep(time)
+        error "sleep parameter must be a float or a integer" if
+          not time.kind_of?(Numeric)
+        seconds = time.to_f
+        puts "Waiting #{time} seconds..."
+        Kernel.sleep seconds
+      end
+
+      # Alias for sleep.
+      alias :wait :sleep
+
+      # Prompt the user for the value of a given property matching a pattern.
+      # 
+      # - message: message to print at prompt. Should include a description
+      #   of the expected pattern.
+      # - property: the name of the property to set.
+      # - default: default value if user doesn't type anything. Written
+      #   into square brakets after prompt message. Optional.
+      # - pattern: a Ruby pattern for prompted value. If this pattern is not
+      #   matched, this task will prompt again. Optional, if no pattern is
+      #   given, any value is accepted.
+      # - error: the error message to print when pattern is not matched.
+      # - attempts: number of allowed attempts. Optional, defaults to 0, which
+      #   means an unlimited number of attempts.
+      #
+      # Example
+      #
+      #  - prompt:
+      #      message:  "Enter your age"
+      #      property: "age"
+      #      default:  18
+      #      pattern:  "^\\d+$"
+      #      error:    "Age must be a positive integer"
+      def prompt(params)
+        params_desc = {
+          :message  => { :mandatory => true,  :type => :string },
+          :property => { :mandatory => true,  :type => :string },
+          :default  => { :mandatory => false, :type => :string },
+          :pattern  => { :mandatory => false, :type => :string },
+          :error    => { :mandatory => false, :type => :string },
+          :attempts => { :mandatory => false, :type => :integer, :default => 0 }
+        }
+        check_parameters(params, params_desc)
+        message = params[:message]
+        property = params[:property]
+        default = params[:default]
+        pattern = params[:pattern]
+        error = params[:error]
+        attempts = params[:attempts]
+        message << " [#{default}]" if default
+        message << ':'
+        ok = false
+        nb_attempts = 1
+        while not (ok or (nb_attempts > attempts and attempts != 0))
+          puts message
+          value = gets.strip
+          value = default if default and value.length == 0
+          if pattern
+            if value =~ /#{pattern}/
+              ok = true
+            elsif error
+              puts error
+            end
+          else
+            ok = true
+          end
+          nb_attempts += 1
+        end
+        error "Failed to obtain a matching prompt" if not ok
+        @build.context.set_property(property, value)
+      end
+
+      # Get a given URL and store its content in a given file. Parameters
+      # is a Hash with following entries:
+      #
+      # - url: the URL to get.
+      # - dest: destination file. Optional, defaults to retrieved file name
+      #   in current directory. If destination is a directory, file is saved
+      #   in destination directory with the name of the retrieved file.
+      # - limit: the redirections limit. Optional, defaults to 10.
+      #
+      # Example
+      #
+      #   - get:
+      #       url: http://rubyforge.org/frs/download.php/22185/bee-0.4.0.zip
+      def get(parameters)
+        params_desc = {
+          :url   => { :mandatory => true,   :type => :string },
+          :dest  => { :mandatory => false,  :type => :string },
+          :limit => { :mandatory => false,  :type => :integer, :default => 10 }
+        }
+        check_parameters(parameters, params_desc)
+        url = parameters[:url]
+        dest = parameters[:dest]
+        if not dest
+          destination = File.basename(url)
+        elsif File.directory?(dest)
+          destination = File.join(dest, File.basename(url))
+        else
+          destination = dest
+        end
+        limit = parameters[:limit]
+        puts "Getting URL '#{url}'..."
+        begin
+          content = Util::fetch(url, limit)
+        rescue Exception
+          error "Error getting URL: #{$!}"
+        end
+        todir = File.dirname(destination)
+        begin
+          FileUtils.makedirs(todir) if not File.exists?(todir)
+          File.open(destination, 'w') { |file| file.write(content) }
+        rescue Exception
+          error "Error saving file: #{$!}"
+        end
+      end
+
+      ######################################################################
+      #                         FILE RELATED TASKS                         #
+      ######################################################################
+    
       # Print contents of a given file on the console. Parameter is the name
       # of the file to output, as a String.
       # 
@@ -50,203 +184,609 @@ module Bee
       # 
       #  - cat: "doc/welcome-message.txt"
       def cat(file)
-        file = file
-        error "Parameter must be a String" unless file.kind_of?(String)
-        error "File '#{file}' not found" unless 
-        File.exists?(file) or File.directory?(file)
+        error "Parameter must be a string" unless file.kind_of?(String)
+        error "File '#{file}' not a regular file or not readable" unless 
+          File.file?(file) and File.readable?(file)
         puts File.read(file).strip
       end
-      
+
       # Change working directory. This change will persist for all tasks in
-      # the target but not in other targets. Parameter is a String with 
-      # directory to change to.
+      # the current target. Entering a new target, working directory will
+      # recover its default value, which is the directory of the build file
+      # (or property 'base'). Parameter is a String with directory to change
+      # to.
       # 
       # Example
       # 
       #  - cd: "build"
       def cd(dir)
-        dir = dir
-        error "cd parameter is a String" unless dir.kind_of?(String)
+        error "cd parameter must be a string" unless dir.kind_of?(String)
+        error "cd parameter must be a readable existing directory" unless
+          File.directory?(dir) and File.executable?(dir)
+        puts "Changing directory to '#{dir}'"
         Dir.chdir(dir)
       end
-      
-      # Make a directory and parent directories if necessary. Doesn't complain 
-      # if directory already exists. Parameter is directory to create as a 
-      # String or a list of directories as Strings.
+
+      # Put working directory in a given property. Parameter is the name of
+      # the property to write current directory into.
+      #
+      # Example
+      #
+      #   - pwd: current_dir
+      def pwd(property)
+        error "pwd parameter must be a string" unless property.kind_of?(String)
+        pwd = FileUtils.pwd
+        @build.context.set_property(property, pwd)
+      end
+
+      # Make a symbolic link from a source file to a destination one.
+      # Parameter is a Hash with following entries:
+      #
+      # - old: source of the link, as a glob. If there are more than one
+      #   file to link, this task will make links 'new/file' for each file
+      #   of the glob.
+      # - new: destination of the link.
+      #
+      # Example
+      #
+      #   - ln:
+      #       old: /usr/local
+      #       new: /opt
+      #
+      # Note:
+      #
+      #   This task is not implemented under Windows.
+      def ln(parameters)
+        params_desc = {
+          :old => { :mandatory => true, :type => :string },
+          :new => { :mandatory => true, :type => :string }
+        }
+        check_parameters(parameters, params_desc)
+        old = parameters[:old]
+        new = parameters[:new]
+        files = Dir.glob(old)
+        files = files.first if files.length == 1
+        puts "Linking #{files.length} file(s) to '#{new}'"
+        begin
+          FileUtils.ln_s(files, new)
+        rescue
+          error "Error making the link: #{$!}"
+        end
+      end
+
+      # Alias for ln.
+      alias :link :ln
+
+      # Change permissions for a set of files. Parameters is a Hash with
+      # following entries:
+      #
+      # - files: files to change permissions for, as a glob.
+      # - mode: permissons as an Unix integer (such as 0644 or 0755). Note that
+      #   numbers starting with 0 are considered octal, with 0x, they are
+      #   supposed to be hexa and in base 10 otherwise.
+      # - recursive: tells if should process directories recursively.
+      #   Optional, defaults to 'false'.
+      #
+      # Example:
+      #
+      #   - chmod:
+      #       files: /usr/local/bin/*
+      #       mode:  0755
+      #
+      # Note:
+      #
+      #   This task is not implemented under Windows.
+      def chmod(parameters)
+        params_desc = {
+          :files     => { :mandatory => true,  :type => :string_or_array },
+          :mode      => { :mandatory => true,  :type => :integer },
+          :recursive => { :mandatory => false, :type => :boolean, :default => false }
+        }
+        check_parameters(parameters, params_desc)
+        files = parameters[:files]
+        mode = parameters[:mode]
+        recursive = parameters[:recursive]
+        files = Dir.glob(files)
+        if files.length > 0
+          puts "Changing permissions for #{files.length} file(s) to '#{mode}'"
+          begin
+            if recursive
+              FileUtils.chmod_R(mode, files)
+            else
+              FileUtils.chmod(mode, files)
+            end
+          rescue
+            error "Error changing permissions: #{$!}"
+          end
+        end
+      end
+
+      # Change owner and group for a set of files. Parameters is a Hash with
+      # following entries:
+      #
+      # - files: files to change owner for, as a glob.
+      # - user: the user to change for, may be a name or an ID (integer). If
+      #   not set, the user is not changed.
+      # - group: the group to change for, may be a name or an ID (integer). If
+      #   not set, the group is not changed.
+      # - recursive: tells if should process directories recursively.
+      #   Optional, defaults to 'false'.
+      #
+      # Example:
+      #
+      #   - chown:
+      #       files:     /home/casa
+      #       user:      casa
+      #       group:     staff
+      #       recursive: true
+      #
+      # Note:
+      #
+      #   This task is not implemented under Windows.
+      def chown(parameters)
+        params_desc = {
+          :files     => { :mandatory => true,  :type => :string_or_array },
+          :user      => { :mandatory => false, :type => :string_or_integer },
+          :group     => { :mandatory => false, :type => :string_or_integer },
+          :recursive => { :mandatory => false, :type => :boolean, :default => false }
+        }
+        check_parameters(parameters, params_desc)
+        files = parameters['files']
+        user = parameters['user']
+        group = parameters['group']
+        recursive = parameters['recursive']
+        files = Dir.glob(files)
+        if files.length > 0
+          puts "Changing owner of #{files.length} file(s) to '#{user}/#{group}'"
+          begin
+            if recursive
+              FileUtils.chown_R(user, group, files)
+            else
+              FileUtils.chown(user, group, files)
+            end
+          rescue
+            error "Error changing owner: #{$!}"
+          end
+        end        
+      end
+
+      # Make a directory, and parent directories if necessary. Doesn't
+      # complain if directory already exists. Parameter is directory to
+      # create as a String or a list of directories as an Array of Strings.
       # 
       # Example
       # 
       #  - mkdir: "foo/bar"
-      #  - mkdir: ["foo", "bar"]
       def mkdir(dirs)
-        require 'fileutils'
-        dirs = dirs
         error "mkdir parameter must a String or an array of Strings" unless
-        dirs.kind_of?(String) or dirs.kind_of?(Array)
+          dirs.kind_of?(String) or dirs.kind_of?(Array)
         for dir in dirs
           error "mkdir parameter must a String or an array of Strings" unless
-          dir.kind_of?(String)
-          FileUtils.makedirs(dir)
+            dir.kind_of?(String)
+          puts "Creating directory '#{dir}'"
+          begin
+            FileUtils.makedirs(dir)
+          rescue
+            error "Error creating directory '#{dir}': #{$!}"
+          end
         end
       end
-      
+
       # Copy files or directories to destination file or directory. Parameter 
       # is a Hash with following entries:
       # 
-      # - includes: glob or list of globs for source files or directories to
-      #   include.
-      # - excludes: glob or list of globs for source files or directories to
-      #   exclude.
+      # - src: glob or list of globs for source files or directories to copy.
+      #   Included source directories are copied recursively.
       # - dest: destination file or directory.
       # 
       # Example
       # 
       #  - cp:
-      #      includes: "doc/img/**/*"
-      #      excludes: ["**/*.bmp", "**/*.psd"]
+      #      src:  "img/*"
       #      dest: :doc
       def cp(params)
-        require 'fileutils'
         params_desc = {
-          'includes' => :mandatory,
-          'excludes' => :optional,
-          'dest' => :mandatory
+          :src  => { :mandatory => true, :type => :string_or_array },
+          :dest => { :mandatory => true, :type => :string }
         }
-        check_task_parameters(params, params_desc)
-        includes = params['includes']
-        excludes = params['excludes']
+        check_parameters(params, params_desc)
+        src = params['src']
         dest = params['dest']
-        error "cp 'dest' parameter must a String" unless dest.kind_of?(String)
-        files = select_files(includes, excludes)
-        files = files[0] if files.length == 1
-        FileUtils.cp_r(files, dest)
+        src = Array(src).map { |s| Dir.glob(s) }.flatten.uniq
+        src = src.first if src.length == 1
+        if src.kind_of?(Array)
+          nb_copies = src.length
+        else
+          nb_copies = 1
+        end
+        puts "Copying #{nb_copies} file(s) to '#{dest}'"
+        begin
+          FileUtils.cp_r(src, dest)
+        rescue
+          error "Error copying file(s): #{$!}"
+        end
       end
-      
-      # Move source file(s) or directory(ies) to dest file or directory. 
-      # Parameter is a Hash with following entries:
+
+      # Moves files or directories to destination file or directory. Parameter 
+      # is a Hash with following entries:
       # 
-      # - includes: glob or list of globs for files or directories to move.
-      # - excludes: glob or list of globs for files or directories that should
-      #   not move.
-      # - dest: file or directory to move file(s) to.
+      # - src: glob or list of globs for source files or directories to move.
+      #   Included source directories are moved recursively.
+      # - dest: destination file or directory.
       # 
       # Example
       # 
-      #  - mv: { includes: "**/*~", dest: "trash" }
+      #  - mv:
+      #      src:  "**/*~"
+      #      dest: :trash
       def mv(params)
-        require 'fileutils'
         params_desc = {
-          'includes' => :mandatory,
-          'excludes' => :optional,
-          'dest' => :mandatory
+          :src  => { :mandatory => true, :type => :string_or_array },
+          :dest => { :mandatory => true, :type => :string }
         }
-        check_task_parameters(params, params_desc)
-        includes = params['includes']
-        excludes = params['excludes']
+        check_parameters(params, params_desc)
+        src = params['src']
         dest = params['dest']
-        error "mv 'dest' parameter must a String" unless dest.kind_of?(String)
-        files = select_files(includes, excludes)
-        files = files[0] if files.length == 1
-        FileUtils.mv(files, dest)
+        src = Array(src).map { |s| Dir.glob(s) }.flatten.uniq
+        src = src.first if src.length == 1
+        if src.kind_of?(Array)
+          nb_moves = src.length
+        else
+          nb_moves = 1
+        end
+        puts "Moving #{nb_moves} file(s) to '#{dest}'"
+        begin
+          FileUtils.mv(src, dest)
+        rescue
+          error "Error moving file(s): #{$!}"
+        end
       end
-      
+
+      # Copy filtered files. Parameter is a hash with following entries:
+      #
+      # - root: root directory for files to copy. Optional, defaults to current
+      #   directory.
+      # - includes: list of globs for files to copy. Optional, defaults to 
+      #   '**/*' to include all files recursively.
+      # - excludes: list of globs for files to exclude from copy. Optional,
+      #   default to nil to exclude no file.
+      # - dotmatch: tells if joker matches dot files. Optional, defaults to
+      #   false.
+      # - flatten: tells if included files should be copied in destination
+      #   directory, ignoring their subdirectory. Optional, defaults to false.
+      #
+      # Example:
+      #
+      # To copy all files from directory 'src', except those living in 'CVS'
+      # directories, into directory 'destination', you could write:
+      #
+      #   - copy:
+      #       root:     src
+      #       includes: **/*
+      #       excludes: **/CVS/**/*
+      #       dest:     destination
+      #
+      # Note: this task only deals with files. Thus, 'includes' and 'excludes'
+      # globs should be ones for files.
+      def copy(params)
+        # check parameters and set default values
+        params_desc = {
+          :root     => { :mandatory => false, :type => :string, :default => '.' },
+          :includes => { :mandatory => false, :type => :string_or_array },
+          :excludes => { :mandatory => false, :type => :string_or_array },
+          :dest     => { :mandatory => true,  :type => :string },
+          :flatten  => { :mandatory => false, :type => :boolean, :default => false },
+          :dotmatch => { :mandatory => false, :type => :boolean, :default => false }
+        }
+        check_parameters(params, params_desc)
+        root     = params[:root]
+        includes = params[:includes]
+        excludes = params[:excludes]
+        dest     = params[:dest]
+        flatten  = params[:flatten]
+        dotmatch = params[:dotmatch]
+        error "copy 'root' parameter must be an existing directory" unless
+          File.exists?(root) and File.directory?(root)
+        error "copy 'dest' parameter must be an existing directory" unless
+          File.exists?(dest) and File.directory?(dest)
+        # select files and copy
+        files = filter_files(includes, excludes, root, dotmatch)
+        puts "Copying #{files.length} file(s) to '#{dest}'"
+        for file in files
+          from_file = File.join(root, file)
+          if flatten
+            to_file = File.join(dest, File.basename(file))
+          else
+            to_file = File.join(dest, file)
+          end
+          to_dir    = File.dirname(to_file)
+          FileUtils.makedirs(to_dir) if not File.exists?(to_dir)
+          FileUtils.cp(from_file, to_file)
+        end
+      end
+
+      # Move filtered files. Parameter is a hash with following entries:
+      #
+      # - root: root directory for files to move. Optional, defaults to
+      #   current directory.
+      # - includes: list of globs for files to move. Optional, defaults to 
+      #   '**/*' to include all files recursively.
+      # - excludes: list of globs for files to exclude from move. Optional,
+      #   default to nil to exclude no file.
+      # - flatten: tells if included files should be moved to destination
+      #   directory, ignoring their subdirectory. Optional, defaults to false.
+      # - dotmatch: tells if joker matches dot files. Optional, defaults to
+      #   false.
+      #
+      # Example:
+      #
+      # To move all files from directory 'src', except those living in 'CVS'
+      # directories, into directory 'destination', you could write:
+      #
+      #   - move:
+      #       root:     src
+      #       includes: **/*
+      #       excludes: **/CVS/**/*
+      #       dest:     destination
+      #
+      # Note: this task only deals with files. Thus, 'includes' and 'excludes'
+      # globs should be ones for files and directories from root will not
+      # be affected by this task.
+      def move(params)
+        # check parameters and set default values
+        params_desc = {
+          :root     => { :mandatory => false, :type => :string, :default => '.' },
+          :includes => { :mandatory => false, :type => :string_or_array },
+          :excludes => { :mandatory => false, :type => :string_or_array },
+          :dest     => { :mandatory => true,  :type => :string },
+          :flatten  => { :mandatory => false, :type => :boolean, :default => false },
+          :dotmatch => { :mandatory => false, :type => :boolean, :default => false }
+        }
+        check_parameters(params, params_desc)
+        root     = params[:root]
+        includes = params[:includes]
+        excludes = params[:excludes]
+        dest     = params[:dest]
+        flatten  = params[:flatten]
+        dotmatch = params[:dotmatch]
+        error "move 'root' parameter must be an existing directory" unless
+          File.exists?(root) and File.directory?(root)
+        error "move 'dest' parameter must be an existing directory" unless
+          File.exists?(dest) and File.directory?(dest)
+        # select files and make move
+        files = filter_files(includes, excludes, root, dotmatch)
+        puts "Moving #{files.length} file(s) to '#{dest}'"
+        for file in files
+          from_file = File.join(root, file)
+          if flatten
+            to_file = File.join(dest, File.basename(file))
+          else
+            to_file = File.join(dest, file)
+          end
+          to_dir    = File.dirname(to_file)
+          FileUtils.makedirs(to_dir) if not File.exists?(to_dir)
+          FileUtils.mv(from_file, to_file)
+        end
+      end
+
       # Delete files for a given glob or list of globs. Parameter is a glob or 
-      # list of globs for files to delete.
+      # list of globs for files to delete. This task will raise an error if
+      # told to delete a directory. Use task 'rmrf' to do so.
       # 
       # Example
       # 
-      #  - rm: "**/*.bak"
       #  - rm: ["**/*~", "**/.DS_Store"]
       def rm(globs)
-        require 'fileutils'
-        globs = globs
         error "rm parameter is a String or Array of Strings" unless
           globs.kind_of?(String) or globs.kind_of?(Array)
         for glob in globs
           error "rm parameter is a String or Array of Strings" unless
             glob.kind_of?(String)
           files = Dir.glob(glob)
+          size = (files.kind_of?(Array) ? files.size : 1)
+          puts "Deleting #{size} file(s)" if files.length > 0
           for file in files
-            FileUtils.rm_f(file)
+            begin
+              FileUtils.rm(file)
+            rescue
+              error "Error deleting files: #{$!}"
+            end
           end
         end
       end
-      
-      # Delete directories recursively. Parameter is a string for glob of
-      # directories to delete.
+
+      # Delete files and directories recursively. Parameter is a glob or list
+      # of globs for files and directories to delete.
       # 
       # Example
       # 
-      #  - rmdir: :build
-      def rmdir(globs)
-        require 'fileutils'
-        globs = globs
-        error "rmdir parameter is a String or an Array of Strings" unless
+      #  - rmrf: :build
+      def rmrf(globs)
+        globs = [globs] if globs.kind_of?(String)
+        error "rmrf parameter is a String or an Array of Strings" unless
           globs.kind_of?(String) or globs.kind_of?(Array)
         for glob in globs
-          error "rmdir parameter is a String or an Array of Strings" unless
+          error "rmrf parameter is a String or an Array of Strings" unless
             glob.kind_of?(String)
           dirs = Dir.glob(glob)
+          size = (dirs.kind_of?(Array) ? dirs.size : 1)
+          puts "Deleting #{size} directory(ies)" if dirs.length > 0
           for dir in dirs
-            FileUtils.rm_rf(dir)
+            begin
+              FileUtils.rm_rf(dir)
+            rescue
+              error "Error deleting directory(ies): #{$!}"
+            end
           end
         end
       end
-      
+
+      # Alias for rmrf.
+      alias :rmdir :rmrf
+
+      # Update modification time and access time of files in a list. Files
+      # are created if they don't exist. Parameter is a glob or list of
+      # globs for files to touch.
+      #
+      # Example
+      # 
+      #   - touch: '#{target}/classes/**/*.class'
+      def touch(globs)
+        globs = [globs] if globs.kind_of?(String)
+        error "touch parameter is a String or an Array of Strings" unless
+          globs.kind_of?(String) or globs.kind_of?(Array)
+        files = []
+        for glob in globs
+          error "touch parameter is a String or an Array of Strings" unless
+            glob.kind_of?(String)
+          new_files = Dir.glob(glob)
+          if new_files.length == 0
+            files << glob
+          else
+            files += new_files
+          end
+        end
+        files.uniq!
+        size = (files.kind_of?(Array) ? files.size : 1)
+        puts "Touching #{size} file(s)" if size > 0
+        begin
+          FileUtils.touch(files)
+        rescue
+          error "Error touching file(s): #{$!}"
+        end
+      end
+
       # Find files for a glob or list of globs and store list in a property. 
       # Parameter is a Hash with entries:
       # 
-      # - includes: glob or list of globs for files to look for.
+      # - root: root directory for file search. Defaults to '.' (current
+      #   directory).
+      # - includes: glob or list of globs for files to look for. Defaults to
+      #   '**/*' to include all files recursively.
       # - excludes: glob or list of globs for files to exclude from search.
+      #   Defaults to nil to exclude no file.
+      # - dotmatch: tells if joker matches dot files. Optional, defaults to
+      #   false.
       # - property: name of the property to set.
+      # - join: a character used to join the list in a string. Defaults
+      #   to nil so that list is not joined.
       # 
       # Example
+      #
+      # To find all PNG in files in 'img' directory, and store the list in
+      # property image_files, one could write:
       # 
-      #  - find: { includes: "**/*.rb", property: "rb_files_to_check" }
       #  - find:
-      #      - includes: "doc/img/**/*"
-      #      - excludes: "**/*.psd"
-      #      - property: "image_files"
-      def find(parameters)
+      #      root:     "img"
+      #      includes: "**/*.png"
+      #      property: "image_files"
+      def find(params)
         params_desc = {
-          'includes' => :mandatory,
-          'excludes' => :optional,
-          'property' => :mandatory
+          :root     => { :mandatory => false, :type => :string, :default => '.' },
+          :includes => { :mandatory => false, :type => :string_or_array },
+          :excludes => { :mandatory => false, :type => :string_or_array },
+          :property => { :mandatory => true,  :type => :string },
+          :dotmatch => { :mandatory => false, :type => :boolean, :default => false },
+          :join     => { :mandatory => false, :type => :string }
         }
-        check_task_parameters(parameters, params_desc)
-        includes = parameters['includes']
-        excludes = parameters['excludes']
-        property = parameters['property']
-        files = select_files(includes, excludes)
+        check_parameters(params, params_desc)
+        root     = params[:root]
+        includes = params[:includes]
+        excludes = params[:excludes]
+        property = params[:property]
+        dotmatch = params[:dotmatch]
+        join     = params[:join]
+        files = filter_files(includes, excludes, root, dotmatch)
+        if join
+          files = files.join(join)
+        end
         @build.context.set_property(property, files)
       end
-      
-      # Run a set of tests selected using globs. Parameter is a glob or list of
-      # globs for files or directories to run.
-      # 
+
+      ######################################################################
+      #                        RUBY RELATED TASKS                          #
+      ######################################################################
+    
+      # Tests a required library and prints an error message if import
+      # fails. Parameter is a Hash with entries:
+      #
+      # - library: required library (as in require call).
+      # - message: error message to print if require fails.
+      #
       # Example
+      #
+      #  - required:
+      #      library: foo
+      #      message: >
+      #        Library foo must be installed (gem install foo) to run
+      #        task bar.
+      def required(params)
+        require 'rubygems'
+        require 'rubygems/gem_runner'
+        params_desc = {
+          :library => { :mandatory => true, :type => :string },
+          :message => { :mandatory => true, :type => :string }
+        }
+        check_parameters(params, params_desc)
+        library = params[:library]
+        message = params[:message]
+        if Gem::RubyGemsVersion < '1.3.0'
+          begin
+            Gem::activate(library, false)
+            available = true
+          rescue LoadError
+            available = false
+          end
+        else
+          available = Gem::available?(library)
+        end
+        error message if not available
+      end
+
+      # Run Ruby unit tests listed as a glob or list of globs in a given
+      # directory (that defaults to current one). Parameter is a Hash with
+      # following entries:
       # 
-      #  - test: "**/tc_*.rb"
+      # - root: root directory for files to include. Defaults to current
+      #   directory.
+      # - includes: glob or list of globs for unit test files to run.
+      #   Defaults to '**/*' to include all files recursively.
+      # - excludes: glob or list of globs for unit test files to exclude.
+      #   Defaults to nil to exclude no file.
+      # - dotmatch: tells if joker matches dot files. Optional, defaults to
+      #   false.
+      # - dir: directory where to run unit tests.
       # 
-      # FIXME
+      # Example
       # 
-      # if tasks runs twice, it will run twice loaded tests...
-      def test(globs)
+      #  - find:
+      #      root:     :test
+      #      includes: "**/tc_*.rb"
+      #      dir:      "test"
+      def test(params)
         require 'test/unit'
         require 'test/unit/testresult'
-        files = []
-        globs = globs
-        error "test parameter must be a String or a list of Strings" unless
-          globs.kind_of?(String) or globs.kind_of?(Array)
-        for glob in globs
-          error "Parameter must be a String or a list of Strings" unless
-            glob.kind_of?(String)
-          files += Dir.glob(glob)
-        end
+        params_desc = {
+          :root     => { :mandatory => false, :type => :string },
+          :includes => { :mandatory => true,  :type => :string },
+          :excludes => { :mandatory => false, :type => :string },
+          :dotmatch => { :mandatory => false, :type => :boolean, :default => false },
+          :dir      => { :mandatory => false, :type => :string, :default => '.' }
+        }
+        check_parameters(params, params_desc)
+        root     = params[:root]
+        includes = params[:includes]
+        excludes = params[:excludes]
+        dotmatch = params[:dotmatch]
+        dir      = params[:dir]
+        files = filter_files(includes, excludes, root, dotmatch)
         for file in files
           load file
         end
-        Test::Unit::AutoRunner.run
+        size = (files.kind_of?(Array) ? files.size : 1)
+        puts "Running #{size} unit test(s)"
+        ok = Test::Unit::AutoRunner.run(false, dir)
+        error "Tests failed" if not ok
       end
       
       # Run an ERB file or source in bee context and store result in a file or
@@ -267,34 +807,32 @@ module Bee
       # 
       #  <p>Hello <%= foo %>!</p>
       def erb(params)
-        require 'erb'
-        # check parameters
         params_desc = {
-          'source' => :optional,
-          'src'   => :optional,
-          'dest' => :optional,
-          'property' => :optional
+          :source   => { :mandatory => false, :type => :string },
+          :src      => { :mandatory => false, :type => :string },
+          :dest     => { :mandatory => false, :type => :string },
+          :property => { :mandatory => false, :type => :string }
         }
-        check_task_parameters(params, params_desc)
-        source = params['source']
-        error "erb 'source' parameter must be a String" unless 
-          source.kind_of?(String) or source == nil
-        src = params['src']
-        error "erb 'src' parameter must be a String" unless 
-          src.kind_of?(String) or src == nil
-        dest = params['dest']
-        error "erb 'dest' parameter must be a String" unless
-          dest.kind_of?(String) or dest == nil
-        property = params['property']
-        error "erb 'property' parameter must be a String" unless
-          property.kind_of?(String) or property == nil
+        check_parameters(params, params_desc)
+        source   = params[:source]
+        src      = params[:src]
+        dest     = params[:dest]
+        property = params[:property]
         error "Must pass one of 'source' or 'src' parameters to erb task" if
           not source and not src
         error "Must pass one of 'dest' or 'property' parameters to erb task" if
           not dest and not property
+        error "erb src file '#{src}' not found" if src and
+          (not File.exists?(src) or not File.file?(src) or
+           not File.readable?(src))
         # load ERB source
         erb_source = source||File.read(src)
         template = ERB.new(erb_source)
+        if src
+          puts "Processing ERB '#{src}'"
+        else
+          puts "Processing ERB"
+        end
         begin
           result = template.result(@build.context.context_binding)
         rescue
@@ -302,7 +840,11 @@ module Bee
         end
         # write result in file or set property
         if dest
-          File.open(dest, 'w') { |file| file.write(result) }
+          begin
+            File.open(dest, 'w') { |file| file.write(result) }
+          rescue
+            error "Error writing ERB processing result in file: #{$!}"
+          end
         else
           @build.context.set_property(property, result)
         end
@@ -312,106 +854,226 @@ module Bee
       # exclude and a destination directory. Parameter is a Hash with following
       # entries:
       # 
-      # - includes: glob or list of globs for files to document.
-      # - excludes: glob or list of globs for files that should not be
-      #   documented.
+      # - root: root directory for files to include. Defaults to current
+      #   directory.
+      # - includes: glob or list of globs for files or directories to document.
+      #   Defaults to '**/*' to include all files.
+      # - excludes: glob or list of globs for files or directories that should
+      #   not be documented. Defaults to nil to exclude no file.
+      # - dotmatch: tells if joker matches dot files. Optional, defaults to
+      #   false.
       # - dest: destination directory for generated documentation.
       # - options: additional options as a string or list of strings.
       # 
       # Example
       # 
       #  - rdoc:
-      #      includes: ["README", "LICENSE", :src]
+      #      includes: ["README", "LICENSE", "#{src}/**/*"]
       #      dest: :api
-      def rdoc(parameters)
+      def rdoc(params)
         require 'rdoc/rdoc'
-        params_desc = {
-          'includes' => :mandatory,
-          'excludes' => :optional,
-          'dest' => :mandatory,
-          'options' => :optional
+        params_desc= {
+          :root     => { :mandatory => false, :type => :string },
+          :includes => { :mandatory => true,  :type => :string_or_array },
+          :excludes => { :mandatory => false, :type => :string_or_array },
+          :dotmatch => { :mandatory => false, :type => :boolean, :default => false },
+          :dest     => { :mandatory => true,  :type => :string },
+          :options  => { :mandatory => false, :type => :string_or_array }
         }
-        check_task_parameters(parameters, params_desc)
-        includes = parameters['includes']
-        excludes = parameters['excludes']
-        dest = parameters['dest']
-        options = parameters['options']
-        error "rdoc 'dest' parameter must be a String" unless 
-          dest.kind_of?(String)
-        files = select_files(includes, excludes)
+        check_parameters(params, params_desc)
+        root     = params[:root]
+        includes = params[:includes]
+        excludes = params[:excludes]
+        dotmatch = params[:dotmatch]
+        dest     = params[:dest]
+        options  = params[:options]
+        files = filter_files(includes, excludes, root, dotmatch)
         command_line = ['-S', '-o', dest]
         command_line << options if options
         command_line += files
-        rdoc = RDoc::RDoc.new
-        rdoc.document(command_line)
+        begin
+          rdoc = RDoc::RDoc.new
+          rdoc.document(command_line)
+        rescue
+          error "Error generating RDoc: #{$!}"
+        end
       end
       
-      # Generate a Gem package. Parameter is the name of the Gem description 
-      # file. Resulting Gem package is generated in current directory (as with
-      # command line tool).
+      # Generate a Gem package in current directory, named after the Gem name
+      # and version. Parameter is the name of the Gem description file.
       # 
       # Example
       # 
-      #  - gembuild: :gem_spec
-      def gembuild(description)
+      #  - gem: :gem_spec
+      def gem(description)
         require 'rubygems'
-        description = description
+        require 'rubygems/gem_runner'
+        error "gem parameter must be an existing file" if
+          not description.kind_of?(String) or not File.exists?(description)
         arguments = ['build', description]
-        Gem.manage_gems
-        Gem::GemRunner.new.run(arguments)
+        begin
+          Gem::GemRunner.new.run(arguments)
+        rescue Exception
+          error "Error generating Gem: #{$!}"
+        end
       end
       
+      # Run another bee build file.
+      # 
+      # - file: the build file to run, relative to current build file. 
+      #   Optional, defaults to 'build.yml'.
+      # - target: target or list of targets to run (default target if omitted).
+      # - properties: boolean (true or false) that tells if properties of
+      #   current build file should be sent and overwrite those of target
+      #   build. Properties modified in child build don't change in parent
+      #   one. Defaults to false.
+      # 
+      # Example
+      # 
+      #  - bee:
+      #      file:       "doc/build.yml"
+      #      target:     "pdf"
+      #      properties: true
+      def bee(parameters)
+        # parse parameters
+        params_desc = {
+          :file       => { :mandatory => false, :type => :string, :default => 'build.yml' },
+          :target     => { :mandatory => false, :type => :string_or_array,  :default => '' },
+          :properties => { :mandatory => false, :type => :boolean, :default => false }
+        }
+        check_parameters(parameters, params_desc)
+        file = parameters[:file]
+        target = parameters[:target]
+        properties = parameters[:properties]
+        # run target build
+        props = {}
+        if properties
+          for name in @build.context.properties
+            props[name] = @build.context.get_property(name)
+          end
+        end
+        begin
+          build = Bee::Build.load(file, false, props)
+          build.run(target, @build.listener.clone)
+        rescue
+          error "Error invoking build file '#{file}': #{$!}"
+        end
+      end
+
+      ######################################################################
+      #                            ARCHIVE TASKS                           #
+      ######################################################################
+    
       # Generate a ZIP archive. Parameter is a Hash with following entries:
       # 
+      # - root: root directory for files to include in the archive. Defaults
+      #   to '.' for current directory.
       # - includes: glob or list of globs for files to select for the archive.
+      #   Defaults to '**/*' to include all files recursively.
       # - excludes: glob or list of globs for files to exclude from the archive.
+      #   Defaults to nil to exclude no file.
+      # - dotmatch: tells if joker matches dot files. Optional, defaults to
+      #   false.
       # - dest: the archive file to generate.
       # - prefix: prefix for archive entries (default to nil).
       # 
       # Example
       # 
       #  - zip:
-      #      includes: "**/*"
-      #      excludes: ["build", "build/**/*", "**/*~"]
-      #      dest: :zip_archive
+      #      excludes: ["build/**/*", "**/*~"]
+      #      dest:     :zip_archive
       # 
       # Note
       # 
       # If archive already exists, files are added to the archive.
       def zip(parameters)
         require 'zip/zip'
-        # parse parameters
         params_desc = {
-          'includes' => :mandatory,
-          'excludes' => :optional,
-          'dest' => :mandatory,
-          'prefix' => :optional
+          :root     => { :mandatory => false, :type => :string },
+          :includes => { :mandatory => true,  :type => :string_or_array },
+          :excludes => { :mandatory => false, :type => :string_or_array, :default => nil },
+          :dotmatch => { :mandatory => false, :type => :boolean, :default => false },
+          :dest     => { :mandatory => true,  :type => :string },
+          :prefix   => { :mandatory => false, :type => :string }
         }
-        check_task_parameters(parameters, params_desc)
-        includes = parameters['includes']
-        excludes = parameters['excludes']
-        dest = parameters['dest']
-        error "zip 'dest' parameter must be a String" unless
-          dest.kind_of?(String)
-        prefix = parameters['prefix']
-        error "zip 'prefix' parameter must be a String" unless
-          !prefix or prefix.kind_of?(String)
-        files = select_files(includes, excludes)
+        check_parameters(parameters, params_desc)
+        root     = parameters[:root]
+        includes = parameters[:includes]
+        excludes = parameters[:excludes]
+        dotmatch = parameters[:dotmatch]
+        dest     = parameters[:dest]
+        prefix   = parameters[:prefix]
+        files = filter_files(includes, excludes, root, dotmatch)
         # build the archive
-        zipfile = Zip::ZipFile.open(dest, Zip::ZipFile::CREATE) do |zip|
-          for file in files
-            entry = prefix ? File.join(prefix, file) : file
-            puts "Adding '#{entry}'"
-            zip.add(entry, file)
+        puts "Building ZIP archive '#{dest}'"
+        begin
+          zipfile = Zip::ZipFile.open(dest, Zip::ZipFile::CREATE) do |zip|
+            for file in files
+              path = (root == nil ? file : File.join(root, file))
+              entry = prefix ? File.join(prefix, file) : file
+              puts "Adding '#{entry}'" if @build.listener.verbose
+              zip.add(entry, path)
+            end
+            zip.close
+          end
+        rescue
+          error "Error building ZIP archive: #{$!}"
+        end
+      end
+
+      # Extract ZIP archive to a destination directory. Existing extracted
+      # files are not overwritten and result in an error. Parameter is a Hash
+      # with following entries:
+      #
+      # - src: archive to extract.
+      # - dest: destination directory for extracted files. Optional, defaults
+      #   to current directory.
+      #
+      # Example
+      #
+      #   - unzip:
+      #       src:  myarchive.zip
+      #       dest: mydir
+      def unzip(parameters)
+        require 'zip/zip'
+        params_desc = {
+          :src  => { :mandatory => true,  :type => :string },
+          :dest => { :mandatory => false, :type => :string, :default => '.' }
+        }
+        check_parameters(parameters, params_desc)
+        src  = parameters[:src]
+        dest = parameters[:dest]
+        error "unzip 'src' parameter must be an readable ZIP archive" unless
+          File.exists?(src) and File.readable?(src)
+        FileUtils.makedirs(dest) if not File.exists?(dest)
+        puts "Extracting ZIP file '#{src}' to '#{dest}'"
+        begin
+          Zip::ZipFile.foreach(src) do |entry|
+            puts "Writing '#{entry}'" if @build.listener.verbose
+            tofile = File.join(dest, entry.name)
+            if entry.file?
+              dir = File.dirname(tofile)
+              FileUtils.makedirs(dir) if not File.exists?(dir)
+              entry.extract(tofile)
+            elsif entry.directory?
+              FileUtils.makedirs(tofile)
+            end
           end
-          zip.close
+        rescue
+          error "Error extracting ZIP archive: #{$!}"
         end
       end
       
       # Generate a TAR archive. Parameter is a Hash with following entries:
       # 
+      # - root: root directory for files to include. Defaults to current
+      #   directory.
       # - includes: glob or list of globs for files to select for the archive.
+      #   Defaults to '**/*' to include all files recursively.
       # - excludes: glob or list of globs for files to exclude from the archive.
+      #   Defaults to nil to exclude no file.
+      # - dotmatch: tells if joker matches dot files. Optional, defaults to
+      #   false.
       # - dest: the archive file to generate.
       # 
       # Example
@@ -423,28 +1085,40 @@ module Bee
       # 
       # Note
       # 
-      # If archive already exists, its is overwritten.
+      # If archive already exists, it's overwritten.
       def tar(parameters)
         require 'archive/tar/minitar'
         # parse parameters
         params_desc = {
-          'includes' => :mandatory,
-          'excludes' => :optional,
-          'dest' => :mandatory
+          :root     => { :mandatory => false, :type => :string },
+          :includes => { :mandatory => true,  :type => :string_or_array },
+          :excludes => { :mandatory => false, :type => :string_or_array, :default => nil },
+          :dotmatch => { :mandatory => false, :type => :boolean, :default => false },
+          :dest     => { :mandatory => true,  :type => :string }
         }
-        check_task_parameters(parameters, params_desc)
-        includes = parameters['includes']
-        excludes = parameters['excludes']
-        dest = parameters['dest']
-        error "tar 'dest' parameter must be a String" unless
-          dest.kind_of?(String)
-        files = select_files(includes, excludes)
+        check_parameters(parameters, params_desc)
+        root     = parameters[:root]
+        includes = parameters[:includes]
+        excludes = parameters[:excludes]
+        dotmatch = parameters[:dotmatch]
+        dest     = parameters[:dest]
+        files = filter_files(includes, excludes, root, dotmatch)
         # build the archive
-        Archive::Tar::Minitar::Output.open(dest) do |tarfile|
-          for file in files
-            puts "Adding '#{file}'"
-            Archive::Tar::Minitar.pack_file(file, tarfile)
+        puts "Processing TAR archive '#{dest}'"
+        begin
+          current_dir = Dir.pwd
+          abs_dest = File.expand_path(dest)
+          Dir.chdir(root) if root
+          Archive::Tar::Minitar::Output.open(abs_dest) do |tarfile|
+            for file in files
+              puts "Adding '#{file}'" if @build.listener.verbose
+              Archive::Tar::Minitar.pack_file(file, tarfile)
+            end
           end
+        rescue Exception
+          error "Error generating TAR archive: #{$!}"
+        ensure
+          Dir.chdir(current_dir)
         end
       end
       
@@ -452,7 +1126,8 @@ module Bee
       # following entries:
       # 
       # - src: source file to generate GZIP for.
-      # - dest: GZIP file to generate.
+      # - dest: GZIP file to generate. Defaults to the src file with '.gz'
+      #   extension added.
       # 
       # Example
       # 
@@ -463,61 +1138,173 @@ module Bee
         require 'zlib'
         # parse parameters
         params_desc = {
-          'src' => :mandatory,
-          'dest' => :mandatory
+          :src  => { :mandatory => true,  :type => :string },
+          :dest => { :mandatory => false, :type => :string }
         }
-        check_task_parameters(parameters, params_desc)
-        src = parameters['src']
-        dest = parameters['dest']
+        check_parameters(parameters, params_desc)
+        src  = parameters[:src]
+        dest = parameters[:dest]
+        dest = src + '.gz' if not dest
         # compress file
-        File.open(src) do |input|
-          output = Zlib::GzipWriter.new(File.open(dest, 'wb'))
-          output.write(input.read)
-          output.close
+        puts "Processing GZIP archive '#{dest}'"
+        begin
+          File.open(src) do |input|
+            output = Zlib::GzipWriter.new(File.open(dest, 'wb'))
+            output.write(input.read)
+            output.close
+          end
+        rescue
+          error "Error generating GZIP archive: #{$!}"
+        end
+      end
+
+      # Expand a GZIP archive for a given file. Parameter is a Hash with
+      # following entries:
+      # 
+      # - src: GZIP file to expand.
+      # - dest: destination for expanded file. Destination file can be guessed
+      #   (and thus omitted) for src files '.gz', '.gzip' and '.tgz';
+      #   corresponding dest for latest will be '.tar'.
+      # 
+      # Example
+      # 
+      #  - gunzip:
+      #      src: "dist.tar.gz"
+      #      dest: "dist.tar"
+      def gunzip(parameters)
+        require 'zlib'
+        # parse parameters
+        params_desc = {
+          :src  => { :mandatory => true,  :type => :string },
+          :dest => { :mandatory => false, :type => :string }
+        }
+        check_parameters(parameters, params_desc)
+        src  = parameters[:src]
+        dest = parameters[:dest]
+        error "gunzip 'src' parameter must be an readable GZIP archive" unless
+          File.exists?(src) and File.readable?(src)
+        if not dest
+          if src =~ /.*\.gz$/
+            dest = src[0..-4]
+          elsif src =~ /.*\.gzip$/
+            dest = src[0..-6]
+          elsif src =~ /.*\.tgz/
+            dest = src[0..-5]+'.tar'
+          else
+            error "gunzip can't guess 'dest' parameter from 'src' file name"
+          end
+        end
+        # expand file
+        puts "Expanding GZIP archive '#{dest}'"
+        begin
+          Zlib::GzipReader.open(src) do |input|
+            output = File.open(dest, 'wb')
+            output.write(input.read)
+            output.close
+          end
+        rescue
+          error "Error expanding GZIP archive: #{$!}"
         end
       end
 
       # Generate a TAR.GZ archive. Parameter is a Hash with following entries:
       # 
+      # - root: root directory for files to include. Defaults to current 
+      #   directory.
       # - includes: glob or list of globs for files to select for the archive.
+      #   Defaults to '**/*' to include all files recursively.
       # - excludes: glob or list of globs for files to exclude from the archive.
+      #   Defaults to nil to exclude no file.
+      # - dotmatch: tells if joker matches dot files. Optional, defaults to
+      #   false.
       # - dest: the archive file to generate.
       # 
       # Example
       # 
       #  - targz:
-      #      includes: "**/*"
-      #      excludes: ["build", "build/**/*", "**/*~"]
-      #      dest: :targz_archive
+      #      excludes: ["build/**/*", "**/*~"]
+      #      dest:     :targz_archive
       # 
       # Note
       # 
-      # If archive already exists, its is overwritten.
+      # If archive already exists, it's overwritten.
       def targz(parameters)
         require 'archive/tar/minitar'
         require 'zlib'
         # parse parameters
         params_desc = {
-          'includes' => :mandatory,
-          'excludes' => :optional,
-          'dest' => :mandatory
+          :root     => { :mandatory => false, :type => :string },
+          :includes => { :mandatory => true,  :type => :string_or_array },
+          :excludes => { :mandatory => false, :type => :string_or_array, :default => nil },
+          :dotmatch => { :mandatory => false, :type => :boolean, :default => false },
+          :dest     => { :mandatory => true,  :type => :string }
         }
-        check_task_parameters(parameters, params_desc)
-        includes = parameters['includes']
-        excludes = parameters['excludes']
-        dest = parameters['dest']
-        error "targz 'dest' parameter must be a String" unless
-          dest.kind_of?(String)
-        files = select_files(includes, excludes)
+        check_parameters(parameters, params_desc)
+        root     = parameters[:root]
+        includes = parameters[:includes]
+        excludes = parameters[:excludes]
+        dotmatch = parameters[:dotmatch]
+        dest     = parameters[:dest]
+        files = filter_files(includes, excludes, root, dotmatch)
         # build the archive
-        Archive::Tar::Minitar::Output.open(Zlib::GzipWriter.new(File.open(dest, 'wb'))) do |tgz|
-          for file in files
-            puts "Adding '#{file}'"
-            Archive::Tar::Minitar.pack_file(file, tgz)
+        begin
+          current_dir = Dir.pwd
+          abs_dest = File.expand_path(dest)
+          Dir.chdir(root) if root
+          Archive::Tar::Minitar::Output.
+            open(Zlib::GzipWriter.new(File.open(abs_dest, 'wb'))) do |tgz|
+            for file in files
+              puts "Adding '#{file}'" if @build.listener.verbose
+              Archive::Tar::Minitar.pack_file(file, tgz)
+            end
           end
+        rescue
+          error "Error generating TARGZ archive: #{$!}"
+        ensure
+          Dir.chdir(current_dir)
         end
       end
 
+      # Extract TAR archive to a destination directory. Gziped archives are
+      # managed if their extension is '.tgz' or '.tar.gz'. Extracted files 
+      # are overwritten if they already exist. Parameter is a Hash with
+      # following entries:
+      #
+      # - src: archive to extract.
+      # - dest: destination directory for extracted files. Optional, defaults
+      #   to current directory.
+      #
+      # Example
+      #
+      #   - untar:
+      #       src:  myarchive.tar.gz
+      #       dest: mydir
+      def untar(parameters)
+        require 'archive/tar/minitar'
+        require 'zlib'
+        params_desc = {
+          :src  => { :mandatory => true,  :type => :string },
+          :dest => { :mandatory => false, :type => :string, :default => '.' }
+        }
+        check_parameters(parameters, params_desc)
+        src  = parameters[:src]
+        dest = parameters[:dest]
+        error "untar 'src' parameter must be an readable TAR archive" unless
+          File.exists?(src) and File.readable?(src)
+        FileUtils.makedirs(dest) if not File.exists?(dest)
+        puts "Extracting TAR file '#{src}' to '#{dest}'"
+        begin
+          if src =~ /\.tar\.gz$/ or src =~ /\.tgz$/
+            tgz = Zlib::GzipReader.new(File.open(src, 'rb'))
+            Archive::Tar::Minitar.unpack(tgz, dest)
+          else
+            Archive::Tar::Minitar.unpack(src, dest)
+          end
+        rescue
+          error "Error extracting TAR archive: #{$!}"
+        end
+      end
+      
     end
 
   end