Fixed signals implementation

tests were breaking

Fixed signals implementation
tests were breaking
Sergio Oliveira
1 parent c30d7a00
Showing 5 changed files with 38 additions and 30 deletions Show diff stats
colab/__init__.py
colab/plugins/__init__.py
colab/plugins/apps.py
colab/plugins/utils/apps.py
colab/plugins/utils/signals.py
 from __future__ import absolute_import
  
+from . import plugins
+
 # This will make sure the app is always imported when
 # Django starts so that shared_task will use this app.
 from .celery import app as celery_app  # noqa
+
@@ -0,0 +1,2 @@
+
+default_app_config = 'colab.plugins.apps.PluginAppConfig'
@@ -0,0 +1,12 @@
+
+from django.apps import AppConfig
+
+from .utils.signals import connect_signal, register_signal
+
+
+class PluginAppConfig(AppConfig):
+    name = 'colab.plugins'
+
+    def ready(self):
+        register_signal()
+        connect_signal()
-import importlib
-import inspect
  
 from django.apps import AppConfig
-from colab.plugins.utils.signals import AbstractSignal
  
  
 class ColabProxiedAppConfig(AppConfig):
     colab_proxied_app = True
  
-    def __init__(self, app_name, app_module):
-        super(ColabProxiedAppConfig, self).__init__(app_name, app_module)
-        self._import_signals(app_name)
-        self.signals.register_signal()
+    def register_signals(self):
+        pass
  
-    def _import_signals(self, app_name):
-        self.module_path = app_name + '.signals'
-        self.module = importlib.import_module(self.module_path)
-
-        for module_item_name in dir(self.module):
-            module_item = getattr(self.module, module_item_name)
-            if not inspect.isclass(module_item):
-                continue
-            if issubclass(module_item, AbstractSignal):
-                if module_item != AbstractSignal:
-                    self.signals = module_item()
-                    break
-
-    def ready(self):
-        self.signals.connect_signal()
+    def connect_signals(self):
+        pass
  
-from abc import abstractmethod
+from django.apps import apps
  
  
-class AbstractSignal(object):
+def _init_signals(method_name):
+    for app in apps.get_app_configs():
+        # Try to get the method with `method_name`.
+        #   If it exists call it using `app` as the first parameter.
+        #   This is required because methods take `self` as first
+        #   parameter and as we are calling it as a function python
+        #   won't send it explicitly.
+        # If the method doesn't exist we return a dummy function that
+        #   won't do anything.
+        getattr(app, method_name, lambda x: None)(app)
  
-    @abstractmethod
-    def register_signal(self):
-        raise NotImplementedError
  
-    @abstractmethod
-    def connect_signal(self):
-        raise NotImplementedError
+def register_signal():
+    _init_signals('register_signal')
+
+
+def connect_signal():
+    _init_signals('connect_signal')
1	1	from __future__ import absolute_import
2	2
	3	+from . import plugins
	4	+
3	5	# This will make sure the app is always imported when
4	6	# Django starts so that shared_task will use this app.
5	7	from .celery import app as celery_app # noqa
	8	+
...	...
...	...	@@ -0,0 +1,2 @@
	1	+
	2	+default_app_config = 'colab.plugins.apps.PluginAppConfig'
...	...
...	...	@@ -0,0 +1,12 @@
	1	+
	2	+from django.apps import AppConfig
	3	+
	4	+from .utils.signals import connect_signal, register_signal
	5	+
	6	+
	7	+class PluginAppConfig(AppConfig):
	8	+ name = 'colab.plugins'
	9	+
	10	+ def ready(self):
	11	+ register_signal()
	12	+ connect_signal()
...	...
1		-import importlib
2		-import inspect
3	1
4	2	from django.apps import AppConfig
5		-from colab.plugins.utils.signals import AbstractSignal
6	3
7	4
8	5	class ColabProxiedAppConfig(AppConfig):
9	6	colab_proxied_app = True
10	7
11		- def __init__(self, app_name, app_module):
12		- super(ColabProxiedAppConfig, self).__init__(app_name, app_module)
13		- self._import_signals(app_name)
14		- self.signals.register_signal()
	8	+ def register_signals(self):
	9	+ pass
15	10
16		- def _import_signals(self, app_name):
17		- self.module_path = app_name + '.signals'
18		- self.module = importlib.import_module(self.module_path)
19		-
20		- for module_item_name in dir(self.module):
21		- module_item = getattr(self.module, module_item_name)
22		- if not inspect.isclass(module_item):
23		- continue
24		- if issubclass(module_item, AbstractSignal):
25		- if module_item != AbstractSignal:
26		- self.signals = module_item()
27		- break
28		-
29		- def ready(self):
30		- self.signals.connect_signal()
	11	+ def connect_signals(self):
	12	+ pass
...	...
1	1
2		-from abc import abstractmethod
	2	+from django.apps import apps
3	3
4	4
5		-class AbstractSignal(object):
	5	+def _init_signals(method_name):
	6	+ for app in apps.get_app_configs():
	7	+ # Try to get the method with `method_name`.
	8	+ # If it exists call it using `app` as the first parameter.
	9	+ # This is required because methods take `self` as first
	10	+ # parameter and as we are calling it as a function python
	11	+ # won't send it explicitly.
	12	+ # If the method doesn't exist we return a dummy function that
	13	+ # won't do anything.
	14	+ getattr(app, method_name, lambda x: None)(app)
6	15
7		- @abstractmethod
8		- def register_signal(self):
9		- raise NotImplementedError
10	16
11		- @abstractmethod
12		- def connect_signal(self):
13		- raise NotImplementedError
	17	+def register_signal():
	18	+ _init_signals('register_signal')
	19	+
	20	+
	21	+def connect_signal():
	22	+ _init_signals('connect_signal')
...	...