Class: Logging::ColorScheme

### Home Classes Methods

### In Files

- lib/logging/color_scheme.rb

### Parent

Object

### Methods

- ::[]
- ::[]=
- ::new
- ::reset
- #[]
- #[]=
- #color
- #include?
- #levels?
- #lines?
- #load_from_hash

### Files

- History.txt

### Class/Module Index

Quicksearch

- Logging
- Logging::Appender
- Logging::Appenders
- Logging::Appenders::Buffering
- Logging::Appenders::File
- Logging::Appenders::IO
- Logging::Appenders::RollingFile
- Logging::Appenders::RollingFile::Roller
- Logging::Appenders::Stderr
- Logging::Appenders::Stdout
- Logging::Appenders::StringIo
- Logging::Appenders::Syslog
- Logging::ColorScheme
- Logging::Filter
- Logging::Filters
- Logging::Filters::Level
- Logging::Layout
- Logging::Layouts
- Logging::Layouts::Basic
- Logging::Layouts::Parseable
- Logging::Layouts::Pattern
- Logging::Logger
- Logging::MappedDiagnosticContext
- Logging::NestedDiagnosticContext
- Logging::Proxy
- Logging::RailsCompat
- Logging::Repository
- Logging::Repository::Singleton
- Logging::RootLogger
- RSpec
- RSpec::Core
- RSpec::Core::Configuration
- RSpec::LoggingHelper
- RSpec::LoggingHelper
- Spec
- Spec::Runner
- Spec::Runner::Configuration
- Object
- Object::LoggingHelper
- File
- FileUtils
- Module
- ReentrantMutex
- String

No matching classes.

# Logging::ColorScheme

ColorScheme objects encapsulate a named set of colors to be used in the colors() method call. For example, by applying a ColorScheme that has a `:warning` color then the following could be used:

    scheme.color("This is a warning", :warning)

ColorScheme objects are used by the Pattern layout code to colorize log messages. Each color scheme is given a unique name which is used by the Pattern layout to lookup the appropriate color scheme to use. Please refer to the Pattern layout documentation for more details - specifically the initializer documentation.

The color scheme can be applied to the Pattern layout in several ways. Each token in the log pattern can be colorized with the log level (debug, info, warn, etc) receiving unique colors based on the level itself. Another option is to colorize the entire log message based on the log level; in this mode tokens do not get their own colors. Please see the ColorScheme initializer for the list of colorization options.

### Constants

BLACK
BLINK
BLUE
BOLD
BRIGHT_BLUE
BRIGHT_CYAN
BRIGHT_GREEN
BRIGHT_MAGENTA
BRIGHT_RED
BRIGHT_WHITE
BRIGHT_YELLOW
CLEAR

  Embed in a String to clear all previous ANSI sequences. This MUST be done before the program exits!

CONCEALED
CYAN
DARK
ERASE_CHAR
ERASE_LINE
GREEN
MAGENTA
ON_BLACK
ON_BLUE
ON_BRIGHT_BLUE
ON_BRIGHT_CYAN
ON_BRIGHT_GREEN
ON_BRIGHT_MAGENTA
ON_BRIGHT_RED
ON_BRIGHT_WHITE
ON_BRIGHT_YELLOW
ON_CYAN
ON_GREEN
ON_MAGENTA
ON_RED
ON_WHITE
ON_YELLOW
RED
RESET
REVERSE
UNDERLINE
UNDERSCORE
WHITE
YELLOW

### Public Class Methods

[]( name ) click to toggle source

Retrieve a color scheme by name.

    # File lib/logging/color_scheme.rb, line 36
    def []( name )
      @color_schemes[name.to_s]
    end

[]=( name, value ) click to toggle source

Store a color scheme by name.

    # File lib/logging/color_scheme.rb, line 42
    def []=( name, value )
      raise ArgumentError, "Silly! That's not a ColorSchmeme!" unless ColorScheme === value
      @color_schemes[name.to_s] = value
    end

new( name, opts = {} ) click to toggle source

Create a ColorScheme instance that can be accessed using the given name. If a color scheme already exists with the given name it will be replaced by the new color scheme.

The color names are passed as options to the method with each name mapping to one or more color codes. For example:

    ColorScheme.new('example', :logger => [:white, :on_green], :message => :magenta)

The color codes are the lowercase names of the constants defined at the end of this file. Multiple color codes can be aliased by grouping them in an array as shown in the example above.

