bovem 3.0.5 → 4.0.0

data/lib/bovem/shell.rb

@@ -9,47 +9,32 @@ module Bovem
   module ShellMethods
     # General methods.
     module General
-      # Handles general failure of a file/directory method.
-      #
-      # @param e [Exception] The occurred exception.
-      # @param access_error [String|Symbol] The message to show in case of access errors.
-      # @param not_found_error [String|Symbol] The message to show in case of a not found entry.
-      # @param general_error [String|Symbol] The message to show in case of other errors.
-      # @param entries [Array] The list of entries which failed.
-      # @param fatal [Boolean] If quit in case of fatal errors.
-      # @param show_errors [Boolean] Whether to show errors.
+      private
+
+      # :nodoc:
       def handle_failure(e, access_error, not_found_error, general_error, entries, fatal, show_errors)
-        error_type, locale, final_entries = setup_error_handling(entries, fatal)
+        error_type, final_entries = setup_error_handling(entries, fatal)
 
         case e.class.to_s
-          when "Errno::EACCES" then @console.send(error_type, locale.send(access_error, final_entries))
-          when "Errno::ENOENT" then @console.send(error_type, locale.send(not_found_error, final_entries))
-          else show_general_failure(e, general_error, entries, fatal) if show_errors
+        when "Errno::EACCES" then @console.send(error_type, i18n.send(access_error, final_entries))
+        when "Errno::ENOENT" then @console.send(error_type, i18n.send(not_found_error, final_entries))
+        else show_general_failure(e, general_error, entries, fatal) if show_errors
         end
       end
 
-      # Setups error handling.
-      #
-      # @param entries [Array] The list of entries which failed.
-      # @param fatal [Boolean] If quit in case of fatal errors.
-      # @return [Array] Variables for error handling
+      # :nodoc:
       def setup_error_handling(entries, fatal)
-        [fatal ? :fatal : :error, i18n.shell, entries.length == 1 ? entries[0] : entries]
+        [fatal ? :fatal : :error, entries.length == 1 ? entries[0] : entries]
       end
 
-      # Shows errors when a directory creation failed.
-      #
-      # @param e [Exception] The occurred exception.
-      # @param entries [Array] The list of entries which failed.
-      # @param fatal [Boolean] If quit in case of fatal errors.
+      # :nodoc:
       def show_general_failure(e, general_error, entries, fatal)
-        locale = i18n.shell
-
-        @console.error(locale.send(general_error))
+        @console.error(i18n.send(general_error))
         @console.with_indentation(11) do
-          entries.each do |entry| @console.write(entry) end
+          entries.each { |entry| @console.write(entry) }
         end
-        @console.write(locale.error(e.class.to_s, e), "\n", 5)
+
+        @console.write(i18n.error(e.class.to_s, e), suffix: "\n", indented: 5)
         Kernel.exit(-1) if fatal
       end
     end
@@ -58,55 +43,56 @@ module Bovem
     module Read
       # 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.
+      # Valid tests are every method available in http://www.ruby-doc.org/core-2.3.0/FileTest.html (plus `read`, `write`, `execute`, `exec`, `dir`).
+      #   Trailing question mark can be omitted. Unrecognized tests will make the check fail.
       #
       # @param path [String] The path to test.
       # @param tests [Array] The list of tests to perform.
-      def check(path, tests)
+      def check(path, *tests)
         path = path.ensure_string
 
-        tests.ensure_array.all? { |test|
+        tests.ensure_array(no_duplicates: true, compact: true, flatten: true).all? do |test|
           # Adjust test name
           test = test.ensure_string.strip
 
-          test = case test
+          test =
+            case test
             when "read" then "readable"
             when "write" then "writable"
             when "execute", "exec" then "executable"
             when "dir" then "directory"
             else test
-          end
+            end
 
           # Execute test
           test += "?" if test !~ /\?$/
           FileTest.respond_to?(test) ? FileTest.send(test, path) : nil
-        }
+        end
       end
 
       # Find a list of files in directories matching given regexps or patterns.
       #
-      # You can also pass a block to perform matching. The block will receive a single argument and the path will be considered matched if the blocks not evaluates to `nil` or `false`.
+      # You can also pass a block to perform matching. The block will receive a single argument and the path will be considered if return value is not falsey.
       #
       # Inside the block, you can call `Find.prune` to stop searching in the current directory.
       #
       # @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. Ignored if a block is provided.
