BackboneDiorama is everything you need to build client-side web applications.
Optimised for developer happiness, it builds on the components of Backbone.js
and aims to be the easiest and the fastest way to build for the browser.

diorama generate <lots-of-stuff> - Rails-style code generators which provide convention and structure to your projects, assist you with proven patterns and allow you to rapidly prototype. Run diorama generate for the full list.

New to Backbone.js? The built in conventions and patterns mean there's no easier way to get started.

Written entirely in and for Coffeescript, for clarity and elegance of code.

We've been using BackboneDiorama to build applications for a little while now,
but this is just the first public release. There's lots more planned (AMD
support, testing defaults, minification, coffeescript source maps and more
generators...) and if you've got any feedback or suggestions, we'd love to hear
from you!

This command watches your src/ folder for changes then concatenates and
compiles the files specified in src/compile_manifest.json to js/application.js.
The files should be specified in the order you require them, in this format:

[

"collections/tasks_collection",

"templates/task_index",

"views/task_index_view"

]

When you run a generator, it will print the includes you need to add to this
file.

To run the compile once (without watching for changes), omit the 'watch'
argument:

BackboneDiorama is ready to drop straight into your server side framework.
Simply run diorama new inside your javascripts folder (app/assets/javascripts
in Rails), include the the compiled js/application.js in your app, then use
Diorama as normal.

If you're using Rails or another framework with built in coffeescript
compilation, just include the coffeescripts in your src/ directly. Your
templates will still need to be compiled, which you can do by inserting only
the handlebars templates into compile_manifest.json, then using diorama compile watch to compile them to js/application.js

Diorama controllers are designed to coordinate views and data, and
provide entry points to certain 'states' of your application.
Routers in BackboneDiorama projects only handle URL reading and
setting, but defer to controllers for the actual behavior.

A common pattern for Backbone applications is to nest views inside each
other. For example a collection index view where each model in the
collection gets a sub view. The advantage of this approach is that each
sub view can listen for and respond to events about a particular model,
removing the need for the collection view to be re-rendered.