#!/usr/bin/env python # -*- coding: utf-8 -*- """\ wmlindent - re-indent WML in a uniform way. By Eric S. Raymond, June 2007. Call with no arguments to filter WML on stdin to reindented WML on stdout. If arguments are specified, they are taken to be files to be re-indented in place; a directory name causes reindenting on all WML beneath it. The indent unit is four spaces. Absence of an option to change this is deliberate; the purpose of this tool is to *prevent* style wars, not encourage them. On non-empty lines, this code never modifies anything but leading and trailing whitespace. Leading whitespace will be regularized to the current indent; trailing whitespace will be stripped. After processing all lines will end with a Unix-style \n end-of-line marker. Runs of entirely blank lines will be reduced to one blank line, except in two cases where they will be discarded: (a) before WML closing tags, and (b) after WML opening tags. It is possible to wrap a section of lines in special comments so that wmlindent will ignore them. You may need to do this for unbalanced macros (it's better, though, to get rid of those where possible). Use 'wmlindent: {start,stop} ignoring' anywhere in a comment. It is also possible to declare custom openers an closers, e.g for macros that are actually control constructs. To do this, use declarations # wmlindent: opener "{EXCEPTIONAL_OPENER " # wmlindent: closer "{EXCEPTIONAL_CLOSER " The lines after an opener will be indented an extra level; a closer and lines following will be indented one level less. Note that these declare prefixes; any prefix match to the non-whitespace text of a line will be recognized. The public utility macros "{FOREACH" and "{NEXT" come as wired-in exceptions, because it is not guaranteed that their indent declarations will be processed before the macro library is reached. Interrupting will be safe, as each reindenting will be done to a copy that is atomically renamed when it's done. If the output file is identical to the input, the output file will simply be deleted, so the timestamp on the input file won't be touched. The --dryrun option detects and reports files that would be changed without changing them. The --verbose or -v option enables reporting of files that are (or would be, under --dryrun) changed. With -v -v, unchanged files are also reported. The --exclude option takes a regexp and excludes files matching it. Note: This does not include a parser. It will produce bad results on WML that is syntactically unbalanced. Unbalanced double quotes that aren't part of a multiline literal will also confuse it. You will receive warnings if there's an indent open at end of file or if a closer occurs with indent already zero; these two conditions strongly suggest unbalanced WML. """ import sys, os, getopt, filecmp, re from wesnoth import wmltools closer_prefixes = ["{NEXT "] opener_prefixes = ["{FOREACH "] def is_directive(str): "Identify things that shouldn't be indented." for prefix in ("#ifdef", "#ifndef", "#ifhave", "#ifnhave", "#ifver", "#ifnver", "#else", "#endif", "#define", "#enddef", "#undef"): if str.startswith(prefix): return True return False def closer(str): "Are we looking at a closing tag?" if str.startswith("#"): return False elif str.startswith("[/") or str.startswith(")"): return True else: for prefix in closer_prefixes: if str.startswith(prefix): return True return False def opener(str): "Are we looking at an opening tag?" if str.startswith("#"): return False # This logic is a bit obscure. The 'not "[/" in str' catches the # obvious case of a closing tag, but it also catches the idiom # [allow_undo][/allow_undo] which we want to treat as a no-op. elif (str.startswith("[") and not closer(str) and not "[/" in str): return True # Trailing ( opens a scope to be closed by ). elif str.endswith("(\n") and '#' not in str: return True else: for prefix in opener_prefixes: if str.startswith(prefix): return True return False class bailout: def __init__(self, filename, lineno, msg): self.filename = filename self.lineno = lineno self.msg = msg def reindent(name, infp, outfp): "Reindent WML." dostrip = True in_lua = False seen_wml = False inmacro = False ignoring = False indent = "" lasttag = "" countlines = 0 countblanks = 0 multitag = re.compile(r"\[a-z]].*\[[a-z]") # Avoid triggering on arrays for line in infp: countlines += 1 # User may declare indentation exceptions if "wmlindent: opener" in line: tag = line.split('"')[1] if verbose and not quiet: print >>sys.stderr, "wmlindent: declaring indent exception for %s" % tag opener_prefixes.append(tag) elif "wmlindent: closer" in line: tag = line.split('"')[1] if verbose and not quiet: print >>sys.stderr, "wmlindent: declaring outdent exception for %s" % tag closer_prefixes.append(tag) # Implement passthrough mode if "wmlindent: start ignoring" in line: ignoring = True if countblanks > 0: countblanks = 0 outfp.write("\n") outfp.write(line) continue elif ignoring: outfp.write(line) if "wmlindent: stop ignoring" in line: ignoring = False continue # Detect things we can't handle if multitag.search(line): raise bailout(name, countlines, "multiple tags on the line") # Strip each line, unless we're in something like a multiline string. if dostrip: transformed = line.strip() + "\n" else: transformed = line # Track whether we've seen real WML rather than just macro definitions if transformed.startswith("#define"): saved_indent = indent indent = wmltools.baseindent inmacro = True # Be sure to ignore the newlines and comments elif transformed.rstrip().endswith("#enddef") and transformed.find("#") == transformed.find("#enddef"): indent = saved_indent inmacro = False elif not inmacro and transformed[0] in ('[', ']'): seen_wml = True # In the close case, we must compute new indent *before* emitting # the new line so the close tag will be at the same level as the # one that started the block. if closer(transformed): if indent == "": print >>sys.stderr, 'wmlindent: "%s", line %d: close tag %s with indent already zero.' % (name, countlines, transformed.strip()) else: indent = indent[:-len(wmltools.baseindent)] # Cope with blank lines outside of multiline literals if dostrip: if transformed == "\n": countblanks += 1 continue elif countblanks > 0: countblanks = 0 # All sequences of blank lines get mapped to one blank # line, except (a) before closing tags and (b) after # opening tags, In these cases they are ignored. if not closer(transformed) and not opener(lasttag): outfp.write("\n") # Here's where we apply the current indent if dostrip and transformed and not is_directive(transformed): output = indent + transformed else: output = transformed # Nuke trailing space and canonicalize to Unix-style end-of-line if dostrip: output = output.rstrip() + "\n" # And ship the line outfp.write(output) # May need to indent based on the line we just saw. if opener(transformed): indent += wmltools.baseindent # Compute the dostrip state likewise. # We look for unbalanced string quotes. if dostrip: eligible = re.split("\s#", transformed)[0] else: eligible = transformed if dostrip and "<<" in eligible and not ">>" in eligible.split("<<", 1)[1]: dostrip = False in_lua = True elif in_lua: if ">>" in eligible and not "<<" in eligible.split(">>", 1)[1]: dostrip = True in_lua = False elif eligible.count('"') % 2: dostrip = not dostrip # Are we going to be immediately following a tag? if opener(transformed) or closer(transformed): lasttag = transformed else: lasttag = "" # Pure macro files look like they have unbalanced indents. That's OK if indent != "" and seen_wml: print >>sys.stderr, 'wmlindent: "%s". line %d: end of file with indent nonzero.' % (name, countlines) def allwmlfiles(dir): "Get names of all WML files under dir, or dir itself if not a directory." datafiles = [] if not os.path.isdir(dir): if dir.endswith(".cfg"): datafiles.append(dir) else: for root, dirs, files in os.walk(dir): if wmltools.vcdir in dirs: dirs.remove(wmltools.vcdir) for name in files: if name.endswith(".cfg"): datafiles.append(os.path.join(root, name)) return datafiles def convertor(linefilter, arglist, exclude): "Apply a filter to command-line arguments." if not arglist: linefilter("standard input", sys.stdin, sys.stdout) else: for arg in arglist: for filename in allwmlfiles(arg): if exclude and re.search(exclude, filename): if verbose: sys.stderr.write("wmlindent: %s excluded\n" % filename) continue else: try: infp = open(filename, "rb") outfp = open(filename + ".out", "wb") linefilter(filename, infp, outfp) infp.close() outfp.close() except bailout as e: sys.stderr.write('wmlindent: "%s", %d: %s\n' % (e.filename, e.lineno, e.msg)) os.remove(filename + ".out") except KeyboardInterrupt: os.remove(filename + ".out") sys.stderr.write("wmlindent: %s interrupted\n" % filename) else: if filecmp.cmp(filename, filename + ".out"): if verbose >= 2: sys.stderr.write("wmlindent: %s unchanged\n" % filename) os.remove(filename + ".out") else: if not quiet: sys.stderr.write("wmlindent: %s changed\n" % filename) if dryrun: os.remove(filename + ".out") else: os.remove(filename) # For Windows portability # There's a tiny window open if you keyboard- # interrupt here. It's unavoidable, because # there's no known way to do an atomic rename # under Windows when the target exists -- see # Python manual 14.1.4::rename() os.rename(filename + ".out", filename) if __name__ == '__main__': (options, arguments) = getopt.getopt(sys.argv[1:], "h?de:qv", ['help', 'dryrun', 'exclude=', 'quiet', 'verbose']) verbose = 0 quiet = False dryrun = False exclude = [] for (opt, val) in options: if opt in ('-?', '-h', '--help'): print __doc__ sys.exit(0) elif opt in ('-d', '--dryrun'): dryrun = True verbose = max(1, verbose) elif opt in ('-e', '--exclude'): exclude.append(val) elif opt in ('-q', '--quiet'): quiet = True elif opt in ('-v', '--verbose'): verbose += 1 # in certain situations, Windows' command prompt appends a double quote # to the command line parameters. This block takes care of this issue. for i,arg in enumerate(arguments): if arg.endswith('"'): arguments[i] = arg[:-1] convertor(lambda n, f1, f2: reindent(n, f1, f2), arguments, "|".join(exclude))