bugfix #40: don't try to color non-matching groups

AUTHORS

@@ -0,0 +1,6 @@
+Colout is written by nojhan and maintained by Dongweiming:
+
+Writer
+``````
+
+- Nojhan <https://github.com/nojhan>

CHANGES

@@ -0,0 +1,4 @@
+Version 0.1
+-----------
+
+Released on May 5th 2013, First public preview release.

PKG-INFO

@@ -0,0 +1,195 @@
+Metadata-Version: 1.1
+Name: Colout
+Version: 0.1
+Summary: Color text streams with this simple command
+Home-page: http://nojhan.github.com/colout/
+Author: Nojhan
+Author-email: nojhan@nojhan.net
+License: GPL3
+Description: 
+        Colout
+        -----
+        
+        Colout is Color text streams with this simple commandinja 2 and good
+        intentions. And before you ask: It's BSD licensed!
+        
+        SYNOPSIS
+        ````````````
+        
+        ``colout`` [-h][-e] [-g][-t] [-s][-l] 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 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 or any number between 0 and
+        255.
+
+        Available styles are: normal, bold, faint, italic, underline, blink,
+        rapid\_blink, reverse, conceal or random.
+
+        ``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 a scale defined by the
+        ``-l`` option (see below, [0-100] by default).
+
+        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).
+
+        ``colout`` is released under the GNU Public License v3.
+
+        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).
+
+        -  ``-l``, ``--scale``: When using the 'scale' colormap, parse matches
+           as decimal numbers (taking your locale into account) and apply the
+           rainbow colormap linearly between the given SCALE=min,max
+           (SCALE=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.)
+
+        -  ``-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").
+
+
+        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
+
+        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 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``
+
+
+        
+        
+Platform: any
+Classifier: Development Status :: 4 - Beta
+Classifier: Environment :: Console
+Classifier: Intended Audience :: End Users/Desktop
+Classifier: License :: OSI Approved :: GNU General Public License v3 (GPLv3)
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 2.5
+Classifier: Programming Language :: Python :: 2.6
+Classifier: Programming Language :: Python :: 2.7
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Text Processing
+Classifier: Topic :: Utilities
+Classifier: Topic :: Software Development :: Libraries :: Python Modules

README

@@ -0,0 +1,4 @@
+Colout
+-----
+
+This is the [colout](http://nojhan.github.com/colout/)'s pypi source

README.md

@@ -1,157 +0,0 @@
-colout(1) -- Color Up Arbitrary Command Ouput
-=============================================
-
-## SYNOPSIS
-
-`colout` [-h] [-e] [-g] [-t] [-s] [-l] 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 or any number between 0 and 255.
-
-Available styles are: normal, bold, faint, italic, underline, blink,
-rapid_blink, reverse, conceal or random.
-
-`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 a scale defined by the `-l` option (see
-below, [0-100] by default).
-
-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).
-
-`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
-
-## 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).
-
-* `-l`, `--scale`:
-  When using the 'scale' colormap, parse matches as decimal numbers (taking your locale into account)
-  and apply the rainbow colormap linearly between the given SCALE=min,max (SCALE=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.)
-
-* `-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").
-
-
-## 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
-
-
-## 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`
-

bin/colout

@@ -1,5 +1,5 @@
 #!/bin/bash
-# Copyright © 2013 Martin Ueding <dev@martin-ueding.de>
+# Copyright @ 2013 Martin Ueding <dev@martin-ueding.de>
 
 # Small launcher script for the main module.
 
@@ -8,4 +8,4 @@
 set -e
 set -u
 
-python3 -m colout.colout "$@"
+python -m colout.colout "$@"

colout/colout.py

@@ -304,8 +304,10 @@ def colorup(text, pattern, color="red", style="normal", on_groups=False):
             # but that match.start(0) refers to the whole match, the groups being indexed in [1,n].
             # Thus, we need to range in [1,n+1[.
             for group in range(1, nb_groups+1):
-                partial, end = colorout(text, match, end, group_colors[group-1], group_styles[group-1], group)
-                colored_text += partial
+                # If a group didn't match, there's nothing to color
+                if match.group(group) is not None:
+                    partial, end = colorout(text, match, end, group_colors[group-1], group_styles[group-1], group)
+                    colored_text += partial
 
     # Append the remaining part of the text, if any.
     colored_text += text[end:]

setup.py

@@ -1,10 +1,9 @@
-#!/usr/bin/env python3
+#!/usr/bin/env python
+#coding=utf-8
 
 import os
 import sys
 
-import colout
-
 try:
     from setuptools import setup
 except ImportError:
@@ -18,20 +17,38 @@ packages = ['colout']
 
 requires = ['argparse', 'pygments', 'babel']
 
+classifiers = """\
+Development Status :: 4 - Beta
+Environment :: Console
+Intended Audience :: End Users/Desktop
+License :: OSI Approved :: GNU General Public License v3 (GPLv3)
+Operating System :: OS Independent
+Programming Language :: Python
+Programming Language :: Python :: 2.5
+Programming Language :: Python :: 2.6
+Programming Language :: Python :: 2.7
+Programming Language :: Python :: 3
+Topic :: Text Processing
+Topic :: Utilities
+Topic :: Software Development :: Libraries :: Python Modules
+"""
+
 setup(
     name='colout',
     version='0.1',
     description='Color Up Arbitrary Command Ouput.',
-    long_description=open('README.md').read(),
-    author='nojhan',
+    long_description=open('README').read(),
+    author='Nojhan',
     author_email='nojhan@nojhan.net',
     url='http://nojhan.github.com/colout/',
+    download_url = 'https://pypi.python.org/packages/source/c/colout/colout-0.1.tar.gz',
     packages=packages,
     package_data={'': ['LICENSE']},
     package_dir={'colout': 'colout'},
     scripts=['bin/colout'],
     include_package_data=True,
     install_requires=requires,
-    license=open('LICENSE').read(),
+    license="GPL-3",
+    classifiers = filter(None, classifiers.split("\n")),
     zip_safe=False,
 )