More changes to the extended modeling

Author: agjohnson

readthedocs/builds/models.py

@@ -12,8 +12,8 @@
 from taggit.managers import TaggableManager
 
 from readthedocs.core.utils import broadcast
-from readthedocs.privacy.loader import (VersionManager, RelatedBuildManager,
-                                        BuildManager)
+from readthedocs.privacy.backend import VersionQuerySet, VersionManager
+from readthedocs.privacy.loader import RelatedBuildManager, BuildManager
 from readthedocs.projects.models import Project
 from readthedocs.projects.constants import (PRIVACY_CHOICES, GITHUB_URL,
                                             GITHUB_REGEXS, BITBUCKET_URL,
@@ -69,7 +69,8 @@ class Version(models.Model):
     )
     tags = TaggableManager(blank=True)
     machine = models.BooleanField(_('Machine Created'), default=False)
-    objects = VersionManager()
+
+    objects = VersionManager.from_queryset(VersionQuerySet)()
 
     class Meta:
         unique_together = [('project', 'slug')]

readthedocs/core/utils/extend.py

@@ -6,6 +6,28 @@
 from django.utils.module_loading import import_by_path
 
 
+def get_override_class(proxy_class, default_class):
+    class_id = '.'.join([
+        inspect.getmodule(proxy_class).__name__,
+        proxy_class.__name__
+    ])
+    class_path = getattr(settings, 'CLASS_OVERRIDES', {}).get(class_id)
+    if class_path is None and proxy_class._override_setting is not None:
+        class_path = getattr(settings, proxy_class._override_setting, None)
+    if class_path is not None:
+        default_class = import_by_path(class_path)
+    return default_class
+
+
+class SettingsOverrideMeta(type):
+
+    """Meta class for passing along classmethod class to the underlying class"""
+
+    def __getattr__(cls, attr):
+        proxy_class = getattr(cls, '_default_class')
+        return getattr(proxy_class, attr)
+
+
 class SettingsOverrideObject(object):
 
     """Base class for creating class that can be overridden
@@ -29,25 +51,15 @@ class without monkey patching it. This abstract class allows for lazy
     attempt to pull the key :py:cvar:`_override_setting` from ``settings``.
     """
 
+    __metaclass__ = SettingsOverrideMeta
+
     _default_class = None
     _override_setting = None
 
     def __new__(cls, *args, **kwargs):
         """Set up wrapped object
 
-        This is called when attributes are accessed on :py:class:`LazyObject`
-        and the underlying wrapped object does not yet exist.
+        Create an instance of the underlying proxy class and return instead of
+        this class.
         """
-        cls_new = cls._default_class
-        cls_path = (getattr(settings, 'CLASS_OVERRIDES', {})
-                    .get(cls._get_class_id()))
-        if cls_path is None and cls._override_setting is not None:
-            cls_path = getattr(settings, cls._override_setting, None)
-        if cls_path is not None:
-            cls_new = import_by_path(cls_path)
-        return cls_new(*args, **kwargs)
-
-    @classmethod
-    def _get_class_id(cls):
-        # type() here, because LazyObject overrides some attribute access
-        return '.'.join([inspect.getmodule(cls).__name__, cls.__name__])
+        return get_override_class(cls, cls._default_class)(*args, **kwargs)

readthedocs/privacy/backend.py

@@ -1,3 +1,4 @@
+import logging
 
 from django.db import models
 
@@ -9,8 +10,11 @@
 from readthedocs.builds.constants import LATEST_VERBOSE_NAME
 from readthedocs.builds.constants import STABLE
 from readthedocs.builds.constants import STABLE_VERBOSE_NAME
+from readthedocs.core.utils.extend import (SettingsOverrideObject,
+                                           get_override_class)
 from readthedocs.projects import constants
 
+log = logging.getLogger(__name__)
 
 class ProjectManager(models.Manager):
 
@@ -75,6 +79,47 @@ def api(self, user=None):
 
 class VersionManager(models.Manager):
 
+    """Version manager for manager only queries
+
+    For queries not suitable for the :py:cls:`VersionQuerySet`, such as create
+    queries.
+    """
+
+    @classmethod
+    def from_queryset(cls, queryset_class, class_name=None):
+        queryset_class = get_override_class(
+            VersionQuerySet,
+            VersionQuerySet._default_class
+        )
+        return super(VersionManager, cls).from_queryset(queryset_class, class_name)
+
+    def create_stable(self, **kwargs):
+        defaults = {
+            'slug': STABLE,
+            'verbose_name': STABLE_VERBOSE_NAME,
+            'machine': True,
+            'active': True,
+            'identifier': STABLE,
+            'type': TAG,
+        }
+        defaults.update(kwargs)
+        return self.create(**defaults)
+
+    def create_latest(self, **kwargs):
+        defaults = {
+            'slug': LATEST,
+            'verbose_name': LATEST_VERBOSE_NAME,
+            'machine': True,
+            'active': True,
+            'identifier': LATEST,
+            'type': BRANCH,
+        }
+        defaults.update(kwargs)
+        return self.create(**defaults)
+
+
+class VersionQuerySetBase(models.QuerySet):
+
     """
     Versions take into account their own privacy_level setting.
     """
