Move new dajaxice into place.

 - Legacy-Id: 7623

Author: levkowetz

dajaxice/__init__.py

@@ -0,0 +1 @@
+__version__ = (0, 5, 5, 'beta')

dajaxice/core/Dajaxice.py

@@ -0,0 +1,137 @@
+import logging
+
+from django.utils.importlib import import_module
+
+log = logging.getLogger('dajaxice')
+
+
+class DajaxiceFunction(object):
+    """ Basic representation of a dajaxice ajax function."""
+
+    def __init__(self, function, name, method):
+        self.function = function
+        self.name = name
+        self.method = method
+
+    def call(self, *args, **kwargs):
+        """ Call the function. """
+        return self.function(*args, **kwargs)
+
+
+class DajaxiceModule(object):
+    """ Basic representation of a dajaxice module. """
+
+    def __init__(self, name=None):
+        self.name = name
+        self.functions = {}
+        self.submodules = {}
+
+    def add(self, name, function):
+        """ Add this function at the ``name`` deep. If the submodule already
+        exists, recusively call the add method into the submodule. If not,
+        create the module and call the add method."""
+
+        # If this is not the final function name (there are more modules)
+        # split the name again an register a new submodule.
+        if '.' in name:
+            module, extra = name.split('.', 1)
+            if module not in self.submodules:
+                self.submodules[module] = DajaxiceModule(module)
+            self.submodules[module].add(extra, function)
+        else:
+            self.functions[name] = function
+
+
+class Dajaxice(object):
+
+    def __init__(self):
+        self._registry = {}
+        self._modules = None
+
+    def register(self, function, name=None, method='POST'):
+        """
+        Register this function as a dajaxice function.
+
+        If no name is provided, the module and the function name will be used.
+        The final (customized or not) must be unique. """
+
+        method = self.clean_method(method)
+
+        # Generate a default name
+        if not name:
+            module = ''.join(str(function.__module__).rsplit('.ajax', 1))
+            name = '.'.join((module, function.__name__))
+
+        if ':' in name:
+            log.error('Ivalid function name %s.' % name)
+            return
+
+        # Check for already registered functions
+        if name in self._registry:
+            log.error('%s was already registered.' % name)
+            return
+
+        # Create the dajaxice function.
+        function = DajaxiceFunction(function=function,
+                                    name=name,
+                                    method=method)
+
+        # Register this new ajax function
+        self._registry[name] = function
+
+    def is_callable(self, name, method):
+        """ Return if the function callable or not. """
+        return name in self._registry and self._registry[name].method == method
+
+    def clean_method(self, method):
+        """ Clean the http method. """
+        method = method.upper()
+        if method not in ['GET', 'POST']:
+            method = 'POST'
+        return method
+
+    def get(self, name):
+        """ Return the dajaxice function."""
+        return self._registry[name]
+
+    @property
+    def modules(self):
+        """ Return an easy to loop module hierarchy with all the functions."""
+        if not self._modules:
+            self._modules = DajaxiceModule()
+            for name, function in self._registry.items():
+                self._modules.add(name, function)
+        return self._modules
+
+LOADING_DAJAXICE = False
+
+
+def dajaxice_autodiscover():
+    """
+    Auto-discover INSTALLED_APPS ajax.py modules and fail silently when
+    not present. NOTE: dajaxice_autodiscover was inspired/copied from
+    django.contrib.admin autodiscover
+    """
+    global LOADING_DAJAXICE
+    if LOADING_DAJAXICE:
+        return
+    LOADING_DAJAXICE = True
+
+    import imp
+    from django.conf import settings
+
+    for app in settings.INSTALLED_APPS:
+
+        try:
+            app_path = import_module(app).__path__
+        except AttributeError:
+            continue
+
+        try:
+            imp.find_module('ajax', app_path)
+        except ImportError:
+            continue
+
+        import_module("%s.ajax" % app)
+
+    LOADING_DAJAXICE = False

dajaxice/core/__init__.py

@@ -0,0 +1,38 @@
+from django.conf import settings
+
+from Dajaxice import Dajaxice, dajaxice_autodiscover
+
+
+class DajaxiceConfig(object):
+    """ Provide an easy to use way to read the dajaxice configuration and
+    return the default values if no configuration is present."""
+
+    default_config = {'DAJAXICE_XMLHTTPREQUEST_JS_IMPORT': True,
+                      'DAJAXICE_JSON2_JS_IMPORT': True,
+                      'DAJAXICE_EXCEPTION': 'DAJAXICE_EXCEPTION',
+                      'DAJAXICE_MEDIA_PREFIX': 'dajaxice'}
+
+    def __getattr__(self, name):
+        """ Return the customized value for a setting (if it exists) or the
+        default value if not. """
+
+        if name in self.default_config:
+            if hasattr(settings, name):
+                return getattr(settings, name)
+            return self.default_config.get(name)
+        return None
+
+    @property
+    def dajaxice_url(self):
+        return r'^%s/' % self.DAJAXICE_MEDIA_PREFIX
+
+    @property
+    def django_settings(self):
+        return settings
+
+    @property
+    def modules(self):
+        return dajaxice_functions.modules
+
+dajaxice_functions = Dajaxice()
+dajaxice_config = DajaxiceConfig()

