command_exec 0.1.3 → 0.2.0

data/RELEASE_NOTES.md

@@ -0,0 +1,62 @@
+# 0.2.0
+
+This release is a major rewrite of the library. Please keep in mind it is still
+under very active development and till 1.0.0 the API can change at any time.
+Though I'm quite satisfied with the api and will try to add things only.
+
+* *TREATMENT OF COMMAND NAMES*: 
+
+Now only commands given as symbols will be searched in search path. Which can
+be set as well now. If a string is given, it will be searched in the current
+working directory. Furthermore the resolver was refactored. It is now a ruby
+only solution.
+
+* *TEST SUITE*:
+
+Improved test suite. Added more tests and add `simplecov` for coverage check.
+
+* *WORKING DIRECTORY*:
+
+No side effects any more when using a working directory. This might have had an
+effect on your library if you start your script from directory 'A', but want the 
+command to be run in directory 'B'. After running the command with `CommandExec`
+the current working directory of your script was changed as well. This is fixed
+now.
+
+* *LOGGING*:
+
+Now you have the possibility to change the log level of `CommandExec`. If you
+choose one of `:silent`, `:unknown`, `:fatal`, `:error`, `:warn`, `:info` and
+`:debug`. All possibilities map to their `Logger`-counterpart, so please see
+the ruby logger documentation on the net (google for ruby logger). The only
+exception is `:silent`. Choosing this option `CommandExec` will not output
+anything.
+
+* *VERSIONING*:
+
+This gem now uses semvar versioning scheme. See www.semvar.org for more information.
+
+* *RESULT OF COMMAND EXECUTION*:
+
+Now it's possible that you get the result of the command execution in different formats:
+  * Array
+  * Hash
+  * JSON-String
+  * Simple String
+  * XML-String
+  * YAML-String
+
+* *ERROR DETECTION*:
+
+As part of the new interface there are methods put in place to detect errors
+during command execution: Return code, STDERR, STDOUT and log file.
+
+* *REACTION ON ERRORS*:
+
+If an error happend, you can raise an exception, throw an error or ask
+`CommandExec`to do nothing at all.
+
+* *COMMAND RUNNER*
+
+The new version switches from `POpen4` to `Open3` as default runner.
+Furthermore `system`-call is also supported.

data/Rakefile

@@ -1,14 +1,18 @@
 #!/usr/bin/env rake
-require 'bundler/gem_tasks'
-require 'yard'
-require 'rubygems/package_task'
-require 'active_support/core_ext/string/strip'
-
-YARD::Rake::YardocTask.new do |t|
-  t.files   = ['lib/**/*.rb', 'README.md', 'LICENCE.md']
-  t.options = ['--output-dir=doc/yard', '--markup-provider=redcarpet', '--markup=markdown' ]
+
+unless ENV['TRAVIS_CI'] == 'true'
+  namespace :gem do
+    require 'bundler/gem_tasks'
+  end
+
+  require 'yard'
+  require 'rubygems/package_task'
+  require 'active_support/core_ext/string/strip'
 end
 
+YARD::Rake::YardocTask.new do; end
+
+desc 'start tmux'
 task :terminal do
   sh "script/terminal"
 end
@@ -19,9 +23,10 @@ task :t => :terminal
 namespace :version do
   version_file = Dir.glob('lib/**/version.rb').first
 
+  desc 'bump version of library to new version'
   task :bump do
 
-    new_version = ENV['VERSION']
+    new_version = ENV['VERSION'] || ENV['version']
 
     raw_module_name = File.open(version_file, "r").readlines.grep(/module/).first
     module_name = raw_module_name.chomp.match(/module\s+(\S+)/) {$1}
@@ -40,6 +45,7 @@ end}
     sh "git tag data_uri-#{new_version}" 
   end
 
+  desc 'show version of library'
   task :show do
     raw_version = File.open(version_file, "r").readlines.grep(/VERSION/).first
 
@@ -52,8 +58,33 @@ end}
 
   end
 
+  desc 'Restore version file from git repository'
   task :restore do
     sh "git checkout #{version_file}"
   end
 
 end
+
+namespace :travis do
+  desc 'Runs travis-lint to check .travis.yml'
+  task :check do
+    sh 'travis-lint'
+  end
+end
+
+namespace :test do
+  desc 'Run specs'
+  task :specs do
+    sh 'bundle exec rspec spec'
+  end
+
+  desc 'Run tests in "travis mode"'
+  task :travis_specs do
+    ENV['TRAVIS_CI'] = 'true'
+    sh 'rspec spec'
+  end
+end
+
+task :console do
+  sh 'script/console'
+end

