Format code with black. Add makefile to run fmt/tests
This commit is contained in:
Griatch
parent
d00bce9288
commit
c2c7fa311a
299 changed files with 19037 additions and 11611 deletions
|
|
@ -95,8 +95,9 @@ from evennia.utils import utils
|
|||
|
||||
_PERMISSION_HIERARCHY = [pe.lower() for pe in settings.PERMISSION_HIERARCHY]
|
||||
# also accept different plural forms
|
||||
_PERMISSION_HIERARCHY_PLURAL = [pe + 's' if not pe.endswith('s') else pe
|
||||
for pe in _PERMISSION_HIERARCHY]
|
||||
_PERMISSION_HIERARCHY_PLURAL = [
|
||||
pe + "s" if not pe.endswith("s") else pe for pe in _PERMISSION_HIERARCHY
|
||||
]
|
||||
|
||||
|
||||
def _to_account(accessing_obj):
|
||||
|
|
@ -109,6 +110,7 @@ def _to_account(accessing_obj):
|
|||
|
||||
# lock functions
|
||||
|
||||
|
||||
def true(*args, **kwargs):
|
||||
"Always returns True."
|
||||
return True
|
||||
|
|
@ -171,8 +173,10 @@ def perm(accessing_obj, accessed_obj, *args, **kwargs):
|
|||
gtmode = kwargs.pop("_greater_than", False)
|
||||
is_quell = False
|
||||
|
||||
account = (utils.inherits_from(accessing_obj, "evennia.objects.objects.DefaultObject") and
|
||||
accessing_obj.account)
|
||||
account = (
|
||||
utils.inherits_from(accessing_obj, "evennia.objects.objects.DefaultObject")
|
||||
and accessing_obj.account
|
||||
)
|
||||
# check object perms (note that accessing_obj could be an Account too)
|
||||
perms_account = []
|
||||
if account:
|
||||
|
|
@ -183,7 +187,7 @@ def perm(accessing_obj, accessed_obj, *args, **kwargs):
|
|||
hpos_target = None
|
||||
if permission in _PERMISSION_HIERARCHY:
|
||||
hpos_target = _PERMISSION_HIERARCHY.index(permission)
|
||||
if permission.endswith('s') and permission[:-1] in _PERMISSION_HIERARCHY:
|
||||
if permission.endswith("s") and permission[:-1] in _PERMISSION_HIERARCHY:
|
||||
hpos_target = _PERMISSION_HIERARCHY.index(permission[:-1])
|
||||
if hpos_target is not None:
|
||||
# hieratchy match
|
||||
|
|
@ -192,16 +196,22 @@ def perm(accessing_obj, accessed_obj, *args, **kwargs):
|
|||
|
||||
if account:
|
||||
# we have an account puppeting this object. We must check what perms it has
|
||||
perms_account_single = [p[:-1] if p.endswith('s') else p for p in perms_account]
|
||||
hpos_account = [hpos for hpos, hperm in enumerate(_PERMISSION_HIERARCHY)
|
||||
if hperm in perms_account_single]
|
||||
perms_account_single = [p[:-1] if p.endswith("s") else p for p in perms_account]
|
||||
hpos_account = [
|
||||
hpos
|
||||
for hpos, hperm in enumerate(_PERMISSION_HIERARCHY)
|
||||
if hperm in perms_account_single
|
||||
]
|
||||
hpos_account = hpos_account and hpos_account[-1] or -1
|
||||
|
||||
if not account or is_quell:
|
||||
# only get the object-level perms if there is no account or quelling
|
||||
perms_object_single = [p[:-1] if p.endswith('s') else p for p in perms_object]
|
||||
hpos_object = [hpos for hpos, hperm in enumerate(_PERMISSION_HIERARCHY)
|
||||
if hperm in perms_object_single]
|
||||
perms_object_single = [p[:-1] if p.endswith("s") else p for p in perms_object]
|
||||
hpos_object = [
|
||||
hpos
|
||||
for hpos, hperm in enumerate(_PERMISSION_HIERARCHY)
|
||||
if hperm in perms_object_single
|
||||
]
|
||||
hpos_object = hpos_object and hpos_object[-1] or -1
|
||||
|
||||
if account and is_quell:
|
||||
|
|
@ -261,6 +271,7 @@ def pperm(accessing_obj, accessed_obj, *args, **kwargs):
|
|||
"""
|
||||
return perm(_to_account(accessing_obj), accessed_obj, *args, **kwargs)
|
||||
|
||||
|
||||
def pperm_above(accessing_obj, accessed_obj, *args, **kwargs):
|
||||
"""
|
||||
Only allow Account objects with a permission *higher* in the permission
|
||||
|
|
@ -284,10 +295,10 @@ def dbref(accessing_obj, accessed_obj, *args, **kwargs):
|
|||
if not args:
|
||||
return False
|
||||
try:
|
||||
dbr = int(args[0].strip().strip('#'))
|
||||
dbr = int(args[0].strip().strip("#"))
|
||||
except ValueError:
|
||||
return False
|
||||
if hasattr(accessing_obj, 'dbid'):
|
||||
if hasattr(accessing_obj, "dbid"):
|
||||
return dbr == accessing_obj.dbid
|
||||
return False
|
||||
|
||||
|
|
@ -310,13 +321,15 @@ def pid(accessing_obj, accessed_obj, *args, **kwargs):
|
|||
|
||||
|
||||
# this is more efficient than multiple if ... elif statments
|
||||
CF_MAPPING = {'eq': lambda val1, val2: val1 == val2 or str(val1) == str(val2) or float(val1) == float(val2),
|
||||
'gt': lambda val1, val2: float(val1) > float(val2),
|
||||
'lt': lambda val1, val2: float(val1) < float(val2),
|
||||
'ge': lambda val1, val2: float(val1) >= float(val2),
|
||||
'le': lambda val1, val2: float(val1) <= float(val2),
|
||||
'ne': lambda val1, val2: float(val1) != float(val2),
|
||||
'default': lambda val1, val2: False}
|
||||
CF_MAPPING = {
|
||||
"eq": lambda val1, val2: val1 == val2 or str(val1) == str(val2) or float(val1) == float(val2),
|
||||
"gt": lambda val1, val2: float(val1) > float(val2),
|
||||
"lt": lambda val1, val2: float(val1) < float(val2),
|
||||
"ge": lambda val1, val2: float(val1) >= float(val2),
|
||||
"le": lambda val1, val2: float(val1) <= float(val2),
|
||||
"ne": lambda val1, val2: float(val1) != float(val2),
|
||||
"default": lambda val1, val2: False,
|
||||
}
|
||||
|
||||
|
||||
def attr(accessing_obj, accessed_obj, *args, **kwargs):
|
||||
|
|
@ -348,14 +361,14 @@ def attr(accessing_obj, accessed_obj, *args, **kwargs):
|
|||
value = None
|
||||
if len(args) > 1:
|
||||
value = args[1].strip()
|
||||
compare = 'eq'
|
||||
compare = "eq"
|
||||
if kwargs:
|
||||
compare = kwargs.get('compare', 'eq')
|
||||
compare = kwargs.get("compare", "eq")
|
||||
|
||||
def valcompare(val1, val2, typ='eq'):
|
||||
def valcompare(val1, val2, typ="eq"):
|
||||
"compare based on type"
|
||||
try:
|
||||
return CF_MAPPING.get(typ, CF_MAPPING['default'])(val1, val2)
|
||||
return CF_MAPPING.get(typ, CF_MAPPING["default"])(val1, val2)
|
||||
except Exception:
|
||||
# this might happen if we try to compare two things that
|
||||
# cannot be compared
|
||||
|
|
@ -375,10 +388,11 @@ def attr(accessing_obj, accessed_obj, *args, **kwargs):
|
|||
# will return Fail on False value etc
|
||||
return bool(getattr(accessing_obj, attrname))
|
||||
# check attributes, if they exist
|
||||
if (hasattr(accessing_obj, 'attributes') and accessing_obj.attributes.has(attrname)):
|
||||
if hasattr(accessing_obj, "attributes") and accessing_obj.attributes.has(attrname):
|
||||
if value:
|
||||
return (hasattr(accessing_obj, 'attributes') and
|
||||
valcompare(accessing_obj.attributes.get(attrname), value, compare))
|
||||
return hasattr(accessing_obj, "attributes") and valcompare(
|
||||
accessing_obj.attributes.get(attrname), value, compare
|
||||
)
|
||||
# fails on False/None values
|
||||
return bool(accessing_obj.attributes.get(attrname))
|
||||
return False
|
||||
|
|
@ -455,7 +469,7 @@ def attr_gt(accessing_obj, accessed_obj, *args, **kwargs):
|
|||
|
||||
Only true if access_obj's attribute > the value given.
|
||||
"""
|
||||
return attr(accessing_obj, accessed_obj, *args, **{'compare': 'gt'})
|
||||
return attr(accessing_obj, accessed_obj, *args, **{"compare": "gt"})
|
||||
|
||||
|
||||
def attr_ge(accessing_obj, accessed_obj, *args, **kwargs):
|
||||
|
|
@ -465,7 +479,7 @@ def attr_ge(accessing_obj, accessed_obj, *args, **kwargs):
|
|||
|
||||
Only true if access_obj's attribute >= the value given.
|
||||
"""
|
||||
return attr(accessing_obj, accessed_obj, *args, **{'compare': 'ge'})
|
||||
return attr(accessing_obj, accessed_obj, *args, **{"compare": "ge"})
|
||||
|
||||
|
||||
def attr_lt(accessing_obj, accessed_obj, *args, **kwargs):
|
||||
|
|
@ -475,7 +489,7 @@ def attr_lt(accessing_obj, accessed_obj, *args, **kwargs):
|
|||
|
||||
Only true if access_obj's attribute < the value given.
|
||||
"""
|
||||
return attr(accessing_obj, accessed_obj, *args, **{'compare': 'lt'})
|
||||
return attr(accessing_obj, accessed_obj, *args, **{"compare": "lt"})
|
||||
|
||||
|
||||
def attr_le(accessing_obj, accessed_obj, *args, **kwargs):
|
||||
|
|
@ -485,7 +499,7 @@ def attr_le(accessing_obj, accessed_obj, *args, **kwargs):
|
|||
|
||||
Only true if access_obj's attribute <= the value given.
|
||||
"""
|
||||
return attr(accessing_obj, accessed_obj, *args, **{'compare': 'le'})
|
||||
return attr(accessing_obj, accessed_obj, *args, **{"compare": "le"})
|
||||
|
||||
|
||||
def attr_ne(accessing_obj, accessed_obj, *args, **kwargs):
|
||||
|
|
@ -495,7 +509,7 @@ def attr_ne(accessing_obj, accessed_obj, *args, **kwargs):
|
|||
|
||||
Only true if access_obj's attribute != the value given.
|
||||
"""
|
||||
return attr(accessing_obj, accessed_obj, *args, **{'compare': 'ne'})
|
||||
return attr(accessing_obj, accessed_obj, *args, **{"compare": "ne"})
|
||||
|
||||
|
||||
def tag(accessing_obj, accessed_obj, *args, **kwargs):
|
||||
|
|
@ -570,8 +584,14 @@ def holds(accessing_obj, accessed_obj, *args, **kwargs):
|
|||
if dbref and any((True for obj in contents if obj.dbid == dbref)):
|
||||
return True
|
||||
objid = objid.lower()
|
||||
return any((True for obj in contents
|
||||
if obj.key.lower() == objid or objid in [al.lower() for al in obj.aliases.all()]))
|
||||
return any(
|
||||
(
|
||||
True
|
||||
for obj in contents
|
||||
if obj.key.lower() == objid or objid in [al.lower() for al in obj.aliases.all()]
|
||||
)
|
||||
)
|
||||
|
||||
if not args:
|
||||
# holds() - check if accessed_obj or accessed_obj.obj is held by accessing_obj
|
||||
try:
|
||||
|
|
|
|||
|
|
@ -115,7 +115,6 @@ WARNING_LOG = settings.LOCKWARNING_LOG_FILE
|
|||
_LOCK_HANDLER = None
|
||||
|
||||
|
||||
|
||||
#
|
||||
# Exception class. This will be raised
|
||||
# by errors in lock definitions.
|
||||
|
|
@ -126,6 +125,7 @@ class LockException(Exception):
|
|||
"""
|
||||
Raised during an error in a lock.
|
||||
"""
|
||||
|
||||
pass
|
||||
|
||||
|
||||
|
|
@ -145,6 +145,7 @@ def _cache_lockfuncs():
|
|||
for modulepath in settings.LOCK_FUNC_MODULES:
|
||||
_LOCKFUNCS.update(utils.callables_from_module(modulepath))
|
||||
|
||||
|
||||
#
|
||||
# pre-compiled regular expressions
|
||||
#
|
||||
|
|
@ -161,6 +162,7 @@ _RE_OK = re.compile(r"%s|and|or|not")
|
|||
#
|
||||
#
|
||||
|
||||
|
||||
class LockHandler(object):
|
||||
"""
|
||||
This handler should be attached to all objects implementing
|
||||
|
|
@ -211,12 +213,12 @@ class LockHandler(object):
|
|||
duplicates = 0
|
||||
elist = [] # errors
|
||||
wlist = [] # warnings
|
||||
for raw_lockstring in storage_lockstring.split(';'):
|
||||
for raw_lockstring in storage_lockstring.split(";"):
|
||||
if not raw_lockstring:
|
||||
continue
|
||||
lock_funcs = []
|
||||
try:
|
||||
access_type, rhs = (part.strip() for part in raw_lockstring.split(':', 1))
|
||||
access_type, rhs = (part.strip() for part in raw_lockstring.split(":", 1))
|
||||
except ValueError:
|
||||
logger.log_trace()
|
||||
return locks
|
||||
|
|
@ -224,19 +226,19 @@ class LockHandler(object):
|
|||
# parse the lock functions and separators
|
||||
funclist = _RE_FUNCS.findall(rhs)
|
||||
evalstring = rhs
|
||||
for pattern in ('AND', 'OR', 'NOT'):
|
||||
for pattern in ("AND", "OR", "NOT"):
|
||||
evalstring = re.sub(r"\b%s\b" % pattern, pattern.lower(), evalstring)
|
||||
nfuncs = len(funclist)
|
||||
for funcstring in funclist:
|
||||
funcname, rest = (part.strip().strip(')') for part in funcstring.split('(', 1))
|
||||
funcname, rest = (part.strip().strip(")") for part in funcstring.split("(", 1))
|
||||
func = _LOCKFUNCS.get(funcname, None)
|
||||
if not callable(func):
|
||||
elist.append(_("Lock: lock-function '%s' is not available.") % funcstring)
|
||||
continue
|
||||
args = list(arg.strip() for arg in rest.split(',') if arg and '=' not in arg)
|
||||
kwargs = dict([arg.split('=', 1) for arg in rest.split(',') if arg and '=' in arg])
|
||||
args = list(arg.strip() for arg in rest.split(",") if arg and "=" not in arg)
|
||||
kwargs = dict([arg.split("=", 1) for arg in rest.split(",") if arg and "=" in arg])
|
||||
lock_funcs.append((func, args, kwargs))
|
||||
evalstring = evalstring.replace(funcstring, '%s')
|
||||
evalstring = evalstring.replace(funcstring, "%s")
|
||||
if len(lock_funcs) < nfuncs:
|
||||
continue
|
||||
try:
|
||||
|
|
@ -248,8 +250,17 @@ class LockHandler(object):
|
|||
continue
|
||||
if access_type in locks:
|
||||
duplicates += 1
|
||||
wlist.append(_("LockHandler on %(obj)s: access type '%(access_type)s' changed from '%(source)s' to '%(goal)s' " %
|
||||
{"obj": self.obj, "access_type": access_type, "source": locks[access_type][2], "goal": raw_lockstring}))
|
||||
wlist.append(
|
||||
_(
|
||||
"LockHandler on %(obj)s: access type '%(access_type)s' changed from '%(source)s' to '%(goal)s' "
|
||||
% {
|
||||
"obj": self.obj,
|
||||
"access_type": access_type,
|
||||
"source": locks[access_type][2],
|
||||
"goal": raw_lockstring,
|
||||
}
|
||||
)
|
||||
)
|
||||
locks[access_type] = (evalstring, tuple(lock_funcs), raw_lockstring)
|
||||
if wlist and WARNING_LOG:
|
||||
# a warning text was set, it's not an error, so only report
|
||||
|
|
@ -314,23 +325,24 @@ class LockHandler(object):
|
|||
err = ""
|
||||
# sanity checks
|
||||
for lockdef in lockdefs:
|
||||
if ':' not in lockdef:
|
||||
if ":" not in lockdef:
|
||||
err = _("Lock: '{lockdef}' contains no colon (:).").format(lockdef=lockdef)
|
||||
if validate_only:
|
||||
return False, err
|
||||
else:
|
||||
self._log_error(err)
|
||||
return False
|
||||
access_type, rhs = [part.strip() for part in lockdef.split(':', 1)]
|
||||
access_type, rhs = [part.strip() for part in lockdef.split(":", 1)]
|
||||
if not access_type:
|
||||
err = _("Lock: '{lockdef}' has no access_type "
|
||||
"(left-side of colon is empty).").format(lockdef=lockdef)
|
||||
err = _(
|
||||
"Lock: '{lockdef}' has no access_type " "(left-side of colon is empty)."
|
||||
).format(lockdef=lockdef)
|
||||
if validate_only:
|
||||
return False, err
|
||||
else:
|
||||
self._log_error(err)
|
||||
return False
|
||||
if rhs.count('(') != rhs.count(')'):
|
||||
if rhs.count("(") != rhs.count(")"):
|
||||
err = _("Lock: '{lockdef}' has mismatched parentheses.").format(lockdef=lockdef)
|
||||
if validate_only:
|
||||
return False, err
|
||||
|
|
@ -417,7 +429,7 @@ class LockHandler(object):
|
|||
lockstrings (list): All separate lockstrings
|
||||
|
||||
"""
|
||||
return str(self).split(';')
|
||||
return str(self).split(";")
|
||||
|
||||
def remove(self, access_type):
|
||||
"""
|
||||
|
|
@ -436,6 +448,7 @@ class LockHandler(object):
|
|||
self._save_locks()
|
||||
return True
|
||||
return False
|
||||
|
||||
delete = remove # alias for historical reasons
|
||||
|
||||
def clear(self):
|
||||
|
|
@ -456,7 +469,7 @@ class LockHandler(object):
|
|||
self._cache_locks(self.obj.lock_storage)
|
||||
self.cache_lock_bypass(self.obj)
|
||||
|
||||
def append(self, access_type, lockstring, op='or'):
|
||||
def append(self, access_type, lockstring, op="or"):
|
||||
"""
|
||||
Append a lock definition to access_type if it doesn't already exist.
|
||||
|
||||
|
|
@ -475,7 +488,8 @@ class LockHandler(object):
|
|||
old_lockstring = self.get(access_type)
|
||||
if not lockstring.strip().lower() in old_lockstring.lower():
|
||||
lockstring = "{old} {op} {new}".format(
|
||||
old=old_lockstring, op=op, new=lockstring.strip())
|
||||
old=old_lockstring, op=op, new=lockstring.strip()
|
||||
)
|
||||
self.add(lockstring)
|
||||
|
||||
def check(self, accessing_obj, access_type, default=False, no_superuser_bypass=False):
|
||||
|
|
@ -517,12 +531,19 @@ class LockHandler(object):
|
|||
except AttributeError:
|
||||
# happens before session is initiated.
|
||||
if not no_superuser_bypass and (
|
||||
(hasattr(accessing_obj, 'is_superuser') and accessing_obj.is_superuser) or
|
||||
(hasattr(accessing_obj, 'account') and
|
||||
hasattr(accessing_obj.account, 'is_superuser') and
|
||||
accessing_obj.account.is_superuser) or
|
||||
(hasattr(accessing_obj, 'get_account') and
|
||||
(not accessing_obj.get_account() or accessing_obj.get_account().is_superuser))):
|
||||
(hasattr(accessing_obj, "is_superuser") and accessing_obj.is_superuser)
|
||||
or (
|
||||
hasattr(accessing_obj, "account")
|
||||
and hasattr(accessing_obj.account, "is_superuser")
|
||||
and accessing_obj.account.is_superuser
|
||||
)
|
||||
or (
|
||||
hasattr(accessing_obj, "get_account")
|
||||
and (
|
||||
not accessing_obj.get_account() or accessing_obj.get_account().is_superuser
|
||||
)
|
||||
)
|
||||
):
|
||||
return True
|
||||
|
||||
# no superuser or bypass -> normal lock operation
|
||||
|
|
@ -530,8 +551,9 @@ class LockHandler(object):
|
|||
# we have a lock, test it.
|
||||
evalstring, func_tup, raw_string = self.locks[access_type]
|
||||
# execute all lock funcs in the correct order, producing a tuple of True/False results.
|
||||
true_false = tuple(bool(
|
||||
tup[0](accessing_obj, self.obj, *tup[1], **tup[2])) for tup in func_tup)
|
||||
true_false = tuple(
|
||||
bool(tup[0](accessing_obj, self.obj, *tup[1], **tup[2])) for tup in func_tup
|
||||
)
|
||||
# the True/False tuple goes into evalstring, which combines them
|
||||
# with AND/OR/NOT in order to get the final result.
|
||||
return eval(evalstring % true_false)
|
||||
|
|
@ -549,12 +571,12 @@ class LockHandler(object):
|
|||
|
||||
"""
|
||||
evalstring, func_tup, raw_string = locks[access_type]
|
||||
true_false = tuple(tup[0](accessing_obj, self.obj, *tup[1], **tup[2])
|
||||
for tup in func_tup)
|
||||
true_false = tuple(tup[0](accessing_obj, self.obj, *tup[1], **tup[2]) for tup in func_tup)
|
||||
return eval(evalstring % true_false)
|
||||
|
||||
def check_lockstring(self, accessing_obj, lockstring, no_superuser_bypass=False,
|
||||
default=False, access_type=None):
|
||||
def check_lockstring(
|
||||
self, accessing_obj, lockstring, no_superuser_bypass=False, default=False, access_type=None
|
||||
):
|
||||
"""
|
||||
Do a direct check against a lockstring ('atype:func()..'),
|
||||
without any intermediary storage on the accessed object.
|
||||
|
|
@ -583,12 +605,19 @@ class LockHandler(object):
|
|||
return True
|
||||
except AttributeError:
|
||||
if no_superuser_bypass and (
|
||||
(hasattr(accessing_obj, 'is_superuser') and accessing_obj.is_superuser) or
|
||||
(hasattr(accessing_obj, 'account') and
|
||||
hasattr(accessing_obj.account, 'is_superuser') and
|
||||
accessing_obj.account.is_superuser) or
|
||||
(hasattr(accessing_obj, 'get_account') and
|
||||
(not accessing_obj.get_account() or accessing_obj.get_account().is_superuser))):
|
||||
(hasattr(accessing_obj, "is_superuser") and accessing_obj.is_superuser)
|
||||
or (
|
||||
hasattr(accessing_obj, "account")
|
||||
and hasattr(accessing_obj.account, "is_superuser")
|
||||
and accessing_obj.account.is_superuser
|
||||
)
|
||||
or (
|
||||
hasattr(accessing_obj, "get_account")
|
||||
and (
|
||||
not accessing_obj.get_account() or accessing_obj.get_account().is_superuser
|
||||
)
|
||||
)
|
||||
):
|
||||
return True
|
||||
if ":" not in lockstring:
|
||||
lockstring = "%s:%s" % ("_dummy", lockstring)
|
||||
|
|
@ -599,25 +628,27 @@ class LockHandler(object):
|
|||
if access_type not in locks:
|
||||
return default
|
||||
else:
|
||||
return self._eval_access_type(
|
||||
accessing_obj, locks, access_type)
|
||||
return self._eval_access_type(accessing_obj, locks, access_type)
|
||||
else:
|
||||
# if no access types was given and multiple locks were
|
||||
# embedded in the lockstring we assume all must be true
|
||||
return all(self._eval_access_type(
|
||||
accessing_obj, locks, access_type) for access_type in locks)
|
||||
return all(
|
||||
self._eval_access_type(accessing_obj, locks, access_type) for access_type in locks
|
||||
)
|
||||
|
||||
|
||||
# convenience access function
|
||||
|
||||
# dummy to be able to call check_lockstring from the outside
|
||||
|
||||
|
||||
class _ObjDummy:
|
||||
lock_storage = ''
|
||||
lock_storage = ""
|
||||
|
||||
|
||||
def check_lockstring(accessing_obj, lockstring, no_superuser_bypass=False,
|
||||
default=False, access_type=None):
|
||||
def check_lockstring(
|
||||
accessing_obj, lockstring, no_superuser_bypass=False, default=False, access_type=None
|
||||
):
|
||||
"""
|
||||
Do a direct check against a lockstring ('atype:func()..'),
|
||||
without any intermediary storage on the accessed object.
|
||||
|
|
@ -645,8 +676,12 @@ def check_lockstring(accessing_obj, lockstring, no_superuser_bypass=False,
|
|||
if not _LOCK_HANDLER:
|
||||
_LOCK_HANDLER = LockHandler(_ObjDummy())
|
||||
return _LOCK_HANDLER.check_lockstring(
|
||||
accessing_obj, lockstring, no_superuser_bypass=no_superuser_bypass,
|
||||
default=default, access_type=access_type)
|
||||
accessing_obj,
|
||||
lockstring,
|
||||
no_superuser_bypass=no_superuser_bypass,
|
||||
default=default,
|
||||
access_type=access_type,
|
||||
)
|
||||
|
||||
|
||||
def validate_lockstring(lockstring):
|
||||
|
|
@ -688,11 +723,12 @@ def _test():
|
|||
pass
|
||||
|
||||
import pdb
|
||||
|
||||
obj1 = TestObj()
|
||||
obj2 = TestObj()
|
||||
|
||||
# obj1.lock_storage = "owner:dbref(#4);edit:dbref(#5) or perm(Admin);examine:perm(Builder);delete:perm(Admin);get:all()"
|
||||
#obj1.lock_storage = "cmd:all();admin:id(1);listen:all();send:all()"
|
||||
# obj1.lock_storage = "cmd:all();admin:id(1);listen:all();send:all()"
|
||||
obj1.lock_storage = "listen:perm(Developer)"
|
||||
|
||||
pdb.set_trace()
|
||||
|
|
@ -703,9 +739,9 @@ def _test():
|
|||
# obj1.locks.add("edit:attr(test)")
|
||||
|
||||
print("comparing obj2.permissions (%s) vs obj1.locks (%s)" % (obj2.permissions, obj1.locks))
|
||||
print(obj1.locks.check(obj2, 'owner'))
|
||||
print(obj1.locks.check(obj2, 'edit'))
|
||||
print(obj1.locks.check(obj2, 'examine'))
|
||||
print(obj1.locks.check(obj2, 'delete'))
|
||||
print(obj1.locks.check(obj2, 'get'))
|
||||
print(obj1.locks.check(obj2, 'listen'))
|
||||
print(obj1.locks.check(obj2, "owner"))
|
||||
print(obj1.locks.check(obj2, "edit"))
|
||||
print(obj1.locks.check(obj2, "examine"))
|
||||
print(obj1.locks.check(obj2, "delete"))
|
||||
print(obj1.locks.check(obj2, "get"))
|
||||
print(obj1.locks.check(obj2, "listen"))
|
||||
|
|
|
|||
|
|
@ -26,23 +26,26 @@ from evennia.locks import lockfuncs
|
|||
class TestLockCheck(EvenniaTest):
|
||||
def testrun(self):
|
||||
dbref = self.obj2.dbref
|
||||
self.obj1.locks.add("owner:dbref(%s);edit:dbref(%s) or perm(Admin);examine:perm(Builder) "
|
||||
"and id(%s);delete:perm(Admin);get:all()" % (dbref, dbref, dbref))
|
||||
self.obj2.permissions.add('Admin')
|
||||
self.assertEqual(True, self.obj1.locks.check(self.obj2, 'owner'))
|
||||
self.assertEqual(True, self.obj1.locks.check(self.obj2, 'edit'))
|
||||
self.assertEqual(True, self.obj1.locks.check(self.obj2, 'examine'))
|
||||
self.assertEqual(True, self.obj1.locks.check(self.obj2, 'delete'))
|
||||
self.assertEqual(True, self.obj1.locks.check(self.obj2, 'get'))
|
||||
self.obj1.locks.add(
|
||||
"owner:dbref(%s);edit:dbref(%s) or perm(Admin);examine:perm(Builder) "
|
||||
"and id(%s);delete:perm(Admin);get:all()" % (dbref, dbref, dbref)
|
||||
)
|
||||
self.obj2.permissions.add("Admin")
|
||||
self.assertEqual(True, self.obj1.locks.check(self.obj2, "owner"))
|
||||
self.assertEqual(True, self.obj1.locks.check(self.obj2, "edit"))
|
||||
self.assertEqual(True, self.obj1.locks.check(self.obj2, "examine"))
|
||||
self.assertEqual(True, self.obj1.locks.check(self.obj2, "delete"))
|
||||
self.assertEqual(True, self.obj1.locks.check(self.obj2, "get"))
|
||||
self.obj1.locks.add("get:false()")
|
||||
self.assertEqual(False, self.obj1.locks.check(self.obj2, 'get'))
|
||||
self.assertEqual(True, self.obj1.locks.check(self.obj2, 'not_exist', default=True))
|
||||
self.assertEqual(False, self.obj1.locks.check(self.obj2, "get"))
|
||||
self.assertEqual(True, self.obj1.locks.check(self.obj2, "not_exist", default=True))
|
||||
|
||||
|
||||
class TestLockfuncs(EvenniaTest):
|
||||
def setUp(self):
|
||||
super(TestLockfuncs, self).setUp()
|
||||
self.account2.permissions.add('Admin')
|
||||
self.char2.permissions.add('Builder')
|
||||
self.account2.permissions.add("Admin")
|
||||
self.char2.permissions.add("Builder")
|
||||
|
||||
def test_booleans(self):
|
||||
self.assertEqual(True, lockfuncs.true(self.account2, self.obj1))
|
||||
|
|
@ -55,121 +58,121 @@ class TestLockfuncs(EvenniaTest):
|
|||
|
||||
@override_settings(PERMISSION_HIERARCHY=settings_default.PERMISSION_HIERARCHY)
|
||||
def test_account_perm(self):
|
||||
self.assertEqual(False, lockfuncs.perm(self.account2, None, 'foo'))
|
||||
self.assertEqual(False, lockfuncs.perm(self.account2, None, 'Developer'))
|
||||
self.assertEqual(False, lockfuncs.perm(self.account2, None, 'Developers'))
|
||||
self.assertEqual(True, lockfuncs.perm(self.account2, None, 'Admin'))
|
||||
self.assertEqual(True, lockfuncs.perm(self.account2, None, 'Admins'))
|
||||
self.assertEqual(True, lockfuncs.perm(self.account2, None, 'Player'))
|
||||
self.assertEqual(True, lockfuncs.perm(self.account2, None, 'Players'))
|
||||
self.assertEqual(True, lockfuncs.perm(self.account2, None, 'Builder'))
|
||||
self.assertEqual(True, lockfuncs.perm(self.account2, None, 'Builders'))
|
||||
self.assertEqual(True, lockfuncs.perm_above(self.account2, None, 'Builder'))
|
||||
self.assertEqual(False, lockfuncs.perm(self.account2, None, "foo"))
|
||||
self.assertEqual(False, lockfuncs.perm(self.account2, None, "Developer"))
|
||||
self.assertEqual(False, lockfuncs.perm(self.account2, None, "Developers"))
|
||||
self.assertEqual(True, lockfuncs.perm(self.account2, None, "Admin"))
|
||||
self.assertEqual(True, lockfuncs.perm(self.account2, None, "Admins"))
|
||||
self.assertEqual(True, lockfuncs.perm(self.account2, None, "Player"))
|
||||
self.assertEqual(True, lockfuncs.perm(self.account2, None, "Players"))
|
||||
self.assertEqual(True, lockfuncs.perm(self.account2, None, "Builder"))
|
||||
self.assertEqual(True, lockfuncs.perm(self.account2, None, "Builders"))
|
||||
self.assertEqual(True, lockfuncs.perm_above(self.account2, None, "Builder"))
|
||||
|
||||
@override_settings(PERMISSION_HIERARCHY=settings_default.PERMISSION_HIERARCHY)
|
||||
def test_puppet_perm(self):
|
||||
self.assertEqual(False, lockfuncs.perm(self.char2, None, 'foo'))
|
||||
self.assertEqual(False, lockfuncs.perm(self.char2, None, 'Developer'))
|
||||
self.assertEqual(False, lockfuncs.perm(self.char2, None, 'Develoeprs'))
|
||||
self.assertEqual(True, lockfuncs.perm(self.char2, None, 'Admin'))
|
||||
self.assertEqual(True, lockfuncs.perm(self.char2, None, 'Admins'))
|
||||
self.assertEqual(True, lockfuncs.perm(self.char2, None, 'Player'))
|
||||
self.assertEqual(True, lockfuncs.perm(self.char2, None, 'Players'))
|
||||
self.assertEqual(True, lockfuncs.perm(self.char2, None, 'Builder'))
|
||||
self.assertEqual(True, lockfuncs.perm(self.char2, None, 'Builders'))
|
||||
self.assertEqual(False, lockfuncs.perm(self.char2, None, "foo"))
|
||||
self.assertEqual(False, lockfuncs.perm(self.char2, None, "Developer"))
|
||||
self.assertEqual(False, lockfuncs.perm(self.char2, None, "Develoeprs"))
|
||||
self.assertEqual(True, lockfuncs.perm(self.char2, None, "Admin"))
|
||||
self.assertEqual(True, lockfuncs.perm(self.char2, None, "Admins"))
|
||||
self.assertEqual(True, lockfuncs.perm(self.char2, None, "Player"))
|
||||
self.assertEqual(True, lockfuncs.perm(self.char2, None, "Players"))
|
||||
self.assertEqual(True, lockfuncs.perm(self.char2, None, "Builder"))
|
||||
self.assertEqual(True, lockfuncs.perm(self.char2, None, "Builders"))
|
||||
|
||||
@override_settings(PERMISSION_HIERARCHY=settings_default.PERMISSION_HIERARCHY)
|
||||
def test_account_perm_above(self):
|
||||
self.assertEqual(True, lockfuncs.perm_above(self.char2, None, 'Builder'))
|
||||
self.assertEqual(True, lockfuncs.perm_above(self.char2, None, 'Builders'))
|
||||
self.assertEqual(True, lockfuncs.perm_above(self.char2, None, 'Player'))
|
||||
self.assertEqual(False, lockfuncs.perm_above(self.char2, None, 'Admin'))
|
||||
self.assertEqual(False, lockfuncs.perm_above(self.char2, None, 'Admins'))
|
||||
self.assertEqual(False, lockfuncs.perm_above(self.char2, None, 'Developers'))
|
||||
self.assertEqual(True, lockfuncs.perm_above(self.char2, None, "Builder"))
|
||||
self.assertEqual(True, lockfuncs.perm_above(self.char2, None, "Builders"))
|
||||
self.assertEqual(True, lockfuncs.perm_above(self.char2, None, "Player"))
|
||||
self.assertEqual(False, lockfuncs.perm_above(self.char2, None, "Admin"))
|
||||
self.assertEqual(False, lockfuncs.perm_above(self.char2, None, "Admins"))
|
||||
self.assertEqual(False, lockfuncs.perm_above(self.char2, None, "Developers"))
|
||||
|
||||
@override_settings(PERMISSION_HIERARCHY=settings_default.PERMISSION_HIERARCHY)
|
||||
def test_quell_perm(self):
|
||||
self.account2.db._quell = True
|
||||
self.assertEqual(False, lockfuncs.false(self.char2, None))
|
||||
self.assertEqual(False, lockfuncs.perm(self.char2, None, 'Developer'))
|
||||
self.assertEqual(False, lockfuncs.perm(self.char2, None, 'Developers'))
|
||||
self.assertEqual(False, lockfuncs.perm(self.char2, None, 'Admin'))
|
||||
self.assertEqual(False, lockfuncs.perm(self.char2, None, 'Admins'))
|
||||
self.assertEqual(True, lockfuncs.perm(self.char2, None, 'Player'))
|
||||
self.assertEqual(True, lockfuncs.perm(self.char2, None, 'Players'))
|
||||
self.assertEqual(True, lockfuncs.perm(self.char2, None, 'Builder'))
|
||||
self.assertEqual(True, lockfuncs.perm(self.char2, None, 'Builders'))
|
||||
self.assertEqual(False, lockfuncs.perm(self.char2, None, "Developer"))
|
||||
self.assertEqual(False, lockfuncs.perm(self.char2, None, "Developers"))
|
||||
self.assertEqual(False, lockfuncs.perm(self.char2, None, "Admin"))
|
||||
self.assertEqual(False, lockfuncs.perm(self.char2, None, "Admins"))
|
||||
self.assertEqual(True, lockfuncs.perm(self.char2, None, "Player"))
|
||||
self.assertEqual(True, lockfuncs.perm(self.char2, None, "Players"))
|
||||
self.assertEqual(True, lockfuncs.perm(self.char2, None, "Builder"))
|
||||
self.assertEqual(True, lockfuncs.perm(self.char2, None, "Builders"))
|
||||
|
||||
@override_settings(PERMISSION_HIERARCHY=settings_default.PERMISSION_HIERARCHY)
|
||||
def test_quell_above_perm(self):
|
||||
self.assertEqual(True, lockfuncs.perm_above(self.char2, None, 'Player'))
|
||||
self.assertEqual(True, lockfuncs.perm_above(self.char2, None, 'Builder'))
|
||||
self.assertEqual(True, lockfuncs.perm_above(self.char2, None, "Player"))
|
||||
self.assertEqual(True, lockfuncs.perm_above(self.char2, None, "Builder"))
|
||||
|
||||
@override_settings(PERMISSION_HIERARCHY=settings_default.PERMISSION_HIERARCHY)
|
||||
def test_object_perm(self):
|
||||
self.obj2.permissions.add('Admin')
|
||||
self.assertEqual(False, lockfuncs.perm(self.obj2, None, 'Developer'))
|
||||
self.assertEqual(False, lockfuncs.perm(self.obj2, None, 'Developers'))
|
||||
self.assertEqual(True, lockfuncs.perm(self.obj2, None, 'Admin'))
|
||||
self.assertEqual(True, lockfuncs.perm(self.obj2, None, 'Admins'))
|
||||
self.assertEqual(True, lockfuncs.perm(self.obj2, None, 'Player'))
|
||||
self.assertEqual(True, lockfuncs.perm(self.obj2, None, 'Players'))
|
||||
self.assertEqual(True, lockfuncs.perm(self.obj2, None, 'Builder'))
|
||||
self.assertEqual(True, lockfuncs.perm(self.obj2, None, 'Builders'))
|
||||
self.obj2.permissions.add("Admin")
|
||||
self.assertEqual(False, lockfuncs.perm(self.obj2, None, "Developer"))
|
||||
self.assertEqual(False, lockfuncs.perm(self.obj2, None, "Developers"))
|
||||
self.assertEqual(True, lockfuncs.perm(self.obj2, None, "Admin"))
|
||||
self.assertEqual(True, lockfuncs.perm(self.obj2, None, "Admins"))
|
||||
self.assertEqual(True, lockfuncs.perm(self.obj2, None, "Player"))
|
||||
self.assertEqual(True, lockfuncs.perm(self.obj2, None, "Players"))
|
||||
self.assertEqual(True, lockfuncs.perm(self.obj2, None, "Builder"))
|
||||
self.assertEqual(True, lockfuncs.perm(self.obj2, None, "Builders"))
|
||||
|
||||
@override_settings(PERMISSION_HIERARCHY=settings_default.PERMISSION_HIERARCHY)
|
||||
def test_object_above_perm(self):
|
||||
self.obj2.permissions.add('Admin')
|
||||
self.assertEqual(False, lockfuncs.perm_above(self.obj2, None, 'Admins'))
|
||||
self.assertEqual(True, lockfuncs.perm_above(self.obj2, None, 'Builder'))
|
||||
self.assertEqual(True, lockfuncs.perm_above(self.obj2, None, 'Builders'))
|
||||
self.obj2.permissions.add("Admin")
|
||||
self.assertEqual(False, lockfuncs.perm_above(self.obj2, None, "Admins"))
|
||||
self.assertEqual(True, lockfuncs.perm_above(self.obj2, None, "Builder"))
|
||||
self.assertEqual(True, lockfuncs.perm_above(self.obj2, None, "Builders"))
|
||||
|
||||
@override_settings(PERMISSION_HIERARCHY=settings_default.PERMISSION_HIERARCHY)
|
||||
def test_pperm(self):
|
||||
self.obj2.permissions.add('Developer')
|
||||
self.char2.permissions.add('Developer')
|
||||
self.assertEqual(False, lockfuncs.pperm(self.obj2, None, 'Players'))
|
||||
self.assertEqual(True, lockfuncs.pperm(self.char2, None, 'Players'))
|
||||
self.assertEqual(True, lockfuncs.pperm(self.account, None, 'Admins'))
|
||||
self.assertEqual(True, lockfuncs.pperm_above(self.account, None, 'Builders'))
|
||||
self.assertEqual(False, lockfuncs.pperm_above(self.account2, None, 'Admins'))
|
||||
self.assertEqual(True, lockfuncs.pperm_above(self.char2, None, 'Players'))
|
||||
self.obj2.permissions.add("Developer")
|
||||
self.char2.permissions.add("Developer")
|
||||
self.assertEqual(False, lockfuncs.pperm(self.obj2, None, "Players"))
|
||||
self.assertEqual(True, lockfuncs.pperm(self.char2, None, "Players"))
|
||||
self.assertEqual(True, lockfuncs.pperm(self.account, None, "Admins"))
|
||||
self.assertEqual(True, lockfuncs.pperm_above(self.account, None, "Builders"))
|
||||
self.assertEqual(False, lockfuncs.pperm_above(self.account2, None, "Admins"))
|
||||
self.assertEqual(True, lockfuncs.pperm_above(self.char2, None, "Players"))
|
||||
|
||||
def test_dbref(self):
|
||||
dbref = self.obj2.dbref
|
||||
self.assertEqual(True, lockfuncs.dbref(self.obj2, None, '%s' % dbref))
|
||||
self.assertEqual(False, lockfuncs.id(self.obj2, None, '%s' % (dbref + '1')))
|
||||
self.assertEqual(True, lockfuncs.dbref(self.obj2, None, "%s" % dbref))
|
||||
self.assertEqual(False, lockfuncs.id(self.obj2, None, "%s" % (dbref + "1")))
|
||||
dbref = self.account2.dbref
|
||||
self.assertEqual(True, lockfuncs.pdbref(self.account2, None, '%s' % dbref))
|
||||
self.assertEqual(False, lockfuncs.pid(self.account2, None, '%s' % (dbref + '1')))
|
||||
self.assertEqual(True, lockfuncs.pdbref(self.account2, None, "%s" % dbref))
|
||||
self.assertEqual(False, lockfuncs.pid(self.account2, None, "%s" % (dbref + "1")))
|
||||
|
||||
def test_attr(self):
|
||||
self.obj2.db.testattr = 45
|
||||
self.assertEqual(True, lockfuncs.attr(self.obj2, None, 'testattr', '45'))
|
||||
self.assertEqual(False, lockfuncs.attr_gt(self.obj2, None, 'testattr', '45'))
|
||||
self.assertEqual(True, lockfuncs.attr_ge(self.obj2, None, 'testattr', '45'))
|
||||
self.assertEqual(False, lockfuncs.attr_lt(self.obj2, None, 'testattr', '45'))
|
||||
self.assertEqual(True, lockfuncs.attr_le(self.obj2, None, 'testattr', '45'))
|
||||
self.assertEqual(True, lockfuncs.attr(self.obj2, None, "testattr", "45"))
|
||||
self.assertEqual(False, lockfuncs.attr_gt(self.obj2, None, "testattr", "45"))
|
||||
self.assertEqual(True, lockfuncs.attr_ge(self.obj2, None, "testattr", "45"))
|
||||
self.assertEqual(False, lockfuncs.attr_lt(self.obj2, None, "testattr", "45"))
|
||||
self.assertEqual(True, lockfuncs.attr_le(self.obj2, None, "testattr", "45"))
|
||||
|
||||
self.assertEqual(True, lockfuncs.objattr(None, self.obj2, 'testattr', '45'))
|
||||
self.assertEqual(True, lockfuncs.objattr(None, self.obj2, 'testattr', '45'))
|
||||
self.assertEqual(False, lockfuncs.objattr(None, self.obj2, 'testattr', '45', compare='lt'))
|
||||
self.assertEqual(True, lockfuncs.objattr(None, self.obj2, "testattr", "45"))
|
||||
self.assertEqual(True, lockfuncs.objattr(None, self.obj2, "testattr", "45"))
|
||||
self.assertEqual(False, lockfuncs.objattr(None, self.obj2, "testattr", "45", compare="lt"))
|
||||
|
||||
def test_locattr(self):
|
||||
self.obj2.location.db.locattr = 'test'
|
||||
self.assertEqual(True, lockfuncs.locattr(self.obj2, None, 'locattr', 'test'))
|
||||
self.assertEqual(False, lockfuncs.locattr(self.obj2, None, 'fail', 'testfail'))
|
||||
self.assertEqual(True, lockfuncs.objlocattr(None, self.obj2, 'locattr', 'test'))
|
||||
self.obj2.location.db.locattr = "test"
|
||||
self.assertEqual(True, lockfuncs.locattr(self.obj2, None, "locattr", "test"))
|
||||
self.assertEqual(False, lockfuncs.locattr(self.obj2, None, "fail", "testfail"))
|
||||
self.assertEqual(True, lockfuncs.objlocattr(None, self.obj2, "locattr", "test"))
|
||||
|
||||
def test_tag(self):
|
||||
self.obj2.tags.add("test1")
|
||||
self.obj2.tags.add("test2", "category1")
|
||||
self.assertEqual(True, lockfuncs.tag(self.obj2, None, 'test1'))
|
||||
self.assertEqual(True, lockfuncs.tag(self.obj2, None, 'test2', 'category1'))
|
||||
self.assertEqual(False, lockfuncs.tag(self.obj2, None, 'test1', 'category1'))
|
||||
self.assertEqual(False, lockfuncs.tag(self.obj2, None, 'test1', 'category2'))
|
||||
self.assertEqual(True, lockfuncs.objtag(None, self.obj2, 'test2', 'category1'))
|
||||
self.assertEqual(False, lockfuncs.objtag(None, self.obj2, 'test2'))
|
||||
self.assertEqual(True, lockfuncs.tag(self.obj2, None, "test1"))
|
||||
self.assertEqual(True, lockfuncs.tag(self.obj2, None, "test2", "category1"))
|
||||
self.assertEqual(False, lockfuncs.tag(self.obj2, None, "test1", "category1"))
|
||||
self.assertEqual(False, lockfuncs.tag(self.obj2, None, "test1", "category2"))
|
||||
self.assertEqual(True, lockfuncs.objtag(None, self.obj2, "test2", "category1"))
|
||||
self.assertEqual(False, lockfuncs.objtag(None, self.obj2, "test2"))
|
||||
|
||||
def test_inside_holds(self):
|
||||
self.assertEqual(True, lockfuncs.inside(self.char1, self.room1))
|
||||
|
|
@ -183,7 +186,7 @@ class TestLockfuncs(EvenniaTest):
|
|||
|
||||
@override_settings(IRC_ENABLED=True, TESTVAL=[1, 2, 3])
|
||||
def test_serversetting(self):
|
||||
self.assertEqual(True, lockfuncs.serversetting(None, None, 'IRC_ENABLED', 'True'))
|
||||
self.assertEqual(True, lockfuncs.serversetting(None, None, 'TESTVAL', '[1, 2, 3]'))
|
||||
self.assertEqual(False, lockfuncs.serversetting(None, None, 'TESTVAL', '[1, 2, 4]'))
|
||||
self.assertEqual(False, lockfuncs.serversetting(None, None, 'TESTVAL', '123'))
|
||||
self.assertEqual(True, lockfuncs.serversetting(None, None, "IRC_ENABLED", "True"))
|
||||
self.assertEqual(True, lockfuncs.serversetting(None, None, "TESTVAL", "[1, 2, 3]"))
|
||||
self.assertEqual(False, lockfuncs.serversetting(None, None, "TESTVAL", "[1, 2, 4]"))
|
||||
self.assertEqual(False, lockfuncs.serversetting(None, None, "TESTVAL", "123"))
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue