Using python function call syntax to generated 'revsets' needed by mercurial

revset_generator.py

'''
Module that can generate revset expressions required by Hg from python function call structures.
'''

def _wrap(outer_fn, *args):
    args = args or ''
    if args:
        args = ", ".join(args)
    return '{}({})'.format(outer_fn, args)

def _wrap_str(s):
    return '\'' + s + '\''

def _wrap_kw(key, value):
    return key + '=' + value

def strarg(s):
    return _wrap_str(s)

def range_arg(r1, r2):
    return r1 + ':' + r2

def wrap_fn(fn):
    return lambda *args: _wrap(fn.__name__, *args)

@wrap_fn
def adds(pattern):
    pass

@wrap_fn
def all_():
    pass

@wrap_fn
def ancestor(*changeset):
    pass

@wrap_fn
def ancestors(changeset, depth=None):
    pass

@wrap_fn
def author(string):
    pass

@wrap_fn
def bisect(string):
    pass

@wrap_fn
def bookmark(name=None):
    pass

@wrap_fn
def branch(string_or_set):
    pass

@wrap_fn
def branchpoint():
    pass

@wrap_fn
def bundle():
    pass

@wrap_fn
def children(changesets):
    pass

@wrap_fn
def closed():
    pass

@wrap_fn
def contains(pattern):
    pass

@wrap_fn
def contentdivergent():
    pass

@wrap_fn
def converted(identifier=None):
    pass

@wrap_fn
def date(interval):
    pass

@wrap_fn
def desc(desc):
    pass

@wrap_fn
def descendants(changesets, depth=None):
    pass

@wrap_fn
def destination(changeset=None):
    pass

@wrap_fn
def draft():
    pass

@wrap_fn
def extdata(source):
    pass

@wrap_fn
def extinct():
    pass

@wrap_fn
def extra(label, value=None):
    pass

@wrap_fn
def file(pattern):
    pass

@wrap_fn
def filelog(pattern):
    pass

@wrap_fn
def first(changesets, n=None):
    pass

@wrap_fn
def follow(file=None, startrev=None):
    pass


def followlines(file_, fromline_toline_range, startrev='.', descend=False):
    return _wrap('followlines',
           file_,
           fromline_toline_range,
           _wrap_kw('start_rev', startrev),
           _wrap_kw('descend', str(descend)))

@wrap_fn
def grep(regex):
    pass

@wrap_fn
def head():
    pass

@wrap_fn
def heads(changesets):
    pass

@wrap_fn
def hidden():
    pass

@wrap_fn
def id(string):
    pass

@wrap_fn
def keyword(string):
    pass

@wrap_fn
def last(changesets, n=None):
    pass

@wrap_fn
def limit(changesets, n=None, offset=None):
    pass

@wrap_fn
def matching(revision , field=None):
    pass

@wrap_fn
def max(changesets):
    pass

@wrap_fn
def merge():
    pass

@wrap_fn
def min(changesets):
    pass

@wrap_fn
def modifies(pattern):
    pass

@wrap_fn
def named(namespace):
    pass

@wrap_fn
def obsolete():
    pass

@wrap_fn
def only(changeset, changesets=None):
    pass

@wrap_fn
def origin(changesets=None):
    pass

@wrap_fn
def orphan():
    pass

@wrap_fn
def outgoing(path=None):
    pass

@wrap_fn
def p1(changesets=None):
    pass

@wrap_fn
def p2(changesets=None):
    pass

@wrap_fn
def parents(changesets=None):
    pass

@wrap_fn
def phasedivergent():
    pass

@wrap_fn
def present(changesets):
    pass

@wrap_fn
def public():
    pass

@wrap_fn
def remote(id=None, path=None):
    pass

@wrap_fn
def removes(pattern):
    pass

@wrap_fn
def rev(number):
    pass

@wrap_fn
def reverse(changesets):
    pass

@wrap_fn
def roots(changesets):
    pass

@wrap_fn
def secret():
    pass

@wrap_fn
def sort(changesets, keys=None):
    pass

@wrap_fn
def subrepo(pattern=None):
    pass

@wrap_fn
def successors(changesets):
    pass

@wrap_fn
def tag(name=None):
    pass

@wrap_fn
def user(string):
    pass

@wrap_fn
def wdir():
    pass

# set operators
_binary_map = dict(
        dag_range='::',
        range_=':',
        and_=' and ',
        or_=' or ',
        minus=' - ',
        mod_=' % ',
        nth_parent='^',
        nth_ancestor='~',
        concat=' ## ')


def _wrap_binary(fn):
    return lambda arg1, arg2: arg1 + _binary_map[fn.__name__] + arg2

def not_(changeset):
    return 'not ' + changeset

@_wrap_binary
def dag_range(x, y):
    pass

@_wrap_binary
def range_(x, y):
    pass

@_wrap_binary
def and_(x, y):
    pass

@_wrap_binary
def or_(x, y):  # x | y  or x + y not supported
    pass

@_wrap_binary
def minus(x, y):
    pass

@_wrap_binary
def mod_(x, y):
    pass

@_wrap_binary
def nth_parent(x, n=1):
    pass

@_wrap_binary
def nth_ancestor(x, n):
    pass

@_wrap_binary
def concat(x, y):
    pass