+++ /dev/null
-#! @PYTHON@
-###
-### Generate files by filling in simple templates
-###
-### (c) 2013 Straylight/Edgeware
-###
-
-###----- Licensing notice ---------------------------------------------------
-###
-### This file is part of Catacomb.
-###
-### Catacomb is free software; you can redistribute it and/or modify
-### it under the terms of the GNU Library General Public License as
-### published by the Free Software Foundation; either version 2 of the
-### License, or (at your option) any later version.
-###
-### Catacomb is distributed in the hope that it will be useful,
-### but WITHOUT ANY WARRANTY; without even the implied warranty of
-### MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-### GNU Library General Public License for more details.
-###
-### You should have received a copy of the GNU Library General Public
-### License along with Catacomb; if not, write to the Free
-### Software Foundation, Inc., 59 Temple Place - Suite 330, Boston,
-### MA 02111-1307, USA.
-
-from __future__ import with_statement
-
-import itertools as IT
-import optparse as OP
-import os as OS
-import re as RX
-from cStringIO import StringIO
-from sys import argv, exit, stderr
-
-###--------------------------------------------------------------------------
-### Utilities.
-
-QUIS = OS.path.basename(argv[0])
-
-def die(msg):
- stderr.write('%s: %s\n' % (QUIS, msg))
- exit(1)
-
-def indexed(seq):
- return IT.izip(IT.count(), seq)
-
-###--------------------------------------------------------------------------
-### Reading the input values.
-
-COLMAP = {}
-
-class Cursor (object):
- def __init__(me, rel):
- me._rel = rel
- me._i = 0
- me._row = rel[0]
- def step(me):
- me._i += 1
- if me._i >= len(me._rel):
- me._i = me._row = None
- return False
- me._row = me._rel[me._i]
- return True
- def reset(me):
- me._i = 0
- me._row = me._rel[0]
- def __getitem__(me, i):
- return me._row[i]
- def __repr__(me):
- return '#<Cursor %r[%d] = %r>' % (me._rel, me._i, me._row)
-
-class CursorSet (object):
- def __init__(me):
- me._map = {}
- me._stack = []
- me._act = None
- def push(me, rels):
- cc = []
- rr = []
- for r in rels:
- if r in me._map: continue
- c = me._map[r] = Cursor(r)
- rr.append(r)
- cc.append(c)
- me._stack.append((me._act, rr))
- me._act = cc
- def step(me):
- i = 0
- while i < len(me._act):
- if me._act[i].step(): return True
- if i >= len(me._act): return False
- me._act[i].reset()
- i += 1
- return False
- def pop(me):
- me._act, rels = me._stack.pop()
- for r in rels: del me._map[r]
- def get(me, rel, i):
- return me._map[rel][i]
-
-class Relation (object):
- def __init__(me, head):
- me._head = head
- me._rows = []
- for i, c in indexed(head): COLMAP[c] = me, i
- def addrow(me, row):
- if len(row) != len(me._head):
- die("mismatch: row `%s' doesn't match heading `%s'" %
- (', '.join(row), ', '.join(head)))
- me._rows.append(row)
- def __len__(me):
- return len(me._rows)
- def __getitem__(me, i):
- return me._rows[i]
- def __repr__(me):
- return '#<Relation %r>' % me._head
-
-def read_immediate(word):
- head, rels = word.split('=', 1)
- rel = Relation([c.strip() for c in head.split(',')])
- for row in rels.split(): rel.addrow([c.strip() for c in row.split(',')])
-
-def read_file(spec):
- file, head = spec.split(':', 1)
- rel = Relation([c.strip() for c in head.split(',')])
- cols = [c.strip() for c in head.split(',')]
- with open(file) as f:
- for line in f:
- line = line.strip()
- if line.startswith('#') or line == '': continue
- rel.addrow(line.split())
-
-def read_thing(spec):
- if spec.startswith('@'): read_file(spec[1:])
- else: read_immediate(spec)
-
-###--------------------------------------------------------------------------
-### Template structure.
-
-class BasicTemplate (object):
- pass
-
-class LiteralTemplate (BasicTemplate):
- def __init__(me, text, **kw):
- super(LiteralTemplate, me).__init__(**kw)
- me._text = text
- def relations(me):
- return set()
- def subst(me, out, cs):
- out.write(me._text)
- def __repr__(me):
- return '#<LiteralTemplate %r>' % me._text
-
-class TagTemplate (BasicTemplate):
- def __init__(me, rel, i, op, **kw):
- super(TagTemplate, me).__init__(**kw)
- me._rel = rel
- me._i = i
- me._op = op
- def relations(me):
- return set([me._rel])
- def subst(me, out, cs):
- val = cs.get(me._rel, me._i)
- if me._op is not None: val = me._op(val)
- out.write(val)
- def __repr__(me):
- return '#<TagTemplate %s>' % me._rel._head[me._i]
-
-class SequenceTemplate (BasicTemplate):
- def __new__(cls, seq, **kw):
- if len(seq) == 1:
- return seq[0]
- else:
- me = super(SequenceTemplate, cls).__new__(cls, seq = seq, **kw)
- tt = []
- cls = type(me)
- for t in seq:
- if isinstance(t, cls): tt += t._seq
- else: tt.append(t)
- me._seq = tt
- return me
- def __init__(me, seq, **kw):
- super(SequenceTemplate, me).__init__(**kw)
- def relations(me):
- rr = set()
- for t in me._seq: rr.update(t.relations())
- return rr
- def subst(me, out, cs):
- for t in me._seq: t.subst(out, cs)
- def __repr__(me):
- return '#<SequenceTemplate %r>' % me._seq
-
-class RepeatTemplate (BasicTemplate):
- def __init__(me, sub):
- me._sub = sub
- def relations(me):
- return set()
- def subst(me, out, cs):
- rr = me._sub.relations()
- for r in rr:
- if len(r) == 0: return
- cs.push(rr)
- while True:
- me._sub.subst(out, cs)
- if not cs.step(): break
- cs.pop()
- def __repr__(me):
- return '#<RepeatTemplate %r>' % me._sub
-
-###--------------------------------------------------------------------------
-### Some slightly cheesy parsing machinery.
-
-class ParseState (object):
- def __init__(me, file, text):
- me._file = file
- me._i = 0
- me._it = iter(text.splitlines(True))
- me.step()
- def step(me):
- me.curr = next(me._it, None)
- if me.curr is not None: me._i += 1
- def error(me, msg):
- die('%s:%d: %s' % (me._file, me._i, msg))
-
-class token (object):
- def __init__(me, name):
- me._name = name
- def __repr__(me):
- return '#<%s>' % me._name
-
-EOF = token('eof')
-END = token('end')
-
-R_SIMPLETAG = RX.compile(r'@ (\w+)', RX.VERBOSE)
-R_COMPLEXTAG = RX.compile(r'@ { (\w+) ((?: : \w+)*) }', RX.VERBOSE)
-
-OPMAP = {}
-
-def defop(func):
- name = func.func_name
- if name.startswith('op_'): name = name[3:]
- OPMAP[name] = func
- return func
-
-@defop
-def op_u(val): return val.upper()
-
-@defop
-def op_l(val): return val.lower()
-
-R_NOTIDENT = RX.compile(r'[^a-zA-Z0-9_]+')
-@defop
-def op_c(val): return R_NOTIDENT.sub('_', val)
-
-def _pairify(val):
- c = val.find('=')
- if c >= 0: return val[:c], val[c + 1:]
- else: return val, val
-
-@defop
-def op_left(val): return _pairify(val)[0]
-@defop
-def op_right(val): return _pairify(val)[1]
-
-def parse_text(ps):
- tt = []
- lit = StringIO()
- def spill():
- l = lit.getvalue()
- if l: tt.append(LiteralTemplate(l))
- lit.reset()
- lit.truncate()
- while True:
- line = ps.curr
- if line is None: break
- elif line.startswith('%'):
- if line.startswith('%#'): ps.step(); continue
- elif line.startswith('%%'): line = line[1:]
- else: break
- i = 0
- while True:
- j = line.find('@', i)
- if j < 0: break
- lit.write(line[i:j])
- m = R_SIMPLETAG.match(line, j)
- if not m: m = R_COMPLEXTAG.match(line, j)
- if not m: ps.error('invalid tag')
- col = m.group(1)
- try: rel, i = COLMAP[col]
- except KeyError: ps.error("unknown column `%s'" % col)
- wholeop = None
- ops = m.lastindex >= 2 and m.group(2)
- if ops:
- for opname in ops[1:].split(':'):
- try: op = OPMAP[opname]
- except KeyError: ps.error("unknown operation `%s'" % opname)
- if wholeop is None: wholeop = op
- else: wholeop = (lambda f, g: lambda x: f(g(x)))(op, wholeop)
- spill()
- tt.append(TagTemplate(rel, i, wholeop))
- i = m.end()
- lit.write(line[i:])
- ps.step()
- spill()
- return SequenceTemplate(tt)
-
-DIRECT = []
-
-def direct(rx):
- def _(func):
- DIRECT.append((RX.compile(rx, RX.VERBOSE), func))
- return func
- return _
-
-def parse_template(ps):
- while ps.curr is not None and ps.curr.startswith('%#'): ps.step()
- if ps.curr is None: return EOF
- elif ps.curr.startswith('%'):
- if ps.curr.startswith('%%'): return parse_text(ps)
- for rx, func in DIRECT:
- line = ps.curr[1:].strip()
- m = rx.match(line)
- if m:
- ps.step()
- return func(ps, m)
- ps.error("unrecognized directive")
- else:
- return parse_text(ps)
-
-def parse_templseq(ps, nestp):
- tt = []
- while True:
- t = parse_template(ps)
- if t is END:
- if nestp: break
- else: ps.error("unexpected `end' directive")
- elif t is EOF:
- if nestp: ps.error("unexpected end of file")
- else: break
- tt.append(t)
- return SequenceTemplate(tt)
-
-@direct(r'repeat')
-def dir_repeat(ps, m):
- return RepeatTemplate(parse_templseq(ps, True))
-
-@direct(r'end')
-def dir_end(ps, m):
- return END
-
-def compile_template(file, text):
- ps = ParseState(file, text)
- t = parse_templseq(ps, False)
- return t
-
-###--------------------------------------------------------------------------
-### Main code.
-
-op = OP.OptionParser(
- description = 'Generates files by filling in simple templates',
- usage = 'usage: %prog [-gl] FILE [COL,...=VAL,... ... | @FILE:COL,...] ...',
- version = 'Catacomb version @VERSION@')
-for short, long, kw in [
- ('-l', '--list', dict(
- action = 'store_const', const = 'list', dest = 'mode',
- help = 'list filenames generated')),
- ('-g', '--generate', dict(
- action = 'store', metavar = 'PATH', dest = 'input',
- help = 'generate output (default)'))]:
- op.add_option(short, long, **kw)
-op.set_defaults(mode = 'gen')
-opts, args = op.parse_args()
-
-if len(args) < 1: op.error('missing FILE')
-filepat = args[0]
-for rel in args[1:]: read_thing(rel)
-filetempl = compile_template('<output>', filepat)
-
-def filenames(filetempl):
- cs = CursorSet()
- rr = filetempl.relations()
- for r in rr:
- if not len(r): return
- cs.push(rr)
- while True:
- out = StringIO()
- filetempl.subst(out, cs)
- yield out.getvalue(), cs
- if not cs.step(): break
- cs.pop()
-
-if opts.mode == 'list':
- for file, cs in filenames(filetempl): print file
-elif opts.mode == 'gen':
- with open(opts.input) as f:
- templ = RepeatTemplate(compile_template(opts.input, f.read()))
- for file, cs in filenames(filetempl):
- new = file + '.new'
- with open(new, 'w') as out:
- templ.subst(out, cs)
- OS.rename(new, file)
-else:
- raise Exception, 'What am I doing here?'
-
-###----- That's all, folks --------------------------------------------------
projects / u / mdw / catacomb / blobdiff