Context Navigation

Ticket #6897: newstyle.diff

File newstyle.diff, 9.0 KB (added by Brodie Rao, 17 years ago)
Patch replacing old-style classes with new-style classes

     ])
     return '\r\n'.join(lines)
 class Client:
+class Client(object):
     """
     A class that can act as a client for testing purposes.

 from django.utils.encoding import smart_unicode, force_unicode, smart_str
 from django.utils.maxlength import LegacyMaxlength
 class NOT_PROVIDED:
+class NOT_PROVIDED(object):
     pass
 # Values for filter_interface.

 # This is an extra debug layer over MySQL queries, to display warnings.
 # It's only used when DEBUG=True.
 class MysqlDebugWrapper:
+class MysqlDebugWrapper(object):
     def __init__(self, cursor):
         self.cursor = cursor
 …
             raise Database.Warning("%s: %s" % (w, self.cursor.fetchall()))
     def __getattr__(self, attr):
+        if attr in self.__dict__:
+            return self.__dict__[attr]
+        else:
+            return getattr(self.cursor, attr)
+        return getattr(self.cursor, attr)
 class DatabaseFeatures(BaseDatabaseFeatures):
     autoindexes_primary_keys = False

 # This light wrapper "fakes" a dictionary interface, because some SQLite data
 # types include variables in them -- e.g. "varchar(30)" -- and can't be matched
 # as a simple dictionary lookup.
 class FlexibleFieldLookupDict:
+class FlexibleFieldLookupDict(object):
     def __getitem__(self, key):
         key = key.lower()
         try:

                 {{ option.field }} {{ option.label }}<br />
             {% endfor %}
         """
         class RadioFieldRenderer:
+        class RadioFieldRenderer(object):
             def __init__(self, datalist, ul_class):
                 self.datalist, self.ul_class = datalist, ul_class
             def __unicode__(self):

 from django.core.management.color import color_style
 from django.utils.itercompat import is_iterable
 class ModelErrorCollection:
+class ModelErrorCollection(object):
     def __init__(self, outfile=sys.stdout):
         self.errors = []
         self.outfile = outfile

     """Returns a Style object with the Django color scheme."""
     if not supports_color():
         return no_style()
+    class dummy: pass
+    class dummy(object):
+        pass
     style = dummy()
     style.ERROR = termcolors.make_style(fg='red', opts=('bold',))
     style.ERROR_OUTPUT = termcolors.make_style(fg='red', opts=('bold',))
 …
 def no_style():
     """Returns a Style object that has no colors."""
     class dummy:
+    class dummy(object):
         def __getattr__(self, attr):
             return lambda x: x
     return dummy()

     is equally fast, but not 100% reliable because functions can be stored on an
     attribute named differenty than the function's name such as in:
     class A: pass
+    class A(object): pass
     def foo(self): return "foo"
     A.bar = foo

 __version__ = "$Revision: 1.9 $"[11:-2]
 class _Parameter:
+class _Parameter(object):
     """Used to represent default parameter values."""
     def __repr__(self):
         return self.__class__.__name__

 except ImportError:
     # Python was compiled without threads; create a mock object instead
     import sys
     class MockThreading:
+    class MockThreading(object):
         def local(self, sys=sys):
             return sys.modules[__name__]
     threading = MockThreading()

         else:
             sys.stdout = NullDevice()
     class NullDevice:
+    class NullDevice(object):
         "A writeable object that writes to nowhere -- like /dev/null."
         def write(self, s):
             pass

 except ImportError:
     import dummy_threading as threading
 class RWLock:
+class RWLock(object):
     """
     Classic implementation of reader-writer lock with preference to writers.

         context[self.var_name] = comment_list
         return ''
 class DoCommentForm:
+class DoCommentForm(object):
     """
     Displays a comment form for the given params.
 …
                     raise template.TemplateSyntaxError, "%r tag got invalid parameter '%s'" % (tokens[0], option)
         return CommentFormNode(content_type, obj_id_lookup_var, obj_id, self.free, **kwargs)
 class DoCommentCount:
+class DoCommentCount(object):
     """
     Gets comment count for the given params and populates the template context
     with a variable containing that value, whose name is defined by the 'as'
 …
             raise template.TemplateSyntaxError, "Fourth argument in %r must be 'as'" % tokens[0]
         return CommentCountNode(package, module, var_name, obj_id, tokens[5], self.free)
 class DoGetCommentList:
+class DoGetCommentList(object):
     """
     Gets comments for the given params and populates the template context with a
     special comment_package variable, whose name is defined by the ``as``

     params = urllib.urlencode({'sitemap':url})
     urllib.urlopen("%s?%s" % (ping_url, params))
 class Sitemap:
+class Sitemap(object):
     def __get(self, name, obj, default=None):
         try:
             attr = getattr(self, name)

             context[self.varname] = LogEntry.objects.filter(user__id__exact=self.user).select_related()[:self.limit]
         return ''
 class DoGetAdminLog:
+class DoGetAdminLog(object):
     """
     Populates a template variable with the admin log for the given criteria.

                     return self.nodelist_false.render(context)
             return self.nodelist_true.render(context)
     class LinkTypes:
+    class LinkTypes(object):
         and_ = 0,
         or_ = 1