@@ -83,7 +128,7 @@ class VersionManager(models.Manager):
 
     def _add_user_repos(self, queryset, user):
         if user.has_perm('builds.view_version'):
-            return self.get_queryset().all().distinct()
+            return self.all().distinct()
         if user.is_authenticated():
             user_queryset = get_objects_for_user(user, 'builds.view_version')
             queryset = user_queryset | queryset
@@ -122,30 +167,6 @@ def private(self, user=None, project=None, only_active=True):
     def api(self, user=None):
         return self.public(user, only_active=False)
 
-    def create_stable(self, **kwargs):
-        defaults = {
-            'slug': STABLE,
-            'verbose_name': STABLE_VERBOSE_NAME,
-            'machine': True,
-            'active': True,
-            'identifier': STABLE,
-            'type': TAG,
-        }
-        defaults.update(kwargs)
-        return self.create(**defaults)
-
-    def create_latest(self, **kwargs):
-        defaults = {
-            'slug': LATEST,
-            'verbose_name': LATEST_VERBOSE_NAME,
-            'machine': True,
-            'active': True,
-            'identifier': LATEST,
-            'type': BRANCH,
-        }
-        defaults.update(kwargs)
-        return self.create(**defaults)
-
     def for_project(self, project):
         """Return all versions for a project, including translations"""
         return self.filter(
@@ -154,6 +175,11 @@ def for_project(self, project):
         )
 
 
+class VersionQuerySet(SettingsOverrideObject):
+
+    _default_class = VersionQuerySetBase
+
+
 class BuildManager(models.Manager):
 
     """

readthedocs/privacy/loader.py

@@ -5,9 +5,7 @@
 ProjectManager = import_by_path(
     getattr(settings, 'PROJECT_MANAGER',
             'readthedocs.privacy.backend.ProjectManager'))
-VersionManager = import_by_path(
-    getattr(settings, 'VERSION_MANAGER',
-            'readthedocs.privacy.backend.VersionManager'))
+# VersionQuerySet was replaced by SettingsOverrideObject
 BuildManager = import_by_path(
     getattr(settings, 'BUILD_MANAGER',
             'readthedocs.privacy.backend.BuildManager'))

readthedocs/rtd_tests/tests/test_extend.py

@@ -1,6 +1,7 @@
 from django.test import TestCase, override_settings
 
-from readthedocs.core.utils.extend import SettingsOverrideObject
+from readthedocs.core.utils.extend import (SettingsOverrideObject,
+                                           get_override_class)
 
 
 # Top level to ensure module name is correct
@@ -29,10 +30,12 @@ class Foo(SettingsOverrideObject):
             _override_setting = 'FOO_OVERRIDE_CLASS'
 
         foo = Foo()
-        self.assertEqual(foo._get_class_id(), EXTEND_PATH)
         self.assertEqual(foo.__class__.__name__, 'FooBase')
         self.assertEqual(foo.bar(), 1)
 
+        override_class = get_override_class(Foo, Foo._default_class)
+        self.assertEqual(override_class, FooBase)
+
     @override_settings(FOO_OVERRIDE_CLASS=EXTEND_OVERRIDE_PATH)
     def test_with_basic_override(self):
         """Test class override setting defined"""
@@ -41,10 +44,12 @@ class Foo(SettingsOverrideObject):
             _override_setting = 'FOO_OVERRIDE_CLASS'
 
         foo = Foo()
-        self.assertEqual(foo._get_class_id(), EXTEND_PATH)
         self.assertEqual(foo.__class__.__name__, 'NewFoo')
         self.assertEqual(foo.bar(), 2)
 
+        override_class = get_override_class(Foo, Foo._default_class)
+        self.assertEqual(override_class, NewFoo)
+
     @override_settings(FOO_OVERRIDE_CLASS=None,
                        CLASS_OVERRIDES={
                            EXTEND_PATH: EXTEND_OVERRIDE_PATH,
@@ -56,10 +61,12 @@ class Foo(SettingsOverrideObject):
             _override_setting = 'FOO_OVERRIDE_CLASS'
 
         foo = Foo()
-        self.assertEqual(foo._get_class_id(), EXTEND_PATH)
         self.assertEqual(foo.__class__.__name__, 'NewFoo')
         self.assertEqual(foo.bar(), 2)
 
+        override_class = get_override_class(Foo, Foo._default_class)
+        self.assertEqual(override_class, NewFoo)
+
     @override_settings(FOO_OVERRIDE_CLASS=None,
                        CLASS_OVERRIDES={
                            EXTEND_PATH: EXTEND_OVERRIDE_PATH,
@@ -70,6 +77,8 @@ class Foo(SettingsOverrideObject):
             _default_class = FooBase
 
         foo = Foo()
-        self.assertEqual(foo._get_class_id(), EXTEND_PATH)
         self.assertEqual(foo.__class__.__name__, 'NewFoo')
         self.assertEqual(foo.bar(), 2)
+
+        override_class = get_override_class(Foo, Foo._default_class)
+        self.assertEqual(override_class, NewFoo)