bovem 0.6.0 → 0.8.0

data/.yardopts

@@ -0,0 +1 @@
+--exclude lib/devdnsd/patches/.+ --exclude utils/ -m markdown

data/Gemfile.lock

@@ -1,16 +1,15 @@
 PATH
   remote: .
   specs:
-    bovem (0.6.0)
+    bovem (0.8.0)
       lazier (~> 1.0)
-      rainbow (~> 1.1.0)
 
 GEM
   remote: http://rubygems.org/
   specs:
-    actionpack (3.2.7)
-      activemodel (= 3.2.7)
-      activesupport (= 3.2.7)
+    actionpack (3.2.8)
+      activemodel (= 3.2.8)
+      activesupport (= 3.2.8)
       builder (~> 3.0.0)
       erubis (~> 2.7.0)
       journey (~> 1.0.4)
@@ -18,22 +17,22 @@ GEM
       rack-cache (~> 1.2)
       rack-test (~> 0.6.1)
       sprockets (~> 2.1.3)
-    activemodel (3.2.7)
-      activesupport (= 3.2.7)
+    activemodel (3.2.8)
+      activesupport (= 3.2.8)
       builder (~> 3.0.0)
-    activesupport (3.2.7)
+    activesupport (3.2.8)
       i18n (~> 0.6)
       multi_json (~> 1.0)
     builder (3.0.0)
     coderay (1.0.7)
     diff-lcs (1.1.3)
     erubis (2.7.0)
-    github-markup (0.7.2)
+    github-markup (0.7.4)
     hike (1.2.1)
     i18n (0.6.0)
     journey (1.0.4)
     json (1.7.4)
-    lazier (1.0.1)
+    lazier (1.0.2)
       actionpack (~> 3.0)
       json (~> 1.7.0)
       tzinfo (~> 0.3.0)
@@ -48,17 +47,16 @@ GEM
       rack (>= 0.4)
     rack-test (0.6.1)
       rack (>= 1.0)
-    rainbow (1.1.4)
     rake (0.9.2.2)
     redcarpet (2.1.1)
     rspec (2.11.0)
       rspec-core (~> 2.11.0)
       rspec-expectations (~> 2.11.0)
       rspec-mocks (~> 2.11.0)
-    rspec-core (2.11.0)
-    rspec-expectations (2.11.1)
+    rspec-core (2.11.1)
+    rspec-expectations (2.11.2)
       diff-lcs (~> 1.1.3)
-    rspec-mocks (2.11.1)
+    rspec-mocks (2.11.2)
     simplecov (0.6.4)
       multi_json (~> 1.0)
       simplecov-html (~> 0.5.3)

data/bovem.gemspec

@@ -22,7 +22,6 @@ Gem::Specification.new do |gem|
   gem.require_paths = ["lib"]
 
   gem.add_dependency("lazier", "~> 1.0")
-  gem.add_dependency("rainbow", "~> 1.1.0")
 
   gem.add_development_dependency("rspec", "~> 2.11.0")
   gem.add_development_dependency("rake", "~> 0.9.0")

data/lib/bovem.rb

@@ -4,7 +4,6 @@
 # Licensed under the MIT license, which can be found at http://www.opensource.org/licenses/mit-license.php.
 #
 
-require "rainbow"
 require "logger"
 require "lazier"
 
@@ -13,4 +12,5 @@ Lazier.load!(:object)
 require "bovem/version" if !defined?(Bovem::Version)
 require "bovem/errors"
 require "bovem/configuration"
-require "bovem/logger"
+require "bovem/logger"
+require "bovem/console"

data/lib/bovem/console.rb

