280 lines
11 KiB
Python
Executable File
280 lines
11 KiB
Python
Executable File
#!/usr/bin/env python
|
|
|
|
import sys,os,re
|
|
from argparse import ArgumentParser, RawDescriptionHelpFormatter
|
|
sys.path.append(os.path.dirname(os.path.realpath(__file__)))
|
|
import ansicodes as ansi
|
|
|
|
__author__ = "Ville Rantanen <ville.q.rantanen@gmail.com>"
|
|
__version__ = "0.3"
|
|
|
|
''' Rules modified from mistune project '''
|
|
|
|
def setup_options():
|
|
bc = ansi.code()
|
|
''' Create command line options '''
|
|
usage = '''
|
|
Markdown syntax color in ansi codes.
|
|
Special syntaxes:
|
|
- Colors: insert string e.g. ${C}.
|
|
- Any ANSI control code: ${3A}, ${1;34;42m}, see the table..
|
|
|
|
''' + ansi.demo()
|
|
|
|
parser = ArgumentParser(
|
|
formatter_class = RawDescriptionHelpFormatter,
|
|
description = usage,
|
|
epilog = __author__
|
|
)
|
|
|
|
parser.add_argument("-v","--version",action="version",version=__version__)
|
|
parser.add_argument("-D",action="store_true",dest="debug",default=False,
|
|
help="Debug mode")
|
|
parser.add_argument("--dc",action="store_true",dest="dark_colors",default=False,
|
|
help="Use dark colorscheme, better for white background terminals.")
|
|
parser.add_argument("--no-color","-n",action="store_false",dest="color",default=True,
|
|
help="Disable color.")
|
|
parser.add_argument("--print-template",action="store_true",dest="print_template",default=False,
|
|
help="Print customizable color template.")
|
|
parser.add_argument("--template",action="store",type=str,dest="template",default=None,
|
|
help="Use a custom template file for colorization.")
|
|
parser.add_argument("-z",action="store_true",dest="zero",default=False,
|
|
help="Reset coloring at the end of each line.")
|
|
parser.add_argument("-Z",action="store_false",dest="zero_final",default=True,
|
|
help="Disable reset of colors at the end of file.")
|
|
parser.add_argument("filename",type=str, nargs='?',
|
|
help="File to show, - for stdin")
|
|
opts=parser.parse_args()
|
|
return opts
|
|
|
|
def parse(data):
|
|
data=[[None,row] for row in data]
|
|
block='text'
|
|
new_block='text'
|
|
multiline_block=False
|
|
# Parse styles
|
|
for i,line in enumerate(data):
|
|
row=line[1]
|
|
if line[0] is not None:
|
|
# Previous lines have set the style already
|
|
continue
|
|
for match in blocks:
|
|
if block_match[match]['re'].match(row):
|
|
new_block=match
|
|
if match.startswith('multiline'):
|
|
if multiline_block:
|
|
multiline_block=False
|
|
else:
|
|
multiline_block=match
|
|
break
|
|
if multiline_block:
|
|
new_block=multiline_block
|
|
# Lists must end with empty line
|
|
if new_block not in ('empty','list_bullet') and block.startswith('list_'):
|
|
new_block='list_loose'
|
|
|
|
if 'mod' in block_match[match]:
|
|
# Style sets block in previous or next lines
|
|
data[i+block_match[match]['mod']['pos']][0]=block_match[match]['mod']['name']
|
|
data[i][0]=new_block
|
|
if new_block!=block:
|
|
block=new_block
|
|
return data
|
|
|
|
|
|
def colorize(data, remove_colors = False, dark_colors = False, debug = False):
|
|
# Start inserting colors, and printing
|
|
bc = ansi.code()
|
|
colorized = []
|
|
cs = 'dc' if dark_colors else 'bc'
|
|
csc = cs + 'c'
|
|
for i, line in enumerate(data):
|
|
row = line[1]
|
|
block = line[0]
|
|
multiline_block = block.startswith('multiline')
|
|
if multiline_block:
|
|
row = block_match[block][csc] + row
|
|
if block_match[block][cs]:
|
|
row = block_match[block]['re'].sub(block_match[block][cs], row)
|
|
# No coloring inside block_code, nor multiline
|
|
if not (multiline_block or block == 'block_code'):
|
|
for match in inlines:
|
|
if inline_match[match]['re'].search(row):
|
|
row = inline_match[match]['re'].sub(
|
|
inline_match[match][cs] + block_match[block][csc],
|
|
row
|
|
)
|
|
if remove_colors:
|
|
colored = bc.nocolor_string(row)
|
|
else:
|
|
colored = bc.color_string(row)
|
|
if debug:
|
|
multistr = "*" if multiline_block else " "
|
|
colored = "{:<18}{:}:".format(data[i][0], multistr) + colored
|
|
colorized.append(colored)
|
|
return colorized
|
|
|
|
def md_re_compile(d):
|
|
''' Returns a re.compiled dict '''
|
|
n={}
|
|
for t in d:
|
|
n[t]={}
|
|
for i in d[t]:
|
|
n[t][i]=d[t][i]
|
|
try:
|
|
if n[t]['re']:
|
|
n[t]['re']=re.compile(n[t]['re'])
|
|
except err:
|
|
print("Error compiling: %s"%(n[t]['re']))
|
|
sys.exit(1)
|
|
return n
|
|
|
|
def read_data2(fp):
|
|
data = []
|
|
# Read data
|
|
for row in f:
|
|
if not row:
|
|
continue
|
|
row = row.decode('utf-8').rstrip("\n\r ")
|
|
data.append(row)
|
|
return data
|
|
|
|
def read_data3(fp):
|
|
data = []
|
|
# Read data
|
|
for row in f:
|
|
if not row:
|
|
continue
|
|
row = row.rstrip("\n\r ")
|
|
data.append(row)
|
|
return data
|
|
|
|
def write_colored2(colored, opts):
|
|
for c in colored:
|
|
sys.stdout.write(c.encode('utf-8'))
|
|
if opts.zero:
|
|
sys.stdout.write(bc.Z)
|
|
sys.stdout.write("\n")
|
|
if opts.zero_final:
|
|
sys.stdout.write(bc.Z.encode('utf-8'))
|
|
|
|
def write_colored3(colored, opts):
|
|
for c in colored:
|
|
sys.stdout.write(c)
|
|
if opts.zero:
|
|
sys.stdout.write(bc.Z)
|
|
sys.stdout.write("\n")
|
|
if opts.zero_final:
|
|
sys.stdout.write(bc.Z)
|
|
|
|
|
|
|
|
# re: regular expression, bc: bright colors, bcc: continue with this color after inline
|
|
# dc: dark colors, dcc: continued color after inline
|
|
block_match_str={
|
|
'block_code': {'re':'^( {4}[^*])(.*)$',
|
|
'bc' :'${Z}${c}\\1\\2', 'bcc':'${Z}${c}',
|
|
'dc' :'${Z}${m}\\1\\2', 'dcc':'${Z}${m}'}, # code
|
|
'multiline_code' : {'re':'^ *(`{3,}|~{3,}) *(\S*)',
|
|
'bc' :'${Z}${c}\\1\\2', 'bcc':'${Z}${c}',
|
|
'dc' :'${Z}${m}\\1\\2', 'dcc':'${Z}${m}'}, # ```lang
|
|
'block_quote': {'re':'^(>[ >]* )',
|
|
'bc':'${K}\\1${Z}','bcc':'${Z}',
|
|
'dc':'${Y}\\1${Z}','dcc':'${Z}'}, # > > quote
|
|
'hrule': {'re':'^ {0,3}[-*_]([-*_]){2,}$',
|
|
'bc':'False','bcc':'${Z}',
|
|
'dc':'False','dcc':'${Z}'}, # ----
|
|
'heading' : {'re':'^ *(#{1,6}) *([^\n]+?) *#* *(?:\n+|$)',
|
|
'bc':'${W}\\1 ${U}\\2${Z}','bcc':'${W}${U}',
|
|
'dc':'${B}\\1 ${U}\\2${Z}','dcc':'${B}${U}'}, # # heading
|
|
'lheading' : {'re':'^(=+|-+)$',
|
|
'bc':'${W}\\1', 'bcc':'${W}',
|
|
'dc':'${B}\\1', 'dcc':'${B}',
|
|
'mod':{'pos':-1,'name':'lheading.mod'}}, # ======= under header
|
|
'lheading.mod' : {'re':'^([^\n]+)',
|
|
'bc':'${W}\\1', 'bcc':'${W}',
|
|
'dc':'${B}\\1', 'dcc':'${B}'}, # over the ======= under header
|
|
'list_bullet': {'re':'^( *)([*+-]|[\d\.]+)( +)',
|
|
'bc':'\\1${y}\\2${Z}\\3','bcc':'${Z}',
|
|
'dc':'\\1${r}\\2${Z}\\3','dcc':'${Z}'}, # * or 1.
|
|
'list_loose': {'re':'None',
|
|
'bc':'False','bcc':'${Z}',
|
|
'dc':'False','dcc':'${Z}'},
|
|
'text': {'re':'^([^\n]+)',
|
|
'bc':'${Z}\\1','bcc':'${Z}',
|
|
'dc':'${Z}\\1','dcc':'${Z}'},
|
|
'empty': {'re':'(^$)',
|
|
'bc':'${Z}\\1','bcc':'${Z}',
|
|
'dc':'${Z}\\1','dcc':'${Z}'},
|
|
'preformatted': {'re': 'a^', # Never matches anything
|
|
'bc':'','bcc':'',
|
|
'dc':'','dcc':''},
|
|
}
|
|
block_match=md_re_compile(block_match_str)
|
|
blocks=['block_quote', 'multiline_code','hrule', 'heading','lheading','list_bullet', 'block_code', 'text', 'empty']
|
|
|
|
inline_match_str={
|
|
'bold1': {'re':r'(^| |})(_[^_]+_)',
|
|
'bc':'\\1${W}\\2','dc':'\\1${W}\\2'}, # _bold_
|
|
'bold2': {'re':r'(^| |})(\*{1,2}[^\*]+\*{1,2})',
|
|
'bc':'\\1${W}\\2','dc':'\\1${W}\\2'}, # **bold**
|
|
'code': {'re':r'([`]+[^`]+[`]+)',
|
|
'bc':'${c}\\1','dc':'${m}\\1'}, # `code`
|
|
'code_special': {'re':r'([`]+[^`]+[`]+)([!>])',
|
|
'bc':'${c}\\1${g}\\2','dc':'${m}\\1${r}\\2'}, # `code`! or `code`> for markslider
|
|
'link': {'re':r'(\[)([^\]]+)(\])\(([^\)]+)\)',
|
|
'bc':'${B}\\1${Z}\\2${B}\\3(${U}\\4${u})',
|
|
'dc':'${b}\\1${Z}\\2${b}\\3(${U}\\4${u})'}, # [text](link)
|
|
'image': {'re':r'(!\[[^\]]+\]\([^\)]+\))',
|
|
'bc':'${r}\\1','dc':'${g}\\1'}, # 
|
|
'underline': {'re':r'(^|\W)(__)([^_]+)(__)',
|
|
'bc':'\\1\\2${U}\\3${Z}\\4','dc':'\\1\\2${U}\\3${Z}\\4'}, # __underline__
|
|
'strikethrough': {'re':r'(~~)([^~]+)(~~)',
|
|
'bc':'\\1${st}\\2${so}\\3','dc':'\\1${st}\\2${so}\\3'}, # ~~strike~~
|
|
'checkbox': {'re':r'(\[[x ]\])',
|
|
'bc':'${y}\\1','dc':'${r}\\1'}, # [x] [ ]
|
|
}
|
|
inline_match = md_re_compile(inline_match_str)
|
|
inlines = ['bold1','bold2','code_special','code','image','link','underline','strikethrough', 'checkbox']
|
|
|
|
if __name__ == "__main__":
|
|
opts=setup_options()
|
|
if opts.print_template:
|
|
import json
|
|
print(json.dumps({'about':'re: regular expression, bc: bright colors, bcc: continue with this color after inline, dc: dark colors, dcc: continued color after inline. "blocks" and "inlines" list keys of matchers. ',
|
|
'blocks':blocks,
|
|
'block_match':block_match_str,
|
|
'inline_match':inline_match_str,
|
|
'inlines':inlines},
|
|
indent=2,sort_keys=True))
|
|
sys.exit(0)
|
|
if opts.template:
|
|
import json
|
|
template=json.load(open(opts.template,'r'))
|
|
if 'inlines' in template: inlines=template['inlines']
|
|
if 'blocks' in template: blocks=template['blocks']
|
|
if 'block_match' in template:
|
|
block_match_str=template['block_match']
|
|
block_match=md_re_compile(block_match_str)
|
|
if 'inline_match' in template:
|
|
inline_match_str=template['inline_match']
|
|
inline_match=md_re_compile(inline_match_str)
|
|
|
|
bc = ansi.code()
|
|
if opts.filename == "-" or opts.filename == None:
|
|
f = sys.stdin
|
|
else:
|
|
f = open(opts.filename, 'r')
|
|
if (sys.version_info > (3, 0)):
|
|
data = read_data3(f)
|
|
else:
|
|
data = read_data2(f)
|
|
|
|
data = parse(data)
|
|
colored = colorize(data, not opts.color, opts.dark_colors, opts.debug)
|
|
if (sys.version_info > (3, 0)):
|
|
write_colored3(colored, opts)
|
|
else:
|
|
write_colored2(colored, opts)
|
|
|