Bee C0 Coverage Information - RCov

 require 'rubygems'

 require 'bee_util'

 module Bee

   class Target

     include Bee::Util::BuildErrorMixin

     include Bee::Util::HashCheckerMixin

     KEY = 'target'

     DESCRIPTION = {

     attr_accessor :targets

     attr_reader :name

     attr_accessor :depends

     attr_accessor :description

     attr_reader :script

     def initialize(object, targets)

       check_hash(object, Target::DESCRIPTION)

       @targets = targets

       @name = object[Target::KEY]

       error "Target name cannot be 'null'" if @name == nil

       @depends = Array(object['depends']||[])

       @description = object['description']

       @script = Array(object['script']||[])

     def run(dry=false)

       current_dir = Dir.pwd

       begin

         for depend in @depends

           @targets.run_target(depend, dry)

         @targets.build.listener.target(self) if 

           @targets.build.listener and @targets.is_last(self)

         run_block(@script, dry)

         Dir.chdir(current_dir)

     private

     def run_task(task, dry=false)

       @targets.build.listener.task(task) if @targets.build.listener

       case task

       when String

         run_shell(task, dry)

       when Hash

         if task.keys.length > 1

           run_construct(task, dry)

           if task.key?('rb')

             script = task['rb']

             run_ruby(script, dry)

           elsif task.key?('sh')

             script = task['sh']

             run_shell(script, dry)

           elsif task.key?('super')

             targets.call_super(self, dry)

             run_bee_task(task, dry)

         raise "Task must be a string or a hash"

     def run_shell(script, dry=false)

       @listener.task(script) if @listener

       return if dry

       evaluated_script = @targets.build.context.evaluate_object(script)

       if evaluated_script != ''

         system(evaluated_script)

         error "Script exited with value #{$?}" if $? != 0

     def run_ruby(script, dry=false)

       @listener.task(script) if @listener

       return if dry

       begin

         @targets.build.context.evaluate_script(script)

         raise $!

         error "Error running Ruby script: #{$!}"

     def run_bee_task(task, dry=false)

       @listener.task(task) if @listener

       return if dry

       @targets.build.package_manager.run_task(task)

     def run_construct(construct, dry=false)

       @listener.task(construct) if @listener

       return if dry

       if construct.keys.include?('if')

         construct_if(construct, dry)

       elsif construct.keys.include?('while')

         construct_while(construct, dry)

       elsif construct.keys.include?('for')

         construct_for(construct, dry)

       elsif construct.keys.include?('try')

         construct_try(construct, dry)

         error "Unknown construct '#{construct.keys.join('-')}'"

     def construct_if(task, dry)

       error "If-then-else construct must include 'then' entry" if

         not task.keys.include?('then')

       unknown_keys = task.keys - ['if', 'then', 'else']

       error "If-then-else construct may only include 'if', 'then' and 'else' entries" if

         unknown_keys.length > 0

       error "If entry in if-then-else construct must be a string, a symbol or a boolean" if

         not task['if'].kind_of?(Symbol) and

         not (task['if'].kind_of?(TrueClass) or task['if'].kind_of?(FalseClass))

       error "Then entry in if-then-else construct must be a list" if

         not task['then'].kind_of?(Array)

       error "Else entry in if-then-else construct must be a list" if

         task['else'] and not task['else'].kind_of?(Array)

       if evaluate(task['if'])

         run_block(task['then'], dry)

         run_block(task['else'], dry) if task['else']

     def construct_while(task, dry)

       error "While-do construct must include 'do' entry" if

         not task.keys.include?('do')

       unknown_keys = task.keys - ['while', 'do']

       error "While-do construct may only include 'while' and 'do' entries" if

         unknown_keys.length > 0

       error "While entry in while-do construct must be a string" if

         not task['while'].kind_of?(String)

       error "Do entry in while-do construct must be a list" if

         not task['do'].kind_of?(Array)

       while evaluate(task['while'])

         run_block(task['do'], dry)

     def construct_for(task, dry)

       error "For-in-do construct must include 'in' and 'do' entries" if

         not task.keys.include?('do')

       unknown_keys = task.keys - ['for', 'in', 'do']

       error "For-in-do construct may only include 'for', 'in' and 'do' entries" if

         unknown_keys.length > 0

       error "For entry in for-in-do construct must be a string" if

         not task['for'].kind_of?(String)

       error "In entry in for-in-do construct must be a list, a string or a symbol" if

         not task['in'].kind_of?(String) and

       error "Do entry in for-in-do construct must be a list" if

         not task['do'].kind_of?(Array)

       if task['in'].kind_of?(String) or task['in'].kind_of?(Symbol)

         enumerable = evaluate(task['in'])

         error "In entry in for-in-do construct must result in an enumerable" if

           not enumerable.kind_of?(Enumerable)

         enumerable = task['in']

       for element in enumerable

         begin

           @targets.build.context.set_property(task['for'], element)

           error "Error setting property '#{task['for']}'"

         run_block(task['do'], dry)

     def construct_try(task, dry)

       error "Try-catch construct must include 'catch' entry" if

         not task.keys.include?('catch')

       unknown_keys = task.keys - ['try', 'catch']

       error "Try-catch construct may only include 'try' and 'catch' entries" if

         unknown_keys.length > 0

       error "Try entry in try-catch construct must be a list" if

         not task['try'].kind_of?(Array)

       error "Catch entry in try-catch construct must be a list" if

         task['catch'] and not task['catch'].kind_of?(Array)

       begin

         run_block(task['try'], dry)

         @targets.build.listener.recover if @targets.build.listener

         run_block(task['catch'], dry) if task['catch']

     def run_block(block, dry)

       for task in block

         run_task(task, dry)

     def evaluate(expression)

       begin

         if expression.kind_of?(String)

           return @targets.build.context.evaluate_script(expression)

         elsif (expression.kind_of?(TrueClass) or expression.kind_of?(FalseClass))

           return expression

           return @targets.build.context.evaluate_object(expression)

         error "Error evaluating expression: #{$!}"