From 3848a789a76a61f3a066fa5996291afeb84885a8 Mon Sep 17 00:00:00 2001
From: Griatch <griatch@gmail.com>
Date: Mon, 21 Apr 2014 00:24:33 +0200
Subject: [PATCH] Changed lockhandler.add/replace to use LockExceptions instead
 of log_obj, which should also work more flexibly for handling lock errors for
 players. Resolves #410.

---
 src/commands/default/building.py    |  6 +++++-
 src/locks/lockhandler.py            | 28 +++++++++-------------------
 src/tests/test_locks_lockhandler.py |  4 ++--
 3 files changed, 16 insertions(+), 22 deletions(-)

diff --git a/src/commands/default/building.py b/src/commands/default/building.py
index fe7d11c16..3de477c2c 100644
--- a/src/commands/default/building.py
+++ b/src/commands/default/building.py
@@ -8,6 +8,7 @@ from django.conf import settings
 from src.objects.models import ObjectDB
 from src.utils import create, utils, search
 from src.utils.ansi import raw
+from src.locks.lockhandler import LockException
 from src.commands.default.muxcommand import MuxCommand
 from src.commands.cmdhandler import get_and_merge_cmdsets
 
@@ -1555,7 +1556,10 @@ class CmdLock(ObjManipCommand):
             if not obj.access(caller, 'control'):
                 caller.msg("You are not allowed to do that.")
                 return
-            ok = obj.locks.add(lockdef, caller)
+            try:
+                ok = obj.locks.add(lockdef)
+            except LockException, e:
+                caller.msg(str(e))
             if ok:
                 caller.msg("Added lock '%s' to %s." % (lockdef, obj))
             return
diff --git a/src/locks/lockhandler.py b/src/locks/lockhandler.py
index 992ba051a..9f90348bf 100644
--- a/src/locks/lockhandler.py
+++ b/src/locks/lockhandler.py
@@ -115,7 +115,8 @@ __all__ = ("LockHandler", "LockException")
 
 
 #
-# Exception class
+# Exception class. This will be raised
+# by errors in lock definitions.
 #
 
 class LockException(Exception):
@@ -171,7 +172,6 @@ class LockHandler(object):
             _cache_lockfuncs()
         self.obj = obj
         self.locks = {}
-        self.log_obj = None
         self.reset()
 
     def __str__(self):
@@ -179,12 +179,7 @@ class LockHandler(object):
 
     def _log_error(self, message):
         "Try to log errors back to object"
-        if self.log_obj and hasattr(self.log_obj, 'msg'):
-            self.log_obj.msg(message)
-        elif hasattr(self.obj, 'msg'):
-            self.obj.msg(message)
-        else:
-            logger.log_errmsg("%s: %s" % (self.obj, message))
+        raise LockException(message)
 
     def _parse_lockstring(self, storage_lockstring):
         """
@@ -240,10 +235,9 @@ class LockHandler(object):
                 wlist.append(_("Lock: access type '%(access_type)s' changed from '%(source)s' to '%(goal)s' " % \
                                  {"access_type":access_type, "source":locks[access_type][2], "goal":raw_lockstring}))
             locks[access_type] = (evalstring, tuple(lock_funcs), raw_lockstring)
-        if wlist and self.log_obj:
+        if wlist:
             # a warning text was set, it's not an error, so only report
-            # if log_obj is available.
-            self._log_error("\n".join(wlist))
+            logger.log_warn("\n".join(wlist))
         if elist:
             # an error text was set, raise exception.
             raise LockException("\n".join(elist))
@@ -269,15 +263,12 @@ class LockHandler(object):
         """
         self.lock_bypass = hasattr(obj, "is_superuser") and obj.is_superuser
 
-    def add(self, lockstring, log_obj=None):
+    def add(self, lockstring):
         """
         Add a new lockstring on the form '<access_type>:<functions>'. Multiple
         access types should be separated by semicolon (;).
 
-        If log_obj is given, it will be fed error information.
         """
-        if log_obj:
-            self.log_obj = log_obj
         # sanity checks
         for lockdef in lockstring.split(';'):
             if not ':' in lockstring:
@@ -302,17 +293,16 @@ class LockHandler(object):
         # cache the locks will get rid of eventual doublets
         self._cache_locks(storage_lockstring)
         self._save_locks()
-        self.log_obj = None
         return True
 
-    def replace(self, lockstring, log_obj=None):
+    def replace(self, lockstring):
         "Replaces the lockstring entirely."
         old_lockstring = str(self)
         self.clear()
         try:
-            return self.add(lockstring, log_obj)
+            return self.add(lockstring)
         except LockException:
-            self.add(old_lockstring, log_obj)
+            self.add(old_lockstring)
             raise
 
     def get(self, access_type=None):
diff --git a/src/tests/test_locks_lockhandler.py b/src/tests/test_locks_lockhandler.py
index e9e209aa2..93a87b9d2 100644
--- a/src/tests/test_locks_lockhandler.py
+++ b/src/tests/test_locks_lockhandler.py
@@ -12,7 +12,7 @@ class TestLockHandler(unittest.TestCase):
 
     def test_add(self):
         # lock_handler = LockHandler(obj)
-        # self.assertEqual(expected, lock_handler.add(lockstring, log_obj))
+        # self.assertEqual(expected, lock_handler.add(lockstring))
         assert True # TODO: implement your test here
 
     def test_cache_lock_bypass(self):
@@ -47,7 +47,7 @@ class TestLockHandler(unittest.TestCase):
 
     def test_replace(self):
         # lock_handler = LockHandler(obj)
-        # self.assertEqual(expected, lock_handler.replace(lockstring, log_obj))
+        # self.assertEqual(expected, lock_handler.replace(lockstring))
         assert True # TODO: implement your test here
 
     def test_reset(self):