Metadata-Version: 1.1
Name: django_ajax
Version: 0.2.0
Summary: Utility app to support AJAX development in Django
Home-page: https://github.com/ddanier/django_ajax
Author: David Danier
Author-email: david.danier@team23.de
License: UNKNOWN
Description: ABOUT
        =====
        
        django_ajax provides some basic structure to make working with AJAX (and
        Javascript in general) more easy.
        
        HOW
        ===
        
        django_ajax provides various utils.
        
        render_to_json
        --------------
        
        render_to_json is both implemented as a view and a decorator. The view does
        the real work, while the decorator is a utility function which itself uses
        the view to convert objects to json.
        
        The view expects two arguments:
        
        * request
        * the object to output as JSON
        
        It sets some HTTP headers to make sure the JSON can be loaded everywhere and
        nothing is cached in the browser.
        
        The decorator just calls the original view function. If the response is not
        already a HttpResponse, it will be passed through the view as described above.
        
        {% json %}
        ----------
        
        Template tag to render various objects as JSON.
        
        Syntax:
        
        ::
        	
        	<script type="text/javascript">
        		var obj_as_json = {% json object %};
        	</script>
        	
        	<script type="text/javascript">
        		{# Output "null" of variable does not exist (prevents JS error) #}
        		var obj_as_json = {% json object or null %};
        	</script>
        
        {% ajax_cache %}
        ----------------
        
        Utility template tag to pass objects to some JS function. May be used to
        implement JS-side caching of objects. This will speed up JS-driven apps, as
        the template can put out JS-objects then they are needed anyways. The tag
        makes sure every object will only be cached once, multiple calls will only
        output one JS-call.
        
        Syntax:
        
        ::
        	
        	<script type="text/javascript">
        		{% comment %}
        			Will output the same as "some_func.to.call({% json object %});"
        			But only if object was not used in combination with
        			"some_func.to.call" before.
        		{% endcomment %}
        		{% ajax_cache object using "some_func.to.call" %}
        	</script>
        
        ajax_processors
        ---------------
        
        Like context_processors, but used to put variables into the JS context.
        Provides JS_CONTEXT via a context processor, which can be rendered using
        {% json JS_CONTEXT %}. Example:
        
        ::
        	
        	<script type="text/javascript">
        		var config = {% json JS_CONTEXT %};
        	</script>
        
        Uses settings.AJAX_CONFIG_PROCESSORS, which uses the same syntax as
        for context processors.
        
        dango_ajax comes with three ajax processors
        (living in django_ajax.ajax_processors):
        
        * media: provides MEDIA_URL
        * static: provides STATIC_URL
        * session: provides basic authentcation information
        
          - includes AJAX login/logout urls and views
        
        API
        ===
        
        Uses object.ajax_data() in various places to allow defining method to convert
        models/... into dictionaries, which can be converted to JSON. This way you may
        pass model instances directly to {% json %} and the model may define which
        data to output.
        
Platform: UNKNOWN
Classifier: Development Status :: 5 - Production/Stable
Classifier: Environment :: Web Environment
Classifier: Framework :: Django
Classifier: Intended Audience :: Developers
Classifier: License :: OSI Approved :: BSD License
Classifier: Operating System :: OS Independent
Classifier: Programming Language :: Python
Classifier: Topic :: Utilities
