Master
943acbc573
Durcit la convention de nommage des projets (dérive constatée : 'Sliding Automation', 'code_versioning'... au lieu des formes canoniques). - trilium_api.py : projets_canoniques() lit le référentiel = valeurs du label projet sur les notes de type=projet (source unique, pas de constante en dur). Note-projet CodeVersioning créée (manquait). - mcp_server.py : _valider_projet() branché dans les 6 tools de création (add_decision/history/backlog, new_conversation, create_entite, add_skill). Refuse un projet non canonique (suggestion si faute) ou inconnu (renvoi au processus de création de projet). Ne verrouille pas si référentiel illisible. - lint_audit.py : VAL-nommage aligné sur le référentiel (attrape casse, espace ET snake_case ; l'ancien 'contient un espace' ratait code_versioning). - Données : 79 notes ré-étiquetées vers les 3 formes canoniques. Quality by design : l'erreur de nommage devient impossible à l'écriture, le Lint n'est plus que le filet de sécurité.
103 lines
3.2 KiB
Python
103 lines
3.2 KiB
Python
"""
|
|
pygments.regexopt
|
|
~~~~~~~~~~~~~~~~~
|
|
|
|
An algorithm that generates optimized regexes for matching long lists of
|
|
literal strings.
|
|
|
|
:copyright: Copyright 2006-present by the Pygments team, see AUTHORS.
|
|
:license: BSD, see LICENSE for details.
|
|
"""
|
|
|
|
import re
|
|
from re import escape
|
|
from itertools import groupby
|
|
from operator import itemgetter
|
|
|
|
CS_ESCAPE = re.compile(r'[\[\^\\\-\]]')
|
|
FIRST_ELEMENT = itemgetter(0)
|
|
|
|
|
|
def commonprefix(m):
|
|
"""Given an iterable of strings, returns the longest common leading substring"""
|
|
if not m:
|
|
return ""
|
|
s1 = min(m)
|
|
s2 = max(m)
|
|
for i, c in enumerate(s1):
|
|
if c != s2[i]:
|
|
return s1[:i]
|
|
return s1
|
|
|
|
|
|
def make_charset(letters):
|
|
return '[' + CS_ESCAPE.sub(lambda m: '\\' + m.group(), ''.join(letters)) + ']'
|
|
|
|
|
|
def regex_opt_inner(strings, open_paren):
|
|
"""Return a regex that matches any string in the sorted list of strings."""
|
|
close_paren = open_paren and ')' or ''
|
|
# print strings, repr(open_paren)
|
|
if not strings:
|
|
# print '-> nothing left'
|
|
return ''
|
|
first = strings[0]
|
|
if len(strings) == 1:
|
|
# print '-> only 1 string'
|
|
return open_paren + escape(first) + close_paren
|
|
if not first:
|
|
# print '-> first string empty'
|
|
return open_paren + regex_opt_inner(strings[1:], '(?:') \
|
|
+ '?' + close_paren
|
|
if len(first) == 1:
|
|
# multiple one-char strings? make a charset
|
|
oneletter = []
|
|
rest = []
|
|
for s in strings:
|
|
if len(s) == 1:
|
|
oneletter.append(s)
|
|
else:
|
|
rest.append(s)
|
|
if len(oneletter) > 1: # do we have more than one oneletter string?
|
|
if rest:
|
|
# print '-> 1-character + rest'
|
|
return open_paren + regex_opt_inner(rest, '') + '|' \
|
|
+ make_charset(oneletter) + close_paren
|
|
# print '-> only 1-character'
|
|
return open_paren + make_charset(oneletter) + close_paren
|
|
prefix = commonprefix(strings)
|
|
if prefix:
|
|
plen = len(prefix)
|
|
# we have a prefix for all strings
|
|
# print '-> prefix:', prefix
|
|
return open_paren + escape(prefix) \
|
|
+ regex_opt_inner([s[plen:] for s in strings], '(?:') \
|
|
+ close_paren
|
|
# is there a suffix?
|
|
strings_rev = [s[::-1] for s in strings]
|
|
suffix = commonprefix(strings_rev)
|
|
if suffix:
|
|
slen = len(suffix)
|
|
# print '-> suffix:', suffix[::-1]
|
|
return open_paren \
|
|
+ regex_opt_inner(sorted(s[:-slen] for s in strings), '(?:') \
|
|
+ escape(suffix[::-1]) + close_paren
|
|
# recurse on common 1-string prefixes
|
|
# print '-> last resort'
|
|
return open_paren + \
|
|
'|'.join(regex_opt_inner(list(group[1]), '')
|
|
for group in groupby(strings, lambda s: s[0] == first[0])) \
|
|
+ close_paren
|
|
|
|
|
|
def regex_opt(strings, prefix='', suffix=''):
|
|
"""Return a compiled regex that matches any string in the given list.
|
|
|
|
The strings to match must be literal strings, not regexes. They will be
|
|
regex-escaped.
|
|
|
|
*prefix* and *suffix* are pre- and appended to the final regex.
|
|
"""
|
|
strings = sorted(strings)
|
|
return prefix + regex_opt_inner(strings, '(') + suffix
|