Bee C0 Coverage Information - RCov

 require 'rubygems'

 require 'bee_util'

 module Bee

   module Console

     class Style

       include Bee::Util::BuildErrorMixin

       attr_reader :line_character

       attr_reader :line_length

       attr_reader :target_style

       attr_reader :target_foreground

       attr_reader :target_background

       attr_reader :task_style

       attr_reader :task_foreground

       attr_reader :task_background

       attr_reader :success_style

       attr_reader :success_foreground

       attr_reader :success_background

       attr_reader :error_style

       attr_reader :error_foreground

       attr_reader :error_background

       TYPES = [:target, :task, :success, :error]

       COLORS = [:black, :red, :green, :yellow, :blue, :magenta, :cyan, :white]

       FOREGROUND_COLOR_CODES = {

       BACKGROUND_COLOR_CODES = {

       STYLES = [:reset, :bright, :dim, :underscore, :blink, :reverse, :hidden]

       STYLE_CODES = {

       DEFAULT_STYLE = {

       COLOR_STYLE = {

       SHORT_STYLE_KEYS = {

       def initialize(style=nil, color=nil)

         @line_character = nil

         @line_length = nil

         @target_style = nil

         @target_foreground = nil

         @target_background = nil

         @task_style = nil

         @task_foreground = nil

         @task_background = nil

         @success_style = nil

         @success_foreground = nil

         @success_background = nil

         @error_style = nil

         @error_foreground = nil

         @error_background = nil

         apply(color ? COLOR_STYLE : DEFAULT_STYLE)

         apply(style)

       def style(string, type)

         raise "Type '#{type}' unknown: must be one of " + TYPES.map{|e| ":#{e}"}.join(', ') if

           not TYPES.include?(type)

         style = eval("@#{type}_style")

         foreground = eval("@#{type}_foreground")

         background = eval("@#{type}_background")

         return string if not foreground and not background and not style

         colorized = "\e["

         colorized << "#{STYLE_CODES[style]};" if style

         colorized << "#{FOREGROUND_COLOR_CODES[foreground]};" if foreground

         colorized << "#{BACKGROUND_COLOR_CODES[background]};" if background

         colorized = colorized[0..-2]

         colorized << "m#{string}\e[#{STYLE_CODES[:reset]}m"

         return colorized

       private

       def apply(style)

         if style.kind_of?(Hash)

           for key, value in style

             check_attribute_value(key, value)

             eval("@#{key} = #{value.inspect}")

         elsif style.kind_of?(String)

           for pair in style.split(',')

             key, value = pair.split(':')

             key = SHORT_STYLE_KEYS[key] || key

             key = key.to_sym

             if key == :line_length

               value = value.to_i

             elsif key == :line_character

               value = ' ' if not value or value.length == 0

               value = value.to_sym if value

             check_attribute_value(key, value)

             eval("@#{key} = #{value.inspect}")

           raise "Style must ne a Hash or a String" if style

       def check_attribute_value(attribute, value)

         raise "Attribute '#{attribute}' must be a symbol" unless

           attribute.kind_of?(Symbol)

         raise "Unknown attribute '#{attribute}'" unless

           instance_variable_defined?("@#{attribute}".to_sym)

         if attribute == :line_length

           raise "'line_length' attribute must be an integer" unless

             value.kind_of?(Integer)

         elsif attribute == :line_character

           raise "'line_character' must be a single character" unless

             value.kind_of?(String) and value.length == 1

           raise "Value '#{value}' should be a symbol" unless

             value.kind_of?(Symbol)

           if attribute.to_s[-6..-1] == '_style'

             raise "Unkown style '#{value}'" if not STYLES.member?(value)

             raise "Unkown color '#{value}'" if not COLORS.member?(value)