From 0cb7efa8e7d3e23b843df7ca95696bcccb896b56 Mon Sep 17 00:00:00 2001
From: Jeff Forcier <jeff@bitprophet.org>
Date: Tue, 22 May 2012 13:45:29 -0700
Subject: [PATCH] Attempt at refactoring. Meh.

---
 lexicon/alias_dict.py | 91 +++++++++++++++++++++++--------------------
 1 file changed, 49 insertions(+), 42 deletions(-)

diff --git a/lexicon/alias_dict.py b/lexicon/alias_dict.py
index 69c2aac..58dab04 100644
--- a/lexicon/alias_dict.py
+++ b/lexicon/alias_dict.py
@@ -9,56 +9,63 @@ def alias(self, from_, to):
     def unalias(self, from_):
         del self.aliases[from_]
 
-    def _single(self, key):
-        return isinstance(key, basestring)
-
-    def __setitem__(self, key, value):
+    def _handle(self, key, value, single, multi, unaliased):
         # Attribute existence test required to not blow up when deepcopy'd
         if hasattr(self, 'aliases') and key in self.aliases:
             target = self.aliases[key]
-            # Single-string targets => direct update
-            if self._single(target):
-                self[target] = value
-            # Multi-string targets => update all
+            # Single-string targets
+            if isinstance(target, basestring):
+                return single(self, target, value)
+            # Multi-string targets
             else:
-                for subkey in self.aliases[key]:
-                    self[subkey] = value
+                return multi(self, target, value)
         else:
-            return super(AliasDict, self).__setitem__(key, value)
+            return unaliased(self, key, value)
+
+    def _single(self, target):
+        return isinstance(target, basestring)
+
+    def __setitem__(self, key, value):
+        def single(d, target, value): d[target] = value
+
+        def multi(d, target, value):
+            for subkey in target:
+                d[subkey] = value
+
+        def unaliased(d, key, value): super(AliasDict, d).__setitem__(key, value)
+
+        return self._handle(key, value, single, multi, unaliased)
 
     def __getitem__(self, key):
-        if hasattr(self, 'aliases') and key in self.aliases:
-            target = self.aliases[key]
-            # Single-string targets => go ahead
-            if self._single(target):
-                return self[target]
-            # Multi-string targets => invalid/undefined
-            else:
-                raise ValueError("Multi-target aliases have no well-defined value and can't be read.")
-        else:
-            return super(AliasDict, self).__getitem__(key)
+        def single(d, target, value): return d[target]
+
+        def multi(d, target, value):
+            msg = "Multi-target aliases have no well-defined value and can't be read."
+            raise ValueError(msg)
+
+        def unaliased(d, key, value): return super(AliasDict, d).__getitem__(key)
+
+        return self._handle(key, None, single, multi, unaliased)
 
     def __contains__(self, key):
-        if hasattr(self, 'aliases') and key in self.aliases:
-            target = self.aliases[key]
-            # Single-string targets => return whether target exists
-            if self._single(target):
-                return target in self
-            # Multi-string targets => return whether all targets exist
-            else:
-                return all(subkey in self for subkey in self.aliases[key])
-        else:
-            return super(AliasDict, self).__contains__(key)
+        def single(d, target, value): return target in d
+
+        def multi(d, target, value):
+            return all(subkey in self for subkey in self.aliases[key])
+
+        def unaliased(d, key, value):
+            return super(AliasDict, d).__contains__(key)
+
+        return self._handle(key, None, single, multi, unaliased)
 
     def __delitem__(self, key):
-        if hasattr(self, 'aliases') and key in self.aliases:
-            target = self.aliases[key]
-            # Single-string targets => direct update
-            if self._single(target):
-                del self[target]
-            # Multi-string targets => update all
-            else:
-                for subkey in self.aliases[key]:
-                    del self[subkey]
-        else:
-            return super(AliasDict, self).__delitem__(key)
+        def single(d, target, value): del d[target]
+
+        def multi(d, target, value):
+            for subkey in self.aliases[key]:
+                del self[subkey]
+
+        def unaliased(d, key, value):
+            return super(AliasDict, d).__delitem__(key)
+
+        return self._handle(key, None, single, multi, unaliased)