dajaxice/decorators.py

@@ -0,0 +1,48 @@
+import functools
+
+from dajaxice.core import dajaxice_functions
+
+
+def dajaxice_register(*dargs, **dkwargs):
+    """ Register some function as a dajaxice function
+
+    For legacy purposes, if only a function is passed register it a simple
+    single ajax function using POST, i.e:
+
+    @dajaxice_register
+    def ajax_function(request):
+        ...
+
+    After 0.5, dajaxice allow to customize the http method and the final name
+    of the registered function. This decorator covers both the legacy and
+    the new functionality, i.e:
+
+    @dajaxice_register(method='GET')
+    def ajax_function(request):
+        ...
+
+    @dajaxice_register(method='GET', name='my.custom.name')
+    def ajax_function(request):
+        ...
+
+    You can also register the same function to use a different http method
+    and/or use a different name.
+
+    @dajaxice_register(method='GET', name='users.get')
+    @dajaxice_register(method='POST', name='users.update')
+    def ajax_function(request):
+        ...
+    """
+
+    if len(dargs) and not dkwargs:
+        function = dargs[0]
+        dajaxice_functions.register(function)
+        return function
+
+    def decorator(function):
+        @functools.wraps(function)
+        def wrapper(request, *args, **kwargs):
+            return function(request, *args, **kwargs)
+        dajaxice_functions.register(function, *dargs, **dkwargs)
+        return wrapper
+    return decorator

dajaxice/exceptions.py

@@ -0,0 +1,10 @@
+class DajaxiceError(Exception):
+    pass
+
+
+class FunctionNotCallableError(DajaxiceError):
+    pass
+
+
+class DajaxiceImportError(DajaxiceError):
+    pass

dajaxice/finders.py

@@ -0,0 +1,75 @@
+import os
+import tempfile
+
+from django.contrib.staticfiles import finders
+from django.template import Context
+from django.template.loader import get_template
+from django.core.exceptions import SuspiciousOperation
+
+
+class VirtualStorage(finders.FileSystemStorage):
+    """" Mock a FileSystemStorage to build tmp files on demand."""
+
+    def __init__(self, *args, **kwargs):
+        self._files_cache = {}
+        super(VirtualStorage, self).__init__(*args, **kwargs)
+
+    def get_or_create_file(self, path):
+        if path not in self.files:
+            return ''
+
+        data = getattr(self, self.files[path])()
+
+        try:
+            current_file = open(self._files_cache[path])
+            current_data = current_file.read()
+            current_file.close()
+            if current_data != data:
+                os.remove(path)
+                raise Exception("Invalid data")
+        except Exception:
+            handle, tmp_path = tempfile.mkstemp()
+            tmp_file = open(tmp_path, 'w')
+            tmp_file.write(data)
+            tmp_file.close()
+            self._files_cache[path] = tmp_path
+
+        return self._files_cache[path]
+
+    def exists(self, name):
+        return name in self.files
+
+    def listdir(self, path):
+        folders, files = [], []
+        for f in self.files:
+            if f.startswith(path):
+                f = f.replace(path, '', 1)
+                if os.sep in f:
+                    folders.append(f.split(os.sep, 1)[0])
+                else:
+                    files.append(f)
+        return folders, files
+
+    def path(self, name):
+        try:
+            path = self.get_or_create_file(name)
+        except ValueError:
+            raise SuspiciousOperation("Attempted access to '%s' denied." % name)
+        return os.path.normpath(path)
+
+
+class DajaxiceStorage(VirtualStorage):
+
+    files = {os.path.join('dajaxice', 'dajaxice.core.js'): 'dajaxice_core_js'}
+
+    def dajaxice_core_js(self):
+        from dajaxice.core import dajaxice_autodiscover, dajaxice_config
+
+        dajaxice_autodiscover()
+
+        c = Context({'dajaxice_config': dajaxice_config})
+        return get_template(os.path.join('dajaxice', 'dajaxice.core.js')).render(c)
+
+
+class DajaxiceFinder(finders.BaseStorageFinder):
+    storage = DajaxiceStorage()

dajaxice/models.py

@@ -0,0 +1 @@
+# Don't delete me