bovem 0.8.1 → 1.0.0

data/Gemfile.lock

@@ -1,8 +1,9 @@
 PATH
   remote: .
   specs:
-    bovem (0.8.1)
+    bovem (1.0.0)
       lazier (~> 1.0)
+      open4 (~> 1.3.0)
 
 GEM
   remote: http://rubygems.org/
@@ -38,6 +39,7 @@ GEM
       tzinfo (~> 0.3.0)
     method_source (0.8)
     multi_json (1.3.6)
+    open4 (1.3.0)
     pry (0.9.10)
       coderay (~> 1.0.5)
       method_source (~> 0.8)

data/bovem.gemspec

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

data/lib/bovem.rb

@@ -6,6 +6,8 @@
 
 require "logger"
 require "lazier"
+require "open4"
+require "find"
 
 Lazier.load!(:object)
 
@@ -13,4 +15,5 @@ require "bovem/version" if !defined?(Bovem::Version)
 require "bovem/errors"
 require "bovem/configuration"
 require "bovem/logger"
-require "bovem/console"
+require "bovem/console"
+require "bovem/shell"

data/lib/bovem/configuration.rb

@@ -5,7 +5,7 @@
 #
 
 module Bovem
-  # This class holds the configuration of the applicaton.
+  # This class holds the configuration of an applicaton.
   #
   # Extend this class and add valid properties via {property property} method.
   # Example:
@@ -31,7 +31,7 @@ module Bovem
       self.parse(file, overrides, logger)
     end
 
-    # Creates a new configuration.
+    # Parses a configuration file.
     #
     # A configuration file is a plain Ruby file with a top-level {Configuration config} object.
     #
@@ -69,7 +69,7 @@ module Bovem
       self
     end
 
-    # Defines a new property for the configuration
+    # Defines a new property for the configuration.
     #
     # @param name [Symbol] The name of the property.
     # @param options [Hash] A set of options for the property. Currently, only `:default` (which holds the default value) is supported.

data/lib/bovem/console.rb

@@ -61,14 +61,15 @@ module Bovem
 
     # 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.
+    # 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)
       rv = ""
+      style = style.ensure_string.strip.parameterize
 
-      if style.present? then
+      if style.present? && style !~ /^[,-]$/ then
         style = style.ensure_string
         sym = style.to_sym
 
@@ -87,16 +88,25 @@ module Bovem
 
     # Replaces colors markers in a string.
     #
+    # You can specify markers by enclosing in `{mark=[style]}` and `{/mark}` tags. Separate styles with spaces, dashes or commas. Nesting markers is supported.
+    #
+    # Example:
+    #
+    # ```ruby
+    # Bovem::Console.new.replace_markers("{mark=bright bg_red}{mark=green}Hello world!{/mark}{/mark}")
+    # # => "\e[1m\e[41m\e[32mHello world!\e[1m\e[41m\e[0m"
+    # ```
+    #
     # @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 = []
+      mark_regexp = /((\{mark=([a-z\-_\s,]+)\})|(\{\/mark\}))/mi
+      split_regex = /\s*[\s,-]\s*/
 
-      regexp = /((\{mark=([a-z\-_]+)\})|(\{\/mark\}))/mi
-
-      message = message.gsub(regexp) do
+      message = message.gsub(mark_regexp) do
         tag = $1
         styles = $3
         replacement = ""
@@ -104,9 +114,9 @@ module Bovem
         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("")
+          replacement = plain || stack.blank? ? "" : styles.split(split_regex).collect { |s| self.parse_style(s) }.join("")
         else
-          replacement = plain ? "" : styles.split("-").collect { |s| self.parse_style(s) }.join("")
+          replacement = plain ? "" : styles.split(split_regex).collect { |s| self.parse_style(s) }.join("")
 
           if replacement.length > 0 then
             stack << "reset" if stack.blank?
@@ -165,7 +175,7 @@ module Bovem
     # @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)
+    def with_indentation(width = 3, is_absolute = false)
       old = self.indentation
       self.set_indentation(width, is_absolute)
       yield
@@ -194,7 +204,7 @@ module Bovem
     # 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 width [Fixnum] The indentation width. `true` means to use the current 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")
@@ -212,10 +222,10 @@ module Bovem
 
     # 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.
+    # @see .replace_markers
     #
     # @param message [String] The message to analyze.
-    # @param plain [Boolean] If ignore (cleanify )color markers into the message.
+    # @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)
@@ -223,11 +233,13 @@ module Bovem
 
     # Formats a message.
     #