data/TODO.md

@@ -1,2 +1,8 @@
-* Add options to execute a command silently
-* Check if attr_accessor or attr_reader is better in command.rb
+* Add tests for search command
+* Support shell environment for command
+* Support Time of run in output
+* Support run time in output
+* Support stdin
+* Limit output to n lines
+* YAML should be the same output like the others
+* Support for Proc as an reaction on an error

data/command_exec.gemspec

@@ -17,6 +17,7 @@ Gem::Specification.new do |s|
   s.require_paths = ['lib']
 
   # specify any dependencies here; for example:
-  s.add_runtime_dependency 'POpen4'
-  s.add_runtime_dependency 'colored'
+  s.add_runtime_dependency 'smart_colored'
+  s.add_runtime_dependency 'activesupport'
+  s.add_runtime_dependency 'xml-simple'
 end

data/gemfiles/Gemfile.default

@@ -0,0 +1,28 @@
+source :rubygems
+
+# Specify your gem's dependencies in workplace-letter_generator.gemspec
+gemspec 
+
+group :test do
+  gem 'rake'
+  gem 'rspec'
+  gem 'simplecov'
+  gem 'aruba'
+  gem 'fuubar'
+end
+
+group :documentation do
+  gem 'yard'
+  gem 'redcarpet'
+  gem 'github-markup'
+end
+
+group :development do
+  gem 'tmrb'
+  gem 'debugger'
+  gem 'pry'
+  gem 'pry-doc'
+  gem 'awesome_print'
+  gem 'travis-lint'
+  gem 'activesupport'
+end

data/gemfiles/Gemfile.travis

@@ -0,0 +1,16 @@
+source :rubygems
+
+# Specify your gem's dependencies in workplace-letter_generator.gemspec
+#gemspec path: '../command_exec.gemspec'
+gemspec path: '../'
+
+group :test do
+  gem 'rake'
+  gem 'rspec'
+end
+
+group :documentation do
+  gem 'yard'
+  gem 'redcarpet'
+  gem 'github-markup'
+end

data/gemfiles/Gemfile.travis.lock

@@ -0,0 +1,48 @@
+PATH
+  remote: /home/d/work/projects/ruby-command_exec
+  specs:
+    command_exec (0.1.3)
+      POpen4
+      activesupport
+      colored (>= 1.2)
+      xml-simple
+
+GEM
+  remote: http://rubygems.org/
+  specs:
+    POpen4 (0.1.4)
+      Platform (>= 0.4.0)
+      open4
+    Platform (0.4.0)
+    activesupport (3.2.8)
+      i18n (~> 0.6)
+      multi_json (~> 1.0)
+    colored (1.2)
+    diff-lcs (1.1.3)
+    github-markup (0.7.4)
+    i18n (0.6.1)
+    multi_json (1.3.6)
+    open4 (1.3.0)
+    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.1)
+    rspec-expectations (2.11.3)
+      diff-lcs (~> 1.1.3)
+    rspec-mocks (2.11.2)
+    xml-simple (1.1.1)
+    yard (0.8.2.1)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  command_exec!
+  github-markup
+  rake
+  redcarpet
+  rspec
+  yard

data/lib/command_exec.rb

@@ -1,11 +1,31 @@
 #encoding: utf-8
 
-require 'popen4'
-require 'colored'
+require 'smart_colored/extend'
+require 'json'
+require 'psych'
+require 'xmlsimple'
+require 'open3'
+
 require 'logger'
+require 'command_exec/logger'
+
+require 'active_support/core_ext/object/blank'
+require 'active_support/core_ext/string/filters'
+require 'active_support/core_ext/hash/deep_merge'
+require 'active_support/core_ext/hash/conversions'
+
+require 'command_exec/field_helper'
+
+require 'command_exec/formatter/array'
+require 'command_exec/formatter/hash'
+require 'command_exec/formatter/json'
+require 'command_exec/formatter/yaml'
+require 'command_exec/formatter/xml'
+require 'command_exec/formatter/string'
 
 require 'command_exec/version'
 require 'command_exec/exceptions'
 require 'command_exec/command'
+require 'command_exec/process'
 
 module CommandExec; end

data/lib/command_exec/command.rb

