Bee C0 Coverage Information - RCov

 require 'rubygems'

 require 'syck'

 require 'yaml'

 require 'bee_util'

 require 'bee_context'

 require 'bee_properties'

 require 'bee_target'

 require 'bee_targets'

 require 'bee_task_packagemanager'

 module Bee

   class Build

     include Bee::Util::BuildErrorMixin

     include Bee::Util::HashCheckerMixin

     KEY = 'build'

     DESCRIPTION = {

     attr_reader :file

     attr_reader :base

     attr_reader :here

     attr_reader :name

     attr_reader :extends

     attr_reader :abstract

     attr_reader :description

     attr_reader :properties

     attr_reader :targets

     attr_reader :context

     attr_reader :package_manager

     attr_reader :listener

     def self.load(file, recursive=nil, properties={})

       raise "Can't use recursive URL" if recursive and Bee::Util::url?(file)

       if recursive

         begin

           file = Bee::Util::find(file)

                                           "not found recursively")

       begin

         yaml = Bee::Util::get_file(file)

         object = YAML::load(yaml)

            new("Error loading build file '#{file}': #{$!}")

       return Build.new(object, file, properties)

     def initialize(object, file, properties={}, here=Dir.pwd)

       @file = file

       @base = get_base(@file)

       @here = here

       @properties = Bee::Properties.new

       @scripts = []

       @targets = Targets.new(self)

       parse(object)

       @properties.overwrite(properties)

       @properties.defaults({:base => @base, :here => @here})

       @context = Context.new(@properties.expressions, @scripts)

       @package_manager = Bee::Task::PackageManager.new(self)

     def run(targets, listener=nil, dry=false)

       @listener = listener

       working_directory = Dir.getwd

       @listener.start(self, dry) if @listener

       begin

         error "Abstract build file, must be extended to run" if @abstract

         if not Bee::Util::url?(@base)

           Dir.chdir(@base)

         @context.evaluate

         @targets.run(targets, dry)

         @listener.success() if @listener

         @listener.error($!) if @listener

         raise $!

         @listener.stop() if @listener

         Dir.chdir(working_directory)

         remove_instance_variable(:@listener)

     private

     def parse(object)

       error "Build must be a list" unless object.kind_of?(Array)

       first = true

       for entry in object

         if entry.key?(Build::KEY)

           parse_build(entry)

           error "Build info entry must be first one in build file" if not first

           first = false

         elsif entry.key?(Properties::KEY)

           properties = entry[Properties::KEY]

           if properties.kind_of?(String)

             filename = properties

             begin

               properties = YAML::load(Bee::Util::get_file(filename, @base))

               @properties.write(properties)

               error "Error loading properties file '#{filename}': #{$!}"

             @properties.write(properties)

           first = false

         elsif entry.key?(Target::KEY)

           @targets.add(entry)

           first = false

           error "Unknown entry:\n#{YAML::dump(entry)}"

       if @extends

         for parent in @extends

           @properties.extend(parent.properties.expressions)

           @targets.extend(parent.targets)

     def parse_build(entry)

       begin

         check_hash(entry, Build::DESCRIPTION)

         error "Error parsing build info entry: #{$!}"

       error "Duplicate build info" if @name

       @name = entry['build']

       error "'default' entry of the 'build' block must be a string or an array" if

                               !entry['default'].kind_of?(Array))

       if entry['default']

         @targets.default = Array(entry['default'])

         @targets.default_set = true

         entry['alias'] and !entry['alias'].kind_of?(Hash)

       if entry['alias']

         @targets.alias_set = []

       @description = entry['description']

       @abstract = entry['abstract']

       parents = Array(entry['extends'])

       if parents.length > 0

         @extends = []

         for extended in parents

           absolute_path = Bee::Util::absolute_path(extended, @base)

           begin

             @extends << Bee::Build::load(absolute_path)

             error "Error loading parent build file '#{extended}': #{$!}"

       if @extends

         properties = []

         collisions = []

         for parent in @extends

           parent_properties = parent.properties.expressions.keys

           collisions += properties & parent_properties

           properties += parent_properties

         collisions = collisions - Bee::Properties::SYSTEM_PROPERTIES

         collisions = collisions.uniq.map { |e| e.to_s }.sort

         if collisions.length > 0

           error "Properties in parents are colliding: #{collisions.join(', ')}"

         targets = []

         collisions = []

         for parent in @extends

           parent_targets = parent.targets.hash.keys

           collisions += targets & parent_targets

           targets += parent_targets

         collisions = collisions.uniq.map { |e| e.to_s }.sort

         if collisions.length > 0

           error "Targets in parents are colliding: #{collisions.join(', ')}"

       context = entry['context']

       @scripts = Array(context) if context

     def get_base(file)

       if file

         if Bee::Util::url?(file)

           return File.dirname(file)

           return File.expand_path(File.dirname(file))

         return File.expand_path(Dir.pwd)

   def version

     begin

       require 'bee_version'

       return Bee::VERSION

       return 'UNKNOWN'

   module_function :version