@@ -0,0 +1,527 @@
+# encoding: utf-8
+#
+# This file is part of the bovem gem. Copyright (C) 2012 and above Shogun <shogun_panda@me.com>.
+# Licensed under the MIT license, which can be found at http://www.opensource.org/licenses/mit-license.php.
+#
+
+module Bovem
+  # List of valid terminal colors.
+  TERM_COLORS = {
+    :black => 0,
+    :red => 1,
+    :green => 2,
+    :yellow => 3,
+    :blue => 4,
+    :magenta => 5,
+    :cyan => 6,
+    :white => 7,
+    :default => 9,
+  }
+
+  # List of valid terminal text effects.
+  TERM_EFFECTS = {
+    :reset => 0,
+    :bright => 1,
+    :italic => 3,
+    :underline => 4,
+    :blink => 5,
+    :inverse => 7,
+    :hide => 8,
+  }
+
+  # This is a text utility wrapper console I/O.
+  class Console
+    # The line width. Default to `80`.
+    attr_accessor :line_width
+
+    # The current screen width.
+    attr_accessor :screen_width
+
+    # Current indentation width.
+    attr_accessor :indentation
+
+    # The string used for indentation.
+    attr_accessor :indentation_string
+
+    # Whether to show executed commands.
+    # attr_accessor :show_commands
+
+    # Whether to show output of executed commands.
+    # attr_accessor :show_outputs
+
+    # Whether to simply print commands rather than executing them.
+    # attr_accessor :skip_commands
+
+    # Returns a unique instance for Console.
+    #
+    # @return [Console] A new instance.
+    def self.instance
+      @instance ||= ::Bovem::Console.new
+    end
+
+    # Parse a style and returns terminal codes.
+    #
+    # Supported styles and colors are those in {Bovem::TERM_COLORS} and {Bovem::TERM_EFFECTS}. You can also prefix colors with `bg_` (like `bg_red`) for background colors.
+    #
+    # @param style [String] The style to parse.
+    # @return [String] A string with ANSI color codes.
+    def self.parse_style(style)
+      style = style.ensure_string
+      sym = style.to_sym
+      rv = ""
+
+      if ::Bovem::TERM_EFFECTS.include?(sym) then
+        rv = "\e[#{Bovem::TERM_EFFECTS[sym]}m"
+      elsif style.index("bg_") == 0 then
+        sym = style[3, style.length].to_sym
+        rv = "\e[#{40 + ::Bovem::TERM_COLORS[sym]}m" if ::Bovem::TERM_COLORS.include?(sym)
+      elsif style != "reset" then
+        rv = "\e[#{30 + ::Bovem::TERM_COLORS[sym]}m" if ::Bovem::TERM_COLORS.include?(sym)
+      end
+
+      rv
+    end
+
+    # Replaces colors markers in a string.
+    #
+    # @param message [String] The message to analyze.
+    # @param plain [Boolean] If ignore (cleanify) color markers into the message.
+    # @return [String] The replaced message.
+    # @see #parse_style
+    def self.replace_markers(message, plain = false)
+      stack = []
+
+      regexp = /((\{mark=([a-z\-_]+)\})|(\{\/mark\}))/mi
+
+      message = message.gsub(regexp) do
+        tag = $1
+        styles = $3
+        replacement = ""
+
+        if tag == "{/mark}" then # If it is a tag, pop from the latest opened.
+          stack.pop
+          styles = stack.last
+          replacement = plain || stack.blank? ? "" : styles.split("-").collect { |s| self.parse_style(s) }.join("")
+        else
+          replacement = plain ? "" : styles.split("-").collect { |s| self.parse_style(s) }.join("")
+
+          if replacement.length > 0 then
+            stack << "reset" if stack.blank?
+            stack << styles
+          end
+        end
+
+        replacement
+      end
+
+      message
+    end
+
+    # Executes a command and returns its output.
+    #
+    # @param command [String] The command to execute.
+    # @return [String] The command's output.
+    def self.execute(command)
+      %x{#{command}}
+    end
+
+    # Initializes a new Console.
+    def initialize
+      @line_width = 80
+      @indentation = 0
+      @indentation_string = " "
+    end
+
+    # Gets the current screen width.
+    #
+    # @return [Fixnum] The screen width.
+    def get_screen_width
+      ::Bovem::Console.execute("tput cols").to_integer
+    end
+
+    # Sets the new indentation width.
+    #
+    # @param width [Fixnum] The new width.
+    # @param is_absolute [Boolean] If the new width should not be added to the current one but rather replace it.
+    # @return [Fixnum] The new indentation width.
+    def set_indentation(width, is_absolute = false)
+      self.indentation = [(!is_absolute ? self.indentation : 0) + width, 0].max.to_i
+      self.indentation
+    end
+
+    # Resets indentation width to `0`.
+    #
+    # @return [Fixnum] The new indentation width.
+    def reset_indentation
+      self.indentation = 0
+      self.indentation
+    end
+
+    # Starts a indented region of text.
+    #
+    # @param width [Fixnum] The new width.
+    # @param is_absolute [Boolean] If the new width should not be added to the current one but rather replace it.
+    # @return [Fixnum] The new indentation width.
+    def with_indentation(width, is_absolute = false)
+      old = self.indentation
+      self.set_indentation(width, is_absolute)
+      yield
+      self.set_indentation(old, true)
+
+      self.indentation
+    end
+
+    # Wraps a message in fixed line width.
+    #
+    # @param message [String] The message to wrap.
+    # @param width [Fixnum] The maximum width of a line. Default to the current line width.
+    # @return [String] The wrapped message.
+    def wrap(message, width = nil)
+      if width.to_integer <= 0 then
+        message
+      else
+        width = (width == true || width.to_integer < 0 ? @line_width : width.to_integer)
+
+        message.split("\n").collect { |line|
+          line.length > width ? line.gsub(/(.{1,#{width}})(\s+|$)/, "\\1\n").strip : line
+        }.join("\n")
+      end
+    end
+
+    # Indents a message.
+    #
+    # @param message [String] The message to indent.
+    # @param width [Fixnum] The indentation width. `true` means to use thecurrent indentation, a negative value of `-x` will indent of `x` absolute spaces. `nil` or `false` will skip indentation.
+    # @param newline_separator [String] The character used for newlines.
+    # @return [String] The indentend message.
+    def indent(message, width = true, newline_separator = "\n")
+      if width.to_integer != 0 then
+        width = (width == true ? 0 : width.to_integer)
+        width = width < 0 ? -width : @indentation + width
+
+        message = message.split(newline_separator).collect {|line|
+          (@indentation_string * width) + line
+        }.join(newline_separator)
+      end
+
+      message
+    end
+
+    # Replaces colors markers in a string.
+    #
+    # Supported styles and colors are those in {Bovem::TERM_COLORS} and {Bovem::TERM_EFFECTS}. You can also prefix colors with `bg_` (like `bg_red`) for background colors.
+    #
+    # @param message [String] The message to analyze.
+    # @param plain [Boolean] If ignore (cleanify )color markers into the message.
+    # @return [String] The replaced message.
+    def replace_markers(message, plain = false)
+      ::Bovem::Console.replace_markers(message, plain)
+    end
+
+    # Formats a message.
+    #
+    # You can style text by using `{color}` and `{reset}` syntax.
+    #
+    # @param message [String] The message to format.
+    # @param suffix [Object] If not `nil` or `false`, a suffix to add to the message. `true` means to add `\n`.
+    # @param indent [Object] If not `nil` or `false`, the width to use for indentation. `true` means to use thecurrent indentation, a negative value of `-x` will indent of `x` absolute spaces.
+    # @param wrap [Object] If not `nil` or `false`, the maximum length of a line. `true` means the current line width.
+    # @param plain [Boolean] If ignore color markers into the message.
+    # @return [String] The formatted message.
+    def format(message, suffix = "\n", indent = true, wrap = true, plain = false)
+      rv = message
+
+      rv = self.replace_markers(rv, plain) # Replace markers
+      rv = self.wrap(rv, wrap) # Wrap
+      rv = self.indent(rv, indent) # Indent
+
+      rv += suffix if suffix # Add the suffix
+      rv
+    end
+
+    # Formats a message to be written right-aligned.
+    #
+    # @param message [String] The message to format.
+    # @param width [Fixnum] The screen width. If `true`, it is automatically computed.
+    # @param go_up [Boolean] If go up one line before formatting.
+    # @param plain [Boolean] If ignore color markers into the message.
+    # @return [String] The formatted message.
+    def format_right(message, width = true, go_up = true, plain = false)
+      message = self.replace_markers(message, plain)
+
+      rv = go_up ? "\e[A" : ""
+
+      @screen_width ||= self.get_screen_width
+      width = (width == true || width.to_integer < 1 ? @screen_width : width.to_integer)
+
+      # Get padding
+      padding = width - message.to_s.gsub(/(\e\[[0-9]*[a-z]?)|(\\n)/i, "").length
+
+      # Return
+      rv + "\e[0G\e[#{padding}C" + message
+    end
+
+    # Writes a message.
+    #
+    # @param message [String] The message to format.
+    # @param suffix [Object] If not `nil` or `false`, a suffix to add to the message. `true` means to add `\n`.
+    # @param indent [Object] If not `nil` or `false`, the width to use for indentation. `true` means to use thecurrent indentation, a negative value of `-x` will indent of `x` absolute spaces.
+    # @param wrap [Object] If not `nil` or `false`, the maximum length of a line for wrapped text. `true` means the current line width.
+    # @param plain [Boolean] If ignore color markers into the message.
+    # @param print [Boolean] If `false`, the result will be returned instead of be printed.
+    # @return [String] The printed message.
+    #
+    # @see #format
+    def write(message, suffix = "\n", indent = true, wrap = false, plain = false, print = true)
+      rv = self.format(message, suffix, indent, wrap, plain)
+      Kernel.puts(rv) if print
+      rv
+    end
+
+    # Writes a status to the output. Valid values are `:ok`, `:pass`, `:fail`, `:warn`.
+    #
+    # @param status [Symbol] The status to write.
+    # @param plain [Boolean] If not use colors.
+    # @param go_up [Boolean] If go up one line before formatting.
+    # @param right [Boolean] If to print results on the right.
+    # @param print [Boolean] If `false`, the result will be returned instead of be printed.
+    # @return [Array] An dictionary with `:label` and `:color` keys for the status.
+    def status(status, plain = false, go_up = true, right = true, print = true)
+      statuses = {
+        :ok => {:label => " OK ", :color => "bright green"},
+        :pass => {:label => "PASS", :color => "bright cyan"},
+        :warn => {:label => "WARN", :color => "bright yellow"},
+        :fail => {:label => "FAIL", :color => "bright red"}
+      }
+      statuses.default = statuses[:pass]
+
+      rv = statuses[status]
+
+      if print then
+        banner = self.get_banner(rv[:label], rv[:color])
+
+        if right then
+          Kernel.puts self.format_right(banner + " ", true, go_up, plain)
+        else
+          Kernel.puts self.format(banner + " ", "\n", true, true, plain)
+        end
+      end
+
+      rv
+    end
+
+    # Gets a banner for the messages.
+    #
+    # @param label [String] The label for the banner.
+    # @param base_color [String] The color for the label.
+    # @param full_colored [String] If all the message should be of the label color.
+    # @param bracket_color [String] The color of the brackets.
+    # @param brackets [Array] An array of dimension 2 to use for brackets.
+    # @return [String] The banner.
+    # @see #format
+    def get_banner(label, base_color, full_colored = false, bracket_color = "blue", brackets = ["[", "]"])
+      brackets = brackets.ensure_array
+      bracket_color = base_color if full_colored
+      "{mark=%s}%s{mark=%s}%s{/mark}%s{/mark}" % [bracket_color.parameterize, brackets[0], base_color.parameterize, label, brackets[1]]
+    end
+
+    # Writes a message prepending a cyan type banner.
+    #
+    # @param message [String] The message to format.
+    # @param suffix [Object] If not `nil` or `false`, a suffix to add to the message. `true` means to add `\n`.
+    # @param indent [Object] If not `nil` or `false`, the width to use for indentation. `true` means to use thecurrent indentation, a negative value of `-x` will indent of `x` absolute spaces.
+    # @param wrap [Object] If not `nil` or `false`, the maximum length of a line for wrapped text. `true` means the current line width.
+    # @param plain [Boolean] If ignore color markers into the message.
+    # @param indented_banner [Boolean] If also the banner should be indented.
+    # @param full_colored [Boolean] If the banner should be fully colored.
+    # @param print [Boolean] If `false`, the result will be returned instead of be printed.
+    #
+    # @see #format
+    def info(message, suffix = "\n", indent = true, wrap = false, plain = false, indented_banner = false, full_colored = false, print = true)
+      banner = self.get_banner(" INFO", "bright cyan", full_colored)
+      message = self.indent(message, indented_banner ? 0 : indent)
+      self.write(banner + " " + message, suffix, indented_banner ? indent : 0, wrap, plain, print)
+    end
+
+    # Writes a message prepending a green type banner.
+    #
+    # @param message [String] The message to format.
+    # @param suffix [Object] If not `nil` or `false`, a suffix to add to the message. `true` means to add `\n`.
+    # @param indent [Object] If not `nil` or `false`, the width to use for indentation. `true` means to use thecurrent indentation, a negative value of `-x` will indent of `x` absolute spaces.
+    # @param wrap [Object] If not `nil` or `false`, the maximum length of a line for wrapped text. `true` means the current line width.
+    # @param plain [Boolean] If ignore color markers into the message.
+    # @param indented_banner [Boolean] If also the banner should be indented.
+    # @param full_colored [Boolean] If the banner should be fully colored.
+    # @param print [Boolean] If `false`, the result will be returned instead of be printed.
+    #
+    # @see #format
+    def begin(message, suffix = "\n", indent = true, wrap = false, plain = false, indented_banner = false, full_colored = false, print = true)
+      banner = "    " + self.get_banner("*", "bright green")
+      message = self.indent(message, indented_banner ? 0 : indent)
+      self.write(banner + " " + message, suffix, indented_banner ? indent : 0, wrap, plain, print)
+    end
+
+    # Writes a message prepending a yellow type banner.
+    #
+    # @param message [String] The message to format.
+    # @param suffix [Object] If not `nil` or `false`, a suffix to add to the message. `true` means to add `\n`.
+    # @param indent [Object] If not `nil` or `false`, the width to use for indentation. `true` means to use thecurrent indentation, a negative value of `-x` will indent of `x` absolute spaces.
+    # @param wrap [Object] If not `nil` or `false`, the maximum length of a line for wrapped text. `true` means the current line width.
+    # @param plain [Boolean] If ignore color markers into the message.
+    # @param indented_banner [Boolean] If also the banner should be indented.
+    # @param full_colored [Boolean] If the banner should be fully colored.
+    # @param print [Boolean] If `false`, the result will be returned instead of be printed.
+    #
+    # @see #format
+    def warn(message, suffix = "\n", indent = true, wrap = false, plain = false, indented_banner = false, full_colored = false, print = true)
+      banner = self.get_banner(" WARN", "bright yellow", full_colored)
+      message = self.indent(message, indented_banner ? 0 : indent)
+      self.write(banner + " " + message, suffix, indented_banner ? indent : 0, wrap, plain, print)
+    end
+
+    # Writes a message prepending a red type banner.
+    #
+    # @param message [String] The message to format.
+    # @param suffix [Object] If not `nil` or `false`, a suffix to add to the message. `true` means to add `\n`.
+    # @param indent [Object] If not `nil` or `false`, the width to use for indentation. `true` means to use thecurrent indentation, a negative value of `-x` will indent of `x` absolute spaces.
+    # @param wrap [Object] If not `nil` or `false`, the maximum length of a line for wrapped text. `true` means the current line width.
+    # @param plain [Boolean] If ignore color markers into the message.
+    # @param indented_banner [Boolean] If also the banner should be indented.
+    # @param full_colored [Boolean] If the banner should be fully colored.
+    # @param print [Boolean] If `false`, the result will be returned instead of be printed.
+    #
+    # @see #format
+    def error(message, suffix = "\n", indent = true, wrap = false, plain = false, indented_banner = false, full_colored = false, print = true)
+      banner = self.get_banner("ERROR", "bright red", full_colored)
+      message = self.indent(message, indented_banner ? 0 : indent)
+      self.write(banner + " " + message, suffix, indented_banner ? indent : 0, wrap, plain, print)
+    end
+
+    # Writes a message prepending a red type banner and then quits the application.
+    #
+    # @param message [String] The message to format.
+    # @param suffix [Object] If not `nil` or `false`, a suffix to add to the message. `true` means to add `\n`.
+    # @param indent [Object] If not `nil` or `false`, the width to use for indentation. `true` means to use thecurrent indentation, a negative value of `-x` will indent of `x` absolute spaces.
+    # @param wrap [Object] If not `nil` or `false`, the maximum length of a line for wrapped text. `true` means the current line width.
+    # @param plain [Boolean] If ignore color markers into the message.
+    # @param indented_banner [Boolean] If also the banner should be indented.
+    # @param full_colored [Boolean] If the banner should be fully colored.
+    # @param return_code [Fixnum] The code to return to the shell.
+    # @param print [Boolean] If `false`, the result will be returned instead of be printed.
+    #
+    # @see #format
+    def fatal(message, suffix = "\n", indent = true, wrap = false, plain = false, indented_banner = false, full_colored = false, return_code = -1, print = true)
+      self.error(message, suffix, indent, wrap, plain, indented_banner, full_colored, print)
+      Kernel.abort(return_code)
+    end
+
+    # Writes a message prepending a magenta type banner.
+    #
+    # @param message [String] The message to format.
+    # @param suffix [Object] If not `nil` or `false`, a suffix to add to the message. `true` means to add `\n`.
+    # @param indent [Object] If not `nil` or `false`, the width to use for indentation. `true` means to use thecurrent indentation, a negative value of `-x` will indent of `x` absolute spaces.
+    # @param wrap [Object] If not `nil` or `false`, the maximum length of a line for wrapped text. `true` means the current line width.
+    # @param plain [Boolean] If ignore color markers into the message.
+    # @param indented_banner [Boolean] If also the banner should be indented.
+    # @param full_colored [Boolean] If the banner should be fully colored.
+    # @param print [Boolean] If `false`, the result will be returned instead of be printed.
+    #
+    # @see #format
+    def debug(message, suffix = "\n", indent = true, wrap = false, plain = false, indented_banner = false, full_colored = false, print = true)
+      banner = self.get_banner("DEBUG", "bright magenta", full_colored)
+      message = self.indent(message, indented_banner ? 0 : indent)
+      self.write(banner + " " + message, suffix, indented_banner ? indent : 0, wrap, plain, print)
+    end
+
+    # Reads a string from the console.
+    #
+    # @param prompt [String|Boolean] A prompt to show. If `true`, `Please insert a value:` will be used, if `nil` or `false` no prompt will be shown.
+    # @param default_value [String] Default value if user simply pressed the enter key.
+    # @param validator [Array|Regexp] An array of values or a Regexp to match the submitted value against.
+    # @param echo [Boolean] If to show submitted text to the user.
+    def read(prompt = true, default_value = nil, validator = nil, echo = true)
+      # TODO: Echo and print prompt without newline
+
+      # Write the prompt
+      prompt = "Please insert a value" if prompt == true
+      final_prompt = !prompt.nil? ? prompt.gsub(/:?\s*$/, "") + ": " : nil
+
+      # Adjust validator
+      validator = validator.ensure_array.collect {|v| v.ensure_string} if validator.present? && !validator.is_a?(::Regexp)
+
+      # Handle echo
+      stty = ::Bovem::Console.execute("which stty").strip
+      disable_echo = !echo && stty.present? && /-echo\b/mix.match(::Bovem::Console.execute(stty)).nil?
+
+      # Disable echo
+      ::Bovem::Console.execute("#{stty} -echo") if disable_echo
+
+      begin
+        catch(:reply) do
+          while true do
+            valid = true
+
+            if final_prompt then
+              Kernel.print self.format(final_prompt, false, false)
+              $stdout.flush
+            end
+
+            reply = Kernel.gets.chop
+            reply = default_value if reply.empty?
+
+            # Match against the validator
+            if validator.present? then
+              if validator.is_a?(Array) then
+                valid = false if validator.length > 0 && !validator.include?(reply)
+              elsif validator.is_a?(Regexp) then
+                valid = false if !validator.match(reply)
+              end
+            end
+
+            if !valid then
+              self.write("Sorry, your reply was not understood. Please try again.", false, false)
+            else
+              throw(:reply, reply)
+            end
+          end
+        end
+      rescue Interrupt
+        default_value
+      ensure
+        ::Bovem::Console.execute("#{stty} echo") if disable_echo
+      end
+    end
+
+    # Execute a block of code in a indentation region and then prints out and ending status message.
+    #
+    # @param message [String] The message to format.
+    # @param suffix [Object] If not `nil` or `false`, a suffix to add to the message. `true` means to add `\n`.
+    # @param indent [Object] If not `nil` or `false`, the width to use for indentation. `true` means to use thecurrent indentation, a negative value of `-x` will indent of `x` absolute spaces.
+    # @param wrap [Object] If not `nil` or `false`, the maximum length of a line for wrapped text. `true` means the current line width.
+    # @param plain [Boolean] If ignore color markers into the message.
+    # @param indented_banner [Boolean] If also the banner should be indented.
+    # @param full_colored [Boolean] If the banner should be fully colored.
+    # @param block_indentation [Fixnum] The new width for the indented region.
+    # @param block_indentation_absolute [Boolean] If the new width should not be added to the current one but rather replace it.
+    # @return [Symbol] The exit status for the block.
+    def task(message = nil, suffix = "\n", indent = true, wrap = false, plain = false, indented_banner = false, full_colored = false, block_indentation = 2, block_indentation_absolute = false)
+      status = nil
+
+      self.begin(message, suffix, indent, wrap, plain, indented_banner, full_colored) if message.present?
+
+      self.with_indentation(block_indentation, block_indentation_absolute) do
+        rv = block_given? ? yield.ensure_array : [:ok] # Execute block
+        status = rv[0] # Return value
+
+        if status == :fatal then
+          self.status(:fail, plain)
+          exit(rv.length > 1 ? rv[1].to_integer : -1)
+        else
+          self.status(status, plain)
+        end
+      end
+
+      status
+    end
+  end
+end

data/lib/bovem/logger.rb

@@ -75,8 +75,7 @@ module Bovem
           else :white
         end
 
-        header = ("[%s T+%0.5f] %s:" %[datetime.strftime("%Y/%b/%d %H:%M:%S"), [datetime.to_f - self.start_time.to_f, 0].max, severity.rjust(5)]).bright
-        header = header.color(color) if color.present?
+        header = ::Bovem::Console.replace_markers("{mark=bright-#{color}}[%s T+%0.5f] %s:{/mark}" %[datetime.strftime("%Y/%b/%d %H:%M:%S"), [datetime.to_f - self.start_time.to_f, 0].max, severity.rjust(5)])
         "%s %s\n" % [header, msg]
       }
     end

data/lib/bovem/version.rb

@@ -14,7 +14,7 @@ module Bovem
     MAJOR = 0
 
     # The minor version.
-    MINOR = 6
+    MINOR = 8
 
     # The patch version.
     PATCH = 0

data/spec/bovem/configuration_spec.rb

@@ -7,7 +7,7 @@
 require "spec_helper"
 
 describe Bovem::Configuration do
-  class BaseConfiguration < Bovem::Configuration
+  class BaseConfiguration < ::Bovem::Configuration
     property :property
   end
 
@@ -27,8 +27,8 @@ describe Bovem::Configuration do
       file1 = ::File.open("#{test_prefix}-1", "w") {|f| f.write("config.property = ") }
       file2 = ::File.open("#{test_prefix}-2", "w") {|f| f.write("config.non_property = 1234") }
 
-      expect { config = BaseConfiguration.new("#{test_prefix}-1")}.to raise_error(Bovem::Errors::InvalidConfiguration)
-      expect { config = BaseConfiguration.new("#{test_prefix}-2")}.to raise_error(Bovem::Errors::InvalidConfiguration)
+      expect { config = BaseConfiguration.new("#{test_prefix}-1")}.to raise_error(::Bovem::Errors::InvalidConfiguration)
+      expect { config = BaseConfiguration.new("#{test_prefix}-2")}.to raise_error(::Bovem::Errors::InvalidConfiguration)
 
       File.unlink("#{test_prefix}-1")
       File.unlink("#{test_prefix}-2")

data/spec/bovem/console_spec.rb

@@ -0,0 +1,419 @@
+# encoding: utf-8
+#
+# This file is part of the bovem gem. Copyright (C) 2012 and above Shogun <shogun_panda@me.com>.
+# Licensed under the MIT license, which can be found at http://www.opensource.org/licenses/mit-license.php.
+#
+
+require "spec_helper"
+
+describe Bovem::Console do
+  let(:console) { ::Bovem::Console.new }
+
+  before(:each) do
+    Kernel.stub(:puts).and_return(nil)
+  end
+
+  describe ".instance" do
+    it "should always return the same instance" do
+      instance = ::Bovem::Console.instance
+      expect(::Bovem::Console.instance).to be(instance)
+    end
+  end
+
+  describe ".parse_style" do
+    it "should correctly parse styles" do
+      expect(::Bovem::Console.parse_style("red")).to eq("\e[31m")
+      expect(::Bovem::Console.parse_style("bg_green")).to eq("\e[42m")
+      expect(::Bovem::Console.parse_style("bright")).to eq("\e[1m")
+      expect(::Bovem::Console.parse_style("FOO")).to eq("")
+      expect(::Bovem::Console.parse_style(nil)).to eq("")
+      expect(::Bovem::Console.parse_style(["A"])).to eq("")
+    end
+  end
+
+  describe ".replace_markers" do
+    it "should correct replace markers" do
+      expect(::Bovem::Console.replace_markers("{mark=red}RED{/mark}")).to eq("\e[31mRED\e[0m")
+      expect(::Bovem::Console.replace_markers("{mark=red}RED {mark=green}GREEN{/mark}{/mark}")).to eq("\e[31mRED \e[32mGREEN\e[31m\e[0m")
+      expect(::Bovem::Console.replace_markers("{mark=red}RED {mark=bright-green}GREEN {mark=blue}BLUE{mark=NONE}RED{/mark}{/mark}{/mark}{/mark}")).to eq("\e[31mRED \e[1m\e[32mGREEN \e[34mBLUERED\e[1m\e[32m\e[31m\e[0m")
+      expect(::Bovem::Console.replace_markers("{mark=bg_red}RED{mark=reset}NORMAL{/mark}{/mark}")).to eq("\e[41mRED\e[0mNORMAL\e[41m\e[0m")
+      expect(::Bovem::Console.replace_markers("{mark=NONE}RED{/mark}")).to eq("RED")
+    end
+
+    it "should clean up markers if requested" do
+      expect(::Bovem::Console.replace_markers("{mark=red}RED{/mark}", true)).to eq("RED")
+    end
+  end
+
+  describe ".execute_command" do
+    it "should execute a command" do
+      expect(::Bovem::Console.execute("echo OK")).to eq("OK\n")
+    end
+  end
+
+  describe "#initialize" do
+    it "should correctly set defaults" do
+      expect(console.indentation).to eq(0)
+      expect(console.line_width).to eq(80)
+      expect(console.indentation_string).to eq(" ")
+    end
+  end
+
+  describe "#get_screen_width" do
+    it "should execute tput cols" do
+      ::Bovem::Console.should_receive("execute").with("tput cols")
+      console.get_screen_width
+    end
+
+    it "should return a number >= 0" do
+      expect(console.get_screen_width).to be >= 0
+    end
+  end
+
+  describe "#set_indentation" do
+    it "should correctly set indentation" do
+      expect(console.indentation).to eq(0)
+      console.set_indentation(5)
+      expect(console.indentation).to eq(5)
+      console.set_indentation(-2)
+      expect(console.indentation).to eq(3)
+      console.set_indentation(10, true)
+      expect(console.indentation).to eq(10)
+    end
+  end
+
+  describe "#reset_indentation" do
+    it "should correctly reset indentation" do
+      console.set_indentation(5)
+      expect(console.indentation).to eq(5)
+      console.reset_indentation
+      expect(console.indentation).to eq(0)
+    end
+  end
+
+  describe "#with_indentation" do
+    it "should correctly wrap indentation" do
+      console.set_indentation(5)
+      expect(console.indentation).to eq(5)
+
+      console.with_indentation(7) do
+        expect(console.indentation).to eq(12)
+      end
+      expect(console.indentation).to eq(5)
+
+      console.with_indentation(3, true) do
+        expect(console.indentation).to eq(3)
+      end
+      expect(console.indentation).to eq(5)
+    end
+  end
+
+  describe "#wrap" do
+    it "should correct wrap text" do
+      message = "  ABC__DEF GHI JKL"
+      expect(console.wrap(message, 2)).to eq("ABC__DEF\nGHI\nJKL")
+      expect(console.wrap(message, 3)).to eq("ABC__DEF\nGHI\nJKL")
+      expect(console.wrap(message, 4)).to eq("ABC__DEF\nGHI\nJKL")
+      expect(console.wrap(message, 5)).to eq("ABC__DEF\nGHI\nJKL")
+      expect(console.wrap(message, 20)).to eq("  ABC__DEF GHI JKL")
+
+      expect(console.wrap(message, nil)).to eq(message)
+      expect(console.wrap(message, -1)).to eq(message)
+    end
+
+    it "should work well with #indent" do
+      message = "AB CD"
+      console.set_indentation(2)
+      expect(console.wrap(console.indent(message), 2)).to eq("AB\nCD")
+    end
+  end
+
+  describe "#indent" do
+    it "should correctly indent messages" do
+      message = "ABC\nCDE"
+      console.set_indentation(2)
+
+      expect(console.indent(message)).to eq("  ABC\n  CDE")
+      expect(console.indent(message, -1)).to eq(" ABC\n CDE")
+      expect(console.indent(message, 1)).to eq("   ABC\n   CDE")
+      expect(console.indent(message, true, "D")).to eq("  ABC\nCD  E")
+
+      expect(console.indent(message, 0)).to eq(message)
+      expect(console.indent(message, nil)).to eq(message)
+      expect(console.indent(message, false)).to eq(message)
+      expect(console.indent(message, "A")).to eq(message)
+    end
+  end
+
+  describe "#format" do
+    it "should apply modifications to the message" do
+      message = "ABC"
+      console.set_indentation(2)
+      expect(console.format(message, "\n", false)).to eq("ABC\n")
+      expect(console.format(message, "A")).to eq("  ABCA")
+      expect(console.format(message, "A", 3)).to eq("     ABCA")
+      expect(console.format(message, "A", 3, 4)).to eq("     ABCA")
+      expect(console.format("{mark=red}ABC{/mark}", "\n", true, true, true)).to eq("  ABC\n")
+    end
+  end
+
+  describe "#replace_markers" do
+    it "should just forwards to .replace_markers" do
+      ::Bovem::Console.should_receive("replace_markers").with("A", "B")
+      console.replace_markers("A", "B")
+    end
+  end
+
+  describe "#format_right" do
+    it "should correctly align messages" do
+      message = "ABCDE"
+      extended_message = "ABC\e[AD\e[3mE"
+      console.screen_width = 80
+
+      expect(console.format_right(message)).to eq("\e[A\e[0G\e[#{75}CABCDE")
+      expect(console.format_right(message, 10)).to eq("\e[A\e[0G\e[#{5}CABCDE")
+      expect(console.format_right(extended_message)).to eq("\e[A\e[0G\e[#{75}CABC\e[AD\e[3mE")
+      expect(console.format_right(message, nil, false)).to eq("\e[0G\e[#{75}CABCDE")
+      console.screen_width = 10
+      expect(console.format_right(message)).to eq("\e[A\e[0G\e[#{5}CABCDE")
+    end
+  end
+
+  describe "#write" do
+    it "should call #format" do
+      console.should_receive("format").with("A", "B", "C", "D", "E")
+      console.write("A", "B", "C", "D", "E")
+    end
+  end
+
+  describe "#get_banner" do
+    it "should correctly format arguments" do
+      expect(console.get_banner("LABEL", "red")).to eq("{mark=blue}[{mark=red}LABEL{/mark}]{/mark}")
+      expect(console.get_banner("LABEL", "red", true)).to eq("{mark=red}[{mark=red}LABEL{/mark}]{/mark}")
+      expect(console.get_banner("LABEL", "red", false, "yellow")).to eq("{mark=yellow}[{mark=red}LABEL{/mark}]{/mark}")
+      expect(console.get_banner("LABEL", "red", false, "blue", nil)).to eq("{mark=blue}{mark=red}LABEL{/mark}{/mark}")
+      expect(console.get_banner("LABEL", "red", false, "blue", "A")).to eq("{mark=blue}A{mark=red}LABEL{/mark}{/mark}")
+      expect(console.get_banner("LABEL", "red", false, "blue", ["A", "B"])).to eq("{mark=blue}A{mark=red}LABEL{/mark}B{/mark}")
+    end
+  end
+
+  describe "#info" do
+    it "should forward everything to #get_banner" do
+      console.should_receive("get_banner").with(" INFO", "bright cyan", false).at_least(1).and_return("")
+      console.info("OK", "\n", true, false, false, false, false, false)
+      console.should_receive("get_banner").with(" INFO", "bright cyan", true).at_least(1).and_return("")
+      console.info("OK", "\n", true, false, false, false, true, false)
+    end
+
+    it "should forward everything to #write" do
+      console.should_receive("write").with(/.+/, "B", "C", "D", "E", false)
+      console.info("A", "B", "C", "D", "E", "F", "G", false)
+    end
+  end
+
+  describe "#begin" do
+    it "should forward everything to #get_banner" do
+      console.should_receive("get_banner").with("*", "bright green").at_least(1).and_return("")
+      console.begin("OK", "\n", true, false, false, false, false, false)
+    end
+
+    it "should forward everything to #write" do
+      console.should_receive("write").with(/.+/, "B", "C", "D", "E", false)
+      console.begin("A", "B", "C", "D", "E", "F", "G", false)
+    end
+  end
+
+  describe "#warn" do
+    it "should forward everything to #get_banner" do
+      console.should_receive("get_banner").with(" WARN", "bright yellow", false).at_least(1).and_return("")
+      console.warn("OK", "\n", true, false, false, false, false, false)
+      console.should_receive("get_banner").with(" WARN", "bright yellow", true).at_least(1).and_return("")
+      console.warn("OK", "\n", true, false, false, false, true, false)
+    end
+
+    it "should forward everything to #write" do
+      console.should_receive("write").with(/.+/, "B", "C", "D", "E", false)
+      console.warn("A", "B", "C", "D", "E", "F", "G", false)
+    end
+  end
+
+  describe "#error" do
+    it "should forward everything to #get_banner" do
+      console.should_receive("get_banner").with("ERROR", "bright red", false).at_least(1).and_return("")
+      console.error("OK", "\n", true, false, false, false, false, false)
+      console.should_receive("get_banner").with("ERROR", "bright red", true).at_least(1).and_return("")
+      console.error("OK", "\n", true, false, false, false, true, false)
+    end
+
+    it "should forward everything to #write" do
+      console.should_receive("write").with(/.+/, "B", "C", "D", "E", false)
+      console.error("A", "B", "C", "D", "E", "F", "G", false)
+    end
+  end
+
+  describe "#fatal" do
+    it "should forward anything to #error" do
+      Kernel.stub(:abort).and_return(true)
+      console.should_receive("error").with("A", "B", "C", "D", "E", "F", "G", false)
+      console.fatal("A", "B", "C", "D", "E", "F", "G", "H", false)
+    end
+
+    it "should call abort with the right error code" do
+      Kernel.stub(:abort).and_return(true)
+
+      Kernel.should_receive("abort").with(-1).at_least(1)
+      console.fatal("A", "B", "C", "D", "E", "F", "G", -1, false)
+      Kernel.should_receive("abort").with("H").at_least(1)
+      console.fatal("A", "B", "C", "D", "E", "F", "G", "H", false)
+    end
+  end
+
+  describe "#debug" do
+    it "should forward everything to #get_banner" do
+      console.should_receive("get_banner").with("DEBUG", "bright magenta", false).at_least(1).and_return("")
+      console.debug("OK", "\n", true, false, false, false, false, false)
+      console.should_receive("get_banner").with("DEBUG", "bright magenta", true).at_least(1).and_return("")
+      console.debug("OK", "\n", true, false, false, false, true, false)
+    end
+
+    it "should forward everything to #write" do
+      console.should_receive("write").with(/.+/, "B", "C", "D", "E", false)
+      console.debug("A", "B", "C", "D", "E", "F", "G", false)
+    end
+  end
+
+  describe "status" do
+    it "should get the right status" do
+      expect(console.status(:ok, false, true, false)).to eq({:label => " OK ", :color => "bright green"})
+      expect(console.status(:pass, false, true, false)).to eq({:label => "PASS", :color => "bright cyan"})
+      expect(console.status(:warn, false, true, false)).to eq({:label => "WARN", :color => "bright yellow"})
+      expect(console.status(:fail, false, true, false)).to eq({:label => "FAIL", :color => "bright red"})
+      expect(console.status("NO", false, true, false)).to eq({:label => "PASS", :color => "bright cyan"})
+      expect(console.status(nil, false, true, false)).to eq({:label => "PASS", :color => "bright cyan"})
+    end
+
+    it "should create the banner" do
+      console.should_receive("get_banner").with(" OK ", "bright green").and_return("")
+      console.status(:ok)
+    end
+
+    it "should format correctly" do
+      console.should_receive("format_right").with(/.+/, true, true, false)
+      console.status(:ok, false, true)
+      console.should_receive("format").with(/.+/, "\n", true, true, false)
+      console.status(:ok, false, true, false)
+    end
+  end
+
+  describe "#read" do
+    it "should show a prompt" do
+      prompt = "PROMPT"
+      Kernel.should_receive("print").with("Please insert a value: ")
+      console.read(true)
+      Kernel.should_receive("print").with(prompt + ": ")
+      console.read(prompt)
+      Kernel.should_not_receive("print")
+      console.read(nil)
+    end
+
+    it "should read a value or a default" do
+      Kernel.stub(:gets).and_return("VALUE\n")
+      expect(console.read(nil, "DEFAULT")).to eq("VALUE")
+      Kernel.stub(:gets).and_return("\n")
+      expect(console.read(nil, "DEFAULT")).to eq("DEFAULT")
+    end
+
+    it "should return the default value if the user quits" do
+      Kernel.stub(:gets).and_raise(Interrupt)
+      expect(console.read(nil, "DEFAULT")).to eq("DEFAULT")
+    end
+
+    it "should validate against an object or array validator" do
+      count = 0
+
+      Kernel.stub(:gets) do
+        if count == 0 then
+          count += 1
+          "2\n"
+        else
+          raise Interrupt
+        end
+      end
+
+      console.should_receive("write").with("Sorry, your reply was not understood. Please try again.", false, false).exactly(4)
+      count = 0
+      console.read(nil, nil, "A")
+      count = 0
+      console.read(nil, nil, "1")
+      count = 0
+      console.read(nil, nil, "nil")
+      count = 0
+      console.read(nil, nil, ["A", 1])
+    end
+
+    it "should validate against an regexp validator" do
+      count = 0
+
+      Kernel.stub(:gets) do
+        if count == 0 then
+          count += 1
+          "2\n"
+        else
+          raise Interrupt
+        end
+      end
+
+      console.should_receive("write").with("Sorry, your reply was not understood. Please try again.", false, false)
+      console.read(nil, nil, /[abc]/)
+    end
+
+    it "should hide echo to the user when the terminal shows echo" do
+      stty = %x{which stty}.strip
+
+      ::Bovem::Console.should_receive("execute").with("which stty").and_return(stty)
+      ::Bovem::Console.should_receive("execute").with(stty).and_return("speed 9600 baud;\nlflags: echoe echoke echoctl pendin\niflags: iutf8\noflags: -oxtabs\ncflags: cs8 -parenb")
+      ::Bovem::Console.should_receive("execute").with("#{stty} -echo")
+      ::Bovem::Console.should_receive("execute").with("#{stty} echo")
+      console.read(nil, nil, nil, false)
+    end
+
+    it "shouldn't hide echo again when the terminal already hides it" do
+      stty = %x{which stty}.strip
+
+      ::Bovem::Console.should_receive("execute").with("which stty").and_return(stty)
+      ::Bovem::Console.should_receive("execute").with(stty).and_return("speed 9600 baud;\nlflags: -echo echoe echoke echoctl pendin\niflags: iutf8\noflags: -oxtabs\ncflags: cs8 -parenb")
+      ::Bovem::Console.should_not_receive("execute").with("#{stty} -echo")
+      ::Bovem::Console.should_not_receive("execute").with("#{stty} echo")
+      console.read(nil, nil, nil, false)
+    end
+  end
+
+  describe "#task" do
+    it "should not print the message by default" do
+      console.should_not_receive("begin")
+      console.task { :ok }
+    end
+
+    it "should print the message and indentate correctly" do
+      console.should_receive("begin").with("A", "B", "C", "D", "E", "F", "G")
+      console.should_receive("with_indentation").with("H", "I")
+      console.task("A", "B", "C", "D", "E", "F", "G", "H", "I") { :ok }
+    end
+
+    it "should execute the given block" do
+      ::Bovem::Console.should_receive("foo")
+      console.task { ::Bovem::Console.foo }
+    end
+
+    it "should write the correct status" do
+      console.should_receive(:status).with(:ok, false)
+      console.task { :ok }
+      console.should_receive(:status).with(:fail, false)
+      expect { console.task { :fatal }}.to raise_error(SystemExit)
+    end
+
+    it "should abort correctly" do
+      expect { console.task { [:fatal, -1] }}.to raise_error(SystemExit)
+    end
+  end
+end

data/spec/bovem/logger_spec.rb

@@ -7,41 +7,37 @@
 require "spec_helper"
 
 describe Bovem::Logger do
-  before(:each) do
-    Sickill::Rainbow.enabled = false
-  end
-
   describe ".create" do
     it("should create a new default logger") do
-      logger = Bovem::Logger.create
-      expect(logger.device).to eq(Bovem::Logger.default_file)
+      logger = ::Bovem::Logger.create
+      expect(logger.device).to eq(::Bovem::Logger.default_file)
       expect(logger.level).to eq(::Logger::INFO)
-      expect(logger.formatter).to eq(Bovem::Logger.default_formatter)
+      expect(logger.formatter).to eq(::Bovem::Logger.default_formatter)
     end
 
     it("should create a logger with a custom file and level") do
-      logger = Bovem::Logger.create("/dev/null", ::Logger::WARN)
+      logger = ::Bovem::Logger.create("/dev/null", ::Logger::WARN)
       expect(logger.device).to eq("/dev/null")
       expect(logger.level).to eq(::Logger::WARN)
-      expect(logger.formatter).to eq(Bovem::Logger.default_formatter)
+      expect(logger.formatter).to eq(::Bovem::Logger.default_formatter)
     end
 
     it("should create a logger with a custom formatter") do
       formatter = Proc.new {|severity, datetime, progname, msg| msg }
-      logger = Bovem::Logger.create("/dev/null", ::Logger::WARN, formatter)
+      logger = ::Bovem::Logger.create("/dev/null", ::Logger::WARN, formatter)
       expect(logger.device).to eq("/dev/null")
       expect(logger.level).to eq(::Logger::WARN)
       expect(logger.formatter).to eq(formatter)
     end
 
     it("should raise exceptions for invalid files") do
-      expect { Bovem::Logger.create("/invalid/file") }.to raise_error(Bovem::Errors::InvalidLogger)
+      expect { ::Bovem::Logger.create("/invalid/file") }.to raise_error(::Bovem::Errors::InvalidLogger)
     end
   end
 
   describe ".default_formatter" do
     let(:output) { ::StringIO.new }
-    let(:logger) { Bovem::Logger.create(output, Logger::DEBUG) }
+    let(:logger) { ::Bovem::Logger.create(output, Logger::DEBUG) }
 
     def get_last_line(buffer)
       buffer.string.split("\n").last.strip.gsub(/ T\+\d+\.\d+/, "")
@@ -49,52 +45,52 @@ describe Bovem::Logger do
 
     it "should correctly format a DEBUG message" do
       logger.debug("Message.")
-      expect(get_last_line(output)).to eq("[#{::Time.now.strftime("%Y/%b/%d %H:%M:%S")}] DEBUG: Message.")
+      expect(get_last_line(output)).to eq("\e[1m\e[36m[#{::Time.now.strftime("%Y/%b/%d %H:%M:%S")}] DEBUG:\e[0m Message.")
     end
 
     it "should correctly format a INFO message" do
       logger.info("Message.")
-      expect(get_last_line(output)).to eq("[#{::Time.now.strftime("%Y/%b/%d %H:%M:%S")}]  INFO: Message.")
+      expect(get_last_line(output)).to eq("\e[1m\e[32m[#{::Time.now.strftime("%Y/%b/%d %H:%M:%S")}]  INFO:\e[0m Message.")
     end
 
     it "should correctly format a WARN message" do
       logger.warn("Message.")
-      expect(get_last_line(output)).to eq("[#{::Time.now.strftime("%Y/%b/%d %H:%M:%S")}]  WARN: Message.")
+      expect(get_last_line(output)).to eq("\e[1m\e[33m[#{::Time.now.strftime("%Y/%b/%d %H:%M:%S")}]  WARN:\e[0m Message.")
     end
 
     it "should correctly format a ERROR message" do
       logger.error("Message.")
-      expect(get_last_line(output)).to eq("[#{::Time.now.strftime("%Y/%b/%d %H:%M:%S")}] ERROR: Message.")
+      expect(get_last_line(output)).to eq("\e[1m\e[31m[#{::Time.now.strftime("%Y/%b/%d %H:%M:%S")}] ERROR:\e[0m Message.")
     end
 
     it "should correctly format a FATAL message" do
       logger.fatal("Message.")
-      expect(get_last_line(output)).to eq("[#{::Time.now.strftime("%Y/%b/%d %H:%M:%S")}] FATAL: Message.")
+      expect(get_last_line(output)).to eq("\e[1m\e[35m[#{::Time.now.strftime("%Y/%b/%d %H:%M:%S")}] FATAL:\e[0m Message.")
     end
 
     it "should correctly format a INVALID message" do
       logger.log(::Logger::UNKNOWN, "Message.")
-      expect(get_last_line(output)).to eq("[#{::Time.now.strftime("%Y/%b/%d %H:%M:%S")}]   ANY: Message.")
+      expect(get_last_line(output)).to eq("\e[1m\e[37m[#{::Time.now.strftime("%Y/%b/%d %H:%M:%S")}]   ANY:\e[0m Message.")
     end
   end
 
   describe ".get_real_file" do
     it("should return the standard ouput") do 
-      expect(Bovem::Logger.get_real_file("STDOUT")).to eq($stdout )
+      expect(::Bovem::Logger.get_real_file("STDOUT")).to eq($stdout )
     end
     
     it("should return the standard error") do 
-      expect(Bovem::Logger.get_real_file("STDERR")).to eq($stderr )
+      expect(::Bovem::Logger.get_real_file("STDERR")).to eq($stderr )
     end
     
     it("should return the file") do 
-      expect(Bovem::Logger.get_real_file("/dev/null")).to eq("/dev/null" )
+      expect(::Bovem::Logger.get_real_file("/dev/null")).to eq("/dev/null" )
     end
   end
 
   describe ".default_file" do
     it("should return the standard output") do
-      expect(Bovem::Logger.default_file).to eq($stdout)
+      expect(::Bovem::Logger.default_file).to eq($stdout)
     end
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: bovem
 version: !ruby/object:Gem::Version
-  version: 0.6.0
+  version: 0.8.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-08-04 00:00:00.000000000 Z
+date: 2012-08-16 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: lazier
@@ -27,22 +27,6 @@ dependencies:
     - - ~>
       - !ruby/object:Gem::Version
         version: '1.0'
-- !ruby/object:Gem::Dependency
-  name: rainbow
-  requirement: !ruby/object:Gem::Requirement
-    none: false
-    requirements:
-    - - ~>
-      - !ruby/object:Gem::Version
-        version: 1.1.0
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    none: false
-    requirements:
-    - - ~>
-      - !ruby/object:Gem::Version
-        version: 1.1.0
 - !ruby/object:Gem::Dependency
   name: rspec
   requirement: !ruby/object:Gem::Requirement
@@ -164,6 +148,7 @@ extra_rdoc_files: []
 files:
 - .gitignore
 - .travis.yml
+- .yardopts
 - Gemfile
 - Gemfile.lock
 - README.md
@@ -171,10 +156,12 @@ files:
 - bovem.gemspec
 - lib/bovem.rb
 - lib/bovem/configuration.rb
+- lib/bovem/console.rb
 - lib/bovem/errors.rb
 - lib/bovem/logger.rb
 - lib/bovem/version.rb
 - spec/bovem/configuration_spec.rb
+- spec/bovem/console_spec.rb
 - spec/bovem/logger_spec.rb
 - spec/coverage_helper.rb
 - spec/spec_helper.rb
@@ -192,7 +179,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: 2994685413523034481
+      hash: 1005901381076848041
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements:
@@ -201,7 +188,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: 2994685413523034481
+      hash: 1005901381076848041
 requirements: []
 rubyforge_project: bovem
 rubygems_version: 1.8.24
@@ -210,6 +197,7 @@ specification_version: 3
 summary: A collection of utilities for developers.
 test_files:
 - spec/bovem/configuration_spec.rb
+- spec/bovem/console_spec.rb
 - spec/bovem/logger_spec.rb
 - spec/coverage_helper.rb
 - spec/spec_helper.rb