comparison mercurial/fileset.py @ 38878:0f56d08e6271

fileset: move buildstatus() to matchctx method

In future patches, file status will be computed while evaluating a parsed
tree. This patch provides a matchctx interface to build status.

38877:8d6780f0b34d

    revs = scmutil.revrange(repo, [revspec])

    matchers = []
    for r in revs:
        ctx = repo[r]
        mc = mctx.switch(ctx.p1(), ctx, _buildstatus(ctx.p1(), ctx, x))
        matchers.append(getmatch(mc, x))
    if not matchers:
        return mctx.never()
    if len(matchers) == 1:
        return matchers[0]

    reverr = _("second argument to status must be a revision")
    revspec = getstring(r, reverr)
    if not revspec:
        raise error.ParseError(reverr)
    basectx, ctx = scmutil.revpair(repo, [baserevspec, revspec])
    mc = mctx.switch(basectx, ctx, _buildstatus(basectx, ctx, x))
    return getmatch(mc, x)

@predicate('subrepo([pattern])')
def subrepo(mctx, x):
    """Subrepositories whose paths match the given pattern.

    'not': notmatch,
    'func': func,
}

class matchctx(object):
    def __init__(self, basectx, ctx, status=None, badfn=None):
        self._basectx = basectx
        self.ctx = ctx
        self._status = status
        self._badfn = badfn

    def status(self):
        return self._status

    def matcher(self, patterns):

        """Create a matcher to select nothing"""
        repo = self.ctx.repo()
        return matchmod.nevermatcher(repo.root, repo.getcwd(),
                                     badfn=self._badfn)

    def switch(self, basectx, ctx, status=None):
        return matchctx(basectx, ctx, status, self._badfn)

# filesets using matchctx.switch()
_switchcallers = [
    'revs',
    'status',

def match(ctx, expr, badfn=None):
    """Create a matcher for a single fileset expression"""
    tree = filesetlang.parse(expr)
    tree = filesetlang.analyze(tree)
    tree = filesetlang.optimize(tree)
    mctx = matchctx(ctx.p1(), ctx, _buildstatus(ctx.p1(), ctx, tree),
                    badfn=badfn)
    return getmatch(mctx, tree)

def _buildstatus(basectx, ctx, tree):
    # do we need status info?

    if _intree(_statuscallers, tree):
        unknown = _intree(['unknown'], tree)
        ignored = _intree(['ignored'], tree)

        return basectx.status(ctx, listunknown=unknown, listignored=ignored,
                              listclean=True)
    else:
        return None

def loadpredicate(ui, extname, registrarobj):
    """Load fileset predicates from specified registrarobj
    """
    for name, func in registrarobj._table.iteritems():

38878:0f56d08e6271

    revs = scmutil.revrange(repo, [revspec])

    matchers = []
    for r in revs:
        ctx = repo[r]
        mc = mctx.switch(ctx.p1(), ctx)
        mc.buildstatus(x)
        matchers.append(getmatch(mc, x))
    if not matchers:
        return mctx.never()
    if len(matchers) == 1:
        return matchers[0]

    reverr = _("second argument to status must be a revision")
    revspec = getstring(r, reverr)
    if not revspec:
        raise error.ParseError(reverr)
    basectx, ctx = scmutil.revpair(repo, [baserevspec, revspec])
    mc = mctx.switch(basectx, ctx)
    mc.buildstatus(x)
    return getmatch(mc, x)

@predicate('subrepo([pattern])')
def subrepo(mctx, x):
    """Subrepositories whose paths match the given pattern.

    'not': notmatch,
    'func': func,
}

class matchctx(object):
    def __init__(self, basectx, ctx, badfn=None):
        self._basectx = basectx
        self.ctx = ctx
        self._badfn = badfn
        self._status = None

    def buildstatus(self, tree):
        if not _intree(_statuscallers, tree):
            return
        unknown = _intree(['unknown'], tree)
        ignored = _intree(['ignored'], tree)
        self._status = self._basectx.status(self.ctx,
                                            listignored=ignored,
                                            listclean=True,
                                            listunknown=unknown)

    def status(self):
        return self._status

    def matcher(self, patterns):

        """Create a matcher to select nothing"""
        repo = self.ctx.repo()
        return matchmod.nevermatcher(repo.root, repo.getcwd(),
                                     badfn=self._badfn)

    def switch(self, basectx, ctx):
        return matchctx(basectx, ctx, self._badfn)

# filesets using matchctx.switch()
_switchcallers = [
    'revs',
    'status',

def match(ctx, expr, badfn=None):
    """Create a matcher for a single fileset expression"""
    tree = filesetlang.parse(expr)
    tree = filesetlang.analyze(tree)
    tree = filesetlang.optimize(tree)
    mctx = matchctx(ctx.p1(), ctx, badfn=badfn)
    mctx.buildstatus(tree)
    return getmatch(mctx, tree)


def loadpredicate(ui, extname, registrarobj):
    """Load fileset predicates from specified registrarobj
    """
    for name, func in registrarobj._table.iteritems():