-      # @param by_extension [Boolean] If to only search in extensions. Ignored if a block is provided.
+      # @param extension_only [Boolean] If to only search in extensions. Ignored if a block is provided.
       # @param case_sensitive [Boolean] If the search is case sensitive. Only meaningful for string patterns.
       # @param block [Proc] An optional block to perform matching instead of pattern matching.
-      def find(directories, patterns = [], by_extension = false, case_sensitive = false, &block)
+      def find(directories, patterns: [], extension_only: false, case_sensitive: false, &block)
         rv = []
 
-        directories = directories.ensure_array(nil, true, true) {|d| File.expand_path(d.ensure_string) }
-        patterns = normalize_patterns(patterns, by_extension, case_sensitive)
+        directories = directories.ensure_array(no_duplicates: true, compact: true, flatten: true) { |d| File.expand_path(d.ensure_string) }
+        patterns = normalize_patterns(patterns, extension_only, case_sensitive)
 
         directories.each do |directory|
-          if check(directory, [:directory, :readable, :executable]) then
-            Find.find(directory) do |entry|
-              found = patterns.blank? ? true : match_pattern(entry, patterns, by_extension, &block)
+          next unless check(directory, [:directory, :readable, :executable])
+          Find.find(directory) do |entry|
+            found = patterns.blank? ? true : match_pattern(entry, patterns, extension_only, &block)
 
-              rv << entry if found
-            end
+            rv << entry if found
           end
         end
 
@@ -114,40 +100,33 @@ module Bovem
       end
 
       private