@@ -5,49 +5,190 @@ module CommandExec
   # Run commands
   class Command
 
-    attr_accessor :logfile, :options , :parameter, :error_keywords
+    # @!attribute [rw] log_file
+    #   Set/Get log file for command
+    #
+    # @!attribute [rw] options
+    #   Set/Get options for the command
+    #
+    # @!attribute [rw] parameter
+    #   Set/Get parameter for the command
+    attr_accessor :log_file, :options , :parameter
+
+    # @!attribute [r] result
+    #   Return the result of command execution
+    #
+    # @!attribute [r] path
+    #   Return path to the executable of the command
+    #
+    # @!attribute [r] working_directory
+    #   Return the working directory of the command
     attr_reader :result, :path, :working_directory
 
     # Create a new command to execute
     #
-    # @param [Symbol] name name of command
-    # @param [optional,Hash] opts options for the command
-    # @option opts [String] :options options for binary
-    # @option opts [String] :parameter parameter for binary
-    # @option opts [String] :error_keywords keyword indicating an error on stdout
-    # @option opts [String] :working_directory working directory where the process should run in
-    # @option opts [String] :logfile file path to log file of process
+    # @param [Symbol] name 
+    #   name of command
+    #
+    # @param [optional,Hash] opts 
+    #   options for the command
+    #
+    # @option opts [String] :options ('')
+    #   options for the command
+    #
+    # @option opts [String] :working_directory (current working directory)
+    #   working_directory for the command
+    #
+    # @option opts [String] :log_file ('')
+    #   log file of the command
+    #
+    # @option opts [String,Array] :search_paths ($PATH)
+    #   where to search for the command (please mind the 's' at the end.
+    #
+    # @option opts [String,Array] :error_detection_on (:return_code)
+    #   what information should be considered for error detection,
+    #   available options are :return_code, :stderr, :stdout, :log_file.
+    #   You can use one or more of them.
+    #
+    # @option opts [Hash] :error_indicators 
+    #   what keywords etc. should be considered as errors.
+    #
+    #   You can define allowed or forbidden keywords or exit codes.
+    #   To search for errors in a log file you need to provide one.
+    #
+    #   For each option you can provide a single word or an Array of words.
+    #
+    #   ```
+    #   :allowed_return_code => [0],
+    #   :forbidden_return_code => [],
+    #   :allowed_words_in_stderr => [],
+    #   :forbidden_words_in_stderr => [],
+    #   :allowed_words_in_stdout => [],
+    #   :forbidden_words_in_stdout => [],
+    #   :allowed_words_in_log_file => [],
+    #   :forbidden_words_in_log_file => [],
+    #   ```
+    #
+    # @option opts [Symbol] :on_error_do
+    #   Oh, an error happend, what to do next? Raise an error (:raise_error),
+    #   Throw an error (:throw_error) or do nothing at all (:nothing, default).
+    #
+    # @option opts [Symbol] :run_via
+    #   Which runner should be used to execute the command: :open3 (default)
+    #   or :system.
+    #
+    # @option opts [Logger] :lib_logger
+    #   The logger which is used to output information generated by the
+    #   library. The logger which is provided needs to be compatible with api
+    #   of the Ruby `Logger`-class.
+    #
+    # @option opts [Symbol] :lib_log_level
+    #   What information should handled by the logger: 
+    #   :debug, :info, :warn, :error, :fatal, :unknown. Additionally the
+    #   :silent-option is understood: do not output anything (@see README for
+    #   further information).
     def initialize(name,opts={})
 
       @name = name
       @opts = {
-        :logger => Logger.new($stderr),
         :options => '',
         :parameter => '',
-        :error_keywords => [],
         :working_directory => Dir.pwd,
-        :logfile => '',
-        :log_level => :info,
-      }.update opts
+        :log_file => '',
+        :search_paths => ENV['PATH'].split(':'),
+        :error_detection_on => [:return_code],
+        :error_indicators => {
+          :allowed_return_code => [0],
+          :forbidden_return_code => [],
+          #
+          :allowed_words_in_stderr => [],
+          :forbidden_words_in_stderr => [],
+          #
+          :allowed_words_in_stdout => [],
+          :forbidden_words_in_stdout => [],
+          #
+          :allowed_words_in_log_file => [],
+          :forbidden_words_in_log_file => [],
+        },
+        :on_error_do => :nothing,
+        :run_via => :open3,
+        :lib_logger => Logger.new($stderr),
+        :lib_log_level => :info,
+      }.deep_merge opts
+
+      @logger = @opts[:lib_logger] 
+      configure_logging 
+
+      @logger.debug @opts
 
