Bee C0 Coverage Information - RCov

 require 'rubygems'

 require 'bee_build'

 require 'bee_util'

 module Bee

   module Task

     class Package < Bee::Util::MethodInfoBase

       include Bee::Util::BuildErrorMixin

       attr_reader :verbose

       def initialize(build)

         @build = build

         if @build and @build.listener

           @verbose = @build.listener.formatter.verbose

           @verbose = false

       protected

       def check_parameters(params, description)

         task = caller[0].match(/`(.*)'/)[1]

         error "'#{task}' parameters must be a hash" unless params.kind_of?(Hash)

         for param in description.keys

           error "#{task} '#{param}' parameter is mandatory" unless

             params[param.to_s] or description[param][:mandatory] == false

           if params[param.to_s] != nil

             case description[param][:type]

             when :string

               error "#{task} '#{param}' parameter must be a string" unless

                 params[param.to_s].kind_of?(String)

             when :integer

               error "#{task} '#{param}' parameter must be an integer" unless

                 params[param.to_s].kind_of?(Integer)

             when :float

               error "#{task} '#{param}' parameter must be a float" unless

                 params[param.to_s].kind_of?(Float)

             when :number

               error "#{task} '#{param}' parameter must be a number" unless

                 params[param.to_s].kind_of?(Numeric)

             when :boolean

               error "#{task} '#{param}' parameter must be a boolean" unless

                 params[param.to_s] == true or params[param.to_s] == false

             when :array

               error "#{task} '#{param}' parameter must be an array" unless

                 params[param.to_s].kind_of?(Array)

             when :string_or_array

               error "#{task} '#{param}' parameter must be a string or an array" unless

                 params[param.to_s].kind_of?(String) or params[param.to_s].kind_of?(Array)

               params[param.to_s] = Array(params[param.to_s])

             when :string_or_integer

               error "#{task} '#{param}' parameter must be a string or an integer" unless

                 params[param.to_s].kind_of?(String) or params[param.to_s].kind_of?(Integer)

             when :hash

               error "#{task} '#{param}' parameter must be a hash" unless

                 params[param.to_s].kind_of?(Hash)

             when :hash_or_array

               error "#{task} '#{param}' parameter must be a hash or list of hashes" unless

                 params[param.to_s].kind_of?(Hash) or params[param.to_s].kind_of?(Array)

               if params[param.to_s].kind_of?(Hash)

                 params[param.to_s] = [params[param.to_s]]

               elsif !params[param.to_s].kind_of?(Array)

               error "Unknown parameter type '#{description[param][:type]}'"

             params[param.to_sym] = params[param.to_s]

             if description[param][:default]

               params[param.to_sym] = description[param][:default]

               params[param.to_s] = description[param][:default]

         for param in params.keys

           error "Unknown parameter '#{param}'" if 

             not (description.key?(param) or description.key?(param.to_sym))

       def filter_files(root, includes, excludes, dotmatch=true)

         error "includes must be a glob or a list of globs" unless

           !includes or includes.kind_of?(String) or includes.kind_of?(Array)

         error "excludes must be a glob or a list of globs" unless

           !excludes or excludes.kind_of?(String) or excludes.kind_of?(Array)

         error "root must be an existing directory" unless

           !root or File.exists?(root)

         current_dir = Dir.pwd

         begin

           if dotmatch

             options = File::FNM_PATHNAME | File::FNM_DOTMATCH

             options = File::FNM_PATHNAME

           Dir.chdir(root) if root

           included = []

           includes = '**/*' if not includes

           includes = Array(includes)

           for include in includes

             error "includes must be a glob or a list of globs" unless

               include.kind_of?(String)

             entries = Dir.glob(include, options)

             included += entries if entries

           included.uniq!

           if excludes

             included.reject! do |file|

               rejected = false

               for exclude in excludes

                 if File.fnmatch?(exclude, file, options)

                   rejected = true

                   break

               rejected

           included.reject! { |file| File.directory?(file) }

           return included

           Dir.chdir(current_dir)

       def copy_files(root, files, dest, flatten)

         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))

             to_file = File.join(dest, file)

           to_dir    = File.dirname(to_file)

           FileUtils.makedirs(to_dir) if not File.exists?(to_dir)

           FileUtils.cp(from_file, to_file)

       def print(text)

         if @build and @build.listener

           @build.listener.formatter.print(text)

           Kernel.print(text)

       def puts(text)

         if @build and @build.listener

           @build.listener.formatter.puts(text)

           Kernel.puts(text)