Bee C0 Coverage Information - RCov

 require 'rubygems'

 require 'bee_build'

 require 'bee_util'

 require 'bee_listener'

 require 'bee_console_formatter'

 require 'getoptlong'

 require 'syck'

 require 'yaml'

 module Bee

   module Console

     HELP = <<'EOF'

     OPTIONS = [

     DEFAULT_BUILD_FILE = 'build.yml'

     EXIT_PARSING_CMDLINE = 1

     EXIT_BUILD_ERROR = 2

     EXIT_UNKNOWN_ERROR = 3

     EXIT_INTERRUPT_ERROR = 4

     BEE_OPT_ENV = 'BEEOPT'

     BEE_LOGO = <<"EOF"

        |_.__/ \\___|\\___|  #{Bee.version.ljust(8)}                     http://bee.rubyforge.org

     def self.parse_command_line(arguments)

       arguments = arguments.clone

       version = false

       help = false

       help_build = false

       help_task = false

       help_template = false

       properties = {}

       task = nil

       dry_run = false

       template = nil

       verbose = false

       style = nil

       color = false

       file = DEFAULT_BUILD_FILE

       recursive = false

       logo = false

       resource = nil

       print_targets = false

       print_options = false

       print_tasks = false

       print_templates = false

       targets = []

       options = ENV[BEE_OPT_ENV]

       options.split(' ').reverse.each { |option| arguments.unshift(option) } if

         options

       old_argv = ARGV

       ARGV.replace(arguments)

       opts = GetoptLong.new(*OPTIONS)

       opts.each do |opt, arg|

         case opt

         when '--version'

           version = true

         when '--help'

           help = true

         when '--help-build'

           help_build = true

         when '--help-task'

           help_task = true

           task = arg

         when '--help-template'

           help_template = true

           template = arg

         when '--dry-run'

           dry_run = true

           verbose = true

         when '--property'

           name, value = parse_property(arg)

           properties[name] = value

         when '--template'

           template = arg

         when '--verbose'

           verbose = true

         when '--style'

           style = arg

         when '--color'

           color = true

         when '--black-and-white'

           color = false

         when '--file'

           file = arg

         when '--recursive'

           recursive = true

         when '--logo'

           logo = true

         when '--resource'

           resource = arg

         when '--targets'

           print_targets = true

         when '--options'

           print_options = true

         when '--tasks'

           print_tasks = true

         when '--templates'

           print_templates = true

       targets = Array.new(ARGV)

       ARGV.replace(old_argv)

              print_tasks, print_templates, targets

     def self.parse_property(property)

       begin

         index = property.index('=')

         raise "No = sign (should be 'name=value')" if not index

         name = property[0..index-1]

         value = YAML::load(property[index+1..-1])

         return name, value

         raise "Error parsing property '#{property}': #{$!}"

     def self.start_command_line(arguments)

       STDOUT.sync = true

       begin

           print_tasks, print_templates, targets = parse_command_line(arguments)

         puts "ERROR: parsing command line: #{$!}"

         exit(EXIT_PARSING_CMDLINE)

       begin

         formatter = Formatter.new(style, color, verbose)

         puts "ERROR: bad format string '#{style}'"

         exit(EXIT_PARSING_CMDLINE)

       begin

         puts BEE_LOGO if logo

         if version

           puts Bee.version

         elsif help

           puts HELP

         elsif help_build

           build = Build.load(file, recursive, properties)

           puts formatter.help_build(build)

         elsif help_task

           puts formatter.help_task(task)

         elsif help_template

           puts formatter.help_template(template)

         elsif template

           file = Bee::Util::find_template(template)

           listener = Bee::Listener.new(formatter)

           build = Build.load(file, false, properties)

           build.run(targets, listener, dry_run)

         elsif resource

         elsif print_targets

           begin

             build = Build.load(file)

             targets = build.targets.hash.keys

             targets += build.targets.alias.keys if build.targets.alias

             targets = []

           print targets.sort.join(' ')

         elsif print_options

           print OPTIONS.map {|o| o[0]}.sort.join(' ')

         elsif print_tasks

           print Bee::Task::PackageManager.list_tasks.join(' ')

         elsif print_templates

           print Bee::Task::PackageManager.list_templates.join(' ')

           listener = Listener.new(formatter)

           build = Build.load(file, recursive, properties)

           build.run(targets, listener, dry_run)

           puts formatter.format_success('OK')

         puts formatter.format_error_message($!)

         exit(EXIT_BUILD_ERROR)

         puts "\n#{formatter.format_error('ERROR')}: Build was interrupted!"

         puts $!.backtrace.join("\n") if verbose

         exit(EXIT_INTERRUPT_ERROR)

         puts "#{formatter.format_error('ERROR')}: #{$!}"

         puts $!.backtrace.join("\n")

         exit(EXIT_UNKNOWN_ERROR)