Bee C0 Coverage Information - RCov

 require 'rubygems'

 require 'bee_console_style'

 require 'syck'

 require 'yaml'

 module Bee

   module Console

     class Formatter

       include Bee::Util::BuildErrorMixin

       AUTO_DURATION = 60

       CONSTRUCT_FORMATS = {

       attr_reader :verbose

       def initialize(style, color=false, verbose=false, outputer=Kernel)

         @style = Bee::Console::Style.new(style, color)

         @verbose = verbose

         @outputer = outputer

       def print(message)

         @outputer.print(message)

       def puts(message)

         @outputer.puts(message)

       def print_build_started(build, dry_run)

         if @verbose

           build_type = dry_run ? "dry run of" : "build"

           puts "Starting #{build_type} '#{build.file}'..."

       def print_build_finished(duration)

         puts "Built in #{duration} s" if @verbose or duration >= AUTO_DURATION

       def print_target(target)

         puts format_target(target)

       def print_task(task)

         puts format_task(task) if @verbose

       def format_target(target)

         name = target.name

         return format_title(name)

       def format_task(task)

         if task.kind_of?(String)

           source = task

         elsif task.kind_of?(Hash)

           if task.key?('rb')

             source = "rb: #{task['rb']}"

             if task.keys.length == 1

               source = format_entry(task)

               source = format_construct(task)

         formatted = '- ' + source.strip.gsub(/\n/, "\n. ")

         styled = @style.style(formatted, :task)

         return styled

       def format_success(string)

         string = @style.style(string, :success)

         return string

       def format_error(string)

         string = @style.style(string, :error)

         return string

       def format_error_message(exception)

         message = format_error('ERROR')

         message << ": "

         message << exception.to_s

         if exception.kind_of?(Bee::Util::BuildError)

           message << "\nIn target '#{exception.target.name}'" if exception.target

           message << ", in task:\n#{format_task(exception.task)}" if exception.task

         return message

       def format_description(title, text=nil, indent=0, bullet=true)

         string = ' '*indent

         string << '- ' if bullet

         string << title

         if text and !text.empty?

           string << ": "

           if text.split("\n").length > 1

             string << "\n"

             text.split("\n").each do |line|

               string << ' '*(indent+2) + line.strip + "\n"

             string << text.strip + "\n"

           string << "\n"

         return string

       def format_title(title)

         length = @style.line_length || Bee::Util::term_width

         right = ' ' + @style.line_character*2

         size = length - (title.length + 4)

         size = 2 if size <= 0

         left = @style.line_character*size + ' '

         line = left + title + right

         formatted = @style.style(line, :target)

         return formatted

       def help_build(build)

         build.context.evaluate

         help = ''

         if build.name

           help << "build: #{build.name}\n"

         if build.extends

           help << "extends: #{format_list(build.extends.map{|b| b.name})}\n"

         if build.description

           help << format_description('description', build.description, 0, false)

         if build.context.properties.length > 0

           help << "properties:\n"

           for property in build.context.properties.sort

               "#{format_property_value(build.context.get_property(property))}\n"

         description = build.targets.description

         if description.length > 0

           help << "targets:\n"

           for name in description.keys.sort

             help << format_description(name, description[name], 0)

           build.targets.default

         if build.targets.alias and build.targets.alias.keys.length > 0

         return help.strip

       def help_task(task)

         task = '?' if task == nil or task.length == 0

         package_manager = Bee::Task::PackageManager.new(nil)

         methods = package_manager.help_task(task)

         help = ''

         for method in methods.keys.sort

           text = methods[method].strip

           help << format_title(method)

           help << "\n"

           help << text

           help << "\n"

           if text =~ /Alias for \w+/

             alias_method = text.scan(/Alias for (\w+)/).flatten[0]

             help << "\n"

             help << package_manager.help_task(alias_method)[alias_method].strip

             help << "\n"

         return help

       def help_template(template)

         templates = Bee::Util::search_templates(template)

         help = ''

         for name in templates.keys

           build = YAML::load(File.read(templates[name]))

           properties = nil

           for entry in build

             properties = entry['properties'] if entry['properties']

           description = 'No description found'

           if properties

             if properties['description']

               description = properties['description']

           help << format_title(name)

           help << "\n"

           help << description

           help << "\n"

         return help

       private

       def format_entry(entry)

         return YAML::dump(entry).sub(/---/, '').strip

       def format_construct(construct)

         for key in CONSTRUCT_FORMATS.keys

           if construct.has_key?(key)

             lines = []

             for entry in CONSTRUCT_FORMATS[key]

               lines << format_entry({entry => construct[entry]})

             return lines.join("\n")

         return "UNKNOWN CONSTRUCT"

       def format_property_value(data)

         if data.kind_of?(Hash)

           return data.inspect

       def format_list(list)

         if list.kind_of?(Array)

           if list.length > 1

             return list[0]