mercurial-scm/hg-stable: mercurial/filesetlang.py comparison

comparison mercurial/filesetlang.py @ 43076:2372284d9457

formatting: blacken the codebase This is using my patch to black (https://github.com/psf/black/pull/826) so we don't un-wrap collection literals. Done with: hg files 'set:**.py - mercurial/thirdparty/** - "contrib/python-zstandard/**"' | xargs black -S # skip-blame mass-reformatting only # no-check-commit reformats foo_bar functions Differential Revision: https://phab.mercurial-scm.org/D6971

author	Augie Fackler <augie@google.com>
date	Sun, 06 Oct 2019 09:45:02 -0400
parents	e79a69af1593
children	687b865b95ad

comparison

equal deleted inserted replaced

-:57875cf423c9
+:2372284d9457
 symbols = {}
 globchars = ".*{}[]?/\\_"
 def tokenize(program):
 pos, l = 0, len(program)
 program = pycompat.bytestr(program)
 while pos < l:
 c = program[pos]
-if c.isspace(): # skip inter-token whitespace
+if c.isspace():  # skip inter-token whitespace
 pass
-elif c in "(),-:|&+!": # handle simple operators
+elif c in "(),-:|&+!":  # handle simple operators
 yield (c, None, pos)
-elif (c in '"\'' or c == 'r' and
+elif (
-program[pos:pos + 2] in ("r'", 'r"')): # handle quoted strings
+c in '"\'' or c == 'r' and program[pos : pos + 2] in ("r'", 'r"')
+):  # handle quoted strings
 if c == 'r':
 pos += 1
 c = program[pos]
 decode = lambda x: x
 else:
 decode = parser.unescapestr
 pos += 1
 s = pos
-while pos < l: # find closing quote
+while pos < l:  # find closing quote
 d = program[pos]
-if d == '\\': # skip over escaped characters
+if d == '\\':  # skip over escaped characters
 pos += 2
 continue
 if d == c:
 yield ('string', decode(program[s:pos]), s)
 break
 raise error.ParseError(_("unterminated string"), s)
 elif c.isalnum() or c in globchars or ord(c) > 127:
 # gather up a symbol/keyword
 s = pos
 pos += 1
-while pos < l: # find end of symbol
+while pos < l:  # find end of symbol
 d = program[pos]
 if not (d.isalnum() or d in globchars or ord(d) > 127):
 break
 pos += 1
 sym = program[s:pos]
-if sym in keywords: # operator keywords
+if sym in keywords:  # operator keywords
 yield (sym, None, s)
 else:
 yield ('symbol', sym, s)
 pos -= 1
 else:
 raise error.ParseError(_("syntax error"), pos)
 pos += 1
 yield ('end', None, pos)
 def parse(expr):
 p = parser.parser(elements)
 tree, pos = p.parse(tokenize(expr))
 if pos != len(expr):
 raise error.ParseError(_("invalid token"), pos)
 return parser.simplifyinfixops(tree, {'list', 'or'})
 def getsymbol(x):
 if x and x[0] == 'symbol':
 return x[1]
 raise error.ParseError(_('not a symbol'))
 def getstring(x, err):
 if x and (x[0] == 'string' or x[0] == 'symbol'):
 return x[1]
 raise error.ParseError(err)
 def getkindpat(x, y, allkinds, err):
 kind = getsymbol(x)
 pat = getstring(y, err)
 if kind not in allkinds:
 raise error.ParseError(_("invalid pattern kind: %s") % kind)
 return '%s:%s' % (kind, pat)
 def getpattern(x, allkinds, err):
 if x and x[0] == 'kindpat':
 return getkindpat(x[1], x[2], allkinds, err)
 return getstring(x, err)
 def getlist(x):
 if not x:
 return []
 if x[0] == 'list':
 return list(x[1:])
 return [x]
 def getargs(x, min, max, err):
 l = getlist(x)
 if len(l) < min or len(l) > max:
 raise error.ParseError(err)
 return l
 def _analyze(x):
 if x is None:
 return x
 if op == 'func':
 getsymbol(x[1])  # function name must be a symbol
 ta = _analyze(x[2])
 return (op, x[1], ta)
 raise error.ProgrammingError('invalid operator %r' % op)
 def _insertstatushints(x):
 """Insert hint nodes where status should be calculated (first path)
 This works in bottom-up way, summing up status names and inserting hint
 if getattr(symbols.get(f), '_callstatus', False):
 return (f,), ('withstatus', (op, x[1], ta), ('string', f))
 return (), (op, x[1], ta)
 raise error.ProgrammingError('invalid operator %r' % op)
 def _mergestatushints(x, instatus):
 """Remove redundant status hint nodes (second path)
 This is the top-down path to eliminate inner hint nodes.
 """
 # don't propagate 'instatus' crossing a function boundary
 ta = _mergestatushints(x[2], instatus=False)
 return (op, x[1], ta)
 raise error.ProgrammingError('invalid operator %r' % op)
 def analyze(x):
 """Transform raw parsed tree to evaluatable tree which can be fed to
 optimize() or getmatch()
 All pseudo operations should be mapped to real operations or functions
 """
 t = _analyze(x)
 _h, t = _insertstatushints(t)
 return _mergestatushints(t, instatus=False)
 def _optimizeandops(op, ta, tb):
 if tb is not None and tb[0] == 'not':
 return ('minus', ta, tb[1])
 return (op, ta, tb)
 def _optimizeunion(xs):
 # collect string patterns so they can be compiled into a single regexp
 ws, ts, ss = [], [], []
 for x in xs:
 ts.append(t)
 if ss:
 ws.append(WEIGHT_CHECK_FILENAME)
 ts.append(('patterns',) + tuple(ss))
 return ws, ts
 def _optimize(x):
 if x is None:
 return 0, x
 else:
 return wb, _optimizeandops(op, tb, ta)
 if op == 'or':
 ws, ts = _optimizeunion(x[1:])
 if len(ts) == 1:
-return ws[0], ts[0] # 'or' operation is fully optimized out
+return ws[0], ts[0]  # 'or' operation is fully optimized out
-ts = tuple(it[1] for it in sorted(enumerate(ts),
+ts = tuple(
-key=lambda it: ws[it[0]]))
+it[1] for it in sorted(enumerate(ts), key=lambda it: ws[it[0]])
+)
 return max(ws), (op,) + ts
 if op == 'list':
 ws, ts = zip(*(_optimize(y) for y in x[1:]))
 return sum(ws), (op,) + ts
 if op == 'func':
 w = getattr(symbols.get(f), '_weight', 1)
 wa, ta = _optimize(x[2])
 return w + wa, (op, x[1], ta)
 raise error.ProgrammingError('invalid operator %r' % op)
 def optimize(x):
 """Reorder/rewrite evaluatable tree for optimization
 All pseudo operations should be transformed beforehand.
 """
 _w, t = _optimize(x)
 return t
 def prettyformat(tree):
 return parser.prettyformat(tree, ('string', 'symbol'))

Mercurial > public > mercurial-scm > hg-stable

comparison mercurial/filesetlang.py @ 43076:2372284d9457