Remove more unused stuff.

4 files changed, 0 insertions, 142 deletions

diff --git a/repoze/bfg/functional.py b/repoze/bfg/functional.py
index 2b6fb6dbf..cf196ebd8 100644
--- a/repoze/bfg/functional.py
+++ b/repoze/bfg/functional.py
@@ -119,139 +119,3 @@ def wraps(wrapped,
 
 ### End from Python 2.5 functools.py ##########################################
 
-def memoize(func, cache, num_args):
-    """
-    Wrap a function so that results for any argument tuple are stored in
-    'cache'. Note that the args to the function must be usable as dictionary
-    keys.
-
-    Only the first num_args are considered when creating the key.
-    """
-    def wrapper(*args):
-        mem_args = args[:num_args]
-        if mem_args in cache:
-            return cache[mem_args]
-        result = func(*args)
-        cache[mem_args] = result
-        return result
-    return wraps(func)(wrapper)
-
-class Promise(object):
-    """
-    This is just a base class for the proxy class created in
-    the closure of the lazy function. It can be used to recognize
-    promises in code.
-    """
-    pass
-
-def lazy(func, *resultclasses):
-    """
-    Turns any callable into a lazy evaluated callable. You need to give result
-    classes or types -- at least one is needed so that the automatic forcing of
-    the lazy evaluation code is triggered. Results are not memoized; the
-    function is evaluated on every access.
-    """
-    class __proxy__(Promise):
-        """
-        Encapsulate a function call and act as a proxy for methods that are
-        called on the result of that function. The function is not evaluated
-        until one of the methods on the result is called.
-        """
-        __dispatch = None
-
-        def __init__(self, args, kw):
-            self.__func = func
-            self.__args = args
-            self.__kw = kw
-            if self.__dispatch is None:
-                self.__prepare_class__()
-
-        def __prepare_class__(cls):
-            cls.__dispatch = {}
-            for resultclass in resultclasses:
-                cls.__dispatch[resultclass] = {}
-                for (k, v) in resultclass.__dict__.items():
-                    if hasattr(cls, k):
-                        continue
-                    setattr(cls, k, cls.__promise__(resultclass, k, v))
-            cls._delegate_str = str in resultclasses
-            cls._delegate_unicode = unicode in resultclasses
-            assert not (cls._delegate_str and cls._delegate_unicode), "Cannot call lazy() with both str and unicode return types."
-            if cls._delegate_unicode:
-                cls.__unicode__ = cls.__unicode_cast
-            elif cls._delegate_str:
-                cls.__str__ = cls.__str_cast
-        __prepare_class__ = classmethod(__prepare_class__)
-
-        def __promise__(cls, klass, funcname, func):
-            # Builds a wrapper around some magic method and registers that magic
-            # method for the given type and method name.
-            def __wrapper__(self, *args, **kw):
-                # Automatically triggers the evaluation of a lazy value and
-                # applies the given magic method of the result type.
-                res = self.__func(*self.__args, **self.__kw)
-                for t in type(res).mro():
-                    if t in self.__dispatch:
-                        return self.__dispatch[t][funcname](res, *args, **kw)
-                raise TypeError("Lazy object returned unexpected type.")
-
-            if klass not in cls.__dispatch:
-                cls.__dispatch[klass] = {}
-            cls.__dispatch[klass][funcname] = func
-            return __wrapper__
-        __promise__ = classmethod(__promise__)
-
-        def __unicode_cast(self):
-            return self.__func(*self.__args, **self.__kw)
-
-        def __str_cast(self):
-            return str(self.__func(*self.__args, **self.__kw))
-
-        def __cmp__(self, rhs):
-            if self._delegate_str:
-                s = str(self.__func(*self.__args, **self.__kw))
-            elif self._delegate_unicode:
-                s = unicode(self.__func(*self.__args, **self.__kw))
-            else:
-                s = self.__func(*self.__args, **self.__kw)
-            if isinstance(rhs, Promise):
-                return -cmp(rhs, s)
-            else:
-                return cmp(s, rhs)
-
-        def __mod__(self, rhs):
-            if self._delegate_str:
-                return str(self) % rhs
-            elif self._delegate_unicode:
-                return unicode(self) % rhs
-            else:
-                raise AssertionError('__mod__ not supported for non-string types')
-
-        def __deepcopy__(self, memo):
-            # Instances of this class are effectively immutable. It's just a
-            # collection of functions. So we don't need to do anything
-            # complicated for copying.
-            memo[id(self)] = self
-            return self
-
-    def __wrapper__(*args, **kw):
-        # Creates the proxy object, instead of the actual value.
-        return __proxy__(args, kw)
-
-    return wraps(func)(__wrapper__)
-
-def allow_lazy(func, *resultclasses):
-    """
-    A decorator that allows a function to be called with one or more lazy
-    arguments. If none of the args are lazy, the function is evaluated
-    immediately, otherwise a __proxy__ is returned that will evaluate the
-    function when needed.
-    """
-    def wrapper(*args, **kwargs):
-        for arg in list(args) + kwargs.values():
-            if isinstance(arg, Promise):
-                break
-        else:
-            return func(*args, **kwargs)
-        return lazy(func, *resultclasses)(*args, **kwargs)
-    return wraps(func)(wrapper)
diff --git a/repoze/bfg/tests/test_chameleon_genshi.py b/repoze/bfg/tests/test_chameleon_genshi.py
index 9b210e1ad..0833dc72f 100644
--- a/repoze/bfg/tests/test_chameleon_genshi.py
+++ b/repoze/bfg/tests/test_chameleon_genshi.py
@@ -139,8 +139,6 @@ class GetRendererTests(Base, unittest.TestCase):
         from repoze.bfg.interfaces import ITemplateRenderer
         class Dummy:
             template = object()
-            def implementation(self):
-                return self.template
         gsm = getGlobalSiteManager()
         utility = Dummy()
         gsm.registerUtility(utility, ITemplateRenderer, name='foo')
diff --git a/repoze/bfg/tests/test_chameleon_text.py b/repoze/bfg/tests/test_chameleon_text.py
index 992957d0e..49e07a79d 100644
--- a/repoze/bfg/tests/test_chameleon_text.py
+++ b/repoze/bfg/tests/test_chameleon_text.py
@@ -145,8 +145,6 @@ class GetRendererTests(Base, unittest.TestCase):
         from repoze.bfg.interfaces import ITemplateRenderer
         class Dummy:
             template = object()
-            def implementation(self):
-                return self.template
         gsm = getGlobalSiteManager()
         utility = Dummy()
         gsm.registerUtility(utility, ITemplateRenderer, name='foo')
diff --git a/repoze/bfg/tests/test_chameleon_zpt.py b/repoze/bfg/tests/test_chameleon_zpt.py
index 088930069..bd2c67cc9 100644
--- a/repoze/bfg/tests/test_chameleon_zpt.py
+++ b/repoze/bfg/tests/test_chameleon_zpt.py
@@ -142,8 +142,6 @@ class GetRendererTests(Base, unittest.TestCase):
         from repoze.bfg.interfaces import ITemplateRenderer
         class Dummy:
             template = object()
-            def implementation(self):
-                return self.template
         gsm = getGlobalSiteManager()
         utility = Dummy()
         gsm.registerUtility(utility, ITemplateRenderer, name='foo')