def update(self, doc, process=None):
        if process is None:
            pk = 'id'
            id = doc.id
            doc.synced = False
            set = doc
        elif process == UPDATE_PROCESS:
            if self.db.docs.find({'sid': doc.sid}).count() == 0:
                return self.insert(doc, synced=True)
            pk = 'sid'
            id = doc.sid
            doc.synced = not doc.merged() # must be commited if was merged
            doc.merged(False)
            set = {'tid': doc.tid, 'data': doc.data, 'user': doc.user,
                   'public': doc.public, 'synced': doc.synced}
        elif process == COMMIT_PROCESS:
            pk = 'id'
            id = doc.id
            doc.synced = True
            set = {'sid': doc.sid, 'tid': doc.tid, 'synced': doc.synced}
        else:
            raise DatabaseException('Incorrect update process')

        try:
            rs = self.db.docs.update({pk: id}, {'$set': set}, safe=True)
            assert rs['n'] == 1
        except Exception as e:
            raise DatabaseException(e)
        return doc
def _kindpatstoglobs(kindpats, recursive=False):
    """Attempt to convert 'kindpats' to glob patterns that can be used in a
    treematcher.

    kindpats should be already normalized to be relative to repo root.

    If recursive is True, `glob:a*` will match both `a1/b` and `a1`, otherwise
    `glob:a*` will only match `a1` but not `a1/b`.

    Return None if there are unsupported patterns (ex. regular expressions).
    """
    if not _usetreematcher:
        return None
    globs = []
    for kindpat in kindpats:
        kind, pat = kindpat[0:2]
        if kind == "re":
            # Attempt to convert the re pat to globs
            reglobs = _convertretoglobs(pat)
            if reglobs is not None:
                globs += reglobs
            else:
                return None
        elif kind == "glob":
            # The treematcher (man gitignore) does not support csh-style
            # brackets (ex. "{a,b,c}"). Expand the brackets to patterns.
            for subpat in pathmatcher.expandcurlybrackets(pat):
                normalized = pathmatcher.normalizeglob(subpat)
                if recursive:
                    normalized = _makeglobrecursive(normalized)
                globs.append(normalized)
        elif kind == "path":
            if pat == ".":
                # Special case. Comes from `util.normpath`.
                pat = ""
            else:
                pat = pathmatcher.plaintoglob(pat)
            pat = _makeglobrecursive(pat)
            globs.append(pat)
        else:
            return None
    return globs