-      @logger = @opts[:logger] 
       @options = @opts[:options]
+      @path = resolve_path @name, @opts[:search_paths]
       @parameter = @opts[:parameter]
-      @path = resolve_cmd_name(name)
-      @error_keywords = @opts[:error_keywords]
-      @logfile = @opts[:logfile]
+      @log_file = @opts[:log_file]
 
-      configure_logging
+      *@error_detection_on = @opts[:error_detection_on]
+      @error_indicators = @opts[:error_indicators]
+      @on_error_do = @opts[:on_error_do]
 
-      @working_directory = @opts[:working_directory] 
-      Dir.chdir(working_directory)
+      @run_via = @opts[:run_via]
 
+      @working_directory = @opts[:working_directory] 
+      @result = nil
     end
 
     private
 
+    # Find path to cmd
+    #
+    # @param [String] name 
+    #   Name of command. It accepts :cmd, 'cmd', 'rel_path/cmd' or
+    #   '/fq_path/to/cmd'. When :cmd is used it searches 'search_paths' for the
+    #   executable. Whenn 'cmd' is used it looks for cmd in local dir. The same
+    #   happens when 'rel_path/cmd' is used. A full qualified path
+    #   '/fq_path/to/cmd' is used as normal.
+    # 
+    # @param [Array] search_paths
+    #   Where to look for executables
+    #
+    # @return [String] fully qualified path to command
+    def resolve_path(name,*search_paths)
+      search_paths ||= ['/bin', '/usr/bin']
+      search_paths = search_paths.flatten
+
+      if name.kind_of? Symbol
+        path = search_paths.map{ |p| File.join(p, name.to_s) }.find {|p| File.exists? p } || ""
+      else
+        path = File.expand_path(name)
+      end
+
+      path
+    end
+    
+    # Check if executable exists, if it's executable and is a file
+    #
+    # @raise [CommandExec::Exceptions::CommandNotFound] if command does not exist
+    # @raise [CommandExec::Exceptions::CommandNotExecutable] if command is not executable
+    # @raise [CommandExec::Exceptions::CommandIsNotAFile] if command is not a file
+    def check_path
+      unless exists?
+        @logger.fatal("Command '#{@name}' not found.")
+        raise Exceptions::CommandNotFound , "Command '#{@name}' not found."
+      end
+
+      unless executable?
+        @logger.fatal("Command '#{@name}' not executable.")
+        raise Exceptions::CommandNotExecutable , "Command '#{@name}' not executable."
+      end
+
+      unless file?
+        @logger.fatal("Command '#{@name}' not a file.")
+        raise Exceptions::CommandIsNotAFile, "Command '#{@name}' not a file."
+      end
+    end
+
+    # Set appropriate log level
     def configure_logging
-      case @opts[:log_level]
+      case @opts[:lib_log_level]
       when :debug
         @logger.level = Logger::DEBUG
       when :error
@@ -61,191 +202,200 @@ module CommandExec
       when :warn
         @logger.level = Logger::WARN
       when :silent
-        @logger.instance_variable_set(:@logdev, nil)
+        @logger.level = Logger::SILENT
       else
-        log_level = Logger::INFO
+        @logger.level = Logger::INFO
       end
-    end
 