-    # You can style text by using `{color}` and `{reset}` syntax.
+    # You can style text by using `{mark}` and `{/mark}` syntax.
+    #
+    # @see #replace_markers
     #
     # @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 indent [Object] If not `nil` or `false`, the width to use for indentation. `true` means to use the current 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.
@@ -268,7 +280,7 @@ module Bovem
     #
     # @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 indent [Object] If not `nil` or `false`, the width to use for indentation. `true` means to use the current 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.
@@ -296,7 +308,7 @@ module Bovem
         :warn => {:label => "WARN", :color => "bright yellow"},
         :fail => {:label => "FAIL", :color => "bright red"}
       }
-      statuses.default = statuses[:pass]
+      statuses.default = statuses[:ok]
 
       rv = statuses[status]
 
@@ -328,11 +340,11 @@ module Bovem
       "{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.
+    # Writes a message prepending a cyan 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 indent [Object] If not `nil` or `false`, the width to use for indentation. `true` means to use the current 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.
@@ -346,11 +358,11 @@ module Bovem
       self.write(banner + " " + message, suffix, indented_banner ? indent : 0, wrap, plain, print)
     end
 
-    # Writes a message prepending a green type banner.
+    # Writes a message prepending a green 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 indent [Object] If not `nil` or `false`, the width to use for indentation. `true` means to use the current 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.
@@ -364,11 +376,11 @@ module Bovem
       self.write(banner + " " + message, suffix, indented_banner ? indent : 0, wrap, plain, print)
     end
 
-    # Writes a message prepending a yellow type banner.
+    # Writes a message prepending a yellow 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 indent [Object] If not `nil` or `false`, the width to use for indentation. `true` means to use the current 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.
@@ -382,11 +394,11 @@ module Bovem
       self.write(banner + " " + message, suffix, indented_banner ? indent : 0, wrap, plain, print)
     end
 
-    # Writes a message prepending a red type banner.
+    # Writes a message prepending a red 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 indent [Object] If not `nil` or `false`, the width to use for indentation. `true` means to use the current 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.
@@ -400,11 +412,11 @@ module Bovem
       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.
+    # Writes a message prepending a red 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 indent [Object] If not `nil` or `false`, the width to use for indentation. `true` means to use the current 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.
@@ -415,14 +427,14 @@ module Bovem
     # @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)
+      Kernel.exit(return_code.to_integer(-1))
     end
 
-    # Writes a message prepending a magenta type banner.
+    # Writes a message prepending a magenta 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 indent [Object] If not `nil` or `false`, the width to use for indentation. `true` means to use the current 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.
@@ -443,8 +455,6 @@ module Bovem
     # @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
@@ -495,11 +505,11 @@ module Bovem
       end
     end
 
-    # Execute a block of code in a indentation region and then prints out and ending status message.
+    # Executes 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 indent [Object] If not `nil` or `false`, the width to use for indentation. `true` means to use the current 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.

data/lib/bovem/logger.rb

@@ -13,7 +13,8 @@ module Bovem
     # The file or device to log messages to.
     attr_reader :device
 
-    # Creates a new logger
+    # Creates a new logger.
+    #
     # @see http://www.ruby-doc.org/stdlib-1.9.3/libdoc/logger/rdoc/Logger.html
     #
     # @param logdev [String|IO] The log device. This is a filename (String) or IO object (typically STDOUT, STDERR, or an open file).
@@ -24,7 +25,7 @@ module Bovem
       super(logdev, shift_age, shift_size)
     end
 
-    # Creates a new logger
+    # Creates a new logger.
     #
     # @param file [String|IO] The log device. This is a filename (String) or IO object (typically STDOUT, STDERR, or an open file).
     # @param level [Fixnum] The minimum severity to log. See http://www.ruby-doc.org/stdlib-1.9.3/libdoc/logger/rdoc/Logger.html for valid levels.

data/lib/bovem/shell.rb

