nojhan
f617d9c302
Don't use nested groups or colout will duplicate the corresponding input text with each matching colors.
246 lines
8.7 KiB
Markdown
246 lines
8.7 KiB
Markdown
colout(1) -- Color Up Arbitrary Command Ouput
|
|
=============================================
|
|
|
|
## SYNOPSIS
|
|
|
|
`colout` [-h] [-g] [-c] [-l] [-a] [-t] [-T] [-s] PATTERN [COLOR(S)] [STYLE(S)]
|
|
|
|
|
|
## DESCRIPTION
|
|
|
|
`colout` read lines of text stream on the standard input and output characters
|
|
matching a given regular expression *PATTERN* in given <COLOR> and *STYLE*.
|
|
|
|
If groups are specified in the regular expression pattern, only them are taken
|
|
into account, else the whole matching pattern is colored.
|
|
|
|
You can specify severall colors or styles when using groups by separating them
|
|
with commas. If you indicate more colors than groups, the last ones will be ignored.
|
|
If you ask for less colors, the last one will be duplicated across remaining
|
|
groups.
|
|
|
|
Available colors are: blue, black, yellow, cyan, green, magenta, white, red,
|
|
rainbow, random, Random, scale, none, an RGB hexadecimal triplet or any number
|
|
between 0 and 255.
|
|
|
|
Available styles are: normal, bold, faint, italic, underline, blink,
|
|
rapid_blink, reverse, conceal or random (some styles may have no effect, depending
|
|
on your terminal).
|
|
|
|
`Random` will color each matching pattern with a random color among the 255
|
|
available in the ANSI table. `random` will do the same in 8 colors mode.
|
|
|
|
`rainbow` will cycle over a 8 colors rainbow at each matching pattern.
|
|
|
|
`scale` will parse the matching text as a decimal number and apply the rainbow
|
|
colormap according to its position on the scale defined by the `-l` option (see
|
|
below, [0-100] by default).
|
|
|
|
If the python-pygments library is installed, you can use the name of a
|
|
syntax-coloring "lexer" as a color (for example: "Cpp", "ruby", "xml+django", etc.).
|
|
|
|
If GIMP palettes files (*.gpl) are available, you can also use their names as a
|
|
colormap (see the `-P` switch below).
|
|
|
|
Note that the RGB colors (either the hex triplets or the palettes's colors) will
|
|
be converted to their nearest ANSI 256-colors mode equivalents.
|
|
|
|
When not specified, a *COLOR* defaults to _red_ and a *STYLE* defaults to _bold_.
|
|
|
|
`colout` comes with some predefined themes to rapidely color well-known outputs
|
|
(see the `-t` switch below).
|
|
|
|
If the python-pygments library is available, `colout` can be used as an interface
|
|
to it (see also the `-s` switch below).
|
|
|
|
To have a list of all colors, styles, special colormaps, themes, palettes and lexers,
|
|
use the `-r` switch (see below).
|
|
|
|
`colout` is released under the GNU Public License v3.
|
|
|
|
|
|
## INSTALLATION
|
|
|
|
sudo python setup.py install
|
|
|
|
and then soft link `/usr/local/bin/colout` to your colout.py under your installaion directory, which usually like
|
|
|
|
/usr/local/lib/python2.7/dist-packages/colout-0.1-py2.7.egg/colout/colout.py
|
|
|
|
|
|
## OTHER INSTALLATION METHOD
|
|
|
|
Pypi(the Python Package Index)
|
|
|
|
sudo pip install colout
|
|
|
|
or
|
|
|
|
sudo easy_install colout
|
|
|
|
Ubuntu 13.04's ppa
|
|
|
|
sudo add-apt-repository ppa:ciici123/colout
|
|
sudo apt-get update
|
|
sudo apt-get/aptitude install colout
|
|
|
|
Gentoo overlay
|
|
|
|
1. Install layman
|
|
|
|
echo "app-portage/layman git" >> $EPREFIX/etc/portage/package.Use
|
|
sudo emerge layman
|
|
|
|
2. Edit `$EPREFIX/etc/layman/layman.cfg`. Add a line after
|
|
|
|
overlays : http://www.gentoo.org/proj/en/overlays/repositories.xml
|
|
|
|
so that it becomes
|
|
|
|
overlays : http://www.gentoo.org/proj/en/overlays/repositories.xml
|
|
file://$EPREFIX/var/lib/layman/my-list.xml
|
|
|
|
3. Edit `$EPREFIX/var/lib/layman/my-list.xml`. The content of this file should be:
|
|
|
|
<?xml version="1.0" ?>
|
|
<repositories version="1.0">
|
|
<repo priority="50" quality="experimental" status="unofficial">
|
|
<name>dongwm-overlay</name>
|
|
<description>dongweiming's gentoo overlay</description>
|
|
<homepage>https://github.com/dongweiming/dongwm-overlay.git</homepage>
|
|
<owner>
|
|
<email>ciici1234@hotmail.com</email>
|
|
</owner>
|
|
<source type="git">git://github.com/dongweiming/dongwm-overlay.git</source>
|
|
</repo>
|
|
</repositories>
|
|
|
|
4. Add this overlay and installation
|
|
|
|
layman -a dongwm-overlay && sudo emerge colout
|
|
|
|
|
|
## OPTIONS
|
|
|
|
* `-h`, `--help`:
|
|
Show an help message and exit
|
|
|
|
* `-g`, `--groups`:
|
|
For color maps (like "rainbow"), iterate over matching groups in the pattern instead of over patterns.
|
|
|
|
* `-c`, `--colormap`:
|
|
Use the given list of comma-separated colors as a colormap (cycle the colors at each match).
|
|
|
|
* `-a`, `--all`
|
|
Color the whole input at once instead of line per line (really useful
|
|
for coloring a source code file with strings on multiple lines).
|
|
|
|
* `-l min,max`, `--scale min,max`:
|
|
When using the 'scale' colormap, parse matches as decimal numbers (taking your locale into account)
|
|
and apply the rainbow colormap linearly between the given min,max (0,100, by default).
|
|
|
|
* `-a`, `--all`:
|
|
Color the whole input at once instead of line per line
|
|
(really useful for coloring a source code file with strings on multiple lines).
|
|
|
|
* `-t`, `--theme`:
|
|
Interpret PATTERN as a predefined theme (perm, cmake, g++, etc.).
|
|
|
|
* `-T DIR`, `--themes-dir DIR`:
|
|
Search for additional themes (colout_*.py files) in this directory.
|
|
|
|
* `-P DIR`, `--palettes-dir DIR`:
|
|
Search for additional palettes (*.gpl files) in this directory.
|
|
|
|
* `-r`, `--resources`:
|
|
Print the names of all available colors, styles, themes and palettes.
|
|
|
|
* `-s`, `--source`:
|
|
Interpret PATTERN as a source code readable by the Pygments library. If the first letter of PATTERN
|
|
is upper case, use the 256 colors mode, if it is lower case, use the 8 colors mode.
|
|
In 256 colors, interpret COLOR as a Pygments style (e.g. "default").
|
|
|
|
* `--debug`:
|
|
Debug mode: print what's going on internally, if you want to check what features are available.
|
|
|
|
|
|
## REGULAR EXPRESSIONS
|
|
|
|
A regular expression (or _regex_) is a pattern that describes a set of strings
|
|
that matches it.
|
|
|
|
`colout` understands regex as specifed in the _re_ python module. Given that
|
|
`colout` is generally called by the command line, you may have to escape
|
|
special characters that would be recognize by your shell.
|
|
|
|
|
|
## DEPENDENCIES
|
|
|
|
Recommended packages :
|
|
|
|
* `argparse` for a usable arguments parsing
|
|
* `pygments` for the source code syntax coloring
|
|
* `babel` for a locale-aware number parsing
|
|
|
|
|
|
## LIMITATIONS
|
|
|
|
Don't use nested groups or colout will duplicate the corresponding input text with each matching colors.
|
|
|
|
|
|
## EXAMPLES
|
|
|
|
* Color in bold red every occurence of the word _color_ in colout sources:
|
|
`cat colout.py | colout color red bold`
|
|
|
|
* Color in bold violet home directories in _/etc/passwd_:
|
|
`colout '/home/[a-z]+' 135 < /etc/passwd`
|
|
|
|
* Use a different color for each line of the auth log
|
|
`grep user /var/log/auth.log | colout "^.*$" rainbow`
|
|
|
|
* Color in yellow user/groups id, in bold green name and in bold red home directories in _/etc/passwd_:
|
|
`colout ':x:([0-9]+:[0-9]+):([^:]+).*(/home/[a-z]+)' yellow,green,red normal,bold < /etc/passwd`
|
|
|
|
* Color in yellow file permissions with read rights for everyone:
|
|
`ls -l | colout '.(r.-){3}' yellow normal`
|
|
|
|
* Color in green read permission, in bold red write and execution ones:
|
|
`ls -l | colout '(r)(w*)(x*)' green,red normal,bold`
|
|
|
|
* Color permissions with a predefined template:
|
|
`ls -l | colout -t perm`
|
|
|
|
* Color in green comments in colout sources:
|
|
`colout '.*(#.*)$' green normal < colout.py`
|
|
|
|
* Color in light green comments in non-empty colout sources, with the sharp in bold green:
|
|
`grep -v '^\s*$' colout.py | colout '.*(#)(.*)$' green,119 bold,normal`
|
|
|
|
* Color in bold green every numbers and in bold red the words _error_ in make output:
|
|
`make 2>&1 | colout '[0-9]+' green normal | colout error`
|
|
|
|
* Color a make output, line numbers in yellow, errors in bold red, warning in magenta, pragma in green and C++ file base names in cyan:
|
|
`make 2>&1 | colout ':([0-9]+):[0-9]*' yellow normal | colout error | colout warning magenta | colout pragma green normal | colout '/(\w+)*\.(h|cpp)' cyan normal`
|
|
Or using themes:
|
|
`make 2>&³ | colout -t cmake | colout -t g++`
|
|
|
|
* Color each word in the head of auth.log with a rainbow color map, starting a new colormap at each new line (the
|
|
begining of the command is just bash magic to repeat the string "(\\w+)\\W+":
|
|
`L=$(seq 10) ; P=${L//??/(\\w+)\\W+} ; head /var/log/auth.log | colout -g "^${P}(.*)$" rainbow`
|
|
|
|
* Color each line of a file with a different color among a 256 color gradient from cyan to green:
|
|
`head /var/log/auth.log | colout -c "^.*$" 39,38,37,36,35,34`
|
|
|
|
* Color a source code in 8 colors mode, without seeing comments:
|
|
`cat colout.py | grep -v "#" | colout -s python`
|
|
|
|
* Color a source code in 256 colors mode:
|
|
`cat colout.py | colout -s Python monokai`
|
|
|
|
* Color a JSON stream:
|
|
`echo '{"foo": "lorem", "bar":"ipsum"}' | python -mjson.tool | colout -t json`
|
|
|
|
* Color a source code substring:
|
|
`echo "There is an error in 'static void Functor::operator()( EOT& indiv ) { return indiv; }' you should fix it" | colout "'(.*)'" Cpp monokai`
|
|
|