-    # Find utility path
-    #
-    # @param [Symbol] name Name of utility
-    # @return [Path] Returns the path to the binary of the binary
-    def resolve_cmd_name(name)
-      path=''
-      path = %x[which #{name} 2>/dev/null].chomp
+      @logger.debug "Logger configured with log level #{@logger.level}"
 
-      if path.empty?
-        @logger.fatal("Command not found #{name}")
-        raise Exceptions::CommandNotFound 
-      end
+      nil
+    end
 
-      path
+    public
+
+    #Is executable valid
+    def valid?
+      exists? and executable? and file?
     end
 
-    # Build string to execute command
-    #
-    # @return [String] Returns to whole command with parameters and options
-    def build_cmd_string
-      cmd = ''
-      cmd += path
-      cmd += options.empty? ? "" : " #{options}"
-      cmd += parameter.empty? ? "" : " #{parameter}"
+    # Does the command exist?
+    # 
+    # @return [True,False] result of check
+    def exists?
+      File.exists? @path
+    end
 
-      cmd
+    # Is the command executable
+    # 
+    # @return [True,False] result of check
+    def executable?
+      File.executable? @path
     end
 
-    public
+    # Is the provided string a file
+    # 
+    # @return [True,False] result of check
+    def file?
+      File.file? @path
+    end
 
     # Output the textual representation of a command
-    # public alias for build_cmd_string
     #
     # @return [String] command in text form
-    def to_txt 
-      build_cmd_string
+    def to_s
+      cmd = ''
+      cmd += @path
+      cmd += @options.blank? ? "" : " #{@options}"
+      cmd += @parameter.blank? ? "" : " #{@parameter}"
+
+      @logger.debug cmd
+
+      cmd
     end
 
     # Run the program
     #
+    # @raise [CommandExec::Exceptions::CommandExecutionFailed] if an error
+    #   occured and `command_exec` should raise an exception in the case of an
+    #   error. 
+    # @throw [:command_execution_failed] if an error
+    #   occured and `command_exec` should throw an error (which you can catch)
+    #   in the case of an error
     def run
+      process = CommandExec::Process.new(:lib_logger => @logger)
+      process.log_file = @log_file if @log_file
+      process.status = :success
 
-      _stdout = ''
-      _stderr = ''
-
-      status = POpen4::popen4(build_cmd_string) do |stdout, stderr, stdin, pid|
-        _stdout = stdout.read.strip
-        _stderr = stderr.read.strip
-      end
+      check_path
 
+      process.start_time = Time.now
 
-      error_in_stdout_found = error_in_string_found?(error_keywords,_stdout)
-      @result = run_successful?( status.success? ,  error_in_stdout_found ) 
-
-      if @result == false
-        msg = message(
-          @result, 
-          help_output(
-            { 
-              :error_in_exec => not(status.success?), 
-              :error_in_stdout => error_in_stdout_found 
-            }, {
-              :stdout => StringIO.new(_stdout),
-              :stderr => StringIO.new(_stderr),
-              :logfile => read_logfile(logfile),
-            }
-          )
-        )
+      case @run_via
+      when :open3
+        Open3::popen3(to_s, :chdir => @working_directory) do |stdin, stdout, stderr, wait_thr|
+          process.stdout = stdout.readlines.map(&:chomp)
+          process.stderr = stderr.readlines.map(&:chomp)
+          process.pid = wait_thr.pid
+          process.return_code = wait_thr.value.exitstatus
+        end
+      when :system
+        Dir.chdir(@working_directory) do
+          system(to_s)
+          process.stdout = []
+          process.stderr = []
+          process.pid = $?.pid
+          process.return_code = $?.exitstatus
+        end
       else
-        msg =  message(@result)
+        Open3::popen3(to_s, :chdir => @working_directory) do |stdin, stdout, stderr, wait_thr|
+          process.stdout = stdout.readlines.map(&:chomp)
+          process.stderr = stderr.readlines.map(&:chomp)
+          process.pid = wait_thr.pid
+          process.return_code = wait_thr.value.exitstatus
+        end
       end
 
-      @logger.info "#{@name.to_s}: #{msg}"
+      process.end_time = Time.now
 
-      @result
-    end
+        if @error_detection_on.include?(:return_code)
+          if not @error_indicators[:allowed_return_code].include? process.return_code or 
+                 @error_indicators[:forbidden_return_code].include? process.return_code
 
-    # Read the content of the logfile
-    #
-    # @param [Path] file path to logfile
-    # @param [Integer] num_of_lines the number of lines which should be read -- e.g. 30 lines = -30
-    def read_logfile(file, num_of_lines=-30)
-      content = StringIO.new
+            @logger.debug "Error detection on return code found an error"
+            process.status = :failed 
+            process.reason_for_failure = :return_code
+          end
+        end
 
-      unless file.empty? 
-        begin
-          content << File.readlines(logfile)[num_of_lines..-1].join("")
-        rescue Errno::ENOENT
-          @logger.warn "Warning: logfile not found!"
+        if @error_detection_on.include?(:stderr) and not process.status == :failed
+          if error_occured?( @error_indicators[:forbidden_words_in_stderr], @error_indicators[:allowed_words_in_stderr], process.stderr)
+            @logger.debug "Error detection on stderr found an error"
+            process.status = :failed 
+            process.reason_for_failure = :stderr
+          end
         end
-      end
 
-      content
-    end
+        if @error_detection_on.include?(:stdout) and not process.status == :failed
+          if error_occured?( @error_indicators[:forbidden_words_in_stdout], @error_indicators[:allowed_words_in_stdout], process.stdout)
+            @logger.debug "Error detection on stdout found an error"
+            process.status = :failed 
+            process.reason_for_failure = :stdout
+          end
+        end
 
-    # Decide if a program run was successful
-    #
-    # @return [Boolean] Returns the decision
-    def run_successful?(success,error_in_stdout)
-      if success == false or error_in_stdout == true 
-        return false
-      else 
-        return true 
-      end
-    end
+        if @error_detection_on.include?(:log_file) and not process.status == :failed
+          if error_occured?( @error_indicators[:forbidden_words_in_log_file], @error_indicators[:allowed_words_in_log_file], process.log_file)
+            @logger.debug "Error detection on log file found an error"
+            process.status = :failed 
+            process.reason_for_failure = :log_file
+          end
+        end
 
-    # Decide which output to return to the user
-    # to help him with debugging
-    #
-    # @return [Array] Returns lines of log/stdout/stderr
-    def help_output(error_indicators={},output={})
-      error_in_exec = error_indicators[:error_in_exec]
-      error_in_stdout = error_indicators[:error_in_stdout]
-
-      logfile = output[:logfile].string
-      stdout = output[:stdout].string
-      stderr = output[:stderr].string
-
-      result = []
-
-      if error_in_exec == true
-        result << '================== LOGFILE ================== '
-        result << logfile if logfile.empty? == false 
-        result << '================== STDOUT ================== '
-        result << stdout if stdout.empty? == false
-        result << '================== STDERR ================== '
-        result << stderr if stderr.empty? == false
-      elsif error_in_stdout == true
-        result << '================== STDOUT ================== '
-        result << stdout 
+        @logger.debug "Result of command run #{process.status}"
+
+      @result = process
+      if process.status == :failed
+        case @on_error_do
+        when :nothing
+          #nothing
+        when :raise_error
+          raise CommandExec::Exceptions::CommandExecutionFailed, "An error occured. Please check for reason via command.reason_for_failure and/or command.stdout, comand.stderr, command.log_file, command.return_code"
+        when :throw_error
+          throw :command_execution_failed 
+        else
+          #nothing
+        end
       end
-
-      result
     end
 
-    # Find error in stdout
-    # 
+    # Find error in data
+    #
+    # @param [Array,String] forbidden_word 
+    #   what are the forbidden words which indidcate an error
+    #
+    # @param [Array,String] exception
+    #  Is there any exception from that forbidden words, maybe a string
+    #  which contains the forbidden word, but is no error?
+    #
+    # @param [Array,String] data
+    #   Where to look for errors.
+    #
     # @return [Boolean] Returns true if it finds an error
-    def error_in_string_found? (keywords=[], string )
-      return false if keywords.empty? or not keywords.is_a? Array 
-      return false if string.nil? or not string.is_a? String
-
+    def error_occured?(forbidden_word, exception, data )
       error_found = false
-      keywords.each do |word|
-        if string.include? word
-          error_found = true
-          break
+      *forbidden_word = forbidden_word
+      *exception = exception
+      *data = data
+
+      return false if forbidden_word.blank?
+      return false if data.blank?
+
+      forbidden_word.each do |word|
+        data.each do |line|
+          line.strip!
+
+          #line includes word -> error
+          #exception does not include line/substring of line -> error, if
+          #  includes line/substring of line -> no error
+          if line.include? word and exception.find{ |e| line[e] }.blank?
+            error_found = true
+            break
+          end
         end
       end
 
       error_found
     end
 
-    # Generate the message which is return to the user
-    # 
-    # @param [Boolean] run_successful true if a positive message should be returned
-    # @param [Array] msg Message which should be returned
-    def message(run_successful, *msg)
-
-      message = []
-      if run_successful
-        message << 'OK'.green.bold
-      else
-        message << 'FAILED'.red.bold
-        message.concat msg.flatten
-      end
-
-      message.join("\n")
-    end
-
-    # Constructur to initiate a new command and run it later
+    # Run a command 
     #
     # @see #initialize
-    def Command.execute(name,opts={})
+    def self.execute(name,opts={})
       command = new(name,opts)
       command.run
 
       command
     end
-
   end
 end