Can you make my terminal less boring?

Question

Terminals are so boring these days. They used to look like this:

Now they're just bland and dull and black-and-white. I want you to write me a program that will make my terminal all colorful again!

Description

Take this example Ruby code:

Most Linux terminals support these escape sequences (\e stands for the escape character), and Windows can support them with ANSICON. Here is the syntax of the specific escape sequence that can change the text or background color of a string:

\e[{{COLOR}}m

where \e stands for the escape character (0x1B in ASCII) and {{COLOR}} is replaced by the number of the color that you want to use (more details on that later). Text that comes after this escape sequence will be formatted as directed, and a value of 0 will reset all formatting.

Your challenge is to take a string specifying some text that may contain color, and output a colorful version of it.

Input / Output

Normal text works just like normal, and is printed literally. For example, the input waffles yields the same output, with no special color.

The syntax for specifying a color is similar to Wikipedia's syntax. For example, to color the words "the color red" in red in the sentence This is the color red!, the input would be:

This is {{red|the color red}}!

Background colors work too. If you wanted black letters on a white background, you would use this:

{{black|white|This text is black on white}}

To get only a background color, omit the foreground:

{{|red|This text has a red background}}

Specification

Two open curly brackets always specify the beginning of a color directive. Two closing curly brackets specify the end. Brackets will always match; there will never be a {{ without a corresponding }}, and a }} will never come before its corresponding {{. These color directives will not be nested, and a {{ will never appear within a color directive.

Within a color directive, there will always be either one or two | symbols. If there is one, the text before it is the foreground color and the text after is the string to show in that color. If there are two, the text before the first one is the foreground color, the text after the first but before the second is the background color, and the text after the second is the string to display. These vertical bars may exist outside of a color directive, and should be printed literally.

The foreground color or background color (but not both) may be empty, in which case you should leave them as the default. The final string (the one to output) will never be empty.

Here are the directions to output text of a certain color:

• A color sequence is defined in the "Description" section. For example, a color sequence of 42 would be "\e[42m".

• To set a color, print the color sequence of the number determined below:

   Color name   | Color sequence number (foreground / background)
  --------------+----------
   black        | 30 / 40
   red          | 31 / 41
   green        | 32 / 42
   yellow       | 33 / 43
   blue         | 34 / 44
   magenta      | 35 / 45
   cyan         | 36 / 46
   lightgray    | 37 / 47
   darkgray     | 90 / 100
   lightred     | 91 / 101
   lightgreen   | 92 / 102
   lightyellow  | 93 / 103
   lightblue    | 94 / 104
   lightmagenta | 95 / 105
   lightcyan    | 96 / 106
   white        | 97 / 107
  

• Color names are case sensitive, and an invalid color name will never be provided. You don't have to handle stuff like RED or lightgrey (spelled with an e).

• After you print a color sequence, it will apply for all text following it. To end a color sequence (reset to the default color), output a color sequence of 0 ("\e[0m").

Test case

 {{|yellow|     }}
{{|yellow| }}     {{|yellow| }}
{{|yellow| }} {{red|'}} {{red|'}} {{|yellow| }}
{{|yellow| }} \_/ {{|yellow| }}
{{|yellow| }}     {{|yellow| }}
 {{|yellow|     }}

This should output a smiley face... with evil red eyes.

Rules

• You may not use any libraries or functions of your programming language to automatically parse a color. This means that you must be the one to determine what "red" means; you can't have a library automatically do that for you.

• This is code-golf, so the shortest code in bytes will win!

Answer 1

Ruby, 205 189 188 186 185 182 174 170 165 161 159 154 bytes

Putting long strings of color names in your code doesn't look nerdy enough.

Down to 170 partly thanks to rubik. Now the scrolling bars are gone!

One obvious and one not so obvious improvement, thanks to the flex answer, without the improvement to it, I wouldn't have revisited this!

Not anymore, I saved 4 bytes with #sum. I didn't intend it, but I just noticed this solution is case-insensitive as well. It happily processes {{RED|Red text}}.

Hex dump:

0000000: 7a3d 2d3e 6a7b 693d 2240 3054 2d44 1547  z=->j{i="@0T-D.G
0000010: 5155 0034 3256 2f46 1749 0b22 2e69 6e64  QU.42V/F.I.".ind
0000020: 6578 2028 415b 6a5d 2e74 6f5f 732e 7375  ex (A[j].to_s.su
0000030: 6d25 3839 292e 6368 723b 692b 3d69 3e39  m%89).chr;i+=i>9
0000040: 3f38 303a 3330 7d0a 243e 3c3c 243c 2e72  ?80:30}.$><<$<.r
0000050: 6561 642e 6773 7562 282f 7b7b 282e 2a3f  ead.gsub(/{{(.*?
0000060: 297d 7d2f 297b 413d 2431 2e73 706c 6974  )}}/){A=$1.split
0000070: 277c 273b 221b 5b25 693b 2569 6d23 7b41  '|';".[%i;%im#{A
0000080: 2e70 6f70 7d1b 5b30 6d22 255b 7a5b 305d  .pop}.[0m"%[z[0]
0000090: 2c31 302b 7a5b 315d 5d7d                 ,10+z[1]]}

You can convert it with xxd -r hex.dump.

The program with all non-printable characters escaped for reference purposes:

z=->j{i="@0T-D\x15GQU\x0042V/F\x17I\v".index (A[j].to_s.sum%89).chr;i+=i>9?80:30}
$><<$<.read.gsub(/{{(.*?)}}/){A=$1.split'|';"\x1b[%i;%im#{A.pop}\x1b[0m"%[z[0],10+z[1]]}

That is one line. Use it like this

ruby colors.rb -W0 < input.txt

The -W0 flag suppresses warnings that would be sent to stderr otherwise. However, the program works fine without any flags.

Output:

Answer 2

Ruby, 329 bytes.

h={};(y=0..15).each{|i|h[%w(black red green yellow blue magenta cyan lightgray darkgray lightred lightgreen lightyellow lightblue lightmagenta lightcyan white)[i]]=y.map{|j|[30,40].map{|k|k+i%8+i/8*60}}[i]}
loop{puts gets.gsub(/{{.+?}}/){|x|"\e[#{h[(g=x.scan(/[^{}|]+/))[0]][0]}m#{(g[2]? "\e[#{h[g[1]][1]}m":'')}#{g.last}\e[0m"}}

Answer 3

Flex (lexer) - 226 197 192 182 168 (or 166)

To get it down to 166, change the \33 to an actual escape character.

 int z;p(i){printf("\33[%dm",i);}
%%
"{{" z=2;
[a-z]*\| if(!z)REJECT;~-yyleng&&p("062q00t03058ns7uo0p90r4"[*(int*)&yytext[yyleng>7?4:0]%131%27]-10*z);z--;
"}}" p(z=0);

Compile and run:

$ flex -o colour.c colour.l
$ gcc -o colour colour.c -lfl
$ ./colour < input

Answer 4

Python - 351

import re,sys
R=range
E=lambda n,d=0:'\033[%dm'%(T[n]+d)if n else''
def P(m):f,b,t=m.groups();return'%s%s%s\033[0m'%(E(f),E(b,10),t)
x='!red!green!yellow!blue!magenta!cyan'.replace
T=dict(zip(('black'+x('!',' ')+' lightgray darkgray'+x('!',' light')+' white').split(),R(30,38)+R(90,98)))
print re.sub(r'{{(\w+)?\|?(\w+)?\|?(.+?)}}',P,sys.stdin.read())

Answer 5

Cobra - 496

It could almost be a single print statement.

use System.Text.RegularExpressions
class P
    def main
        print Regex.replace(Console.readLine,r'\{\{('+(l=List<of String>(((m=' black red green yellow blue magenta cyan'.split).join(' ')+' lightgray darkgray'+m.join(' light')+' white').split))[1:].join('|')+r')?\|?('+l[1:].join('|')+r')?\|(.*?)\}\}',do(a as Match))
            return if(x=l.indexOf('[a.groups[1]]'),r'\e['+'[if(x>8,x+81,x+29)]m','')+if(y=l.indexOf('[a.groups[2]]'),r'\e['+'[if(y>8,y+91,y+39)]m','')+'[a.groups[3]]'+if(x+y,r'\e[0m','')

Answer 6

Python, 561

Reads the text to format from stdin.

import re,sys
def p(f,b,t):
    p=''
    m='\033[%dm'
    if f!=0:p+=m%f
    if b!=0:p+=m%b
    return p+t+m%0
def c(n,b=0):
    s='black:30#red:31#green:32#yellow:33#blue:34#magenta:35#cyan:36#lightgray:37#darkgray:90#lightred:91#lightgreen:92#lightyellow:93#lightblue:94#lightmagenta:95#lightcyan:96#white:97'
    r=0
    for i in s.split('#'):
        (t,c)=i.split(':')
        if t==n:
            r=int(c)
            if b==1:r+=10
    return r
def r(m):
    i=m.groups()
    f=b=0
    if i[0]!='':f=c(i[0])
    if i[1]!=None:b=c(i[1],1)
    return p(f,b,i[2])
print re.sub('{{(\w*)\|(?:(\w*)\|)?([^}]+)}}',r,sys.stdin.read())