@@ -0,0 +1,377 @@
+# 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
+  # A utility class for most common shell operation.
+  class Shell
+    # A {Console Console} instance.
+    attr_accessor :console
+
+    # Returns a unique instance for Shell.
+    #
+    # @return [Shell] A new instance.
+    def self.instance
+      @instance ||= ::Bovem::Shell.new
+    end
+
+    # Initializes a new Shell.
+    def initialize
+      @console = ::Bovem::Console.instance
+    end
+
+    # Runs a command into the shell.
+    #
+    # @param command [String] The string to run.
+    # @param message [String] A message to show before running.
+    # @param run [Boolean] If `false`, it will just print a message with the full command that will be run.
+    # @param show_exit [Boolean] If show the exit status.
+    # @param show_output [Boolean] If show command output.
+    # @param fatal [Boolean] If quit in case of fatal errors.
+    # @return [Hash] An hash with `status` and `output` keys.
+    def run(command, message = nil, run = true, show_exit = true, show_output = false, fatal = true)
+      rv = {:status => 0, :output => ""}
+      command = command.ensure_string
+
+      # Show the command
+      self.console.begin(message) if message.present?
+
+
+      if !run then # Print a message
+        self.console.warn("Will run command: {mark=bright}\"#{command}\"{/mark}...")
+        self.console.status(:ok) if show_exit
+      else # Run
+        output = ""
+
+        rv[:status] = ::Open4::open4(command + " 2>&1") { |pid, stdin, stdout, stderr|
+          stdout.each_line do |line|
+            output << line
+            Kernel.print line if show_output
+          end
+        }.exitstatus
+
+        rv[:output] = output
+      end
+
+      # Return
+      self.console.status(rv[:status] == 0 ? :ok : :fail) if show_exit
+      exit(rv[:status]) if fatal && rv[:status] != 0
+      rv
+    end
+
+    # Tests a path against a list of test.
+    #
+    # Valid tests are every method available in http://www.ruby-doc.org/core-1.9.3/FileTest.html (plus `read`, `write`, `execute`, `exec`, `dir`). Trailing question mark can be omitted.
+    #
+    #
+    # @param path [String] The path to test.
+    # @param tests [Array] The list of tests to perform.
+    def check(path, tests)
+      path = path.ensure_string
+
+      tests.ensure_array.all? {|test|
+        # Adjust test name
+        test = test.ensure_string.strip
+
+        test = case test
+          when "read" then "readable"
+          when "write" then "writable"
+          when "execute", "exec" then "executable"
+          when "dir" then "directory"
+          else test
+        end
+
+        # Execute test
+        test += "?" if test !~ /\?$/
+        FileTest.respond_to?(test) ? FileTest.send(test, path) : nil
+      }
+    end
+
+    # Deletes a list of files.
+    #
+    # @param files [Array] The list of files to remove
+    # @param run [Boolean] If `false`, it will just print a list of message that would be deleted.
+    # @param show_errors [Boolean] If show errors.
+    # @param fatal [Boolean] If quit in case of fatal errors.
+    # @return [Boolean] `true` if operation succeeded, `false` otherwise.
+    def delete(files, run = true, show_errors = false, fatal = true)
+      rv = true
+      files = files.ensure_array.compact.collect {|f| File.expand_path(f.ensure_string) }
+
+      if !run then
+        self.console.warn("Will remove file(s):")
+        self.console.with_indentation(11) do
+          files.each do |file| self.console.write(file) end
+        end
+      else
+        rv = catch(:rv) do
+          begin
+            FileUtils.rm_r(files, {:noop => false, :verbose => false, :secure => true})
+            throw(:rv, true)
+          rescue Errno::EACCES => e
+            self.console.send(fatal ? :fatal : :error, "Cannot remove following non writable file: {mark=bright}#{e.message.gsub(/.+ - (.+)/, "\\1")}{/mark}")
+          rescue Errno::ENOENT => e
+            self.console.send(fatal ? :fatal : :error, "Cannot remove following non existent file: {mark=bright}#{e.message.gsub(/.+ - (.+)/, "\\1")}{/mark}")
+          rescue Exception => e
+            if show_errors then
+              self.console.error("Cannot remove following file(s):")
+              self.console.with_indentation(11) do
+                files.each do |file| self.console.write(file) end
+              end
+              self.console.write("due to this error: [#{e.class.to_s}] #{e}.", "\n", 5)
+              Kernel.exit(-1) if fatal
+            end
+          end
+
+          false
+        end
+      end
+
+      rv
+    end
+
+    # Copies or moves a set of files or directory to another location.
+    #
+    # @param src [String|Array] The entries to copy or move. If is an Array, `dst` is assumed to be a directory.
+    # @param dst [String] The destination. **Any existing entries will be overwritten.** Any required directory will be created.
+    # @param operation [Symbol] The operation to perform. Valid values are `:copy` or `:move`.
+    # @param run [Boolean] If `false`, it will just print a list of message that would be copied or moved.
+    # @param show_errors [Boolean] If show errors.
+    # @param fatal [Boolean] If quit in case of fatal errors.
+    # @return [Boolean] `true` if operation succeeded, `false` otherwise.
+    def copy_or_move(src, dst, operation, run = true, show_errors = false, fatal = true)
+      rv = true
+      operation = :copy if operation != :move
+      single = !src.is_a?(Array)
+
+      if single then
+        src = File.expand_path(src)
+      else
+        src = src.collect {|s| File.expand_path(s) }
+      end
+
+      dst = File.expand_path(dst.ensure_string)
+
+      if !run then
+        if single then
+          self.console.warn("Will #{operation} a file:")
+          self.console.write("From: {mark=bright}#{File.expand_path(src.ensure_string)}{/mark}", "\n", 11)
+          self.console.write("To: {mark=bright}#{dst}{/mark}", "\n", 11)
+        else
+          self.console.warn("Will #{operation} following entries:")
+          self.console.with_indentation(11) do
+            src.each do |s| self.console.write(s) end
+          end
+          self.console.write("to directory: {mark=bright}#{dst}{/mark}", "\n", 5)
+        end
+      else
+        rv = catch(:rv) do
+          dst_dir = single ? File.dirname(dst) : dst
+          has_dir = self.check(dst_dir, :dir)
+
+          # Create directory
+          has_dir = self.create_directories(dst_dir, 0755, true, show_errors, fatal) if !has_dir
+          throw(:rv, false) if !has_dir
+
+          if single && self.check(dst, :dir) then
+            @console.send(fatal ? :fatal : :error, "Cannot #{operation} file {mark=bright}#{src}{/mark} to {mark=bright}#{dst}{/mark} because it is currently a directory.")
+            throw(:rv, false)
+          end
+
+          # Check that every file is existing
+          src.ensure_array.each do |s|
+            if !self.check(s, :exists) then
+              @console.send(fatal ? :fatal : :error, "Cannot #{operation} non existent file {mark=bright}#{s}{/mark}.")
+              throw(:rv, false)
+            end
+          end
+
+          # Do operation
+          begin
+            FileUtils.send(operation == :move ? :move : :cp_r, src, dst, {:noop => false, :verbose => false})
+          rescue Errno::EACCES => e
+            if single then
+              @console.send(fatal ? :fatal : :error, "Cannot #{operation} file {mark=bright}#{src}{/mark} to non writable directory {mark=bright}#{dst_dir}{/mark}.")
+            else
+              self.console.error("Cannot #{operation} following file(s) to non writable directory {mark=bright}#{dst}{/mark}:")
+              self.console.with_indentation(11) do
+                src.each do |s| self.console.write(s) end
+              end
+              Kernel.exit(-1) if fatal
+            end
+
+            throw(:rv, false)
+          rescue Exception => e
+            if single then
+              @console.send(fatal ? :fatal : :error, "Cannot #{operation} file {mark=bright}#{src}{/mark} to directory {mark=bright}#{dst_dir}{/mark} due to this error: [#{e.class.to_s}] #{e}.", "\n", 5)
+            else
+              self.console.error("Cannot #{operation} following entries to {mark=bright}#{dst}{/mark}:")
+              self.console.with_indentation(11) do
+                src.each do |s| self.console.write(s) end
+              end
+              self.console.write("due to this error: [#{e.class.to_s}] #{e}.", "\n", 5)
+              Kernel.exit(-1) if fatal
+            end
+
+            throw(:rv, false)
+          end
+
+          true
+        end
+      end
+
+      rv
+    end
+
+    # Copies a set of files or directory to another location.
+    #
+    # @param src [String|Array] The entries to copy. If is an Array, `dst` is assumed to be a directory.
+    # @param dst [String] The destination. **Any existing entries will be overwritten.** Any required directory will be created.
+    # @param run [Boolean] If `false`, it will just print a list of message that would be copied or moved.
+    # @param show_errors [Boolean] If show errors.
+    # @param fatal [Boolean] If quit in case of fatal errors.
+    # @return [Boolean] `true` if operation succeeded, `false` otherwise.
+    def copy(src, dst, run = true, show_errors = false, fatal = true)
+      self.copy_or_move(src, dst, :copy, run, show_errors, fatal)
+    end
+
+    # Moves a set of files or directory to another location.
+    #
+    # @param src [String|Array] The entries to move. If is an Array, `dst` is assumed to be a directory.
+    # @param dst [String] The destination. **Any existing entries will be overwritten.** Any required directory will be created.
+    # @param run [Boolean] If `false`, it will just print a list of message that would be deleted.
+    # @param show_errors [Boolean] If show errors.
+    # @param fatal [Boolean] If quit in case of fatal errors.
+    # @return [Boolean] `true` if operation succeeded, `false` otherwise.
+    def move(src, dst, run = true, show_errors = false, fatal = true)
+      self.copy_or_move(src, dst, :move, run, show_errors, fatal)
+    end
+
+    # Executes a block of code in another directory.
+    #
+    # @param directory [String] The new working directory.
+    # @param restore [Boolean] If to restore the original working directory.
+    # @param show_messages [Boolean] Show informative messages about working directory changes.
+    # @return [Boolean] `true` if the directory was valid and the code executed, `false` otherwise.
+    def within_directory(directory, restore = true, show_messages = false)
+      rv = false
+      original = Dir.pwd
+      directory = File.expand_path(directory.ensure_string)
+
+      if self.check(directory, [:directory, :executable]) then
+        begin
+          self.console.info("Moving into directory {mark=bright}#{directory}{/mark}")
+          Dir.chdir(directory)
+          rv = true
+        rescue Exception => e
+        end
+      end
+
+      yield if rv && block_given?
+
+      if rv && original then
+        begin
+          self.console.info("Moving back into directory {mark=bright}#{original}{/mark}")
+          Dir.chdir(original) if restore
+        rescue Exception => e
+          rv = false
+        end
+      end
+
+      rv
+    end
+
+    # Creates a list of directories, included missing parent directories.
+    #
+    # @param directories [Array] The list of directories to create.
+    # @param mode [Fixnum] Initial permissions for the new directories.
+    # @param run [Boolean] If `false`, it will just print a list of directories that would be created.
+    # @param show_errors [Boolean] If show errors.
+    # @param fatal [Boolean] If quit in case of fatal errors.
+    # @return [Boolean] `true` if operation succeeded, `false` otherwise.
+    def create_directories(directories, mode = 0755, run = true, show_errors = false, fatal = true)
+      rv = true
+
+      # Adjust directory
+      directories = directories.ensure_array.compact {|d| File.expand_path(d.ensure_string) }
+
+      if !run then # Just print
+        self.console.warn("Will create directories:")
+        self.console.with_indentation(11) do
+          directories.each do |directory| self.console.write(directory) end
+        end
+      else
+        directories.each do |directory|
+          rv = catch(:rv) do
+            # Perform tests
+            if self.check(directory, :directory) then
+              self.console.send(fatal ? :fatal : :error, "The directory {mark=bright}#{directory}{/mark} already exists.")
+            elsif self.check(directory, :exist) then
+              self.console.send(fatal ? :fatal : :error, "Path {mark=bright}#{directory}{/mark} is currently a file.")
+            else
+              begin # Create directory
+                FileUtils.mkdir_p(directory, {:mode => mode, :noop => false, :verbose => false})
+                throw(:rv, true)
+              rescue Errno::EACCES => e
+                self.console.send(fatal ? :fatal : :error, "Cannot create following directory due to permission denied: {mark=bright}#{e.message.gsub(/.+ - (.+)/, "\\1")}{/mark}.")
+              rescue Exception => e
+                if show_errors then
+                  self.console.error("Cannot create following directories:")
+                  self.console.with_indentation(11) do
+                    directories.each do |directory| self.console.write(directory) end
+                  end
+                  self.console.write("due to this error: [#{e.class.to_s}] #{e}.", "\n", 5)
+                  Kernel.exit(-1) if fatal
+                end
+              end
+            end
+
+            false
+          end
+
+          break if !rv
+        end
+      end
+
+      rv
+    end
+
+    # Find a list of files in directories matching given regexps or patterns.
+    #
+    # @param directories [String] A list of directories where to search files.
+    # @param patterns [Array] A list of regexps or patterns to match files. If empty, every file is returned.
+    # @param by_extension [Boolean] If to only search in extensions.
+    # @param case_sensitive [Boolean] If the search is case sensitive. Only meaningful for string patterns.
+    def find(directories, patterns = [], by_extension = false, case_sensitive = false)
+      rv = []
+
+      # Adjust directory
+      directories = directories.ensure_array.compact {|d| File.expand_path(d.ensure_string) }
+
+      # Adjust patterns
+      patterns = patterns.ensure_array.compact.collect {|p| p.is_a?(::Regexp) ? p : Regexp.new(Regexp.quote(p.ensure_string)) }
+      patterns = patterns.collect {|p| /(#{p.source})$/ } if by_extension
+      patterns = patterns.collect {|p| /#{p.source}/i } if !case_sensitive
+
+      directories.each do |directory|
+        if self.check(directory, [:directory, :readable, :executable]) then
+          Find.find(directory) do |entry|
+            found = patterns.blank? ? true : catch(:found) do
+              patterns.each do |pattern|
+                throw(:found, true) if pattern.match(entry) && (!by_extension || !File.directory?(entry))
+              end
+
+              false
+            end
+
+            rv << entry if found
+          end
+        end
+      end
+
+      rv
+    end
+  end
+end