Since color schemes are primarily intended to be used with the Pattern layout, there are a few special options of note. First the log levels are enumerated in their own hash:

    :levels => {
      :debug => :blue,
      :info  => :cyan,
      :warn  => :yellow,
      :error => :red,
      :fatal => [:white, :on_red]
    }

The log level token will be colorized differently based on the value of the log level itself. Similarly the entire log message can be colorized based on the value of the log level. A different option should be given for this behavior:

    :lines => {
      :debug => :blue,
      :info  => :cyan,
      :warn  => :yellow,
      :error => :red,
      :fatal => [:white, :on_red]
    }

The :levels and :lines options cannot be used together; only one or the other should be given.

The remaining tokens defined in the Pattern layout can be colorized using the following aliases. Their meaning in the Pattern layout are repeated here for sake of clarity.

    :logger       [%c] name of the logger that generate the log event
    :date         [%d] datestamp
    :message      [%m] the user supplied log message
    :pid          [%p] PID of the current process
    :time         [%r] the time in milliseconds since the program started
    :thread       [%T] the name of the thread Thread.current[:name]
    :thread_id    [%t] object_id of the thread
    :file         [%F] filename where the logging request was issued
    :line         [%L] line number where the logging request was issued
    :method       [%M] method name where the logging request was issued

Please refer to the "examples/colorization.rb" file for a working example of log colorization.

    # File lib/logging/color_scheme.rb, line 121
    def initialize( name, opts = {} )
      @scheme = Hash.new

      @lines = opts.key? :lines
      @levels = opts.key? :levels
      raise ArgumentError, "Found both :lines and :levels - only one can be used." if lines? and levels?

      lines = opts.delete :lines
      levels = opts.delete :levels

      load_from_hash(opts)
      load_from_hash(lines) if lines?
      load_from_hash(levels) if levels?

      ::Logging::ColorScheme[name] = self
    end

reset() click to toggle source

Clear all color schemes and setup a default color scheme.

    # File lib/logging/color_scheme.rb, line 49
    def reset
      @color_schemes ||= {}
      @color_schemes.clear

      new(:default, :levels => {
        :info  => :green,
        :warn  => :yellow,
        :error => :red,
        :fatal => [:white, :on_red]
      })
    end

### Public Instance Methods

[]( color_tag ) click to toggle source

Allow the scheme to be accessed like a Hash.

    # File lib/logging/color_scheme.rb, line 166
    def []( color_tag )
      @scheme[to_key(color_tag)]
    end

[]=( color_tag, constants ) click to toggle source

Allow the scheme to be set like a Hash.

    # File lib/logging/color_scheme.rb, line 172
    def []=( color_tag, constants )
      @scheme[to_key(color_tag)] = constants.respond_to?(:map) ?
          constants.map { |c| to_constant(c) }.join : to_constant(constants)
    end

color( string, *colors ) click to toggle source

This method provides easy access to ANSI color sequences, without the user needing to remember to CLEAR at the end of each sequence. Just pass the string to color, followed by a list of colors you would like it to be affected by. The colors can be ColorScheme class constants, or symbols (:blue for BLUE, for example). A CLEAR will automatically be embedded to the end of the returned String.

    # File lib/logging/color_scheme.rb, line 184
    def color( string, *colors )
      colors.map! { |color|
        color_tag = to_key(color)
        @scheme.key?(color_tag) ? @scheme[color_tag] : to_constant(color)
      }

      colors.compact!
      return string if colors.empty?

      "#{colors.join}#{string}#{CLEAR}"
    end

include?( color_tag ) click to toggle source

Does this color scheme include the given tag name?

    # File lib/logging/color_scheme.rb, line 160
    def include?( color_tag )
      @scheme.key?(to_key(color_tag))
    end

levels?() click to toggle source

Returns `true` if the :levels option was passed to the constructor.

    # File lib/logging/color_scheme.rb, line 154
    def levels?
      @levels
    end

lines?() click to toggle source

Returns `true` if the :lines option was passed to the constructor.

    # File lib/logging/color_scheme.rb, line 148
    def lines?
      @lines
    end

load_from_hash( h ) click to toggle source

Load multiple colors from key/value pairs.

    # File lib/logging/color_scheme.rb, line 140
    def load_from_hash( h )
      h.each_pair do |color_tag, constants|
        self[color_tag] = constants
      end
    end

[Validate]

Generated with the Darkfish Rdoc Generator 2.