fileset: add kind:pat operator
":" isn't taken as a symbol character but an infix operator so we can write
e.g. "path:'foo bar'" as well as "'path:foo bar'". An invalid pattern kind
is rejected in the former form as we know a kind is specified explicitly.
The binding strength is copied from "x:y" range operator of revset. Perhaps
it can be adjusted later if we want to parse "foo:bar()" as "(foo:bar)()",
not "foo:(bar())". We can also add "kind:" postfix operator if we want.
One possible confusion is that the scope of the leading "set:" vs "kind:pat"
operator. The former is consumed by a matcher so applies to the whole fileset
expression:
$ hg files 'set:foo() or kind:bar or baz'
^^^^^^^^^^^^^^^^^^^^^^^^
Whereas the scope of kind:pat operator is narrow:
$ hg files 'set:foo() or kind:bar or baz'
^^^
from __future__ import absolute_import
import unittest
import silenttestrunner
from mercurial import (
error,
scmutil,
)
class mockfile(object):
def __init__(self, name, fs):
self.name = name
self.fs = fs
def __enter__(self):
return self
def __exit__(self, *args, **kwargs):
pass
def write(self, text):
self.fs.contents[self.name] = text
def read(self):
return self.fs.contents[self.name]
class mockvfs(object):
def __init__(self):
self.contents = {}
def read(self, path):
return mockfile(path, self).read()
def readlines(self, path):
# lines need to contain the trailing '\n' to mock the real readlines
return [l for l in mockfile(path, self).read().splitlines(True)]
def __call__(self, path, mode, atomictemp):
return mockfile(path, self)
class testsimplekeyvaluefile(unittest.TestCase):
def setUp(self):
self.vfs = mockvfs()
def testbasicwritingiandreading(self):
dw = {'key1': 'value1', 'Key2': 'value2'}
scmutil.simplekeyvaluefile(self.vfs, 'kvfile').write(dw)
self.assertEqual(sorted(self.vfs.read('kvfile').split('\n')),
['', 'Key2=value2', 'key1=value1'])
dr = scmutil.simplekeyvaluefile(self.vfs, 'kvfile').read()
self.assertEqual(dr, dw)
def testinvalidkeys(self):
d = {'0key1': 'value1', 'Key2': 'value2'}
with self.assertRaisesRegexp(error.ProgrammingError,
'keys must start with a letter.*'):
scmutil.simplekeyvaluefile(self.vfs, 'kvfile').write(d)
d = {'key1@': 'value1', 'Key2': 'value2'}
with self.assertRaisesRegexp(error.ProgrammingError, 'invalid key.*'):
scmutil.simplekeyvaluefile(self.vfs, 'kvfile').write(d)
def testinvalidvalues(self):
d = {'key1': 'value1', 'Key2': 'value2\n'}
with self.assertRaisesRegexp(error.ProgrammingError, 'invalid val.*'):
scmutil.simplekeyvaluefile(self.vfs, 'kvfile').write(d)
def testcorruptedfile(self):
self.vfs.contents['badfile'] = 'ababagalamaga\n'
with self.assertRaisesRegexp(error.CorruptedState,
'dictionary.*element.*'):
scmutil.simplekeyvaluefile(self.vfs, 'badfile').read()
def testfirstline(self):
dw = {'key1': 'value1'}
scmutil.simplekeyvaluefile(self.vfs, 'fl').write(dw, firstline='1.0')
self.assertEqual(self.vfs.read('fl'), '1.0\nkey1=value1\n')
dr = scmutil.simplekeyvaluefile(self.vfs, 'fl')\
.read(firstlinenonkeyval=True)
self.assertEqual(dr, {'__firstline': '1.0', 'key1': 'value1'})
if __name__ == "__main__":
silenttestrunner.main(__name__)