Bee C0 Coverage Information - RCov

 require 'rubygems'

 require 'net/http'

 require 'bee_version_dependant'

 module Bee

   module Util

     HTTP_REDIRECTIONS_LIMIT = 10

     DEFAULT_PACKAGE = 'default'    

     COMPACT_PATTERN  = /^:(.*?):(.*?)(\[(.*)\])?$/

     EXPANDED_PATTERN = /^ruby:\/\/(.*?)(:(.*?))?\/(.*)$/

     DEFAULT_TERM_WIDTH = (RUBY_PLATFORM =~ /win32/ ? 79 : 80)

     def self.term_width

       begin

         tiocgwinsz = RUBY_PLATFORM =~ /darwin/ ? 0x40087468 : 0x5413

         string = [0, 0, 0, 0].pack('SSSS')

         if $stdin.ioctl(tiocgwinsz, string) >= 0 then

           rows, cols, xpixels, ypixels = string.unpack('SSSS')

           cols = DEFAULT_TERM_WIDTH if cols <= 0

           return cols

           return DEFAULT_TERM_WIDTH

         return DEFAULT_TERM_WIDTH

     def self.windows?

       return RUBY_PLATFORM =~ /(mswin|ming)/

     def self.get_package_name(packaged)

       if packaged =~ /\./

         package, name = packaged.split('.')

         package, name = DEFAULT_PACKAGE, packaged

       return package, name

     def self.get_file(location, base=nil)

       base = base || Dir.pwd

       abs = absolute_path(location, base)

       if abs =~ /^http:/

         return File.read(abs)

     private

     def self.find(file)

       return file if File.exists?(file)

       raise "File not found" if File.identical?(File.dirname(file), '/')

       file = File.join('..', file)

       find(file)

     def self.url?(location)

       return false if not location.kind_of?(String)

       return location =~ /^http:\/\//

     def self.resource?(location)

       return false if not location.kind_of?(String)

       return location =~ /^ruby:\/\// || location =~ /^:/

     def self.absolute_path?(path)

       if url?(path) or resource?(path)

         return true

         if windows?

           return path =~ /^\//

     def self.absolute_path(path, base=nil)

       path = File.expand_path(path) if path =~ /~.*/

       if absolute_path?(path)

         if resource?(path)

           path = resource_path(path)

         return path

         base = Dir.pwd if not base

         return File.join(base, path)

     def self.fetch(url, limit=HTTP_REDIRECTIONS_LIMIT,

                    username=nil, password=nil)

       raise 'HTTP redirect too deep' if limit == 0

       response = Net::HTTP.get_response(URI.parse(url))

     def self.resource_path(resource)

       case resource

       when COMPACT_PATTERN

         gem, version, path = $1, $4, $2

         gem = "bee_#{gem}" if gem != 'bee'

       when EXPANDED_PATTERN

         gem, version, path = $1, $3, $4

         raise "'#{resource}' is not a valid resource"

       if version

         if Gem::Specification.respond_to?(:find_by_name)

           begin

             gem_descriptor = Gem::Specification.find_by_name(gem, version)

             gem_descriptor = nil

         raise "Gem '#{gem}' was not found in version '#{version}'" if

           not gem_descriptor

         if Gem::Specification.respond_to?(:find_by_name)

           begin

             gem_descriptor = Gem::Specification::find_by_name(gem)

             gem_descriptor = nil

         raise "Gem '#{gem}' was not found" if not gem_descriptor

       gem_path = gem_descriptor.full_gem_path

       file_path = File.join(gem_path, path)

       return file_path

     def self.find_template(template)

       raise Bee::Util::BuildError.new("Invalid template name '#{template}'") if

         not template =~ /^([^.]+\.)?[^.]+$/

       package, egg = template.split('.')

       if not egg

         egg = package

         package = 'bee'

       resource = ":#{package}:egg/#{egg}.yml"

       begin

         file = absolute_path(resource, Dir.pwd)

         raise BuildError.new("Template '#{template}' not found")

       raise BuildError.new("Template '#{template}' not found") if

         not File.exists?(file)

       return file

     def self.search_templates(template)

         new("Invalid template name '#{template}'") if

           not template =~ /^([^.]+\.)?[^.]+$/

       package, egg = template.split('.')

       if not egg

         egg = package

         package = 'bee'

       egg = '*' if egg == '?'

       resource = ":#{package}:egg/#{egg}.yml"

       begin

         glob = absolute_path(resource, nil)

         if egg == '*'

           raise BuildError.new("Template package '#{package}' not found")

           raise BuildError.new("Template '#{template}' not found")

       files = Dir.glob(glob)

       hash = {}

       for file in files

         egg = file.match(/.*?([^\/]+)\.yml/)[1]

         name = "#{package}.#{egg}"

         hash[name] = file

       return hash

     def self.gem_available?(gem)

       return Bee::VersionDependant::gem_available?(gem)

     def self.find_gems(*patterns)

       return Bee::VersionDependant::find_gems(*patterns)

     class MethodInfo

       attr_accessor :source, :comment, :defn, :params

       def initialize(file, lineno)

         lines = file_cache(file)

         @source = match_tabs(lines, lineno, "def")

         @comment = preceding_comment(lines, lineno)

         @defn = lines[lineno].strip.gsub(/^def\W+(.*)/){$1}

         if @defn =~ /.*?\(.*?\)/

           @params = @defn.gsub(/.*?\((.*?)\)/){$1}.split(',').map{|p| p.strip}

           @params = []

       private

       @@file_cache = {}

       def file_cache(file)

         unless lines = @@file_cache[file]

           @@file_cache[file] = lines = File.new(file).readlines

         lines

       def match_tabs(lines, i, keyword)

         lines[i] =~ /(\W*)((#{keyword}(.*;\W*end)?)|(.*))/

         return $2 if $4 or $5

         tabs = $1

         result = ""

         lines[i..-1].each do |line|

           result << line.gsub(/^#{tabs}(.*)/) { $1}

           return result if $1 =~ /^end/

       def preceding_comment(lines, i)

         result = []

         i = i-1

         i = i-1 while lines[i] =~ /^\W*$/

         if lines[i] =~ /^=end/

           i = i-1

           until lines[i] =~ /^=begin/

             result.unshift lines[i]

             i = i-1

           while lines[i] =~ /^\W*#(.*)/

             result.unshift $1[1..-1]

             i = i-1

         result.join("\n")

     class MethodInfoBase

       @@minfo = {}

       def self.method_info(method)

         @@minfo[method.to_s]

       private

       def self.method_added(method)

         super if defined? super

         last = caller[0]

         file, lineno = last.match(/(.+?):(\d+)/)[1, 2]

         @@minfo[method.to_s] = MethodInfo.new(file, lineno.to_i - 1)

     class BuildError < RuntimeError

       attr_accessor :target

       attr_accessor :task

     module BuildErrorMixin

       def error(message)

         Kernel.raise BuildError.new(message)

     module HashCheckerMixin

       include BuildErrorMixin

       def check_hash(hash, description)

         for key in description.keys

           case description[key]

           when :mandatory

             error "Missing mandatory key '#{key}'" if not hash.has_key?(key)

           when :optional

             error "Unknown symbol '#{description[key]}'"

         for key in hash.keys

           error "Unknown key '#{key}'" if not description.keys.member?(key)