Provides easier access to a shared Methadone::CLILogger instance.

Include this module into your class, and logger provides access to a shared logger. This is handy if you want all of your clases to have access to the same logger, but don't want to (or aren't able to) pass it around to each class.

This also provides methods for direct logging without going through the logger

Example

class MyClass
  include Methadone::CLILogger

  def doit
    debug("About to doit!")
    if results
      info("We did it!"
    else
      error("Something went wrong")
    end
    debug("Done doing it")
  end
end

Note that every class that mixes this in shares the *same logger instance*, so if you call change_logger, this will change the logger for all classes that mix this in. This is likely what you want.

Methods
C
D
E
F
I
L
U
W
Constants
LOG_LEVELS = { 'debug' => Logger::DEBUG, 'info' => Logger::INFO, 'warn' => Logger::WARN, 'error' => Logger::ERROR, 'fatal' => Logger::FATAL, }
 
Class Public methods
included(k)
# File lib/methadone/cli_logging.rb, line 30
def self.included(k)
  k.extend(self)
end
Instance Public methods
change_logger(new_logger)

Change the global logger that includers will use. Useful if you don't want the default configured logger. Note that the change_logger version is preferred because Ruby will often parse logger = Logger.new as the declaration of, and assignment to, of a local variable. You'd need to do self.logger=Logger.new to be sure. This method is a bit easier.

new_logger

the new logger. May not be nil and should be a logger of some kind

Also aliased as: logger=
# File lib/methadone/cli_logging.rb, line 48
def change_logger(new_logger)
  raise ArgumentError,"Logger may not be nil" if new_logger.nil?
  @@logger = new_logger
  @@logger.level = @log_level if @log_level
end
debug(progname = nil, &block)

pass-through to logger.debug(progname,&block)

# File lib/methadone/cli_logging.rb, line 58
def debug(progname = nil, &block); logger.debug(progname,&block); end
error(progname = nil, &block)

pass-through to logger.error(progname,&block)

# File lib/methadone/cli_logging.rb, line 64
def error(progname = nil, &block); logger.error(progname,&block); end
fatal(progname = nil, &block)

pass-through to logger.fatal(progname,&block)

# File lib/methadone/cli_logging.rb, line 66
def fatal(progname = nil, &block); logger.fatal(progname,&block); end
info(progname = nil, &block)

pass-through to logger.info(progname,&block)

# File lib/methadone/cli_logging.rb, line 60
def info(progname = nil, &block); logger.info(progname,&block); end
logger()

Access the shared logger. All classes that include this module will get the same logger via this method.

# File lib/methadone/cli_logging.rb, line 36
def logger
  @@logger ||= CLILogger.new
end
logger=(new_logger)
use_log_level_option()

Call this if you've included Methadone::Main to set up a --log-level option for your app that will allow the user to configure the logging level.

Example:

main do 
  # your app
end

use_log_level_option

go!
# File lib/methadone/cli_logging.rb, line 89
def use_log_level_option
  on("--log-level LEVEL",LOG_LEVELS,'Set the logging level',
                                    '(' + LOG_LEVELS.keys.join('|') + ')',
                                    '(Default: info)') do |level|
    @log_level = level
    logger.level = level
  end
end
warn(progname = nil, &block)

pass-through to logger.warn(progname,&block)

# File lib/methadone/cli_logging.rb, line 62
def warn(progname = nil, &block); logger.warn(progname,&block); end