Metadata-Version: 1.1
Name: django-quickview
Version: 0.2
Summary: Simple reusable package for quick scaffolding and basic views based on a given model.
Home-page: https://bitbucket.org/weholt/django-quickview
Author: Thomas A. Weholt
Author-email: thomas@weholt.org
License: BSD License
Description: =========
        QuickView
        =========
        
        QuickView is sort of a class based view on steriods, which handles basic scaffolding and basic views
        in very few lines of code. Take a look at quickview/__init__.py to look at what to override.
        
        The main job is creating necessary templates. It takes care of creating and adding entries in your urls.py as well.
        
        NB! This is a proof-of-concept-release and has ONLY been tested under Python 3.3 and Django 1.5b2.
        
        Quick start
        -----------
        
        0. pip install django-quickview.
        
        1. Add "quickview" to your INSTALLED_APPS setting like this::
        
              INSTALLED_APPS = (
                  ...
                  'quickview',
              )
        
        2. In your views.py do:
        
              import quickview
        
              class YourView(quickview.ModelQuickView);
                  model = YourModel # points to a model in models.py
        
        3. In your project urls.py do something like this::
        
              import quickview
              urlpattern += quickview.discover_views()
        
        3. Run `python manage.py syncdb` to create any models.
        
        4. You'll have to create some templates and put these under yourapp/templates/yourapp/yourmodel or directly in your default templatefolder. The templates are:
        
            - index.html : lists all your models.
            - detail.html : detail view of one specific instance.
            - add.html : template to add instances.
            - update.html : template to update instances.
            - delete.html : template to delete an instance.
        
        5. Start the development server and visit http://127.0.0.1:8000/yourapp/yourmodel/list/.
        
        Elaboration and motivation
        --------------------------
        
        Being somewhat underwhelmed by class based views due to the repetative
        coding in urls.py etc I tried to see if I could get generic
        scaffolding and basic views up and running based on a given model in
        less lines of code. It's pretty simple and not heavily tested, but I'd
        like to see if any of you has any inital comments before I spend a lot
        of time on it.
        
        The idea is that we always write the same views for alot of our
        models; a list view, a detail view and add/update/delete. My
        app/urls.py seem to have repeating patterns for all these views.
        Generic views, class based or plain functions, do help but I still
        find all the coding a bit redundant. In essence the templates are the
        only thing that I really have to code manually.
        
        Using quickview you define your model like so :
        
        
            class Person(models.Model):
                name = models.CharField(max_length=30)
        
                age = models.IntegerField(default=10)
        
        In views.py:
        
            from models import Person
        
            from quickview import *
        
            class PersonView(ModelQuickView):
                model = Person
        
        And in urls.py:
        
            import quickview
            urlpattern += quickview.discover_views()
        
        
        After a little syncdb and runserver you'll have an urlconfig/pattern
        something like this:
        
            myapp/person/list/$ [name='myapp-person-list']
            myapp/person/add/$ [name='myapp-person-add']
            myapp/person/(?P<pk>\d+)/$ [name='myapp-person-detail']
            myapp/person/update/(?P<pk>\d+)/$ [name='myapp-person-update']
            myapp/person/delete/(?P<pk>\d+)/$ [name='myapp-person-delete']
        
        where myapp is the app my person-models resides in. Now you define
        some templates ( list.html, detail.html, add.html, update.html,
        delete.html ) in /templates/myapp/person/ and you're good to go ;-).
        
        
        Todos: user authentication/login_required etc. and unittests.
        
        Version history
        ---------------
        
        0.2     - Refactored code; QuickView is not dependent on a model. A subclass of QuickView named ModelQuickView takes
                  care of all model related magic. This makes it easier to write non-model based views based on the same concept.
        
        0.1     - Initial release.
Platform: UNKNOWN
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: Programming Language :: Python :: 3.3
Classifier: Programming Language :: Python :: 2.7
Classifier: Topic :: Internet :: WWW/HTTP
Classifier: Topic :: Internet :: WWW/HTTP :: Dynamic Content