-        # Normalizes a set of patterns to find.
-        #
-        # @param patterns [Array] A list of regexps or patterns to match files. If empty, every file is returned. Ignored if a block is provided.
-        # @param by_extension [Boolean] If to only search in extensions. Ignored if a block is provided.
-        # @param case_sensitive [Boolean] If the search is case sensitive. Only meaningful for string patterns.
-        # @return [Array] The normalized patterns.
-        def normalize_patterns(patterns, by_extension, case_sensitive)
-          # Adjust patterns
-          patterns = patterns.ensure_array(nil, true, true) {|p| p.is_a?(::Regexp) ? p : Regexp.new(Regexp.quote(p.ensure_string)) }
-          patterns = patterns.map {|p| /(#{p.source})$/ } if by_extension
-          patterns = patterns.map {|p| /#{p.source}/i } if !case_sensitive
-          patterns
+
+      # :nodoc:
+      def normalize_patterns(patterns, by_extension, case_sensitive)
+        # Adjust patterns
+        patterns = patterns.ensure_array(no_duplicates: true, compact: true, flatten: true) do |p|
+          p.is_a?(::Regexp) ? p : Regexp.new(Regexp.quote(p.ensure_string))
         end
 
-        # Matches an entry against a set of patterns or a procedure.
-        #
-        # @param entry [String] The entry to search.
-        # @param patterns [Array] A list of regexps or patterns to match files. If empty, every file is returned. Ignored if a block is provided.
-        # @param by_extension [Boolean] If to only search in extensions. Ignored if a block is provided.
-        # @param block [Proc|nil] An optional block to run instead of pattern matching.
-        # @return [Boolean] `true` if entry matched, `false` otherwise.
-        def match_pattern(entry, patterns, by_extension, &block)
-          catch(:found) do
-            if block then
-              throw(:found, true) if block.call(entry)
-            else
-              patterns.each do |pattern|
-                throw(:found, true) if pattern.match(entry) && (!by_extension || !File.directory?(entry))
-              end
-            end
+        patterns = patterns.map { |p| /(#{p.source})$/ } if by_extension
+        patterns = patterns.map { |p| /#{p.source}/i } unless case_sensitive
+        patterns
+      end
 
-            false
+      # :nodoc:
+      def match_pattern(entry, patterns, by_extension)
+        catch(:found) do
+          if block_given?
+            throw(:found, true) if yield(entry)
+          else
+            patterns.each do |pattern|
+              throw(:found, true) if pattern.match(entry) && (!by_extension || !File.directory?(entry))
+            end
           end
+
+          false
         end
+      end
     end
 
     # Methods to copy or move entries.
@@ -158,10 +137,10 @@ module Bovem
       # @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.
+      # @param fatal_errors [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)
-        copy_or_move(src, dst, :copy, run, show_errors, fatal)
+      def copy(src, dst, run: true, show_errors: false, fatal_errors: true)
+        copy_or_move(src, dst, operation: :copy, run: run, show_errors: show_errors, fatal_errors: fatal_errors)
       end
 
       # Moves a set of files or directory to another location.
@@ -170,26 +149,20 @@ module Bovem
       # @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.
+      # @param fatal_errors [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)
-        copy_or_move(src, dst, :move, run, show_errors, fatal)
+      def move(src, dst, run: true, show_errors: false, fatal_errors: true)
+        copy_or_move(src, dst, operation: :move, run: run, show_errors: show_errors, fatal_errors: fatal_errors)
       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.
+      private
+
+      # :nodoc:
       def copy_or_move(src, dst, operation, run = true, show_errors = true, fatal = true)
         rv = true
         operation, operation_s, single, src, dst = sanitize_copy_or_move(operation, src, dst)
 
-        if !run then
+        if !run
           dry_run_copy_or_move(single, operation_s, src, dst)
         else
           rv = catch(:rv) do
@@ -203,135 +176,118 @@ module Bovem
         rv
       end
 
-      private
-        # Sanitizes arguments for copy or move.
-        #
-        # @param operation [String] The operation which will be executed.
-        # @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.
-        # @return [Array] A list of sanitized arguments.
-        def sanitize_copy_or_move(operation, src, dst)
-          operation = :copy if operation != :move
-          single = !src.is_a?(Array)
-          src = single ? File.expand_path(src) : src.map {|s| File.expand_path(s) }
-
-          [operation, i18n.shell.send(operation), single, src, File.expand_path(dst.ensure_string)]
+      # :nodoc:
+      def sanitize_copy_or_move(operation, src, dst)
+        operation = :copy if operation != :move
+        single = !src.is_a?(Array)
+        src = single ? File.expand_path(src) : src.map { |s| File.expand_path(s) }
+
+        [operation, i18n.send(operation), single, src, File.expand_path(dst.ensure_string)]
+      end
+
+      # :nodoc:
+      def dry_run_copy_or_move(single, operation, src, dst)
+        if single
+          dry_run_copy_or_move_single(src, dst, operation)
+        else
+          dry_run_copy_or_move_multi(src, dst, operation)
         end
+      end
 
-        # Shows which copy or move operation are going to executed.
-        #
-        # @param single [Boolean] Whether `src` is a single file or directory.
-        # @param operation [String] The operation which will be executed.
-        # @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.
-        def dry_run_copy_or_move(single, operation, src, dst)
-          locale = i18n.shell
-
-          if single then
-            @console.warn(locale.copy_move_single_dry(operation))
-            @console.write(locale.copy_move_from(File.expand_path(src.ensure_string)), "\n", 11)
-            @console.write(locale.copy_move_to(dst), "\n", 11)
-          else
-            @console.warn(locale.copy_move_multi_dry(operation))
-            @console.with_indentation(11) do
-              src.each do |s| @console.write(s) end
-            end
-            @console.write(locale.copy_move_to_multi(dst), "\n", 5)
+      # :nodoc:
+      def dry_run_copy_or_move_single(src, dst, operation)
+        @console.warn(i18n.copy_move_single_dry(operation))
+        @console.write(i18n.copy_move_from(File.expand_path(src.ensure_string)), suffix: "\n", indented: 11)
+        @console.write(i18n.copy_move_to(dst), suffix: "\n", indented: 11)
+      end
+
+      # :nodoc:
+      def dry_run_copy_or_move_multi(src, dst, operation)
+        @console.warn(i18n.copy_move_multi_dry(operation))
+        @console.with_indentation(11) do
+          src.each do |s|
+            @console.write(s)
           end
         end
+        @console.write(i18n.copy_move_to_multi(dst), suffix: "\n", indented: 5)
+      end
 
-        # Prepares a destination directory for a copy or move.
-        #
-        # @param single [Boolean] Whether `src` is a single file or directory.
-        # @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 [String] The operation which will be executed.
-        # @param show_errors [Boolean] If show errors.
-        # @param fatal [Boolean] If quit in case of fatal errors.
-        # @return [String] The prepared destination.
-        def prepare_destination(single, src, dst, operation, show_errors, fatal)
-          dst_dir = single ? File.dirname(dst) : dst
-          has_dir = check(dst_dir, :dir)
-
-          # Create directory
-          has_dir = create_directories(dst_dir, 0755, true, show_errors, fatal) if !has_dir
-          throw(:rv, false) if !has_dir
-
-          if single && check(dst, :dir) then
-            @console.send(fatal ? :fatal : :error, i18n.shell.copy_move_single_to_directory(operation, src, dst))
-            throw(:rv, false)
-          end
+      # :nodoc:
+      def prepare_destination(single, src, dst, operation, show_errors, fatal)
+        dst_dir = single ? File.dirname(dst) : dst
+        has_dir = check(dst_dir, :dir)
 
-          dst_dir
-        end
+        # Create directory
+        has_dir = create_directories(dst_dir, mode: 0755, show_errors: show_errors, fatal_errors: fatal) unless has_dir
+        throw(:rv, false) unless has_dir
 
-        # Checks every sources for a copy or move.
-        #
-        # @param src [String|Array] The entries to copy or move. If is an Array, `dst` is assumed to be a directory.
-        # @param operation [String] The operation which will be executed.
-        # @param fatal [Boolean] If quit in case of fatal errors.
-        def check_sources(src, operation, fatal)
-          # Check that every file is existing
-          src.ensure_array.each do |s|
-            if !check(s, :exists) then
-              @console.send(fatal ? :fatal : :error, i18n.shell.copy_move_src_not_found(operation, s))
-              throw(:rv, false)
-            end
-          end
+        # Check if the destination directory is a file in single mode
+        if single && check(dst, :dir)
+          @console.send(fatal ? :fatal : :error, i18n.copy_move_single_to_directory(operation, src, dst))
+          throw(:rv, false)
         end
 
-        # Executes the copy or move operation.
-        #
-        # @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 dst_dir [String] The destination directory.
-        # @param single [Boolean] Whether `src` is a single file or directory.
-        # @param operation [Symbol] The operation to perform. Valid values are `:copy` or `:move`.
-        # @param operation_s [String] The string representation of the operation to perform.
-        # @param show_errors [Boolean] If show errors.
-        # @param fatal [Boolean] If quit in case of fatal errors.
-        def execute_copy_or_move(src, dst, dst_dir, single, operation, operation_s, show_errors, fatal)
-          locale = i18n.shell
+        dst_dir
+      end
 
-          begin
-            FileUtils.send(operation == :move ? :mv : :cp_r, src, dst, {noop: false, verbose: false})
-          rescue Errno::EACCES
-            single_msg = locale.copy_move_dst_not_writable_single(operation_s, src, dst_dir)
-            multi_msg = locale.copy_move_dst_not_writable_single(operation_s, dst)
-            handle_copy_move_failure(single, src, show_errors, fatal, single_msg, multi_msg, nil)
-          rescue => e
-            single_msg = locale.copy_move_error_single(operation_s, src, dst_dir, e.class.to_s, e)
-            multi_msg = locale.copy_move_error_multi(operation_s, dst)
-            handle_copy_move_failure(single, src, show_errors, fatal, single_msg, multi_msg, locale.error(e.class.to_s, e))
+      # :nodoc:
+      def check_sources(src, operation, fatal)
+        # Check that every file is existing
+        src.ensure_array.each do |s|
+          unless check(s, :exists)
+            @console.send(fatal ? :fatal : :error, i18n.copy_move_src_not_found(operation, s))
+            throw(:rv, false)
           end
         end
+      end
 
-        # Handles a failure on copy or move.
-        #
-        # @param single [Boolean] Whether `src` is a single file or directory.
-        # @param src [String|Array] The entries to copy or move. If is an Array, `dst` is assumed to be a directory.
-        # @param show_errors [Boolean] If show errors.
-        # @param fatal [Boolean] If quit in case of fatal errors.
-        # @param single_msg [String] The message to show in case of a single source.
-        # @param multi_msg [String] The starting message to show in case of multiple sources.
-        # @param error [String|nil] The ending message to show in case of multiple sources.
-        def handle_copy_move_failure(single, src, show_errors, fatal, single_msg, multi_msg, error)
-          if single then
-            @console.send(fatal ? :fatal : :error, single_msg, "\n", 5) if fatal || show_errors
-          else
-            if show_errors then
-              @console.error(multi_msg)
-              @console.with_indentation(11) do
-                src.each do |s| @console.write(s) end
-              end
-              @console.write(error, "\n", 5) if error
-            end
+      # :nodoc:
+      def execute_copy_or_move(src, dst, dst_dir, single, operation, operation_s, show_errors, fatal)
+        FileUtils.send(operation == :move ? :mv : :cp_r, src, dst, {noop: false, verbose: false})
+      rescue Errno::EACCES
+        handle_copy_or_move_access_error(src, dst, dst_dir, single, operation_s, show_errors, fatal)
+      rescue => e
+        handle_copy_or_move_general_erorr(src, dst, dst_dir, single, e, operation_s, show_errors, fatal)
+      end
+
+      # :nodoc:
+      def handle_copy_or_move_general_erorr(src, dst, dst_dir, single, e, operation_s, show_errors, fatal)
+        single_msg = i18n.copy_move_error_single(operation_s, src, dst_dir, e.class.to_s, e)
+        multi_msg = i18n.copy_move_error_multi(operation_s, dst)
+        handle_copy_or_move_failure(single, src, show_errors, fatal, single_msg, multi_msg, i18n.error(e.class.to_s, e))
+      end
 
+      # :nodoc:
+      def handle_copy_or_move_access_error(src, dst, dst_dir, single, operation_s, show_errors, fatal)
+        single_msg = i18n.copy_move_dst_not_writable_single(operation_s, src, dst_dir)
+        multi_msg = i18n.copy_move_dst_not_writable_multi(operation_s, dst)
+        handle_copy_or_move_failure(single, src, show_errors, fatal, single_msg, multi_msg, nil)
+      end
+
+      # :nodoc:
+      def handle_copy_or_move_failure(single, src, show_errors, fatal, single_msg, multi_msg, error)
+        if fatal || show_errors
+          if single
+            @console.send(fatal ? :fatal : :error, single_msg, suffix: "\n", indented: 5)
+          else
+            show_copy_move_failed_files(src, error, multi_msg)
             Kernel.exit(-1) if fatal
           end
+        end
 
-          throw(:rv, false)
+        throw(:rv, false)
+      end
+
+      # :nodoc:
+      def show_copy_move_failed_files(src, error, multi_msg)
+        @console.error(multi_msg)
+        @console.with_indentation(11) do
+          src.each do |s|
+            @console.write(s)
+          end
         end
+        @console.write(error, suffix: "\n", indented: 5) if error
+      end
     end
 
     # Methods to run commands or delete entries.
@@ -344,26 +300,23 @@ module Bovem
       # @param show_exit [Boolean] If show the exit status.
       # @param show_output [Boolean] If show command output.
       # @param show_command [Boolean] If show the command that will be run.
-      # @param fatal [Boolean] If quit in case of fatal errors.
+      # @param fatal_errors [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, show_command = false, fatal = true)
+      def run(command, message = nil, run: true, show_exit: true, show_output: false, show_command: false, fatal_errors: true)
         rv = {status: 0, output: ""}
         command = command.ensure_string
-        locale = i18n.shell
 
         # Show the command
         @console.begin(message) if message.present?
 
-        if !run then # Print a message
-          @console.warn(locale.run_dry(command))
-          @console.status(:ok) if show_exit
+        if !run # Print a message
+          show_dry_run(command, show_exit)
         else # Run
           rv = execute_command(command, show_command, show_output)
         end
 
         # Return
-        @console.status(rv[:status] == 0 ? :ok : :fail) if show_exit
-        exit(rv[:status]) if fatal && rv[:status] != 0
+        handle_command_exit(rv, show_exit, fatal_errors)
         rv
       end
 
@@ -372,54 +325,73 @@ module Bovem
       # @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.
+      # @param fatal_errors [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)
+      def delete(*files, run: true, show_errors: false, fatal_errors: true)
         rv = true
-        locale = i18n.shell
-        files = files.ensure_array(nil, true, true) {|f| File.expand_path(f.ensure_string) }
+        files = files.ensure_array(no_duplicates: true, compact: true, flatten: true) { |f| File.expand_path(f.ensure_string) }
 
-        if !run then
-          @console.warn(locale.remove_dry)
-          @console.with_indentation(11) do
-            files.each do |file| @console.write(file) end
-          end
+        if !run
+          show_dry_delete(files)
         else
-          rv = catch(:rv) do
-            begin
-              FileUtils.rm_r(files, {noop: false, verbose: false, secure: true})
-              throw(:rv, true)
-            rescue => e
-              handle_failure(e, :remove_unwritable, :remove_not_found, :remove_error, files, fatal, show_errors)
-            end
-
-            false
-          end
+          rv = perform_delete(files, show_errors, fatal_errors)
         end
 
         rv
       end
 
       private
-        # Runs a command into the shell.
-        #
-        # @param command [String] The string to run.
-        # @param show_command [Boolean] If show the command that will be run.
-        # @param show_output [Boolean] If show command output.
-        # @return [Hash] An hash with `status` and `output` keys.
-        def execute_command(command, show_command, show_output)
-          output = ""
-
-          @console.info(i18n.shell.run(command)) if show_command
-          status = ::Open4::popen4(command + " 2>&1") { |_, _, stdout, _|
-            stdout.each_line do |line|
-              output << line
-              Kernel.print line if show_output
-            end
-          }.exitstatus
 
-          {status: status, output: output}
+      # :nodoc:
+      def execute_command(command, show_command, show_output)
+        output = ""
+
+        @console.info(i18n.run(command)) if show_command
+        status = ::Open4.popen4(command + " 2>&1") do |_, _, stdout, _|
+          stdout.each_line do |line|
+            output << line
+            Kernel.print line if show_output
+          end
+        end
+
+        {status: status.exitstatus, output: output}
+      end
+
+      # :nodoc:
+      def handle_command_exit(rv, show_exit, fatal_errors)
+        @console.status(rv[:status] == 0 ? :ok : :fail) if show_exit
+        exit(rv[:status]) if fatal_errors && rv[:status] != 0
+      end
+
+      # :nodoc:
+      def show_dry_run(command, show_exit)
+        @console.warn(i18n.run_dry(command))
+        @console.status(:ok) if show_exit
+      end
+
+      # :nodoc:
+      def perform_delete(files, show_errors, fatal)
+        catch(:rv) do
+          begin
+            FileUtils.rm_r(files, {noop: false, verbose: false, secure: true})
+            throw(:rv, true)
+          rescue => e
+            handle_failure(e, :remove_unwritable, :remove_not_found, :remove_error, files, fatal, show_errors)
+          end
+
+          false
         end
+      end
+
+      # :nodoc:
+      def show_dry_delete(files)
+        @console.warn(i18n.remove_dry)
+        @console.with_indentation(11) do
+          files.each do |file|
+            @console.write(file)
+          end
+        end
+      end
     end
 
     # Methods to interact with directories.
@@ -430,15 +402,13 @@ module Bovem
       # @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)
-        locale = i18n.shell
-
+      def within_directory(directory, restore: true, show_messages: false)
         directory = File.expand_path(directory.ensure_string)
         original = Dir.pwd
 
-        rv = enter_directory(directory, show_messages, locale.move_in(directory))
+        rv = enter_directory(directory, show_messages, i18n.move_in(directory))
         yield if rv && block_given?
-        rv = enter_directory(original, show_messages, locale.move_out(directory)) if rv && restore
+        rv = enter_directory(original, show_messages, i18n.move_out(directory)) if rv && restore
 
         rv
       end
@@ -449,20 +419,20 @@ module Bovem
       # @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.
+      # @param fatal_errors [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)
+      def create_directories(*directories, mode: 0755, run: true, show_errors: false, fatal_errors: true)
         rv = true
 
         # Adjust directory
-        directories = directories.ensure_array(nil, true, true) {|d| File.expand_path(d.ensure_string) }
+        directories = directories.ensure_array(no_duplicates: true, compact: true, flatten: true) { |d| File.expand_path(d.ensure_string) }
 
-        if !run then # Just print
+        if !run # Just print
           dry_run_directory_creation(directories)
         else
           directories.each do |directory|
-            rv = rv && try_create_directory(directory, mode, fatal, directories, show_errors)
-            break if !rv
+            rv &&= try_create_directory(directory, mode, fatal_errors, directories, show_errors)
+            break unless rv
           end
         end
 
@@ -470,76 +440,56 @@ module Bovem
       end
 
       private
-        # Change current working directory.
-        #
-        # @param directory [String] The directory which move into.
-        # @param show_message [Boolean] Whether to show or not message.
-        # @param message [String] The message to show.
-        # @return [Boolean] `true` if operation succeeded, `false` otherwise.
-        def enter_directory(directory, show_message, message)
-          begin
-            raise ArgumentError if !check(directory, [:directory, :executable])
-            @console.info(message) if show_message
-            Dir.chdir(directory)
-            true
-          rescue
-            false
-          end
-        end
 
-        # Show which directory are going to be created.
-        # @param directories [Array] The list of directories to create.
-        def dry_run_directory_creation(directories)
-          @console.warn(i18n.shell.mkdir_dry)
-          @console.with_indentation(11) do
-            directories.each do |directory| @console.write(directory) end
+      # :nodoc:
+      def enter_directory(directory, show_message, message)
+        raise ArgumentError unless check(directory, :directory, :executable)
+        @console.info(message) if show_message
+        Dir.chdir(directory)
+        true
+      rescue
+        false
+      end
+
+      # :nodoc:
+      def dry_run_directory_creation(directories)
+        @console.warn(i18n.mkdir_dry)
+        @console.with_indentation(11) do
+          directories.each do |directory|
+            @console.write(directory)
           end
         end
+      end
 
-        # Tries to creates a directory.
-        #
-        # @param directory [String] The directory to create.
-        # @param mode [Fixnum] Initial permissions for the new directories.
-        # @param fatal [Boolean] If quit in case of fatal errors.
-        # @param directories [Array] The list of directories to create.
-        # @param show_errors [Boolean] If show errors.
-        # @return [Boolean] `true` if operation succeeded, `false` otherwise.
-        def try_create_directory(directory, mode, fatal, directories, show_errors)
-          rv = false
-          locale = i18n.shell
-
-          # Perform tests
-          if check(directory, :directory) then
-            @console.send(fatal ? :fatal : :error, locale.mkdir_existing(directory))
-          elsif check(directory, :exist) then
-            @console.send(fatal ? :fatal : :error, locale.mkdir_file(directory))
-          else
-            rv = create_directory(directory, mode, fatal, directories, show_errors)
-          end
+      # :nodoc:
+      def try_create_directory(directory, mode, fatal, directories, show_errors)
+        rv = false
 
-          rv
+        # Perform tests
+        if check(directory, :directory)
+          @console.send(fatal ? :fatal : :error, i18n.mkdir_existing(directory))
+        elsif check(directory, :exist)
+          @console.send(fatal ? :fatal : :error, i18n.mkdir_file(directory))
+        else
+          rv = create_directory(directory, mode, fatal, directories, show_errors)
         end
 
-        # Creates a directory.
-        #
-        # @param directory [String] The directory to create.
-        # @param mode [Fixnum] Initial permissions for the new directories.
-        # @param fatal [Boolean] If quit in case of fatal errors.
-        # @param directories [Array] The list of directories to create.
-        # @param show_errors [Boolean] If show errors.
-        # @return [Boolean] `true` if operation succeeded, `false` otherwise.
-        def create_directory(directory, mode, fatal, directories, show_errors)
-          rv = false
-
-          begin # Create directory
-            FileUtils.mkdir_p(directory, {mode: mode, noop: false, verbose: false})
-            rv = true
-          rescue => e
-            handle_failure(e, :mkdir_denied, nil, :mkdir_error, directories, fatal, show_errors)
-          end
+        rv
+      end
+
+      # :nodoc:
+      def create_directory(directory, mode, fatal, directories, show_errors)
+        rv = false
 
-          rv
+        begin # Create directory
+          FileUtils.mkdir_p(directory, {mode: mode, noop: false, verbose: false})
+          rv = true
+        rescue => e
+          handle_failure(e, :mkdir_denied, nil, :mkdir_error, directories, fatal, show_errors)
         end
+
+        rv
+      end
     end
   end
 
@@ -547,8 +497,9 @@ module Bovem
   #
   # @attribute console
   #   @return [Console] A console instance.
+  # @attribute [r] i18n
+  #   @return [I18n] A i18n helper.
   class Shell
-    include Lazier::I18n
     include Bovem::ShellMethods::General
     include Bovem::ShellMethods::Read
     include Bovem::ShellMethods::Write
@@ -556,6 +507,7 @@ module Bovem
     include Bovem::ShellMethods::Directories
 
     attr_accessor :console
+    attr_reader :i18n
 
     # Returns a unique instance for Shell.
     #
@@ -567,7 +519,7 @@ module Bovem
     # Initializes a new Shell.
     def initialize
       @console = Bovem::Console.instance
-      i18n_setup(:bovem, ::File.absolute_path(::Pathname.new(::File.dirname(__FILE__)).to_s + "/../../locales/"))
+      @i18n = Bovem::I18n.new(root: "bovem.shell", path: Bovem::Application::LOCALE_ROOT)
     end
   end
-end
+end