Merge lp:~nicolas-lunatech/play/play-ssl into lp:play

[Nicolas Leroux]

Unmerged revisions

1053. By Nicolas Leroux <email address hidden> on 2010-09-16

Merge

1052. By Nicolas Leroux <email address hidden> on 2010-09-16

SSL support for netty

1051. By Nicolas Leroux <email address hidden> on 2010-09-16

Reverted as this was not for this branch

1050. By Nicolas Leroux <email address hidden> on 2010-09-16

Missing file

1049. By Guillaume Bort on 2010-09-16

Hum

1048. By Erwan Loisant <erwan@coot> on 2010-09-16

[640637] Introduce Http.StatusCode, with constants for http codes

1047. By Erwan Loisant <erwan@coot> on 2010-09-16

Update the javadoc to match reality and remove dead code

1046. By Erwan Loisant <erwan@coot> on 2010-09-16

Include async v1.2.0

1045. By Erwan Loisant <erwan@coot> on 2010-09-16

Upgrade http-async-client to 1.2

1044. By Erwan Loisant <erwan@coot> on 2010-09-16

Fix test cases

=== modified file '.bzrignore'
--- .bzrignore	2010-06-15 14:04:19 +0000
+++ .bzrignore	2010-09-16 22:21:08 +0000
@@ -67,20 +67,49 @@
 samples-and-tests/yabe/tmp
 *.ser
 modules/cobertura/lib
+modules/scala/lib/play-scala.jar
+samples-and-tests/with-scala/logs
+samples-and-tests/yabe-with-scala/logs
+samples-and-tests/yabe-with-scala/tmp
 samples-and-tests/yabe/.amateras
 samples-and-tests/yabe/.settings
 samples-and-tests/yabe/eclipse
 samples-and-tests/yabe/nbproject
+samples-and-tests/with-scala/.amateras
+samples-and-tests/with-scala/.externalToolBuilders
+samples-and-tests/with-scala/.manager
+samples-and-tests/with-scala/.settings
+samples-and-tests/with-scala/eclipse
+samples-and-tests/test-scala/tmp
+samples-and-tests/test-scala/logs
 samples-and-tests/i-am-a-developer/i-am-working-here
 samples-and-tests/just-test-cases/attachments
 samples-and-tests/booking/logs
 samples-and-tests/booking/tmp
+help
+*.iml
+*.ipr
+*.iws
+modules/router/lib/router.jar
+modules/grizzly/lib/play-grizzly.jar
 play.ipr
 play.iws
 *iml
+modules/router-head
+modules/gwt/samples-and-tests/logs
+modules/gwt/samples-and-tests/test-result
+modules/gwt/samples-and-tests/tmp
+modules/siena-1.0
 samples-and-tests/zencontact/logs
 samples-and-tests/zencontact/test-result
 samples-and-tests/zencontact/tmp
+modules/scala
 modules/*
+build.classes
+modules/crud/nbproject
+nbproject
+samples-and-tests/jobboard/attachments
+samples-and-tests/jobboard/logs
+samples-and-tests/jobboard/test-result
+samples-and-tests/jobboard/tmp
 samples-and-tests/validation/logs
-samples-and-tests/validation/tmp

=== removed file 'documentation/commands/cmd-all.txt'
--- documentation/commands/cmd-all.txt	2010-04-12 10:11:35 +0000
+++ documentation/commands/cmd-all.txt	1970-01-01 00:00:00 +0000
@@ -1,34 +0,0 @@
-~ For all commands, if the application is not specified, the current directory is used
-~ Use 'play help cmd' to get more help on a specific command
-~
-~ Available commands are: 
-~ ~~~~~~~~~~~~~~~~~~~~~~~
-~ auto-test      Automatically run all application tests
-~ build-module   Build and package a module
-~ classpath      Display the computed classpath
-~ clean          Delete temporary files (including the bytecode cache)
-~ eclipsify      Create all Eclipse configuration files
-~ help           Display help on a specific command
-~ id             Define the framework ID
-~ idealize       Create all IntelliJ Idea configuration files
-~ install        Install a module
-~ javadoc        Generate your application Javadoc
-~ list-modules   List modules available from the central modules repository
-~ modules        Display the computed modules list
-~ netbeansify    Create all NetBeans configuration files
-~ new            Create a new application
-~ new-module     Create a new module
-~ out            Follow logs/system.out file
-~ pid            Show a running application's process ID
-~ precompile     Precompile all Java sources and templates to speed up application start-up
-~ run            Run the application in the current shell
-~ restart        Restart the running application
-~ secret         Generate a new secret key
-~ status         Display the running application's status
-~ start          Start the application in the background
-~ stop           Stop the running application
-~ test           Run the application in test mode in the current shell
-~ war            Export the application as a standalone WAR archive
-~ 
-~ Also refer to documentation at http://www.playframework.org/documentation
-~ 
\ No newline at end of file

=== added file 'documentation/commands/cmd-install.txt'
--- documentation/commands/cmd-install.txt	1970-01-01 00:00:00 +0000
+++ documentation/commands/cmd-install.txt	2010-09-16 22:21:08 +0000
@@ -0,0 +1,17 @@
+~ Name:
+~ ~~~~~
+~ install -- Download and install a Play module
+~
+~ Synopsis:
+~ ~~~~~~~~~
+~ play install [module_name]
+~
+~ Description:
+~ ~~~~~~~~~~~~
+~ Modules are 3rd party software to extend Play's capabilities.
+~ Available modules are listed with the play list-modules command,
+~ or online at http://www.playframework.org/modules
+~
+~ Once installed, Play modules can be included in any Play application
+~ by adding the correct line to conf/application.conf.
+~
\ No newline at end of file

=== removed file 'documentation/commands/cmd-install.txt'
--- documentation/commands/cmd-install.txt	2010-04-12 09:35:52 +0000
+++ documentation/commands/cmd-install.txt	1970-01-01 00:00:00 +0000
@@ -1,17 +0,0 @@
-~ Name:
-~ ~~~~~
-~ install -- Download and install a Play module
-~
-~ Synopsis:
-~ ~~~~~~~~~
-~ play install [module_name]
-~
-~ Description:
-~ ~~~~~~~~~~~~
-~ Modules are third-party software to extend Play's capabilities.
-~ Available modules are listed with the play list-modules command,
-~ or on-line at http://www.playframework.org/modules
-~
-~ Once installed, Play modules can be included in any Play application
-~ by adding the correct line to conf/application.conf.
-~
\ No newline at end of file

=== added file 'documentation/images/scala-error.png'
Binary files documentation/images/scala-error.png	1970-01-01 00:00:00 +0000 and documentation/images/scala-error.png	2010-09-16 22:21:08 +0000 differ
=== added file 'documentation/images/scguide1-1.png'
Binary files documentation/images/scguide1-1.png	1970-01-01 00:00:00 +0000 and documentation/images/scguide1-1.png	2010-09-16 22:21:08 +0000 differ
=== added file 'documentation/images/scguide1-3.png'
Binary files documentation/images/scguide1-3.png	1970-01-01 00:00:00 +0000 and documentation/images/scguide1-3.png	2010-09-16 22:21:08 +0000 differ
=== removed file 'documentation/manual/cobertura.textile'
--- documentation/manual/cobertura.textile	2009-11-12 11:56:33 +0000
+++ documentation/manual/cobertura.textile	1970-01-01 00:00:00 +0000
@@ -1,46 +0,0 @@
-h1. Cobertura test coverage
-
-This module for the Play! framework provides a plugin to support the Cobertura test coverage tool.
-
-Cobertura is a free Java tool that calculates the percentage of code accessed by tests. It can be used to identify which parts of your Java program are lacking test coverage. It is based on jcoverage.
-
-See "http://cobertura.sourceforge.net/":http://cobertura.sourceforge.net/ for more information.
-
-Let's see a simple usage example.
-
-h2. <a>Enable the Cobertura module for the application</a>
-
-In the **/conf/application.conf** file, enable the Cobertura module by adding this line:
-
-bc. # The cobertura test coverage module
-module.cobertura=${play.path}/modules/cobertura
-
-This plugin is intended for use in the 'test' mode, and will silently do nothing in other modes. Therefore, leaving it activated while running your application in other modes is not a problem.
-
-h2. <a>Run your tests</a>
-
-Run your tests as normal, for example:
-
-bc. $ play test
-
-or 
-
-bc. $ play auto-test
-
-Code coverage is directly calculated when running the tests - each test you run will add coverage to your Java files. So at this step, it is important to run all the tests you want to analyze coverage for.
-
-h2. <a>Admire the results!</a>
-
-Once the test run is finished, stop the Play! framework. The cobertura module will generate an HTML report automatically in a directory named *test-result/code-coverage/* in your project home.
-
-bc. [...] INFO  - Cobertura plugin: generating test coverage report
-[...]
-[...] INFO  - Test coverage report has been generated: file:/path/to/test-result/code-coverage/index.html
-
-The module will output the URL to view this report on the console. You can view this in your web browser, with a URL like this: "file:/path/to/your/application/test-result/code-coverage/":file:/path/to/your/application/test-result/code-coverage/.
-
-!images/cobertura1!
-
-h2. <a>Continuous integration</a>
-
-Continuous integration tools, such as "Hudson":http://hudson.dev.java.net/, can often use Cobertura results to graph the test coverage. For this purpose, the Cobertura module also generates an XML format report, in *test-result/code-coverage/coverage.xml*.

=== modified file 'documentation/manual/controllers.textile'
--- documentation/manual/controllers.textile	2010-08-26 14:49:38 +0000
+++ documentation/manual/controllers.textile	2010-09-16 22:21:08 +0000
@@ -149,15 +149,33 @@
 * MM-dd-yy
 * MM'/'dd'/'yy
 
+Using the @Bind annotation, you can specify the date format.
+
 For example:
 
 bc. archives?from=21/12/1980
 
-bc. public static void articlesSince(Date from) {
+bc. public static void articlesSince(@Bind("dd/MM/yyyy") Date from) {
     List<Article> articles = Article.findBy("date >= ?", from);
     render(articles);
 }
 
+If no **@Bind** annotation is specified, then Play! uses the default date format according to your locale.
+To set the default date format to use, edit your application.conf and set the following property:
+
+bc. date.format=yyy-MM-dd
+    date.format.fr=dd/MM/yyyy
+
+Please note that the language fr in the application.conf must be enabled as well:
+bc. application.langs=fr
+
+This property also affects how the dates are rendered in the templates using the ${date.format()}.
+
+
+h3. Calendar
+
+The calendar binding works exactly as with the date, except that Play! is choosing the Calendar object according to your locale. The @Bind annotation can also be used.
+
 h3. Files
 
 File upload is easy with Play. Use a **multipart/form-data** encoded request to post files to the server, and then use the **java.io.File** type to retrieve the file object:
@@ -214,7 +232,7 @@
 &client.address.zip=75009
 &client.address.country=France
 
-In order to update a list of model objects, use array notation and reference the object’s ID. For example imagine the Client model has a list of Customer models declared as **List<Customer> customers**. To update the list of Customers you would provide a query string like the following:
+In order to update a list of model objects, use array notation and reference the object’s ID. For example imagine the Client model has a list of Customer models declared as **List Customer customers**. To update the list of Customers you would provide a query string like the following:
 
 bc. ?client.customers[0].id=123
 &client.customers[1].id=456
@@ -427,6 +445,20 @@
  
 }
 
+Or if you want the @Before method to intercept a list of action calls, you can specify a only param :
+
+bc. public class Admin extends Application {
+ 
+    @Before(only={"login","logout"})
+    static void doSomething() {  
+		...  
+	}
+	
+   	...
+}
+
+unless and only params are available for @After @Before and @Finally
+
 h3. @After
 
 Methods annotated with the **@After** annotation are executed after each action call for this Controller.

=== modified file 'documentation/manual/emails.textile'
--- documentation/manual/emails.textile	2010-07-28 19:25:39 +0000
+++ documentation/manual/emails.textile	2010-09-16 22:21:08 +0000
@@ -1,8 +1,31 @@
 h1. Sending e-mail with Play
 
-You can use the play.libs.Mail utility to send e-mail very easily:
-
-bc. Mail.send("[e-mail]","[e-mail]","Subject","Message");
+Email are using the "jakarta commons email":http://commons.apache.org/email/userguide.html library under the hoot. You can use the play.libs.Mail utility to send emails very easily:
+
+A simple email:
+
+bc. SimpleEmail email = new SimpleEmail();
+email.setFrom("[e-mail]");
+email.addTo("[e-mail]");
+email.setSubject("subject");
+email.setMsg("Message");
+Mail.send(email); 
+
+An html email:
+
+bc. HtmlEmail email = new HtmlEmail();
+email.addTo("[e-mail]");
+email.setFrom([e-mail]", "Nicolas");
+email.setSubject("Test email with inline image");
+// embed the image and get the content id
+URL url = new URL("http://www.zenexity.fr/wp-content/themes/zenexity/images/logo.png");
+String cid = email.embed(url, "Zenexity logo");
+// set the html message
+email.setHtmlMsg("<html>Zenexity logo - <img src=\"cid:"+cid+"\"></html>");
+// set the alternative message
+email.setTextMsg("Your email client does not support HTML messages, too bad :(");
+
+More information about the commons email "here":http://commons.apache.org/email/userguide.html
 
 h2. <a>Mail and MVC integration</a>
 
@@ -25,14 +48,17 @@
    public static void welcome(User user) {
       setSubject("Welcome %s", user.name);
       addRecipient(user.email);
-      setFrom("Me <[e-mail]>");
-      addAttachment(Play.getFile("rules.pdf"));
+      addFrom("Me <[e-mail]>");
+      EmailAttachment attachment = new EmailAttachment();
+      attachment.setDescription("A pdf document");
+      attachment.setPath(Play.getFile("rules.pdf").getPath());
+      addAttachment(attachment);
       send(user);
    }
  
    public static void lostPassword(User user) {
       String newpassword = user.password;
-      setFrom("Robot <[e-mail]>");
+      addFrom("Robot <[e-mail]>");
       setSubject("Your password has been reset");
       addRecipient(user.email);
       send(user, newpassword);

=== modified file 'documentation/manual/faq.textile'
--- documentation/manual/faq.textile	2010-08-27 09:19:18 +0000
+++ documentation/manual/faq.textile	2010-09-16 22:21:08 +0000
@@ -1,6 +1,5 @@
 h1. Frequently Asked Questions
 
-
 h2. <a>Where do I ask questions that are not answered here?</a>
 
 The "Community":http://www.playframework.org/community page links to various places where you can read and post about Play. In general, the best place to ask questions is the "play-framework Google Group":http://groups.google.com/group/play-framework.
@@ -51,4 +50,4 @@
 
 We use "launchpad":https://launchpad.net/ as our main development tool, and launchpad itself is very open. You can just register a launchpad account and start to contribute. You can assign any open bug to yourself, fork any Play official branch to your own branch, and propose a merge to us if you have fixed something.
 
-The documentation itself is kept as "Textile":http://en.wikipedia.org/wiki/Textile_(markup_language%29 files in the framework source repository, so you can edit it and contribute just as you can with code.
+The documentation itself is kept as "Textile":http://en.wikipedia.org/wiki/Textile_(markup_language%29 files in the framework "source repository":http://bazaar.launchpad.net/~play-developers/play/1.1-unstable/files/head%3A/documentation/manual, so you can edit it and contribute just as you do with code.

=== modified file 'documentation/manual/home.textile'
--- documentation/manual/home.textile	2010-08-30 13:30:48 +0000
+++ documentation/manual/home.textile	2010-09-16 22:21:08 +0000
@@ -1,8 +1,8 @@
 h1. Play framework documentation
 
-Welcome to the Play framework documentation. This documentation is for the **1.0.3 release**, which differs from previous versions of the framework. Check the "version 1.0.3 release notes":releasenotes-1.0.3 for details.
+Welcome to the play framework documentation. This documentation is intended for the *1.1 release* and may significantly differs from previous versions of the framework. Check the "version 1.1 release notes":releasenotes-1.1.
 
-p(note). This is a work in progress, feel free to ask any question not covered into these documents or report any errors. You can contribute to the documentation the "same way you can contribute code":faq.
+p(note). The 1.1 branch is in active development.
 
 <div id="searchBox"><form action="http://www.google.com/cse" id="cse-search-box"><div><input type="hidden" name="cx" value="002614023023983855063:jn1mu_7bof0" /><input type="hidden" name="ie" value="UTF-8" /><input type="text" name="q" size="31" style="font-size:14px"/> <input type="submit" name="sa" value="Search with google" style="font-size:14px"/></div></form><script type="text/javascript" src="http://www.google.com/coop/cse/brand?form=cse-search-box&lang=en"></script></div>
 
@@ -47,9 +47,8 @@
 ## "The MVC application model":main#mvc
 ## "A request life cycle":main#request
 ## "Application layout & organization":main#application
-## "Development life cycle":main#lifecycle
+## "Development lifecycle":main#lifecycle
 # "HTTP routing":routes
-## "About REST":routes#rest
 ## "The routes file syntax":routes#syntax
 ## "Routes priority":routes#priority
 ## "Serving static resources":routes#static
@@ -57,32 +56,24 @@
 ## "Setting content types":routes#content-types
 ## "Content negotiation":routes#content-negotiation
 # "Controllers":controllers
-## "Controller overview":controllers#overview
-## "Retrieving HTTP parameters":controllers#params
+## "A Controller overview":controllers#overview
+## "Retrieve HTTP parameters":controllers#params
 ## "Advanced HTTP to Java binding":controllers#binding
-## "JPA object binding":controllers#objectbinding
-## "Result types":controllers#result
+## "Return a result":controllers#result
 ## "Interceptions":controllers#interceptions
 ## "Session and Flash scopes":controllers#session
 # "The template engine":templates
 ## "Template syntax":templates#syntax
 ## "Template inheritance":templates#inheritance
-## "Custom tags":templates#tags
-## "Java template extensions":templates#extensions
-## "Implicit objects available in a template":templates#implicits
-# "Validating HTTP data (form validation)":validation
-## "How validation works in Play":validation#how
-## "Retrieving validation error messages":validation#messages
-## "Displaying validation errors in the template":validation#display
-## "Validation annotations":validation#annotations
-## "Validating complex objects":validation#objects
-## "Custom validation":validation#custom
+## "Create tags":templates#tags
+## "Extending the templates language":templates#extensions
+## "Implicit objects":templates#implicits
 # "The domain object model":model
 ## "Properties simulation":model#properties
-## "Set-up a database to persist your model objects":model#database
+## "Setup a database to persist your model objects":model#database
 ## "Persist your object model with Hibernate":model#hibernate
 ## "The stateless model":model#stateless
-# "A little asynchronism using jobs":jobs
+# "A little of asynchronism using jobs":jobs
 ## "Bootstrap jobs":jobs#concepts
 ## "Scheduled jobs":jobs#scheduling
 ## "Suspendable requests":jobs#suspendable
@@ -94,7 +85,7 @@
 # "Deployment options":deployment
 ## "Standalone Play application":deployment#standalone
 ## "Running on JEE application servers":deployment#appservers
-## "Google Application Engine (GAE)":deployment#gae
+## "Google Application Engine":deployment#gae
 ## "Stax cloud hosting platform":deployment#stax
 
 
@@ -102,41 +93,41 @@
 
 Tips about everything and anything.
 
-# "Play modules, and the modules repository":modules
-# "Security guide":security
-# "JPA support":jpa
-# "Logging configuration":logs
+# "Using Play modules, and the modules repository":modules
+# "Security Guide":security
+# "More about the JPA support":jpa
+# "Using data validation":validation
+# "How to configure logs":logs
 # "Manage application.conf in several environments":ids
-# "Internationalisation guide":i18n
-# "Cache and Memcached configuration":cache
-# "Putting your application in production":production
+# "Setting up i18n":i18n
+# "Use cache and configure Memcached":cache
+# "Put your application in production":production
 # "Sending e-mail":emails
 # "OpenID integration":openid
-# "Ajax with JQuery":ajax
-# "YAML":yaml
+# "Doing Ajax with JQuery":ajax
 
-h2. <a name="modules">Standard modules</a>
+h2. <a name="modules">Distribution Modules</a>
 
 These optional modules are included with the standard distribution. "More modules":http://www.playframework.org/modules.
 
 # "CRUD":crud
 # "Secure":secure
 
-h2. <a name="references">Reference documentation</a>
+h2. <a name="references">References</a>
 
 Extended references for day-to-day hacking.
 
-# "API documentation (Javadoc)":/@api/index.html
-# "Template tags":tags
+# "The missing cheat sheet":http://download.playframework.org/miscellaneous/play-cheat-sheet.pdf
+# "Browse API documentation":/@api/index.html
+# "Template tags and extensions reference":tags
 # "Java extensions":javaextensions
-# "Built-in validations":validation-builtin
-# "The missing cheat sheet":http://download.playframework.org/miscellaneous/play-cheat-sheet.pdf
 
 
 h2. <a name="versionnotes">Version notes</a>
 
 New versions of Play include certain changes.
 
+# "Play 1.1":releasenotes-1.1
 # "Play 1.0.3":releasenotes-1.0.3
 # "Play 1.0.2":releasenotes-1.0.2
 # "Play 1.0.1":releasenotes-1.0.1

=== modified file 'documentation/manual/i18n.textile'
--- documentation/manual/i18n.textile	2010-08-26 14:49:38 +0000
+++ documentation/manual/i18n.textile	2010-09-16 22:21:08 +0000
@@ -51,6 +51,19 @@
 
 The new value will be saved back to the user’s language cookie.
 
+h2. <a name="dateformat">Define date format according to your locale</a>
+
+To set the default date format to use, edit your application.conf and set the following property:
+
+bc. date.format=yyy-MM-dd
+    date.format.fr=dd/MM/yyyy
+
+Please note that the language fr in the application.conf must be enabled as well (see above):
+bc. application.langs=fr,en
+
+This property affects how the dates are rendered in the templates using the ${date.format()}.
+It also set the default date format when binding a date parameter.
+
 h2. <a name="output">Retrieve localized messages</a>
 
 From the application code, you can retrieve messages defined in message files. From Java, use the **play.i18n.Messages** object.

=== added file 'documentation/manual/lambdaj.textile'
--- documentation/manual/lambdaj.textile	1970-01-01 00:00:00 +0000
+++ documentation/manual/lambdaj.textile	2010-09-16 22:21:08 +0000
@@ -0,0 +1,129 @@
+h1. Some functional programming techniques
+
+The 1.1 release will allow "support of the Scala programming language":scala. One great thing (but not the only one) about Scala is that it is a mixed imperative -- functional language that allow to solve a lot of problem in a functional way.
+
+But now, what if you prefer keep using Java with play ? Could we bring some of the nice features of Scala to Java as well ? So let's me introduce the new "LambdaJ":http://code.google.com/p/lambdaj/ support in play.
+
+The main purpose of lambdaj is to partially eliminate the burden to write (often nested and poorly readable) loops while iterating over collections. From the LambdaJ website:
+
+bq. How many times have you read or written the same two or three lines of code that frequently seem to go together, and even though they operate on different objects, feel like the same thing? And how often these repetitions involve some sort of collections iteration or more generically manipulation? These repetitions in the code is something that developers eventually learn to filter out and ignore when reading code, once they figure out where the interesting parts are placed. But even if the developers get used to it, it slows them down. Code like that is clearly written for computers to execute, not for developers to read.
+ 
+lambdaj is a library that makes easier to address this issue by allowing to manipulate collections in a pseudo-functional and statically typed way. In our experience to iterate over collection, especially in nested loops, is often error prone and makes the code less readable. The purpose of this library is to alleviate these problems employing some functional programming techniques but without losing the static typing of java. We impose this last constraint to make refactoring easier and safer and allow the compiler to do its job.
+
+h2. <a>Let's use lambdaj</a>
+
+We will start with a fresh application that allow to display a **Car** catalog. The **Car** model class will just be defined as:
+
+bc. package models;
+ 
+import play.*;
+import play.db.jpa.*;
+ 
+import javax.persistence.*;
+import java.util.*;
+ 
+@Entity
+public class Car extends Model {
+    
+    public String name;
+    public String brand;
+    public int numberOfViews;
+    public Date lastViewed;
+    
+    @Transient
+    public double price;
+    
+    public Car viewed() {
+        lastViewed = new Date();
+        numberOfViews++;
+        return this;
+    }
+    
+}
+
+And let's write a simple action that retrieve all these cars:
+
+bc. public static index() {
+    List<Car> cars = Car.find().fetch();
+    render(cars);
+}
+
+Now in the page it would be great to be able to order all these cars by brand. So we need to extract all the brand from the car list. Let's do it the lambdaj way:
+
+bc. List<String> brands = collect(cars, on(Car.class).brand);
+
+This line will iterate over all the retrieved cars, collect all the brands and feed them to the returned list. The very cool things is that we are able to express that stuff in a pure statically typed way.
+
+Now we need to filter this list to remove brand duplication:
+
+bc. Collection<String> brands = selectDistinct(
+    collect(cars, on(Car.class).brand)
+);
+
+Very easy.
+
+h2. <a>Batching method calls</a>
+
+We want to cound each time a Car has been viewed, and remember the last viewed time. As we already have the **viewed()** method that update the **Car** objects we just need to call this method on each retrieved car. Again, let's do it the lambdaj way:
+
+bc. forEach(cars).viewed();
+
+This line will iterate over each car object of the cars list and call the **viewed()** method on each.
+
+And because we modified the state of the persistent objects, we need to save them. So rewrite it as:
+
+bc. forEach(cars).viewed().save();
+
+h2. <a>Using closures</a>
+
+Hugh? But Java doesn't have closure! Wait, lambdaj partially fill this lack by a feature that allow to define, in its traditional DSL style, first-class functions with free variables.
+
+Let's say we have a **PriceWatcher** utility able to fetch in real time the price of each car. 
+
+bc. package models;
+ 
+public class PriceWatcher {
+ 
+    public void setPrice(Car car) {
+        // retrieve the correct price here
+        car.price = currentPrice;
+    }
+    
+}
+
+Because this data need to be **in real time** we don't want store it in the database. Before displaying the car list we need to create a PriceWatcher object and ask it to resolve the current price of each car. Again, let's do it the lambdaj way:
+
+bc. PriceWatcher priceWatcher = new PriceWatcher();
+Car.forEach(cars); {
+    of(priceWatcher).setPrice(var(Car.class));
+}
+
+We define a function with a free variable, and then ask to the Car class to call them for each element of the cars list. 
+
+h2. <a>The final action code</a>
+
+Using all these good lambdaj stuff, we can finally write the **index** action in a very expressive fashion:
+
+bc. public static void index() {
+    List<Car> cars = Car.find().fetch();
+    
+    // Collect brands
+    Collection<String> brands = selectDistinct(
+        collect(cars, on(Car.class).brand)
+    );   
+    
+    // Set all these cars viewed
+    forEach(cars).viewed().save();
+    
+    // Update the prices
+    PriceWatcher priceWatcher = new PriceWatcher();
+    Car.forEach(cars); {
+        of(priceWatcher).update(var(Car.class));
+    }
+        
+    render(cars, brands);
+}
+
+
+
+

=== added file 'documentation/manual/scala.textile'
--- documentation/manual/scala.textile	1970-01-01 00:00:00 +0000
+++ documentation/manual/scala.textile	2010-09-16 22:21:08 +0000
@@ -0,0 +1,208 @@
+h1. Scala support
+
+The 1.1 release of play will include support for the "Scala":http://www.scala-lang.org programming language. Thanks to the flexibility of the play framework architecture, the Scala support is provided with a simple module. You just need to enable the scala module in the **conf/application.conf** file.
+
+bc. module.scala=${play.path}/modules/scala
+
+Then you can write all or parts of your play application using scala. You can of course mix it with Java.
+
+p(note). We are in very very active development on this stuff. You can try it for now as an experimental feature. Don't expect to write a complete play application in Scala right now.
+
+For a quick overview of the scala support, you can watch this "Scala screencast":http://vimeo.com/7731173
+
+h2. <a>Create a new application, with Scala support</a>
+
+You can automatically create a scala ready application, by using the **--with** option of the **play new** command. Just try:
+
+bc. play new myApp --with scala
+
+The play application will be created as usual, but if you look at the **controllers** package, the **Application.java** file is now replaced by a **Application.scala** file:
+
+bc. package controllers
+ 
+import play._
+import play.mvc._
+ 
+object Application extends Controller {
+    
+    def index = render()
+    
+}
+
+It is very close to the Java version of the default Application controller.
+
+Now just run the application as usual using **play run** and it will display the standard welcome page. Now just edit the **Application.scala** file to replace the **render()** call:
+
+bc. def index = "Hello scala !"
+
+Refresh the page, and see the magic. 
+
+As always, if you make a mistake, play will just show you the error in a perfect way; (it's just more difficult now to forget the trailing semicolon)
+
+!images/scala-error!
+
+h2. <a>Direct return types</a>
+
+As shown above, for simple action methods you can directly use the inferred return type to send the action result. For example using a String:
+
+bc. def index = "<h1>Hello world</h1>"
+
+And you can even use the built-in XML support to write XHTML in a literal way:
+
+bc. def index = <h1>Hello world</h1>
+
+If the return type looks like a binary stream, play will automatically use **renderBinary()**. So generating a captcha image using the built-in Captcha helper can be written as:
+
+bc. def index = Images.captcha
+
+h2. <a>Action parameters, and scala default arguments</a>
+
+You can declare some action parameter the same way you do it in Java:
+
+bc. def index(name: String) = <h1>Hello {name}</h1>
+
+To big plus of scala is the ability to define some default values to these parameters:
+
+bc. def index(name: String = "Guest") = <h1>Hello {name}</h1>
+
+This way if the **name** HTTP parameter is missing, play will use the default argument value.
+
+h2. <a>Controllers composition using traits</a>
+
+A controller can use several traits to combine several interceptor.
+
+Let's define a Secure trait:
+
+bc. package controllers
+ 
+import play.__
+import play.mvc.__ 
+ 
+trait Secure extends Controller {
+	
+	@Before
+	def check {
+		session("user") match {
+			name: String => info("Logged as %s", name)
+			_ => Security.login
+		}
+	}
+	
+}
+
+And you can them use it in the Application controller:
+
+bc. package controllers
+ 
+object Application extends Controller with Secure {
+	
+	def index = "Hello world"
+	
+}
+
+
+h2. <a>How to define and access Models</a>
+
+Models can be defined not only in java but in scala as well. Unfortunately, due to the differences between the two langauges the Model API somewhat differs from the java version.
+
+h3. Main differences
+
+* fields are passed as contructor arguments
+* each and every class needs to extend Model[T] 
+* helper methods should be defined in the companion object
+* companion objects need to extend Model[T]
+here is an example:
+
+bc. @Entity
+class User(
+  //fields
+  @Email
+  @Required
+  var email: String,
+  @Required
+  var password: String,
+  var fullname: String
+) extends Model[User] {
+    //instance methods
+    var isAdmin = false
+    override def toString = email
+}
+//finder methods
+object User extends Model[User] {
+    def connect(email: String, password: String) = {
+        User.find("byEmailAndPassword", email, password).first
+    }
+}
+
+h3. <a>Running queries against Scala Models from Scala classes</a>
+
+The following methods are available when running queries against scala models:
+
+bc. def count(implicit m: M[T]) = i.count(m)
+def count(q: String, ps: AnyRef*)(implicit m: M[T])  
+def findAll(implicit m: M[T]) 
+def findById(id: Any)(implicit m: M[T]) 
+def findBy(q: String, ps: AnyRef*)(implicit m: M[T]) 
+def find(q: String, ps: AnyRef*)(implicit m: M[T]) 
+def all(implicit m: M[T]) 
+def delete(q: String, ps: AnyRef*)(implicit m: M[T]) 
+def deleteAll(implicit m: M[T]) = 
+def findOneBy(q: String, ps: AnyRef*)(implicit m: M[T]): T 
+def create(name: String, ps: play.mvc.Scope.Params)(implicit m: M[T]): T
+
+As you can see, it's really similar to the java API, so for example to count the number of users, you can just call count on the User class:
+
+bc. User.count
+
+p(note). One known limitation of the Scala Model API is that the *save* method is not working in a chained call fashion, so you always need to execute it on an instance, as you can see it later at the unit testing section
+
+h3. <a>Running queries against Java Models from Scala classes</a>
+
+In certain situations it might be desirable to query models written in java from scala.
+Since java models are not extending from the scala Model trait, Play needs to provide an alternative query interface which comes in the form of *QueryRunner* trait and the corresponding companion object. In order to utilize this feature you either need to import the query methods like
+
+bc. import play.db.jpa.QueryRunner._
+
+or you can mix in the trait
+
+bc. class MyController extends Controller with QueryRunner {...} 
+
+and the API is defined like this:
+
+bc. def count[T](implicit m: M[T]) = i.count(m)
+def count[T](q: String, ps: AnyRef*)(implicit m: M[T])  
+def findAll[T](implicit m: M[T]) 
+def findById[T](id: Any)(implicit m: M[T]) 
+def findBy[T](q: String, ps: AnyRef*)(implicit m: M[T]) 
+def find[T](q: String, ps: AnyRef*)(implicit m: M[T]) 
+def all[T](implicit m: M[T]) 
+def delete[T](q: String, ps: AnyRef*)(implicit m: M[T]) 
+def deleteAll[T](implicit m: M[T]) = 
+def findOneBy[T <: JPASupport](q: String, ps: AnyRef*)(implicit m: M[T]): T 
+def create[T <: JPASupport](name: String, ps: play.mvc.Scope.Params)(implicit m: M[T]): T
+
+
+Using the previous example *User.count* becomes *count[User]* 
+
+
+h2. <a>Unit Testing</a>
+
+ScalaTest support is integrated into Play, so one can easily write unit tests using ScalaTest, for example: 
+
+bc. class SpecStyle extends UnitTest with FlatSpec with ShouldMatchers {
+"Creating a user" should "be succesfull" in {
+  val user = new User("[e-mail]", "secret", "Bob")
+  user.save
+  bob = User.find("byEmail", "[e-mail]").first
+  bob should not be (null)
+  bob.fullname should be ("Bob")
+ }
+}
+
+h2. <a>Tutorial</a>
+
+p(note). We are currently writing a version of the "play tutorial":guide1 for scala. 
+ 
+Read "The play tutorial (Scala version)":scguide1.
+
+

=== added file 'documentation/manual/scguide1.textile'
--- documentation/manual/scguide1.textile	1970-01-01 00:00:00 +0000
+++ documentation/manual/scguide1.textile	2010-09-16 22:21:08 +0000
@@ -0,0 +1,216 @@
+h1. Starting up the project (Scala version)
+
+h2. <a>Introduction</a>
+
+In this tutorial you will learn the play framework by coding a real web application, from start to finish. In this application, we will try to use everything you would need in a real project, while introducing good practices for play application development.
+
+We have split the tutorial into several independent parts. Each part will introduce more complex features, and provide everything that a real project needs: validation, error handling, security, an automated test suite, a shiny web interface, an administration area, etc.
+
+p(note). **All the code** included in this tutorial can be used for your projects. We encourage you to copy and paste snippets of code or steal whole chunks.
+
+h2. <a>The project</a>
+
+We chose to create yet another blog engine. It's not a very imaginative choice but it will allow to explore most of the functionality needed by a modern web application. 
+
+To complicate things a bit we will manage several users with different roles (editor, admin).
+
+We will call this blog engine project **yabe**.
+
+!images/guide1-0!
+
+p(note). This application is distributed as a sample application as well. You can retrieve the final code in the **samples-and-tests/yabe-with-scala** directory of your play installation.
+
+h2. <a>Prerequisites</a>
+
+First of all, make sure that you have a working Java installation. Play requires **Java 5 or later**.
+
+As we will use the command line a lot, it's better to use a Unix-like OS. If you run a Windows system, it will also work fine; you'll just have to type a few commands in the command prompt.
+
+We will assume that you are familiar with Java and Web development (especially HTML, CSS and Javascript). Additionally, this version of the tutorial assumes a bit of familiarity with Scala, although we won't use many exotic features and will explain as we go. You don't need to have a deep knowledge of all the JEE components. Play is a 'full stack' Java framework and it provides or encapsulates all the Java APIs you will need. No need to know how to configure a JPA entity manager or deploy a JEE component.
+
+You will of course need a text editor. If you are accustomed to use a full featured Java IDE like Eclipse or Netbeans you can of course use it. However with play you can have fun working with a simple text editor like TextMate, Emacs or VI. This is because the framework manages the compilation and the deployment process itself. We will soon see that...
+
+Note that support for Scala in the major IDEs is far less mature than for Java, so we really suggest using a text editor to start with.
+
+Later in this tutorial we will use Lighttpd and MySql to show how to deploy a play application in a 'production' mode. But Play can work without these components so if you can't install them, it's not a problem.
+
+h2. <a>Installation of the play framework</a>
+
+Installation is very simple. Just download the latest binary package from the download page and unzip it to any path.
+
+p(note). If you're using windows, it is generally a good idea to avoid space characters in the path, so for example **c:\play** would be a better choice than **c:\Documents And Settings\user\play**.
+
+To work efficiently, you need to add the play directory to your working path. It allows to type just **'play'** at the command prompt to use the play utility. To check that the installation worked, just open a new command line and type **'play'**; it should show you the play basic usage help.
+
+h2. <a>Project creation</a>
+
+Now that play is correctly installed, it's time to create the blog application. Creating a play application is pretty easy and fully managed by the play command line utility. That allows for standard project layouts between all play applications. 
+
+Open a new command line and type:
+
+bc. ~$ play new yabe-with-scala --with scala
+
+It will prompt you for the application full name. Type **'Yet Another Blog Engine'**.
+
+!images/scguide1-1!
+
+The **'play new'** command creates a new directory **yabe-with-scala/** and populates it with a series of files and directories, the most important being:
+
+**app/** contains the core of the application, split between models, controllers and views directories. It can contain other Java packages as well. This is the directory where *.java and *.scala source files live.
+
+**conf/** contains all the configuration files of the application, especially the main **application.conf** file, the **routes** definition files and the **messages** files used for internationalization.
+
+**lib/** contains all optional Java/Scala libraries packaged as standard .jar files.
+
+**public/** contains all the publicly available resources, which includes Javascript files, stylesheets and images directories.
+
+**test/** contains all the application tests. Tests are either written either as Java JUnit tests or as Selenium tests.
+
+p(note). Because **play uses UTF-8** as single encoding, it's very important that all text files hosted in these directories are encoded using this charset. Make sure to configure your text editor accordingly.
+
+Now if you're a seasoned Java developer, you may wonder where all the .class files go. The answer is nowhere: play doesn't use any class files but reads directly the java source files. Under the hood we use the Eclipse compiler to compile Java sources on the fly, as well as the standard Scala compiler for scala files. 
+
+That allows two very important things in the development process. The first one is that play will detect changes you make to any Java/Scala source file and automatically reload them at runtime. The second is that when a Java exception occurs, play will create better error reports showing you the exact source code.
+
+p(note). In fact play can keep a bytecode cache in the application **/tmp** directory, but only to speed up things between restart on large applications. You can discard this cache using the **'play clean'** command if needed.
+
+h2. <a>Running the application</a>
+
+We can now test the newly created application. Just return to the command line, go to the newly created **yabe-with-scala/** directory and type **'play run'**. Play will now load the application and start a Web server on port 9000.
+
+You can see the new application by opening a browser to "http://localhost:9000":http://localhost:9000. A new application has a standard welcome page that just tells you that it was successfully created.
+
+!images/guide1-2!
+
+Let's see how the new application can display this page. 
+
+The main entry point of your application is the **conf/routes** file. This file defines all accessible URL of the application. If you open the generated routes file you will see this first 'route':
+
+bc. GET		/			Application.index
+
+That simply tells play that when the web server receives a **GET** request for the **/** path, it must call the **Application.index** Scala method. In this case, **Application.index** is a shortcut for **controllers.Application.index**, because the controllers package is implicit. 
+
+A play application has several entry points, one for each URL. We call these methods **'action'** methods. Action methods are defined in special objects which we call **'controllers'**.
+
+Let's see what the **controllers.Application** controller looks like. Open the **yabe-with-scala/app/controllers/Application.scala** source file:
+
+bc. package controllers
+ 
+import play._
+import play.mvc._
+ 
+object Application extends Actions {
+    
+    def index = render()
+    
+}
+
+As you see, a controller is not a class but an object. It extends the **play.mvc.Actions** class. This class provides all useful methods for controllers, like the **render()** method we use in the index action.
+
+Scala objects are always single instances (singletons) and are automatically initialized the first time one of their methods is called. All their methods correspond with **static** methods in Java.
+
+The type signature of the index action is not visible here, it's __inferred__ from the body of the method. If we wanted to be explicit, we would write **def index(): Unit = {…}** which means: a method with no parameters and no return value (**Unit** is Scala's name for Java's **void**).
+
+The default index action is simple: it calls the **render()** method which tells play to render a template. Using a template is the most common way (but not the only one) to generate the HTTP response.
+
+Templates are simple text files that live in the **/app/views** directory. Because we didn't specify a template, the default one for this action will be used: **Application/index.html**
+
+To see what the template looks like, open the **/yabe/app/views/Application/index.html** file:
+
+bc. #{extends 'main.html' /}
+#{set title:'Home' /}
+ 
+#{welcome /}
+
+The template content seems pretty light. In fact, all you see are play tags. Play tags are very close to JSP tags as defined in a taglib. It is the **#{welcome /}** tag that generates the welcome message you've seen in the browser. 
+
+The **#{extends /}** tags tells play that this template inherits another template called **main.html**. Template inheritance is a powerful concept that allows you to create complex web pages by reusing common parts.
+
+Open the **/yabe/app/views/main.html** template:
+
+bc. <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+ 
+<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
+    <head>
+        <title>#{get 'title' /}</title>		
+        <meta http-equiv="Content-Type" content="text/html; charset=utf-8"/>
+        <link rel="stylesheet" type="text/css" media="screen" 
+            href="@{'/public/stylesheets/main.css'}" />
+        <link rel="shortcut icon" type="image/png" 
+            href="@{'/public/images/favicon.png'}" />
+    </head>
+    <body>
+        #{doLayout /} 
+    </body>
+</html>
+
+Do you see the **#{doLayout /}** tag? This is where the content of **Application/index.html** will be inserted.
+ 
+We can try to edit the controller file to see how play automatically reloads it. Open the **yabe/app/controllers/Application.scala** file in a text editor, and add a mistake by calling a non-existent method:
+
+bc. def index = reindeer()
+
+Go to the browser and refresh the page. You can see that play detected the change and tried to reload the Application controller. But because you made a mistake, you get a compilation error. 
+
+!images/scguide1-3!
+
+Ok, let's correct the error, and make a real modification:
+
+bc. def index {
+    println("Yop")
+    render()
+}
+
+Notice that we've added curly braces now that the index action involves multiple statements and, because this method has no return value, we've removed the equals sign.
+
+This time, play has correctly reloaded the controller and replaced the old code in the JVM. Each request to the **'/'** URL will output the 'Yop' message to the console.
+
+You can remove this useless line, and now edit the **yabe/app/views/Application/index.html** template to replace the welcome message:
+
+bc. #{extends 'main.html' /}
+#{set title:'Home' /}
+ 
+<h1>A blog will be there</h1>
+
+Like for Scala code changes, just refresh the page in the browser to see the modification.
+
+p(note). We will now start to code the blog application. You can either continue to work with a text editor or open the project in a Scala IDE like Eclipse or Netbeans. If you want to set up a Scala IDE, please check "this page":scide. 
+
+h2. <a>Setting up the database</a>
+
+One more thing before starting to code. For the blog engine, we will need a database. For development purposes, play comes with a standalone SQL database management system called HSQLDB. This is the best way to start a project before switching to a more robust database if needed. You can choose to have an in-memory database or a filesystem database that will keep your data between application restarts. 
+
+At the beginning, we will do a lot of testing and changes in the application model. For that reason, it's better to use an in-memory database so we always start with a fresh data set.
+
+To set up the database, open the **yabe/conf/application.conf** file and uncomment this line:
+
+bc. db=mem
+
+As you see in the comments, you can easily set up any JDBC compliant database and even configure the connection pool.
+
+Now, go back to your browser and refresh the welcome page. Play will automatically start the database. Check for this line in the application logs:
+
+bc. INFO  ~ Connected to jdbc:hsqldb:mem:playembed
+
+h2. <a>Using a version control system (VCS) to track changes</a>
+
+When you work on a project, it's highly recommended to store your source code in a VCS. It allows you to revert to a previous version if a change breaks something, work with multiple people and give access to all the successive versions of the application. Of course you can use any VCS to store your project, but here we will use Bazaar as an example. Bazaar is a distributed source version control system.
+
+Installing bazaar is out of the scope of this tutorial but it is very easy for any system. Once you have a working installation of bazaar, go to the yabe-with-scala directory and initialize the application versioning by typing :
+
+bc. $ bzr init
+
+When storing a play application in a VCS, it's important to exclude the **tmp/** and **logs/** directories.
+
+bc. $ bzr ignore tmp
+$ bzr ignore logs
+
+Now we can commit our first blog engine version :
+
+bc. $ bzr add
+$ bzr commit -m "YABE inital version"
+
+Version 1 is committed and we now have a solid foundation for our project. 
+
+p(note). Go to the "next part":scguide2. 
+

=== added file 'documentation/manual/scguide2.textile'
--- documentation/manual/scguide2.textile	1970-01-01 00:00:00 +0000
+++ documentation/manual/scguide2.textile	2010-09-16 22:21:08 +0000
@@ -0,0 +1,409 @@
+h1. A first iteration for the data model (Scala version)
+
+Here we will start to write the model for our blog engine.
+
+h2. <a>Introduction to JPA</a>
+
+The model layer has a central position in a play application (and in fact in all well designed applications). It is the domain-specific representation of the information on which the application operates. As we want to create a blog engine, the model layer will certainly contain classes like User, Post and Comment.
+
+Because most model objects need to survive between application restarts, we have to save them in a persistent datastore. A common choice is to use a relational database. But because Java and Scala are object oriented languages, we will use an **'Object Relational Mapper'** to help reduce the impedance mismatch.
+
+JPA is a Java specification that defines a standard API for object relational mapping. As implementation of JPA, play uses the well-known "Hibernate":http://www.hibernate.org framework. One advantage of using JPA over the standard Hibernate API is that all the 'mapping' is declared directly in the Java objects.
+
+If you have ever used Hibernate or JPA before you will be surprised by the simplicity added by play. No need to configure anything; JPA just works out of the box with play.
+
+If you don't know JPA, you can read "some of these simple presentations":http://java.sun.com/javaee/5/docs/tutorial/doc/bnbpz.html before continuing.
+
+h2. <a>Starting with the User class</a>
+
+We will start to code the blog engine by creating the User class. Create a new file **/yabe/app/models/User.scala**, and declare a first implementation of the User class:
+
+bc. package models
+ 
+import java.util._
+import javax.persistence._
+ 
+import play.db.jpa._
+ 
+@Entity
+class User(
+    var email: String,
+    var password: String,
+    var fullname: String
+) extends Model {
+ 
+    var isAdmin: Boolean = false
+ 
+    def this() = this(null, null, null)
+}
+
+If you're new to Scala then this class definition might look a bit strange. What is happening here is that the definition of 3 fields is combined with the definition of the primary constructor. Then there is a fourth field which is set to false by default.
+
+Scala really takes care of a lot of boilerplate, here's what this code represents:
+
+* a public class
+* a public 3-argument constructor
+* a public 0-argument constructor
+* 4 private fields
+* 4 public accessors and mutators
+
+The **@Entity** annotation marks this class as a managed JPA entity, and the Model superclass automatically provides a set of useful JPA helpers that we will discover later. All fields of this class will be automatically persisted to the database. 
+
+p(note). It's not required that your model objects extend the **play.db.jpa.Model** class. You can work as plain JPA as well. But extending this class is a good choice in most cases as it will ease a lot the JPA stuff.
+
+If you have already used JPA before, you know that every JPA entity must provide an **@Id** property. Here the Model superclass provides an automatically generated numeric id, in most cases this is good enough.
+
+p(note). Don't think about this provided **id** field as a **functional identifier** but as a **technical identifier**. It is generally a good idea to keep both concepts separated and to keep an automatically generated numeric id as technical identifier.
+
+You can now refresh the application homepage, to see the result. In fact, unless you made a mistake, you should not see any change: play has automatically compiled and loaded the User class, but this does not provide any feature to the application.
+
+h2. <a>Writing the first test</a>
+
+A good way to test the newly created User class is to write a JUnit test case. It will allow to incrementally complete the application model and ensure that all is fine.
+
+To run a test case, you need to start the application in a special 'test' mode. Stop the currently running application, open a command line and type:
+
+bc. ~$ play test
+
+!images/guide2-0!
+
+The **'play test'** command is almost the same than **'play run'**, except that it loads a test runner module that allows to run test suite directly from a browser. 
+
+p(note). When you run a play application in **test mode**, play will automatically switch to the **test** framework id and load the **application.conf** file accordingly. Check "this page":ids for more informations.
+
+Open a browser to the "http://localhost:9000/@tests":http://localhost:9000/@tests URL to see the test runner. Try to select all the default tests and run them; all should be green... But these default tests don't really test anything.
+
+!images/guide2-1!
+
+To test the model part of the application we will use a JUnit test. As you see a default BasicTests.java already exists, so let's open it (**/yabe/test/BasicTest.scala**):
+
+bc. import org.junit._
+import org.junit.Assert._
+import play.test._
+import play.db.jpa.QueryFunctions._
+import models._
+ 
+class BasicTest extends UnitTest {
+ 
+    @Test
+    def aVeryImportantThingToTest() {
+    	
+        assertEquals(2, 1 + 1)
+    }
+ 
+}
+
+
+Remove the useless default test (aVeryImportantThingToTest) and create a test that tries to create a new user and retrieve it:
+
+bc. @Test
+def createAndRetrieveUser() {
+    // Create a new user and save it
+    new User("[e-mail]", "secret", "Bob").save()
+ 
+    // Retrieve the user with bob's email address
+    val bob = find[User]("byEmail", "[e-mail]").first
+ 
+    // Test 
+    assertNotNull(bob)
+    assertEquals("Bob", bob.fullname)
+}
+
+
+As you can see, the Model superclass gives us the very useful **save()** method and the QueryFunctions import gives us the **find** function.
+Select **BasicTests** in the test runner, click start and check that all is green. 
+
+We will need a method on User that checks if a user with a specified username and password exists. But in Scala, methods that don't act on a specific instance need to be defined in a companion object. Let's write it and test it.
+
+In the **User.scala** source, add an import statement (either at the top or just before the new code), the User **object** definition and the **connect()** method:
+
+bc. import play.db.jpa.QueryFunctions._
+ 
+object User {
+    def connect(email: String, password: String) = {
+        find[User]("byEmailAndPassword", email, password).first
+    }
+}
+
+And now the test case:
+
+bc. @Test
+def tryConnectAsUser() {
+    // Create a new user and save it
+    new User("[e-mail]", "secret", "Bob").save()
+ 
+    // Test 
+    assertNotNull(User.connect("[e-mail]", "secret"))
+    assertNull(User.connect("[e-mail]", "badpassword"))
+    assertNull(User.connect("[e-mail]", "secret"))
+}
+
+Each time you make a modification you can run all the tests from the play test runner to make sure you didn't break anything. 
+
+h2. <a>The Post class</a>
+
+The Post class will represent blog posts. Let's write a first implementation:
+
+bc. package models
+ 
+import java.util._
+import javax.persistence._
+import play.db.jpa._
+ 
+@Entity
+class Post(
+    @ManyToOne
+    var author: User,
+    var title: String,
+    @Lob
+    var content: String
+) extends Model {
+ 
+    var postedAt: Date = new Date()
+ 
+    def this() = this(null, null, null)
+}
+
+Here we use the **@Lob** annotation to tell JPA to use a large text database type to store the post content. We have declared the relation to the User class using **@ManyToOne**. That means that each Post is authored by a single User, and that each User can author several Posts.
+
+We will write a new test case to check that the Post class works as expected. But before to write more tests, we need to do something in the JUnit class. In the current test, the database content is never deleted, each new run creating more and more objects. It will become problematic soon when more advanced test will start to count objects to check that all is fine.
+
+So let's write a JUnit **setup()** method to delete the database before each test:
+
+bc. public class BasicTest extends UnitTest {
+ 
+    @Before
+    def setup() {
+        Fixtures.deleteAll()
+    }
+    
+    ...
+ 
+}
+
+p(note). The **@Before** concept is a core concept of the JUnit testing tool.
+
+As you can see, the Fixtures class is a helper to deal with your database during tests. Run the test again to check that you don't have broken anything, and start to write the next test:
+
+bc. @Test
+def createPost() {
+    // Create a new user and save it
+    val bob: User = new User("[e-mail]", "secret", "Bob").save()
+ 
+    // Create a new post
+    new Post(bob, "My first post", "Hello world").save()
+ 
+    // Test that the post has been created
+    assertEquals(1L, count[Post])
+ 
+    // Retrieve all post created by bob
+    val bobPosts = find[Post]("byAuthor", bob).fetch
+ 
+    // Tests
+    assertEquals(1, bobPosts.length)
+    val firstPost = bobPosts.head
+    assertNotNull(firstPost)
+    assertEquals(bob, firstPost.author)
+    assertEquals("My first post", firstPost.title)
+    assertEquals("Hello world", firstPost.content)
+    assertNotNull(firstPost.postedAt)
+}
+
+
+h2. <a>Finish with Comment</a>
+
+The last thing that we need to add at this first model draft is the ability to attach comments to posts.
+
+The creation of the Comment class is pretty straightforward.
+
+bc. package models
+ 
+import java.util._
+import javax.persistence._
+import play.db.jpa._
+ 
+@Entity
+class Comment(
+    @ManyToOne
+    var post: Post,
+    var author: String,
+    @Lob
+    var content: String
+) extends Model {
+ 
+    var postedAt: Date = new Date()
+ 
+    def this() = this(null, null, null)
+}
+
+Let's write a first test case:
+
+bc. @Test
+def postComments() {
+    // Create a new user and save it
+    val bob: User = new User("[e-mail]", "secret", "Bob").save()
+ 
+    // Create a new post
+    val bobPost: Post = new Post(bob, "My first post", "Hello world").save()
+ 
+    // Post a first comment
+    new Comment(bobPost, "Jeff", "Nice post").save()
+    new Comment(bobPost, "Tom", "I knew that !").save()
+ 
+    // Retrieve all comments
+    val bobPostComments = find[Comment]("byPost", bobPost).fetch
+ 
+    // Tests
+    assertEquals(2, bobPostComments.length)
+ 
+    val firstComment = bobPostComments(0)
+    assertNotNull(firstComment)
+    assertEquals("Jeff", firstComment.author)
+    assertEquals("Nice post", firstComment.content)
+    assertNotNull(firstComment.postedAt)
+ 
+    val secondComment = bobPostComments(1)
+    assertNotNull(secondComment)
+    assertEquals("Tom", secondComment.author)
+    assertEquals("I knew that !", secondComment.content)
+    assertNotNull(secondComment.postedAt)
+}
+
+You see that the navigation between Post and Comments is not very easy: we need to use a query to retrieve all comments attached to Post. We can do better by setting up the other side of the relationship to the Post class. 
+
+Add the comments field to the Post class:
+
+bc. ...
+    @OneToMany(mappedBy="post", cascade=Array(CascadeType.ALL))
+    var comments: List[Comment] = new ArrayList[Comment]
+...
+
+Note how we have used the **mappedBy** attribute to tell JPA that the Post class maintains the relationship. When you define bi-directional relation with JPA it is very important to tell which side will maintain the relationship. In this case, since the Comments belong to the Post it's better that the Comment class maintains the relationship.
+
+We have set the **casacade** property to tell JPA that we want that the Post deletion be cascaded to comments. This way, if you delete a post, all related comments will be deleted as well.
+
+With this new relationship, we will add a helper method to the Post class to simplify adding comments:
+
+bc. def addComment(author: String, content: String): Post = {
+    val newComment: Comment = new Comment(this, author, content).save()
+    this.comments.add(newComment)
+    return this
+}
+
+Let's write another test case to check that:
+
+bc. @Test
+def useTheCommentsRelation() {
+    // Create a new user and save it
+    val bob: User = new User("[e-mail]", "secret", "Bob").save()
+ 
+    // Create a new post
+    var bobPost: Post = new Post(bob, "My first post", "Hello world").save()
+ 
+    // Post a first comment
+    bobPost.addComment("Jeff", "Nice post")
+    bobPost.addComment("Tom", "I knew that !")
+ 
+    // Count things
+    assertEquals(1L, count[User])
+    assertEquals(1L, count[Post])
+    assertEquals(2L, count[Comment])
+ 
+    // Retrieve Bob's post
+    bobPost = find[Post]("byAuthor", bob).first
+    assertNotNull(bobPost)
+ 
+    // Navigate to comments
+    assertEquals(2, bobPost.comments.size())
+    assertEquals("Jeff", bobPost.comments.get(0).author)
+ 
+    // Delete the post
+    bobPost.delete();
+ 
+    // Check the all comments have been deleted
+    assertEquals(1L, count[User])
+    assertEquals(0L, count[Post])
+    assertEquals(0L, count[Comment])
+}
+
+Is it green?
+
+!images/guide2-2!
+
+h2. <a>Using Fixtures to write more complicated test</a>
+
+When you start to write more complex tests, you often need a set of data to test on. Fixtures lets you describe your model in a YAML file and load it at any time before a test.
+
+Edit the **/yabe/test/data.yml** file and start to describe a User:
+
+bc. 
+User(bob):
+    email: [e-mail]
+    password: secret
+    fullname: Bob
+ 
+...
+ 
+
+Well, because the data.yml file is a litle big, you can "download it here":files/data.yml.
+
+Now we create create a test case that loads this data and run some assertions over it:
+
+bc. @Test
+def fullTest() {
+    Fixtures.load("data.yml")
+ 
+    // Count things
+    assertEquals(2L, count[User])
+    assertEquals(3L, count[Post])
+    assertEquals(3L, count[Comment])
+ 
+    // Try to connect as users
+    assertNotNull(User.connect("[e-mail]", "secret"))
+    assertNotNull(User.connect("[e-mail]", "secret"))
+    assertNull(User.connect("[e-mail]", "badpassword"))
+    assertNull(User.connect("[e-mail]", "secret"))
+ 
+    // Find all bob posts
+    val bobPosts = find[Post]("author.email", "[e-mail]").fetch
+    assertEquals(2, bobPosts.length)
+ 
+    // Find all comments related to bob posts
+    val bobComments = find[Comment]("post.author.email", "[e-mail]").fetch
+    assertEquals(3, bobComments.length)
+ 
+    // Find the most recent post
+    val frontPost = find[Post]("order by postedAt desc").first
+    assertNotNull(frontPost)
+    assertEquals("About the model layer", frontPost.title)
+ 
+    // Check that this post has two comments
+    assertEquals(2, frontPost.comments.size())
+ 
+    // Post a new comment
+    frontPost.addComment("Jim", "Hello guys")
+    assertEquals(3, frontPost.comments.size())
+    assertEquals(4L, count[Comment])
+}
+
+h2. <a>Save your work</a>
+
+We have now finished an huge part on the blog engine. With all this things created and tested, we can now start to develop the web application itself.
+
+But before continuing, it's time to save your work in bazaar. Open a command line an type **bzr st** to see the modifications made since the latest commit:
+
+bc. $ bzr st
+
+As you can see, some new files are not under version control. The **test-result** folder doesn't need to be versioned, so let's ignore it.
+
+bc. $ bzr ignore test-result
+
+Add other files to version control using **bzr add**.
+
+bc. $ bzr add
+
+You can now commit your project.
+
+bc. $ bzr commit -m "The model layer is ready"
+
+p(note). Go to the "next part":scguide3. 

=== added file 'documentation/manual/scguide3.textile'
--- documentation/manual/scguide3.textile	1970-01-01 00:00:00 +0000
+++ documentation/manual/scguide3.textile	2010-09-16 22:21:08 +0000
@@ -0,0 +1,329 @@
+h1. Building the first screen (Scala version)
+
+Now that we have built a first data model, it's time to start to create the first page of the application. This page will just show the most recent posts, as well as a list of older posts.
+
+Here is a mock of what we want to achieve:
+
+!images/guide-mock1!
+
+h2. <a>Bootstrapping with default data</a>
+
+In fact before coding the first screen we need one more thing. Working on a web application without test data is not fun. You can't even test what you're doing. But because we haven't developed the contribution screens yet, we can't populate the blog with posts ourselves. 
+
+One way to inject default data into the blog is to load a fixture file at application load time. To do that we will create a Bootstrap Job. A play job is something that executes itself outside of any HTTP request, for example at the application start or at specific interval using a CRON job.
+
+Let's create the **/yabe/app/Bootstrap.java** job that will load a set of default data using fixture:
+
+bc. import play._
+import play.jobs._
+import play.test._
+import play.db.jpa.QueryFunctions._
+ 
+import models._
+ 
+@OnApplicationStart
+class Bootstrap extends Job {
+ 
+    override def doJob() {
+        // Check if the database is empty
+        if(count[User] == 0) {
+            Fixtures.load("initial-data.yml")
+        }
+    }
+ 
+}
+
+We have annotated this Job with the **@OnApplicationStart** annotation to tell play that we want to run this jobs synchronously at the application start.
+
+p(note). In fact this job will be run differently in DEV or PROD modes. In DEV mode, play waits for a first request to start. So this job will be executed synchronously at the first request. This way, if the job fail, you will get the error message in your browser. In PROD mode however, the job will be executed at application start (synchrously with the **'play run'** command) and will prevent the application to start in case of error.
+
+You have to create a initial-data.yml in the **/yabe/conf** directory. You can of course reuse the **data.yml** content that we just used for tests previously.
+
+Now run the application using **play run** and display the "http://localhost:9000":http://localhost:9000 page in the browser.
+
+h2. <a>The blog home page</a>
+
+This time, we can really start to code the home page.
+
+Do you remember how the first page is displayed? First the routes file defines that the **/** URL will invoke the **controllers.Application.index()** action method. Then this method calls **render()** and execute the **/yabe/app/views/Application/index.html** template.
+
+We will keep these components but add code to them to load the posts list and display them.
+
+Open the **/yabe/app/controllers/Application.java** controller and modify the **index()** action to load the posts list, as is:
+
+bc. package controllers
+ 
+import play._
+import play.mvc._
+import play.db.jpa.QueryFunctions._
+ 
+import models._
+ 
+object Application extends Actions {
+ 
+    def index() {
+        val frontPost = find[Post]("order by postedAt desc").first
+        val olderPosts = find[Post](
+            "order by postedAt desc"
+        ).from(1).fetch(10)
+ 
+        render(frontPost, olderPosts)
+    }
+ 
+}
+
+Can you see how we pass objects to the render method? It will allow us to access them from the template using the same name.
+
+Open the **/yabe/app/views/Application/index.html** and modify it to display these objects:
+
+bc. #{extends 'main.html' /}
+#{set title:'Home' /}
+ 
+#{if frontPost}
+    <div class="post">
+        <h2 class="post-title">
+            <a href="#">${frontPost.title}</a>
+        </h2>
+        <div class="post-metadata">
+            <span class="post-author">by ${frontPost.author.fullname}</span>
+            <span class="post-date">${frontPost.postedAt.format('MMM dd')}</span>
+            <span class="post-comments">
+                &nbsp;|&nbsp; 
+                ${frontPost.comments.size() ?: 'no'} 
+                comment${frontPost.comments.size().pluralize()}</a>
+                #{if frontPost.comments}
+                    , latest by ${frontPost.comments[0].author}
+                #{/if}
+            </span>
+        </div>
+        <div class="post-content">
+            ${frontPost.content.nl2br()}
+        </div>
+    </div>
+    
+    #{if olderPosts.size() > 1}
+        <div class="older-posts">    
+            <h3>Older posts <span class="from">from this blog</span></h3>
+        
+            #{list items:olderPosts, as:'oldPost'}
+                <div class="post">
+                    <h2 class="post-title">
+                        <a href="#">${oldPost.title}</a>
+                    </h2>
+                    <div class="post-metadata">
+                        <span class="post-author">
+                            by ${oldPost.author.fullname}
+                        </span>
+                        <span class="post-date">
+                            ${oldPost.postedAt.format('dd MMM yy')}
+                        </span>
+                        <div class="post-comments">
+                            ${oldPost.comments.size() ?: 'no'} 
+                            comment${oldPost.comments.size().pluralize()}
+                            #{if oldPost.comments}
+                                - latest by ${oldPost.comments[0].author}
+                            #{/if}
+                        </div>
+                    </div>
+                </div>
+            #{/list}
+        </div>
+        
+    #{/if}
+    
+#{/if}
+ 
+#{else}
+    <div class="empty">
+        There is currently nothing to read here.
+    </div>
+#{/else}
+
+You can read more about the "template language here":templates. Basically, it allows you to access your java objects dynamically. Under the hood we use Groovy. Most of the pretty constructs you see (like the ?: operator) come from Groovy. But you don't really need to learn groovy to write play templates. If you're already familiar with another template language like JSP with JSTL you won't be lost.
+
+OK, now refresh the blog home page.
+
+!images/guide3-0!
+
+Not pretty but it works!
+
+However you see you have already started to duplicate code. Because we will display posts in several fashions (full, full with comment, teaser) we should create something like a function that we could call from several templates. This is exactly what a play tag does!
+
+To create a tag, just create the new **/yabe/app/views/tags/display.html** file. A tag is just another template. It has parameters (like a function). The **#{display /}** tag will have 2 parameters: the Post object to display and the display mode which will be one of 'home', 'teaser' or 'full'.
+
+bc. *{ Display a post in one of these modes: 'full', 'home' or 'teaser' }*
+ 
+<div class="post ${_as == 'teaser' ? 'teaser' : ''}">
+    <h2 class="post-title">
+        <a href="#">${_post.title}</a>
+    </h2>
+    <div class="post-metadata">
+        <span class="post-author">by ${_post.author.fullname}</span>,
+        <span class="post-date">${_post.postedAt.format('dd MMM yy')}</span>
+        #{if _as != 'full'}
+            <span class="post-comments">
+                &nbsp;|&nbsp; ${_post.comments.size() ?: 'no'} 
+                comment${_post.comments.size().pluralize()}
+                #{if _post.comments}
+                    , latest by ${_post.comments[0].author}
+                #{/if}
+            </span>
+        #{/if}
+    </div>
+    #{if _as != 'teaser'}
+        <div class="post-content">
+            <div class="about">Detail: </div>
+            ${_post.content.nl2br()}
+        </div>
+    #{/if}
+</div>
+ 
+#{if _as == 'full'}
+    <div class="comments">
+        <h3>
+            ${_post.comments.size() ?: 'no'} 
+            comment${_post.comments.size().pluralize()}
+        </h3>
+        
+        #{list items:_post.comments, as:'comment'}
+            <div class="comment">
+                <div class="comment-metadata">
+                    <span class="comment-author">by ${comment.author},</span>
+                    <span class="comment-date">
+                        ${comment.postedAt.format('dd MMM yy')}
+                    </span>
+                </div>
+                <div class="comment-content">
+                    <div class="about">Detail: </div>
+                    ${comment.content.escape().nl2br()}
+                </div>
+            </div>
+        #{/list}
+        
+    </div>
+#{/if}
+
+Now using this tag we can rewrite the home page without code duplication :
+
+bc. #{extends 'main.html' /}
+#{set title:'Home' /}
+ 
+#{if frontPost}
+    
+    #{display post:frontPost, as:'home' /}
+    
+    #{if olderPosts.size()}
+    
+        <div class="older-posts">
+            <h3>Older posts <span class="from">from this blog</span></h3>
+        
+            #{list items:olderPosts, as:'oldPost'}
+                #{display post:oldPost, as:'teaser' /}
+            #{/list}
+        </div>
+        
+    #{/if}
+    
+#{/if}
+ 
+#{else}
+    <div class="empty">
+        There is currently nothing to read here.
+    </div>
+#{/else}
+
+Reload the page and check that all is fine.
+
+h2. <a>Improving the layout</a>
+
+As you can see, the **index.html** template extends **main.html**. Because we want to provide a common layout to all blog pages with the blog title and authentication links, we need to modify this file.
+
+Edit the **/yabe/app/views/main.html** file :
+
+bc. <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+ 
+<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
+    <head>
+        <title>#{get 'title' /}</title>		
+        <meta http-equiv="Content-Type" content="text/html; charset=utf-8"/>
+        <link rel="stylesheet" type="text/css" media="screen" 
+            href="@{'/public/stylesheets/main.css'}" />
+        <link rel="shortcut icon" type="image/png" 
+            href="@{'/public/images/favicon.png'}" />
+    </head>
+    <body>
+        
+        <div id="header">
+            <div id="logo">
+                yabe.
+            </div>
+            <ul id="tools">
+                <li>
+                    <a href="#">Log in to write something</a>
+                </li>
+            </ul>
+            <div id="title">
+                <span class="about">About this blog</span>
+                <h1><a href="#">${blogTitle}</a></h1>
+                <h2>${blogBaseline}</h2>
+            </div>
+        </div>
+        
+        <div id="main">
+            #{doLayout /} 
+        </div>
+        
+        <p id="footer">
+            Yabe is a (not that) powerful blog engine built with the 
+            <a href="http://www.playframework.org">play framework</a>
+            as a tutorial application.
+        </p>
+        
+    </body>
+</html>
+
+Refresh and check the result. It seems to work, except that the **blogTitle** and the **blogBaseLine** variables are not displayed. This is because we didn't pass them during the **render(...)** call. Of course we could add them to the **render()** call in the index action. But because the **main.html** file will be used as main template for all application actions, we don't want to add them every time.
+
+One way to execute the same code for each action of a controller (or a hierarchy of controllers) is to define a **@Before** interceptor. 
+
+Let's add the **addDefaults()** method to the Application controller :
+
+bc. @Before
+def addDefaults() {
+	renderArgs.put("blogTitle", Play.configuration.getProperty("blog.title"))
+	renderArgs.put("blogBaseline", Play.configuration.getProperty("blog.baseline"))
+}
+
+All variables added to the **renderArgs** scope will be available from the templates. And you can see that the method reads the variable's values from the **Play.configuration** object. This object contains all configuration keys from the **/yabe/conf/application.conf** file.
+
+Add these 2 keys to the configuration file:
+
+bc. # Configuration of the blog engine
+# ~~~~~
+blog.title=Yet another blog
+blog.baseline=We won't write about anything
+
+Reload the home page and check that it works!
+
+!images/guide3-1!
+
+h2. <a>Adding some style</a>
+
+Now the blog home page is almost done, but it's not really pretty. We'll add some style to make it shinier. As you have seen, the main template file main.html includes the **/public/stylesheets/main.css** stylesheet. We'll keep it but add more style rules to it.
+
+You can "download it here":files/main.css, and copy it to the **/public/stylsheets/main.css** file.
+
+Refresh the home page and you should see a styled page now.
+
+!images/guide3-2!
+
+h2. <a>Commit your work</a>
+
+This time the blog home page is finished. As usual we can commit this blog version to bazaar:
+
+bc. $ bzr st
+$ bzr add
+$ bzr commit -m 'Home page'
+
+p(note). Go to the "next part":scguide4. 
+

=== added file 'documentation/manual/scguide4.textile'
--- documentation/manual/scguide4.textile	1970-01-01 00:00:00 +0000
+++ documentation/manual/scguide4.textile	2010-09-16 22:21:08 +0000
@@ -0,0 +1,245 @@
+h1. Viewing and posting comments (Scala version)
+
+The blog home page is now set, and we will continue by writing the post details page. This page will show all the comments about the current post, and will include a form to post new comments.
+
+h2. <a>Creating the 'show' action</a>
+
+To display the post details page, we will need a new action method to the Application controller. Let's call it **show()**:
+
+bc. def show(id: Long) {
+	val post = findById[Post](id)
+	render(post)
+}
+
+As you can see this action is pretty simple. We declare the **id** method parameter to automatically retrieve the HTTP **'id'** parameter as a Long  object. This parameter will be extracted either from the queryString, from the URL path or from the request body.
+
+p(note). If we try to send an **id** HTTP parameter that is not a valid number, the id variable value will be null and play will automatically add a validation error to the **errors** container.
+
+This action will display the **/yabe/app/views/Application/show.html** template :
+
+bc. #{extends 'main.html' /}
+#{set title:post.title /}
+ 
+#{display post:post, as:'full' /}
+
+Because we've already written the display tag, this page is really simple to write.
+
+h2. <a>Adding links to the details page</a>
+
+In the display tag we've left all links empty (using #). It's now time to make these links pointing to the **Application.show** action. With play you can easily build links in a template using the **@{...} notation**. This syntax uses the router to 'reverse' the URL needed to call the specified action. 
+
+Let's edit the **/yabe/app/views/tags/display.html** tag :
+
+bc. ...
+<h2 class="post-title">
+    <a href="@{Application.show(_post.id)}">${_post.title}</a>
+</h2>
+...
+
+You can new refresh the home page, and click on a post title to display it. 
+
+!images/guide4-0!
+
+It's great, but it lacks a link to go back to the home page. Edit the **/yabe/app/views/main.html** template to complete the title link:
+
+bc. ...
+<div id="title">
+    <span class="about">About this blog</span>
+    <h1><a href="@{Application.index()}">${blogTitle}</a></h1>
+    <h2>${blogBaseline}</h2>
+</div>
+... 
+
+We can now navigate between the home page and the post detail pages.
+
+h2. <a>Specifying a better URL</a>
+
+As you can see, the post detail page URL looks like
+
+bc. /application/show?id=1
+
+This is because play has used the default 'catch all' route.
+
+bc. *       /{controller}/{action}                  {controller}.{action}
+
+We can have a better URL by specifying a custom path for the **Application.show** action. Edit the **/yabe/conf/routes** file and add this route after the first one:
+
+bc. GET     /posts/{id}                             Application.show
+
+p(note). This way the id parameter will be extracted from the URL path.
+
+Refresh the browser and check that it now uses the correct URL.
+
+h2. <a>Adding some pagination</a>
+
+To allow users to navigate easily through posts, we will add a pagination mechanism. We'll extend the Post class to be able to fetch the previous and next post as required:
+
+bc. import play.db.jpa.QueryFunctions._
+...
+def previous(): Post = {
+    find[Post]("postedAt < ? order by postedAt desc", postedAt).first
+}
+ 
+def next(): Post = {
+    find[Post]("postedAt > ? order by postedAt asc", postedAt).first
+}
+
+Since we will call these methods several times during a request it could be optimized, but it's good enough for now. Also, add the pagination links in top of the show.html template (before the **#{display/}** tag):
+
+bc. <ul id="pagination">
+    #{if post.previous()}
+        <li id="previous">
+            <a href="@{Application.show(post.previous().id)}">
+                ${post.previous().title}
+            </a>
+        </li>
+    #{/if}
+    #{if post.next()}
+        <li id="next">
+            <a href="@{Application.show(post.next().id)}">
+                ${post.next().title}
+            </a>
+        </li>
+    #{/if}
+</ul>
+
+It's better now.
+
+h2. <a>Adding the comment form</a>
+
+Now it's time to set up a comments form. We'll start by adding the **postComment** action method to the Application controller.
+
+bc. def postComment(postId: Long, author: String, content: String) {
+    val post = findById[Post](postId)
+    post.addComment(author, content)
+    show(postId)
+}
+
+As you see we just reuse the **addComment()** method we previously added to the Post class.
+
+Let's write the HTML form in the show.html template (after the **#{display /}** tag in fact):
+
+bc. <h3>Post a comment</h3>
+ 
+#{form @Application.postComment(post.id)}
+    <p>
+        <label for="author">Your name: </label>
+        <input type="text" name="author" id="author" />
+    </p>
+    <p>
+        <label for="content">Your message: </label>
+        <textarea name="content" id="content"></textarea>
+    </p>
+    <p>
+        <input type="submit" value="Submit your comment" />
+    </p>
+#{/form}
+
+You can try to post a new comment. It should just work.
+
+!images/guide4-1!
+
+h2. <a>Adding validation</a>
+
+Currently we don't validate the form content before creating the comment. We would like to set both fields as required. We can easily use the play validation mechanism to ensure that HTTP parameters are correctly filled. Modify the **postComment** action to add validation annotations and check that no error occurs:
+
+bc. def postComment(postId: Long, @Required author: String, @Required content: String) {
+    val post = findById[Post](postId)
+    if (Validation.hasErrors()) {
+        render("Application/show.html", post)
+    }
+    post.addComment(author, content)
+    show(postId)
+}
+
+p(note). **Don't forget** to import play.data.validation._ as well.
+
+As you see, in case of validation errors, we re-display the post detail page. We have to modify the form code to display the error message:
+
+bc. <h3>Post a comment</h3>
+ 
+#{form @Application.postComment(post.id)}
+ 
+    #{ifErrors}
+        <p class="error">
+            All fields are required!
+        </p>
+    #{/ifErrors}
+ 
+    <p>
+        <label for="author">Your name: </label>
+        <input type="text" name="author" id="author" value="${params.author}" />
+    </p>
+    <p>
+        <label for="content">Your message: </label>
+        <textarea name="content" id="content">${params.content}</textarea>
+    </p>
+    <p>
+        <input type="submit" value="Submit your comment" />
+    </p>
+#{/form}
+
+Note that we reuse the posted parameters to fill the HTML input values.
+
+To make the UI feedback more pleasant for the poster, we will add a little Javascript to automatically focus the comment form in case of an error. As this script uses "JQuery":files/jquery-1.3.2.min.js and "JQuery Tools":files/jquery.tools.min.js as support libraries, you have to include them. Download these 2 libraries to the **/yabe/public/javascripts** directory and modify the **main.html** template to include them:
+
+bc. ...
+    <script src="@{'/public/javascripts/jquery-1.3.2.min.js'}"></script>
+    <script src="@{'/public/javascripts/jquery.tools.min.js'}"></script>
+</head>
+
+Now you can add this script to the **show.html** template (add it at the end of the page):
+
+bc. <script type="text/javascript" charset="utf-8">
+    $(function() {         
+        // Expose the form 
+        $('form').click(function() { 
+            $('form').expose({api: true}).load(); 
+        }); 
+        
+        // If there is an error, focus to form
+        if($('form .error').size()) {
+            $('form').expose({api: true, loadSpeed: 0}).load(); 
+            $('form input').get(0).focus();
+        }
+    });
+</script>
+
+!images/guide4-2!
+
+The comment form looks pretty cool now. We will add two more things.
+
+First we will display a success message after a comment is successfully posted. For that, we use the flash scope that allows to dispatch messages from one action call to the next one.
+
+Modify the **postComment** action to add a success message:
+
+bc. public static void postComment(Long postId, @Required String author, @Required String content) {
+    Post post = Post.findById(postId);
+    if(validation.hasErrors()) {
+        render("Application/show.html", post);
+    }
+    post.addComment(author, content);
+    flash.success("Thanks for posting, %s", author);
+    show(postId);
+}
+
+and display the success message in the **show.html** if present (add it at the top the page):
+
+bc. ...
+#{if flash.success}
+    <p class="success">${flash.success}</p>
+#{/if}
+ 
+#{display post:post, as:'full' /}
+...
+
+!images/guide4-3!
+
+The last thing we will adjust in this form is the URL used for the **postComment** action. As always it uses the default catch all route because we didn't define any specific route. So add this route to the application routes file:
+
+bc. POST    /posts/{postId}/comments                Application.postComment
+
+That's done. As always, commit the version to bazaar.
+
+p(note). Go to the "next part":scguide5. 
+

=== added file 'documentation/manual/scguide5.textile'
--- documentation/manual/scguide5.textile	1970-01-01 00:00:00 +0000
+++ documentation/manual/scguide5.textile	2010-09-16 22:21:08 +0000
@@ -0,0 +1,137 @@
+h1. Setting up a captcha (Scala version)
+
+Because anyone can post a comment to our blog engine, we should protect it a little to avoid automated spam. A simple way to protect a form from this is to add a captcha image.
+
+h2. <a>Generating the captcha image</a>
+
+We'll start to see how we can easily generate a captcha image using play. Basically we will just use another action, except that it will return a binary stream instead of HTML responses like what we've returned so far.
+
+Play being a **full-stack** web framework, we try to include built-in constructs for a web application's most typical needs; generating a captcha is one of them. We can use the **play.libs.Images** utility to simply generate a captcha image, and then write it to the HTTP response. 
+
+As usual, we will start with a simple implementation. Add the **captcha** action to the **Application** controller:
+
+bc. def captcha() {
+    val captcha = Images.captcha()
+    renderBinary(captcha)
+}
+
+Note that we can pass the captcha object directly to the renderBinary() method because the Images.Captcha class implements java.io.InputStream. 
+
+p(note). **Don't forget** to import play.libs._
+
+Now add a new route to the **/yabe/conf/routes** file:
+
+bc. GET     /captcha                                Application.captcha
+
+And try the **captcha** action by opening "http://localhost:9000/captcha":http://localhost:9000/captcha.
+
+!images/guide5-1!
+
+It should generate a random text for each refresh.
+
+h2. <a>How to manage the state?</a>
+
+Until now it was easy, but the most complicated part is coming. To validate the captcha we need to save the random text written to the captcha image and then check it at the form submission time. 
+
+Of course we could just put the text in the user session at image generation time and then retrieve it later. But this solution has two drawbacks:
+
+**First** the play session is stored as a cookie. It solves a lot of problems in terms of architecture but has a lot of implications. Data written to the session cookie are signed (so the user can't modify them) but not encrypted. If we write the captcha code to the session any bot could easily resolve it by reading the session cookie.
+
+**Then** remember that play is a **stateless** framework. We want to manage things in a pure stateless way. Typically, what happens if a user simultaneously opens two different blog pages with two different captcha images? We have to track the captcha code for each form.
+
+So to resolve the problem we need two things. We will store the captcha secret key on the server side. Because it is transient data we can easily use the play **Cache**. Moreover because cached data have a limited life time it will add one more security mechanism (let's say that a captcha code will be available for only 10mn). Then to resolve the code later we need to generate a **unique ID**. This unique ID will be added to each form as a hidden field and implicitly references a generated captcha code.
+
+This way we elegantly solve our state problem.
+
+Modify the **captcha** action as follows:
+
+bc. def captcha(id: String) {
+    val captcha = Images.captcha()
+    val code = captcha.getText("#E4EAFD")
+    Cache.set(id, code, "10mn")
+    renderBinary(captcha)
+}
+
+Note that the **getText()** method takes any color as parameter. It will use this color to draw the text.
+
+p(note). **Don't forget** to import play.cache._
+
+h2. <a>Adding the captcha image to the comment form</a>
+
+Now, before displaying a comment form we will generate a unique ID. Then we will modify the HTML form to integrate a captcha image using this ID, and add the ID to another hidden field.
+
+Let's rewrite the **Application.show** action:
+
+bc. public static void show(Long id) {
+    Post post = Post.findById(id);
+    String randomID = Codec.UUID();
+    render(post, randomID);
+}
+
+And now the form in the **/yable/app/views/Application/show.html** template:
+
+bc. ...
+<p>
+    <label for="content">Your message: </label>
+    <textarea name="content" id="content">${params.content}</textarea>
+</p>
+<p>
+    <label for="code">Please type the code below: </label>
+    <img src="@{Application.captcha(randomID)}" />
+    <br />
+    <input type="text" name="code" id="code" size="18" value="" />
+    <input type="hidden" name="randomID" value="${randomID}" />
+</p>
+<p>
+    <input type="submit" value="Submit your comment" />
+</p>
+...
+
+Good start. The comment form now has a captcha image.
+
+!images/guide5-2!
+
+h2. <a>Validating the captcha</a>
+
+Now we just have to validate the captcha. We have added the **randomID** as an hidden field right ? So we can retrieve it in the **postComment** action, then retrieve the actual code from Cache and finally compare it to the submitted code.
+
+Not that difficult. Let's modify the **postComment** action.
+
+bc. public static void postComment(
+        Long postId, 
+        @Required(message="Author is required") String author, 
+        @Required(message="A message is required") String content, 
+        @Required(message="Please type the code") String code, 
+        String randomID) 
+{
+    Post post = Post.findById(postId);
+    validation.equals(
+        code, Cache.get(randomID)
+    ).message("Invalid code. Please type it again");
+    if(validation.hasErrors()) {
+        render("Application/show.html", post, randomID);
+    }
+    post.addComment(author, content);
+    flash.success("Thanks for posting %s", author);
+    show(postId);
+}
+
+Because we have now more error messages, modify the way we display errors in the **show.html** template (yes we will just display the first error, it's good enough):
+
+bc. .. 
+#{ifErrors}
+    <p class="error">
+        ${errors[0]}
+    </p>
+#{/ifErrors}
+...
+
+p(note). Typically for more complex forms, error messages are not managed this way but externalized in the **messages** file and each error is printed in side of the corresponding field.
+
+Check that the captcha is now fully functional.
+
+!images/guide5-3!
+
+Great!
+
+p(note). Go to the "next part":guide6. 
\ No newline at end of file

=== removed file 'documentation/manual/search.textile'
--- documentation/manual/search.textile	2010-04-12 10:11:35 +0000
+++ documentation/manual/search.textile	1970-01-01 00:00:00 +0000
@@ -1,78 +0,0 @@
-h1. Search module
-
-The **Search** module allows you to have basic full text search functionality to your JPA Model. It is based on Lucene, and requires a real file system to store its indexes.
-
-h2. <a> Enable the module</a>
-
-In the **/conf/application.conf** file, enable the Search module by adding this line: 
-
-bc. # The search module
-module.search=${play.path}/modules/search
-
-h2. <a> Indexing your objects </a>
-
-Use the **@Indexed** annotation to mark **your Model**, and then use the **@Field** to mark the fields to be indexed.
-
-bc. @Indexed
-public class Folder extends Model {
-    @Field
-    @Column(unique=true)
-    public Integer poseidonNumber; 
-    @Field
-    public String object;
-
-The **@Field** annotation currently supports only primitive types.
-
-h2. <a> Search the objects </a>
-
-Use the **Search** helper to build your queries:
-
-bc. Search.search("object:dogs", Folder.class)
-
-The first parameter is a lucene query and the second is your Model class. You may want to refer to the Lucene query documentation at this point, knowing that the **Search** maintains a separated index per class and adds the properties marked with **@Field** as a Lucene Field.
-
-The Search.search returns a query object that you can tweak:
-
-bc. Query q = Search.search("object:dogs", Folder.class);
-q.orderBy("object")
-    .page(2,5)
-    .reverse();
-    
-
-To finish your query, if you wish to retrieve your **Model** objects, use
-
-bc. List<Folder> folders = q.fetch();
-    
-
-or to get only ids (to use in a JPA query by example...):
-
-bc. List<Long> folderIds = q.fetchIds();
-    
-
-To get full informations (like relevance), you would use:
-
-bc. List<QueryResult> results = q.executeQuery();
-    
-
-h2. <a> Maintaining the indexes </a>
-
-Each time you create, update or delete your **Model** objects, the corresponding index is automatically updated. 
-
-Should you need to re-index your objects (like if you have manually modified your database), you will reboot your application with:
-
-bc. play.search.reindex=enabled
-
-In your conf/application.conf. Don't forget to remove it after!
-
-h2. <a> Misc configuration </a>
-
-You can use the following properties in your conf/application.conf file:
-
-bc. play.search.path=/tmp/myDevApplication
-play.search.analyser=org.apache.lucene.analysis.standard.StandardAnalyzer
-
-**play.search.path** is where the module stores it's indexes
-**play.search.analyser** is the lucene analyzer class used for indexation.
-
-
-

=== modified file 'documentation/manual/tags.textile'
--- documentation/manual/tags.textile	2010-07-29 13:08:05 +0000
+++ documentation/manual/tags.textile	2010-09-16 22:21:08 +0000
@@ -92,6 +92,26 @@
 #{/errors}
 </table>
 
+h2. <a>ifErrors</a>
+
+If there's any validation error, tag's content will be rendered
+
+bc. #{ifErrors}
+  <p>Error(s) found!</p>
+#{/ifErrors}
+
+h2. <a>ifError</a>
+
+If corresponding input as error, tag's content will be rendered
+
+* **arg** (required) - input's name
+
+bc. #{ifError 'user.name'}
+  <p>
+    User name is invalid: 
+    #{error 'user.name' /}
+  <p>
+#{/ifError}
 
 h2. <a>extends</a>
 
@@ -343,3 +363,60 @@
 
 In this example, the first line outputs **&amp;** while the second line outputs an ampersand. 
 
+
+h2. <a>select</a>
+
+Insert a **select** tag in the template.
+
+* **name** (required) - attribute sets a name to the select element.
+
+Any unknow attribute will be considered as an HTML attribute, and rendered "as is"
+
+bc. #{select 'booking.beds', value:2, id:'select1'}
+	#{option 1}One king-size bed#{/option}
+	#{option 2}Two double beds#{/option}
+	#{option 3}Three beds#{/option}
+#{/select}
+
+Will output:
+
+bc. <select name="booking.beds" size="1" id="select1" >
+  <option value="1">One king-size bed</option>
+  <option value="2" selected="selected">Two double beds</option>
+  <option value="3">Three beds</option>
+</select>
+
+
+This tag can generate options using **items** attribute.
+
+* **items** (optional) - list of objects, used to create **options**
+* **value** (optional) - selected element in **items**
+* **labelProperty** (optional) - for each item, attribute used as option's label 
+* **valueProperty** (optional) - for each item, attribute used as option's value. **id** is used by default.
+
+For example, giving a list of User, each having a name attribute:
+
+bc. #{select 'users', items:users, valueProperty:'id', labelProperty:'name', value:'User-5', class:"test", id:'select2' /}
+
+Will output:
+
+bc. <select name="users" size="1" class="test" id="select2" >
+  <option value="0" >User-0</option>
+  <option value="1" >User-1</option>            
+  <option value="2" >User-2</option>            
+  <option value="3" >User-3</option>
+  <option value="4" >User-4</option>
+  <option value="5" selected="selected">User-5</option>
+</select>
+
+h2. <a>option</a>
+
+Insert an **option** tag in the template.
+
+* **value** - option's value
+
+bc. #{option user.id} ${user.name} #{/option}
+
+Will output:
+
+bc. <option value="42">jto</option>
\ No newline at end of file

=== modified file 'documentation/manual/templates.textile'
--- documentation/manual/templates.textile	2010-08-26 14:49:38 +0000
+++ documentation/manual/templates.textile	2010-09-16 22:21:08 +0000
@@ -22,7 +22,34 @@
 
 bc. <h1>Client ${client?.name}</h1>
 
-Which will only display the client name if the client is not null. 
+Which will only display the client name if the client is not null.
+
+h3. Template decorators : #{extends  /} and  #{doLayout  /}
+
+Decorators provide a clean solution to share a page layout (or design) across several templates. 
+
+p(note). Use "#{get}":tags#ageta and "#{set}":tags#aseta tags to share variables between the template and the decorator. 
+
+Embedding a page in a decorator is the matter of a one liner:
+
+bc. #{extends 'simpledesign.html' /}
+ 
+#{set title:'A decorated page' /}
+This content will be decorated.
+
+The decorator : **simpledesign.html**
+
+bc. <html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
+<head>
+  <title>#{get 'title' /}</title>
+  <link rel="stylesheet" type="text/css" href="@{'/public/stylesheets/main.css'}" />
+</head>
+<body>
+  <h1>#{get 'title' /}</h1>
+  #{doLayout /}
+  <div class="footer">Built with the play! framework</div>
+</body>
+</html>
 
 h3. Tags: #{tagName /}
 
@@ -212,7 +239,11 @@
 #{/list}
 </ul>
 
+<<<<<<< TREE
+The same applies to **java.util.Date**.
+=======
 You can find a list of available methods within the "API documentation":/@api/play/templates/JavaExtensions.html.
+>>>>>>> MERGE-SOURCE
 
 h3. Create custom extensions
 

=== modified file 'framework/build.xml'
--- framework/build.xml	2010-05-11 20:47:09 +0000
+++ framework/build.xml	2010-09-16 22:21:08 +0000
@@ -8,21 +8,27 @@
             <include name="*.jar"/>                        
         </fileset> 
     </path>
-        
+
     <target name="clean" description="clean resources">
         <delete dir="classes" /> 
         <delete dir="dist" />
         <delete dir="tests-results" />
         <delete dir="tests-tmp" />
         <delete file="play.jar" /> 
-        <delete file="src/play/version" /> 
+        <delete file="src/play/version" />  
         <delete includeemptydirs="true">
+            <fileset dir="pym">
+                <include name="**/*.pyc"/> 
+            </fileset>
             <fileset dir="../samples-and-tests">
                 <include name="**/test-result/**"/> 
                 <include name="**/tmp/**"/> 
                 <include name="**/db/**"/> 
                 <include name="**/attachments/**"/> 
                 <include name="**/nbproject/**"/>
+                <include name="**/data/**"/>
+                <include name="**/logs/**"/>
+                <include name="**/i-am-working-here/**"/>
             </fileset> 
         </delete>
     </target>
@@ -31,7 +37,7 @@
         <exec executable="bzr" outputproperty="bzrversion" errorproperty="bzrerror" failonerror="false" failifexecutionfails="false">
             <arg value="revno" />
         </exec>
-        <condition property="version" value="1.0-r${bzrversion}" else="1.0-localbuild">
+        <condition property="version" value="1.1-unstable-r${bzrversion}" else="1.1-unstable-localbuild">
             <equals arg1="" arg2="${bzrerror}" trim="true" />
         </condition> 
         <echo message="Version ${version}"></echo>
@@ -63,11 +69,15 @@
                windowtitle="Play! API">
             <classpath refid="project.classpath"/>
             <doctitle><![CDATA[<h1>Play! ${version}</h1>]]></doctitle>
-            <bottom><![CDATA[<a href="http://guillaume.bort.fr">Guillaume Bort</a> & <a href="http://www.zenexity.fr">zenexity</a> - Distributed under <a href="http://www.apache.org/licenses/LICENSE-2.0.html">Apache 2 licence</a>, without any warrantly]]></bottom>
+            <bottom><![CDATA[<a href="http://guillaume.bort.fr">Guillaume Bort</a> &amp; <a href="http://www.zenexity.fr">zenexity</a> - Distributed under <a href="http://www.apache.org/licenses/LICENSE-2.0.html">Apache 2 licence</a>, without any warrantly]]></bottom>
             <tag name="todo" scope="all" description="To do:"/>
             <group title="Libs" packages="play.libs.*"/>
-            <link offline="false" href="http://java.sun.com/j2se/1.5.0/docs/api/" />
-            <link href="http://developer.java.sun.com/developer/products/xml/docs/api/"/>
+            <link offline="false" href="http://java.sun.com/javaee/5/docs/api" />
+            <link offline="false" href="http://commons.apache.org/fileupload/apidocs" />
+            <link offline="false" href="http://google-gson.googlecode.com/svn/tags/1.2.3/docs/javadocs" />
+            <link offline="false" href="https://www.hibernate.org/hib_docs/v3/api" />
+            <link offline="false" href="http://www.mchange.com/projects/c3p0/apidocs" />
+            
         </javadoc>
     </target>
     
@@ -94,13 +104,14 @@
     </target>
     
     <target name="modules">
+        <property name="play.path" value="../.."/>
         <ant antfile="build.xml" target="build" dir="../modules/testrunner" />
     </target>
     
     <!-- Netbeans support -->
     
     <target name="nb-profile-application">
-        <property name="application.path" value="/Users/guillaume/Desktop/webmail" />
+        <property name="application.path" value="" />
         <loadfile property="play.id" srcFile="../id" failonerror="false" quiet="true" />  
         <loadproperties srcfile="${application.path}/conf/application.conf" />
         <property name="jpda.port" value="8000" />
@@ -194,7 +205,8 @@
         
         <echo message="Testing development lifecycle (wait ...)" />
 
-        <exec executable="${basedir}/../samples-and-tests/i-am-a-developer/tests.py" failonerror="true">
+        <exec executable="python" failonerror="false">
+            <arg value="${basedir}/../samples-and-tests/i-am-a-developer/tests.py" />
         </exec>
         
         <echo message="Using ${basedir}/../play${playExtension}" />
@@ -208,14 +220,14 @@
         </antcall>
         
         <antcall target="play-test">
+            <param name="testAppPath" value="${basedir}/../samples-and-tests/zencontact"/>
+        </antcall>
+        
+        <antcall target="play-test">
             <param name="testAppPath" value="${basedir}/../samples-and-tests/jobboard"/>
         </antcall>
         
         <antcall target="play-test">
-            <param name="testAppPath" value="${basedir}/../samples-and-tests/chat"/>
-        </antcall>
-        
-        <antcall target="play-test">
             <param name="testAppPath" value="${basedir}/../samples-and-tests/yabe"/>
         </antcall>
         
@@ -232,10 +244,6 @@
     <target name="play-test">
         <echo message="play auto-test ${testAppPath} (wait)" />
         <exec executable="${basedir}/../play${playExtension}" failonerror="true">
-            <arg value="clean"/>
-            <arg value="${testAppPath}"/>
-        </exec>
-        <exec executable="${basedir}/../play${playExtension}" failonerror="true">
             <arg value="auto-test"/>
             <arg value="${testAppPath}"/>
         </exec>
@@ -290,8 +298,9 @@
     <target name="package" depends="clean,version,jar,javadoc">
         <mkdir dir="dist" /> 
         <zip destfile="dist/play-${version}.zip" comment="Play! ${version}" update="false">
-            <zipfileset prefix="play-${version}" dir=".." includes="**/*" excludes=".*,.*/*,framework/dist/**,id,play,nbproject/**,**/.bzr/**,*.bzrignore,support/textmate/**,framework/classes/**,framework/tests-results/**,samples-and-tests/**/test-result,samples-and-tests/**/tmp,samples-and-tests/**/db,samples-and-tests/**/attachments" />   
+            <zipfileset prefix="play-${version}" dir=".." includes="**/*" excludes="**/cobertura.ser,**/*.pyc,hs_err*,.*,.*/*,framework/dist/**,id,play,nbproject/**,**/.bzr/**,*.bzrignore,support/textmate/**,framework/classes/**,framework/tests-results/**,samples-and-tests/**/test-result,samples-and-tests/**/i-am-working-here,samples-and-tests/**/data,samples-and-tests/**/logs,samples-and-tests/**/tmp,samples-and-tests/**/db,samples-and-tests/**/attachments,modules/**" />   
             <zipfileset prefix="play-${version}" dir=".." includes="play" filemode="777" />
+            <zipfileset prefix="play-${version}" dir=".." includes="modules/crud/**,modules/secure/**,modules/docviewer/**,modules/testrunner/**" excludes="**/*.pyc" />
         </zip>
     </target>
     

=== removed file 'framework/lib/SnakeYAML-1.2.jar'
Binary files framework/lib/SnakeYAML-1.2.jar	2009-05-06 19:32:26 +0000 and framework/lib/SnakeYAML-1.2.jar	1970-01-01 00:00:00 +0000 differ
=== removed file 'framework/lib/WikiText.jar'
Binary files framework/lib/WikiText.jar	2009-08-07 16:01:53 +0000 and framework/lib/WikiText.jar	1970-01-01 00:00:00 +0000 differ
=== removed file 'framework/lib/ZDB.jar'
Binary files framework/lib/ZDB.jar	2009-10-15 16:51:49 +0000 and framework/lib/ZDB.jar	1970-01-01 00:00:00 +0000 differ
=== added file 'framework/lib/activation-1.1.1.jar'
Binary files framework/lib/activation-1.1.1.jar	1970-01-01 00:00:00 +0000 and framework/lib/activation-1.1.1.jar	2010-09-16 22:21:08 +0000 differ
=== removed file 'framework/lib/activation.jar'
Binary files framework/lib/activation.jar	2008-11-20 16:26:31 +0000 and framework/lib/activation.jar	1970-01-01 00:00:00 +0000 differ
=== added file 'framework/lib/async-http-client-1.2.0-SNAPSHOT.jar'
Binary files framework/lib/async-http-client-1.2.0-SNAPSHOT.jar	1970-01-01 00:00:00 +0000 and framework/lib/async-http-client-1.2.0-SNAPSHOT.jar	2010-09-16 22:21:08 +0000 differ
=== removed file 'framework/lib/asyncweb-common-0.9.0-SNAPSHOT.jar'
Binary files framework/lib/asyncweb-common-0.9.0-SNAPSHOT.jar	2008-07-11 12:50:21 +0000 and framework/lib/asyncweb-common-0.9.0-SNAPSHOT.jar	1970-01-01 00:00:00 +0000 differ
=== removed file 'framework/lib/backport-util-concurrent-3.0.jar'
Binary files framework/lib/backport-util-concurrent-3.0.jar	2009-05-22 10:39:52 +0000 and framework/lib/backport-util-concurrent-3.0.jar	1970-01-01 00:00:00 +0000 differ
=== added file 'framework/lib/bcprov-jdk16-145.jar'
Binary files framework/lib/bcprov-jdk16-145.jar	1970-01-01 00:00:00 +0000 and framework/lib/bcprov-jdk16-145.jar	2010-09-16 22:21:08 +0000 differ
=== added file 'framework/lib/c3p0-0.9.1.2.jar'
Binary files framework/lib/c3p0-0.9.1.2.jar	1970-01-01 00:00:00 +0000 and framework/lib/c3p0-0.9.1.2.jar	2010-09-16 22:21:08 +0000 differ
=== removed file 'framework/lib/c3p0-0.9.1.jar'
Binary files framework/lib/c3p0-0.9.1.jar	2008-05-26 10:52:38 +0000 and framework/lib/c3p0-0.9.1.jar	1970-01-01 00:00:00 +0000 differ
=== added file 'framework/lib/cglib-2.2.jar'
Binary files framework/lib/cglib-2.2.jar	1970-01-01 00:00:00 +0000 and framework/lib/cglib-2.2.jar	2010-09-16 22:21:08 +0000 differ
=== removed file 'framework/lib/cglib-nodep-2.2.jar'
Binary files framework/lib/cglib-nodep-2.2.jar	2008-05-26 15:58:12 +0000 and framework/lib/cglib-nodep-2.2.jar	1970-01-01 00:00:00 +0000 differ
=== added file 'framework/lib/commons-beanutils-1.8.3.jar'
Binary files framework/lib/commons-beanutils-1.8.3.jar	1970-01-01 00:00:00 +0000 and framework/lib/commons-beanutils-1.8.3.jar	2010-09-16 22:21:08 +0000 differ
=== removed file 'framework/lib/commons-beanutils.jar'
Binary files framework/lib/commons-beanutils.jar	2008-06-23 22:35:20 +0000 and framework/lib/commons-beanutils.jar	1970-01-01 00:00:00 +0000 differ
=== added file 'framework/lib/commons-codec-1.4.jar'
Binary files framework/lib/commons-codec-1.4.jar	1970-01-01 00:00:00 +0000 and framework/lib/commons-codec-1.4.jar	2010-09-16 22:21:08 +0000 differ
=== removed file 'framework/lib/commons-codec.jar'
Binary files framework/lib/commons-codec.jar	2008-06-23 22:35:20 +0000 and framework/lib/commons-codec.jar	1970-01-01 00:00:00 +0000 differ
=== added file 'framework/lib/commons-email-1.2.jar'
Binary files framework/lib/commons-email-1.2.jar	1970-01-01 00:00:00 +0000 and framework/lib/commons-email-1.2.jar	2010-09-16 22:21:08 +0000 differ
=== removed file 'framework/lib/commons-httpclient.jar'
Binary files framework/lib/commons-httpclient.jar	2008-06-23 22:35:20 +0000 and framework/lib/commons-httpclient.jar	1970-01-01 00:00:00 +0000 differ
=== added file 'framework/lib/commons-io-1.4.jar'
Binary files framework/lib/commons-io-1.4.jar	1970-01-01 00:00:00 +0000 and framework/lib/commons-io-1.4.jar	2010-09-16 22:21:08 +0000 differ
=== removed file 'framework/lib/commons-io.jar'
Binary files framework/lib/commons-io.jar	2008-05-28 12:53:00 +0000 and framework/lib/commons-io.jar	1970-01-01 00:00:00 +0000 differ
=== added file 'framework/lib/commons-lang-2.5.jar'
Binary files framework/lib/commons-lang-2.5.jar	1970-01-01 00:00:00 +0000 and framework/lib/commons-lang-2.5.jar	2010-09-16 22:21:08 +0000 differ
=== removed file 'framework/lib/commons-lang.jar'
Binary files framework/lib/commons-lang.jar	2008-06-23 22:35:20 +0000 and framework/lib/commons-lang.jar	1970-01-01 00:00:00 +0000 differ
=== removed file 'framework/lib/compiler-jdt.jar'
Binary files framework/lib/compiler-jdt.jar	2010-01-31 12:12:26 +0000 and framework/lib/compiler-jdt.jar	1970-01-01 00:00:00 +0000 differ
=== removed file 'framework/lib/ehcache-1.5.0.jar'
Binary files framework/lib/ehcache-1.5.0.jar	2009-05-22 10:39:52 +0000 and framework/lib/ehcache-1.5.0.jar	1970-01-01 00:00:00 +0000 differ
=== added file 'framework/lib/ehcache-core-2.0.0.jar'
Binary files framework/lib/ehcache-core-2.0.0.jar	1970-01-01 00:00:00 +0000 and framework/lib/ehcache-core-2.0.0.jar	2010-09-16 22:21:08 +0000 differ
=== removed file 'framework/lib/ejb3-persistence.jar'
Binary files framework/lib/ejb3-persistence.jar	2009-05-21 15:44:21 +0000 and framework/lib/ejb3-persistence.jar	1970-01-01 00:00:00 +0000 differ
=== removed file 'framework/lib/gson-1.3.jar'
Binary files framework/lib/gson-1.3.jar	2009-08-13 22:09:29 +0000 and framework/lib/gson-1.3.jar	1970-01-01 00:00:00 +0000 differ
=== added file 'framework/lib/gson-1.4.jar'
Binary files framework/lib/gson-1.4.jar	1970-01-01 00:00:00 +0000 and framework/lib/gson-1.4.jar	2010-09-16 22:21:08 +0000 differ
=== added file 'framework/lib/hibernate-annotations-3.5.6-Final.jar'
Binary files framework/lib/hibernate-annotations-3.5.6-Final.jar	1970-01-01 00:00:00 +0000 and framework/lib/hibernate-annotations-3.5.6-Final.jar	2010-09-16 22:21:08 +0000 differ
=== removed file 'framework/lib/hibernate-annotations.jar'
Binary files framework/lib/hibernate-annotations.jar	2009-05-21 15:44:21 +0000 and framework/lib/hibernate-annotations.jar	1970-01-01 00:00:00 +0000 differ
=== added file 'framework/lib/hibernate-commons-annotations-3.2.0.Final.jar'
Binary files framework/lib/hibernate-commons-annotations-3.2.0.Final.jar	1970-01-01 00:00:00 +0000 and framework/lib/hibernate-commons-annotations-3.2.0.Final.jar	2010-09-16 22:21:08 +0000 differ
=== removed file 'framework/lib/hibernate-commons-annotations.jar'
Binary files framework/lib/hibernate-commons-annotations.jar	2009-05-21 15:44:21 +0000 and framework/lib/hibernate-commons-annotations.jar	1970-01-01 00:00:00 +0000 differ
=== added file 'framework/lib/hibernate-core-3.5.6-Final-patched.jar'
Binary files framework/lib/hibernate-core-3.5.6-Final-patched.jar	1970-01-01 00:00:00 +0000 and framework/lib/hibernate-core-3.5.6-Final-patched.jar	2010-09-16 22:21:08 +0000 differ
=== added file 'framework/lib/hibernate-entitymanager-3.5.6-Final.jar'
Binary files framework/lib/hibernate-entitymanager-3.5.6-Final.jar	1970-01-01 00:00:00 +0000 and framework/lib/hibernate-entitymanager-3.5.6-Final.jar	2010-09-16 22:21:08 +0000 differ
=== removed file 'framework/lib/hibernate-entitymanager.jar'
Binary files framework/lib/hibernate-entitymanager.jar	2009-05-21 15:44:21 +0000 and framework/lib/hibernate-entitymanager.jar	1970-01-01 00:00:00 +0000 differ
=== added file 'framework/lib/hibernate-jpa-2.0-api-1.0.0.Final.jar'
Binary files framework/lib/hibernate-jpa-2.0-api-1.0.0.Final.jar	1970-01-01 00:00:00 +0000 and framework/lib/hibernate-jpa-2.0-api-1.0.0.Final.jar	2010-09-16 22:21:08 +0000 differ
=== removed file 'framework/lib/hibernate-validator.jar'
Binary files framework/lib/hibernate-validator.jar	2010-04-01 10:08:27 +0000 and framework/lib/hibernate-validator.jar	1970-01-01 00:00:00 +0000 differ
=== removed file 'framework/lib/hibernate3-ast.jar'
Binary files framework/lib/hibernate3-ast.jar	2009-09-09 11:02:29 +0000 and framework/lib/hibernate3-ast.jar	1970-01-01 00:00:00 +0000 differ
=== removed file 'framework/lib/hibernate3.jar'
Binary files framework/lib/hibernate3.jar	2009-09-09 12:08:38 +0000 and framework/lib/hibernate3.jar	1970-01-01 00:00:00 +0000 differ
=== added file 'framework/lib/hsqldb-1.8.1.2.jar'
Binary files framework/lib/hsqldb-1.8.1.2.jar	1970-01-01 00:00:00 +0000 and framework/lib/hsqldb-1.8.1.2.jar	2010-09-16 22:21:08 +0000 differ
=== removed file 'framework/lib/hsqldb.jar'
Binary files framework/lib/hsqldb.jar	2008-05-26 10:52:38 +0000 and framework/lib/hsqldb.jar	1970-01-01 00:00:00 +0000 differ
=== added file 'framework/lib/javamail-1.4.3.jar'
Binary files framework/lib/javamail-1.4.3.jar	1970-01-01 00:00:00 +0000 and framework/lib/javamail-1.4.3.jar	2010-09-16 22:21:08 +0000 differ
=== added file 'framework/lib/javassist-3.9.0.GA.jar'
Binary files framework/lib/javassist-3.9.0.GA.jar	1970-01-01 00:00:00 +0000 and framework/lib/javassist-3.9.0.GA.jar	2010-09-16 22:21:08 +0000 differ
=== removed file 'framework/lib/javassist.jar'
Binary files framework/lib/javassist.jar	2008-11-21 19:28:31 +0000 and framework/lib/javassist.jar	1970-01-01 00:00:00 +0000 differ
=== added file 'framework/lib/jj-imaging.jar'
Binary files framework/lib/jj-imaging.jar	1970-01-01 00:00:00 +0000 and framework/lib/jj-imaging.jar	2010-09-16 22:21:08 +0000 differ
=== added file 'framework/lib/jj-simplecaptcha.jar'
Binary files framework/lib/jj-simplecaptcha.jar	1970-01-01 00:00:00 +0000 and framework/lib/jj-simplecaptcha.jar	2010-09-16 22:21:08 +0000 differ
=== added file 'framework/lib/jj-textile.jar'
Binary files framework/lib/jj-textile.jar	1970-01-01 00:00:00 +0000 and framework/lib/jj-textile.jar	2010-09-16 22:21:08 +0000 differ
=== added file 'framework/lib/jj-wikitext.jar'
Binary files framework/lib/jj-wikitext.jar	1970-01-01 00:00:00 +0000 and framework/lib/jj-wikitext.jar	2010-09-16 22:21:08 +0000 differ
=== removed file 'framework/lib/joda-time-1.6.jar'
Binary files framework/lib/joda-time-1.6.jar	2010-03-23 10:20:26 +0000 and framework/lib/joda-time-1.6.jar	1970-01-01 00:00:00 +0000 differ
=== added file 'framework/lib/jodatime-1.6.jar'
Binary files framework/lib/jodatime-1.6.jar	1970-01-01 00:00:00 +0000 and framework/lib/jodatime-1.6.jar	2010-09-16 22:21:08 +0000 differ
=== added file 'framework/lib/jregex-1.2_01.jar'
Binary files framework/lib/jregex-1.2_01.jar	1970-01-01 00:00:00 +0000 and framework/lib/jregex-1.2_01.jar	2010-09-16 22:21:08 +0000 differ
=== removed file 'framework/lib/jregex1.2_01.jar'
Binary files framework/lib/jregex1.2_01.jar	2008-05-23 16:01:41 +0000 and framework/lib/jregex1.2_01.jar	1970-01-01 00:00:00 +0000 differ
=== added file 'framework/lib/jta-1.1.jar'
Binary files framework/lib/jta-1.1.jar	1970-01-01 00:00:00 +0000 and framework/lib/jta-1.1.jar	2010-09-16 22:21:08 +0000 differ
=== removed file 'framework/lib/jta.jar'
Binary files framework/lib/jta.jar	2008-05-26 15:58:12 +0000 and framework/lib/jta.jar	1970-01-01 00:00:00 +0000 differ
=== removed file 'framework/lib/junit-4.4.jar'
Binary files framework/lib/junit-4.4.jar	2008-05-26 10:52:38 +0000 and framework/lib/junit-4.4.jar	1970-01-01 00:00:00 +0000 differ
=== added file 'framework/lib/junit-4.8.1.jar'
Binary files framework/lib/junit-4.8.1.jar	1970-01-01 00:00:00 +0000 and framework/lib/junit-4.8.1.jar	2010-09-16 22:21:08 +0000 differ
=== removed file 'framework/lib/lucene-analyzers-2.3.1.jar'
Binary files framework/lib/lucene-analyzers-2.3.1.jar	2008-08-12 10:32:25 +0000 and framework/lib/lucene-analyzers-2.3.1.jar	1970-01-01 00:00:00 +0000 differ
=== removed file 'framework/lib/lucene-core-2.3.1.jar'
Binary files framework/lib/lucene-core-2.3.1.jar	2008-06-29 20:09:10 +0000 and framework/lib/lucene-core-2.3.1.jar	1970-01-01 00:00:00 +0000 differ
=== removed file 'framework/lib/mail.jar'
Binary files framework/lib/mail.jar	2008-11-20 16:26:31 +0000 and framework/lib/mail.jar	1970-01-01 00:00:00 +0000 differ
=== removed file 'framework/lib/mina-core-2.0.0-M2-SNAPSHOT.jar'
Binary files framework/lib/mina-core-2.0.0-M2-SNAPSHOT.jar	2008-05-27 14:08:39 +0000 and framework/lib/mina-core-2.0.0-M2-SNAPSHOT.jar	1970-01-01 00:00:00 +0000 differ
=== removed file 'framework/lib/mysql-connector-java-5.1.8-bin.jar'
Binary files framework/lib/mysql-connector-java-5.1.8-bin.jar	2009-08-18 10:42:29 +0000 and framework/lib/mysql-connector-java-5.1.8-bin.jar	1970-01-01 00:00:00 +0000 differ
=== added file 'framework/lib/mysql-connector-java-5.1.8.jar'
Binary files framework/lib/mysql-connector-java-5.1.8.jar	1970-01-01 00:00:00 +0000 and framework/lib/mysql-connector-java-5.1.8.jar	2010-09-16 22:21:08 +0000 differ
=== added file 'framework/lib/netty-3.2.2.Final.jar'
Binary files framework/lib/netty-3.2.2.Final.jar	1970-01-01 00:00:00 +0000 and framework/lib/netty-3.2.2.Final.jar	2010-09-16 22:21:08 +0000 differ
=== added file 'framework/lib/org.eclipse.jdt.core_3.6.0.v_A56.jar'
Binary files framework/lib/org.eclipse.jdt.core_3.6.0.v_A56.jar	1970-01-01 00:00:00 +0000 and framework/lib/org.eclipse.jdt.core_3.6.0.v_A56.jar	2010-09-16 22:21:08 +0000 differ
=== removed file 'framework/lib/oval-1.31.jar'
Binary files framework/lib/oval-1.31.jar	2009-05-23 21:02:57 +0000 and framework/lib/oval-1.31.jar	1970-01-01 00:00:00 +0000 differ
=== added file 'framework/lib/oval-1.50.jar'
Binary files framework/lib/oval-1.50.jar	1970-01-01 00:00:00 +0000 and framework/lib/oval-1.50.jar	2010-09-16 22:21:08 +0000 differ
=== removed file 'framework/lib/play-SimpleCaptcha.jar'
Binary files framework/lib/play-SimpleCaptcha.jar	2010-01-12 14:42:25 +0000 and framework/lib/play-SimpleCaptcha.jar	1970-01-01 00:00:00 +0000 differ
=== removed file 'framework/lib/play-imaging.jar'
Binary files framework/lib/play-imaging.jar	2010-01-12 14:42:25 +0000 and framework/lib/play-imaging.jar	1970-01-01 00:00:00 +0000 differ
=== removed file 'framework/lib/provided-geronimo-servlet_2.5_spec-1.2.jar'
Binary files framework/lib/provided-geronimo-servlet_2.5_spec-1.2.jar	2009-05-20 10:41:13 +0000 and framework/lib/provided-geronimo-servlet_2.5_spec-1.2.jar	1970-01-01 00:00:00 +0000 differ
=== added file 'framework/lib/provided-servlet-2.5.jar'
Binary files framework/lib/provided-servlet-2.5.jar	1970-01-01 00:00:00 +0000 and framework/lib/provided-servlet-2.5.jar	2010-09-16 22:21:08 +0000 differ
=== removed file 'framework/lib/slf4j-api-1.5.0.jar'
Binary files framework/lib/slf4j-api-1.5.0.jar	2008-05-26 15:58:12 +0000 and framework/lib/slf4j-api-1.5.0.jar	1970-01-01 00:00:00 +0000 differ
=== added file 'framework/lib/slf4j-api-1.5.8.jar'
Binary files framework/lib/slf4j-api-1.5.8.jar	1970-01-01 00:00:00 +0000 and framework/lib/slf4j-api-1.5.8.jar	2010-09-16 22:21:08 +0000 differ
=== added file 'framework/lib/snakeyaml-1.6.jar'
Binary files framework/lib/snakeyaml-1.6.jar	1970-01-01 00:00:00 +0000 and framework/lib/snakeyaml-1.6.jar	2010-09-16 22:21:08 +0000 differ
=== removed file 'framework/lib/wikitext.core_1.1.1.jar'
Binary files framework/lib/wikitext.core_1.1.1.jar	2009-09-22 14:27:13 +0000 and framework/lib/wikitext.core_1.1.1.jar	1970-01-01 00:00:00 +0000 differ
=== added directory 'framework/patches'
=== added file 'framework/patches/hibernate-3.5.x.Final.patch'
--- framework/patches/hibernate-3.5.x.Final.patch	1970-01-01 00:00:00 +0000
+++ framework/patches/hibernate-3.5.x.Final.patch	2010-09-16 22:21:08 +0000
@@ -0,0 +1,114 @@
+--- project/core/src/main/java/org/hibernate/EmptyInterceptor.java	2008-07-30 11:46:34.000000000 +0200
++++ project/core/src/main/java/org/hibernate/EmptyInterceptor.java	2010-04-08 21:07:24.000000000 +0200
+@@ -112,10 +112,10 @@
+ 		return sql;
+ 	}
+ 
+-	public void onCollectionRemove(Object collection, Serializable key) throws CallbackException {}
++	public boolean onCollectionRemove(Object collection, Serializable key) throws CallbackException { return true; }
+ 
+-	public void onCollectionRecreate(Object collection, Serializable key) throws CallbackException {}
++	public boolean onCollectionRecreate(Object collection, Serializable key) throws CallbackException { return true; }
+ 
+-	public void onCollectionUpdate(Object collection, Serializable key) throws CallbackException {}
++	public boolean onCollectionUpdate(Object collection, Serializable key) throws CallbackException { return true; }
+ 	
+ }
+\ No newline at end of file
+
+--- project/core/src/main/java/org/hibernate/Interceptor.java	2008-07-30 11:46:34.000000000 +0200
++++ project/core/src/main/java/org/hibernate/Interceptor.java	2010-04-08 21:06:52.000000000 +0200
+@@ -84,15 +84,15 @@
+ 	/**
+ 	 * Called before a collection is (re)created.
+ 	 */
+-	public void onCollectionRecreate(Object collection, Serializable key) throws CallbackException;
++	public boolean onCollectionRecreate(Object collection, Serializable key) throws CallbackException;
+ 	/**
+ 	 * Called before a collection is deleted.
+ 	 */
+-	public void onCollectionRemove(Object collection, Serializable key) throws CallbackException;
++	public boolean onCollectionRemove(Object collection, Serializable key) throws CallbackException;
+ 	/**
+ 	 * Called before a collection is updated.
+ 	 */
+-	public void onCollectionUpdate(Object collection, Serializable key) throws CallbackException;
++	public boolean onCollectionUpdate(Object collection, Serializable key) throws CallbackException;
+ 	/**
+ 	 * Called before a flush
+ 	 */
+
+--- project/core/src/main/java/org/hibernate/event/def/AbstractFlushingEventListener.java	2010-03-10 03:25:04.000000000 +0100
++++ project/core/src/main/java/org/hibernate/event/def/AbstractFlushingEventListener.java	2010-04-08 21:06:14.000000000 +0200
+@@ -255,39 +255,42 @@
+ 			CollectionEntry ce = (CollectionEntry) me.getValue();
+ 
+ 			if ( ce.isDorecreate() ) {
+-				session.getInterceptor().onCollectionRecreate( coll, ce.getCurrentKey() );
+-				actionQueue.addAction(
+-						new CollectionRecreateAction( 
+-								coll, 
+-								ce.getCurrentPersister(), 
+-								ce.getCurrentKey(), 
+-								session 
+-							)
+-					);
++				if ( session.getInterceptor().onCollectionRecreate( coll, ce.getCurrentKey() ) ) {
++					actionQueue.addAction(
++							new CollectionRecreateAction( 
++									coll, 
++									ce.getCurrentPersister(), 
++									ce.getCurrentKey(), 
++									session 
++								)
++						);
++			    }
+ 			}
+ 			if ( ce.isDoremove() ) {
+-				session.getInterceptor().onCollectionRemove( coll, ce.getLoadedKey() );
+-				actionQueue.addAction(
+-						new CollectionRemoveAction( 
+-								coll, 
+-								ce.getLoadedPersister(), 
+-								ce.getLoadedKey(), 
+-								ce.isSnapshotEmpty(coll), 
+-								session 
+-							)
+-					);
++				if ( session.getInterceptor().onCollectionRemove( coll, ce.getLoadedKey() ) ) {
++					actionQueue.addAction(
++							new CollectionRemoveAction( 
++									coll, 
++									ce.getLoadedPersister(), 
++									ce.getLoadedKey(), 
++									ce.isSnapshotEmpty(coll), 
++									session 
++								)
++						);
++				}
+ 			}
+ 			if ( ce.isDoupdate() ) {
+-				session.getInterceptor().onCollectionUpdate( coll, ce.getLoadedKey() );
+-				actionQueue.addAction(
+-						new CollectionUpdateAction( 
+-								coll, 
+-								ce.getLoadedPersister(), 
+-								ce.getLoadedKey(), 
+-								ce.isSnapshotEmpty(coll), 
+-								session 
+-							)
+-					);
++				if ( session.getInterceptor().onCollectionUpdate( coll, ce.getLoadedKey() ) ) {
++					actionQueue.addAction(
++							new CollectionUpdateAction( 
++									coll, 
++									ce.getLoadedPersister(), 
++									ce.getLoadedKey(), 
++									ce.isSnapshotEmpty(coll), 
++									session 
++								)
++						);
++				}
+ 			}
+ 
+ 		}

=== added file 'framework/patches/hibernate-3.5.x.Final.patch.README'
--- framework/patches/hibernate-3.5.x.Final.patch.README	1970-01-01 00:00:00 +0000
+++ framework/patches/hibernate-3.5.x.Final.patch.README	2010-09-16 22:21:08 +0000
@@ -0,0 +1,1 @@
+Download Hibernate 3.5.0.Final source code, apply the patch, and build with maven (good luck)
\ No newline at end of file

=== added directory 'framework/pym/play'
=== added file 'framework/pym/play/__init__.py'
=== added file 'framework/pym/play/application.py'
--- framework/pym/play/application.py	1970-01-01 00:00:00 +0000
+++ framework/pym/play/application.py	2010-09-16 22:21:08 +0000
@@ -0,0 +1,262 @@
+import sys
+import os, os.path
+import re
+import shutil
+import socket
+
+class ModuleNotFound(Exception):
+    def __init__(self, value):
+        self.value = value
+    def __str__(self):
+        return repr(self.value)
+
+class PlayApplication:
+    """A Play Application: conf file, java"""
+
+    # ~~~~~~~~~~~~~~~~~~~~~~ Constructor
+
+    def __init__(self, application_path, env):
+        self.path = application_path
+        if application_path is not None:
+            confpath = os.path.join(application_path, 'conf/application.conf')
+            try:
+                self.conf = PlayConfParser(confpath, env["id"])
+            except:
+                self.conf = None # No app / Invalid app
+        else:
+            self.conf = None
+        self.play_env = env
+        self.jpda_port = self.readConf('jpda_port')
+
+    # ~~~~~~~~~~~~~~~~~~~~~~ Configuration File
+
+    def check(self):
+        if not os.path.exists(os.path.join(self.path, 'conf', 'routes')):
+            print "~ Oops. %s does not seem to host a valid application" % os.path.normpath(self.path)
+            print "~"
+            sys.exit(-1)
+
+    def readConf(self, key):
+        if (self.conf is None):
+            return ''
+        return self.conf.get(key)
+
+    def readConfs(self, key):
+        if (self.conf is None):
+            return []
+        return self.conf.getAll(key)
+
+    # ~~~~~~~~~~~~~~~~~~~~~~ Modules
+
+    def modules(self):
+        modules = []
+        for m in self.readConfs('module.'):
+            om = m
+            if '${play.path}' in m:
+                m = m.replace('${play.path}', self.play_env["basedir"])
+            if m[0] is not '/':
+                m = os.path.normpath(os.path.join(self.path, m))
+            if not os.path.exists(m):
+                print "~ Oops,"
+                print "~ Module not found: %s" % (m)
+                print "~"
+                if m.startswith('${play.path}/modules'):
+                    print "~ You can try to install the missing module using 'play install %s'" % (m[21:])
+                    print "~"
+                sys.exit(-1)
+            modules.append(m)
+        if self.play_env["id"] == 'test':
+            modules.append(os.path.normpath(os.path.join(self.play_env["basedir"], 'modules/testrunner')))
+        return modules
+
+    def module_names(self):
+        return map(lambda x: x[7:],self.conf.getAllKeys("module."))
+
+    def load_modules(self):
+        if os.environ.has_key('MODULES'):
+            if os.name == 'nt':
+                modules = os.environ['MODULES'].split(';')
+            else:
+                modules = os.environ['MODULES'].split(':')
+        else:
+            modules = []
+
+        if play_app is not None:
+            try:
+                modules = play_app.modules()
+            except ModuleNotFound, e:
+                print 'Module not found %s' % e
+                sys.exit(-1)
+
+            if play_env["id"] == 'test':
+                modules.append(os.path.normpath(os.path.join(play_env["basedir"], 'modules/testrunner')))
+
+    def override(self, f, t):
+        fromFile = None
+        for module in self.modules():
+            pc = os.path.join(module, f)
+            if os.path.exists(pc): fromFile = pc
+        if not fromFile:
+            print "~ %s not found in any module" % f
+            print "~ "
+            sys.exit(-1)
+        toFile = os.path.join(self.path, t)
+        if os.path.exists(toFile):
+            response = raw_input("~ Warning! %s already exists and will be overriden (y/n)? " % toFile)
+            if not response == 'y':
+                return
+        if not os.path.exists(os.path.dirname(toFile)):
+            os.makedirs(os.path.dirname(toFile))
+        shutil.copyfile(fromFile, toFile)
+        print "~ Copied %s to %s " % (fromFile, toFile)
+
+    def name(self):
+        return self.readConf("application.name")
+
+    # ~~~~~~~~~~~~~~~~~~~~~~ JAVA
+
+    def getClasspath(self):
+        classpath = []
+
+        # The default
+        classpath.append(os.path.normpath(os.path.join(self.path, 'conf')))
+        classpath.append(os.path.normpath(os.path.join(self.play_env["basedir"], 'framework/play.jar')))
+
+        # The application
+        if os.path.exists(os.path.join(self.path, 'lib')):
+            for jar in os.listdir(os.path.join(self.path, 'lib')):
+                if jar.endswith('.jar'):
+                    classpath.append(os.path.normpath(os.path.join(self.path, 'lib/%s' % jar)))
+
+        # The modules
+        for module in self.modules():
+            if os.path.exists(os.path.join(module, 'lib')):
+                libs = os.path.join(module, 'lib')
+                if os.path.exists(libs):
+                    for jar in os.listdir(libs):
+                        if jar.endswith('.jar'):
+                            classpath.append(os.path.normpath(os.path.join(libs, '%s' % jar)))
+
+        # The framework
+        for jar in os.listdir(os.path.join(self.play_env["basedir"], 'framework/lib')):
+            if jar.endswith('.jar'):
+                classpath.append(os.path.normpath(os.path.join(self.play_env["basedir"], 'framework/lib/%s' % jar)))
+
+        return classpath
+
+    def agent_path(self):
+        return os.path.join(self.play_env["basedir"], 'framework/play.jar')
+
+    def cp_args(self):
+        classpath = self.getClasspath()
+        cp_args = ':'.join(classpath)
+        if os.name == 'nt':
+            cp_args = ';'.join(classpath)
+        return cp_args
+
+    def java_path(self):
+        if not os.environ.has_key('JAVA_HOME'):
+            return "java"
+        else:
+            return os.path.normpath("%s/bin/java" % os.environ['JAVA_HOME'])
+
+    def pid_path(self):
+        if os.environ.has_key('PLAY_PID_PATH'):
+            return os.environ['PLAY_PID_PATH'];
+        else:
+            return os.path.join(self.path, 'server.pid');
+
+    def log_path(self):
+        if not os.environ.has_key('PLAY_LOG_PATH'):
+            log_path = os.path.join(self.path, 'logs');
+        else:
+            log_path = os.environ['PLAY_LOG_PATH'];
+        if not os.path.exists(log_path):
+            os.mkdir(log_path);
+        return log_path
+
+    def check_jpda(self):
+        self.jpda_port = self.readConf('jpda.port')
+        try:
+            s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+            s.bind(('127.0.0.1', int(self.jpda_port)))
+            s.close()
+        except socket.error, e:
+            print 'JPDA port %s is already used. Will try to use any free port for debugging' % self.jpda_port
+            self.jpda_port = 0
+
+    def java_cmd(self, java_args, cp_args=None, className='play.server.Server', args=['']):
+        memory_in_args=False
+        for arg in java_args:
+            if arg.startswith('-Xm'):
+                memory_in_args=True
+        if not memory_in_args:
+            memory = self.readConf('jvm.memory')
+            if memory:
+                java_args = java_args + memory.split(' ')
+        if cp_args is None:
+            cp_args = self.cp_args()
+
+        self.jpda_port = self.readConf('jpda.port')
+
+        application_mode = self.readConf('application.mode')
+
+        if application_mode == 'prod':
+            java_args.append('-server')
+
+        java_policy = self.readConf('java.policy')
+        if java_policy != '':
+            policyFile = os.path.join(self.path, 'conf', java_policy)
+            if os.path.exists(policyFile):
+                print "~ using policy file \"%s\"" % policyFile
+                java_args.append('-Djava.security.manager')
+                java_args.append('-Djava.security.policy==%s' % policyFile)
+
+        java_cmd = [self.java_path(), '-javaagent:%s' % self.agent_path()] + java_args + ['-classpath', cp_args, '-Dapplication.path=%s' % self.path, '-Dplay.id=%s' % self.play_env["id"], className] + args
+        return java_cmd
+
+class PlayConfParser:
+
+    DEFAULTS = {
+        'http.port': '9000',
+        'jpda.port': '8000'
+    }
+
+    def __init__(self, filepath, frameworkId):
+        self.id = frameworkId
+        f = file(filepath)
+        self.entries = dict()
+        for line in f:
+            linedef = line.strip()
+            if len(linedef) == 0:
+                continue
+            if linedef[0] in ('!', '#'):
+                continue
+            if linedef.find('=') == -1:
+                continue
+            self.entries[linedef.split('=')[0].rstrip()] = linedef.split('=')[1].lstrip()
+        f.close()
+
+    def get(self, key):
+        idkey = '%' + self.id + "." + key
+        if idkey in self.entries:
+            return self.entries[idkey]
+        if key in self.entries:
+            return self.entries[key]
+        if key in self.DEFAULTS:
+            return self.DEFAULTS[key]
+        return ''
+
+    def getAllKeys(self, query):
+        result = []
+        for (key, value) in self.entries.items():
+            if key.startswith(query) or key.startswith('%' + self.id + '.' + query):
+                result.append(key)
+        return result
+
+    def getAll(self, query):
+        result = []
+        for (key, value) in self.entries.items():
+            if key.startswith(query) or key.startswith('%' + self.id + '.' + query):
+                result.append(value)
+        return result

=== added file 'framework/pym/play/cmdloader.py'
--- framework/pym/play/cmdloader.py	1970-01-01 00:00:00 +0000
+++ framework/pym/play/cmdloader.py	2010-09-16 22:21:08 +0000
@@ -0,0 +1,40 @@
+import imp
+import os
+
+class CommandLoader:
+    def __init__(self, play_path):
+        self.path = os.path.join(play_path, 'framework', 'pym', 'play', 'commands')
+        self.commands = {}
+        self.modules = {}
+        self.load_core()
+
+    def load_core(self):
+        for filename in os.listdir(self.path):
+            if filename != "__init__.py" and filename.endswith(".py"):
+                name = filename.replace(".py", "")
+                mod = load_python_module(name, self.path)
+                self._load_cmd_from(mod)
+
+    def load_play_module(self, modname):
+        try:
+            leafname = os.path.basename(modname).split('.')[0]
+            mod = imp.load_source(leafname, os.path.join(modname, "commands.py"))
+            self._load_cmd_from(mod)
+        except:
+            pass # No command to load in this module
+
+    def _load_cmd_from(self, mod):
+        try:
+            for name in mod.COMMANDS:
+                if name in self.commands:
+                    print "~ Warning: conflict on command " + name
+                self.commands[name] = mod
+            if 'MODULE' in dir(mod):
+                self.modules[mod.MODULE] = mod
+        except Exception:
+            print "~ Warning: error loading command " + name
+
+def load_python_module(name, location):
+    mod_desc = imp.find_module(name, [location])
+    return imp.load_module(name, mod_desc[0], mod_desc[1], mod_desc[2])
+

=== added directory 'framework/pym/play/commands'
=== added file 'framework/pym/play/commands/__init__.py'
=== added file 'framework/pym/play/commands/base.py'
--- framework/pym/play/commands/base.py	1970-01-01 00:00:00 +0000
+++ framework/pym/play/commands/base.py	2010-09-16 22:21:08 +0000
@@ -0,0 +1,273 @@
+# Command related to creation and execution: run, new, clean, test, auto-test
+
+import sys
+import os
+import subprocess
+import shutil
+import getopt
+import urllib2
+import webbrowser
+import time
+
+from play.utils import *
+
+COMMANDS = ['run', 'new', 'clean', 'test', 'autotest', 'auto-test', 'id', 'new,run', 'clean,run']
+
+HELP = {
+    'id': "Define the framework ID",
+    'new': "Create a new application",
+    'clean': "Delete temporary files (including the bytecode cache)",
+    'run': "Run the application in the current shell",
+    'test': "Run the application in test mode in the current shell",
+    'auto-test': "Automatically run all application tests"
+}
+
+def execute(**kargs):
+    command = kargs.get("command")
+    app = kargs.get("app")
+    args = kargs.get("args")
+    env = kargs.get("env")
+
+    if command == 'id':
+        id(env)
+    if command == 'new' or command == 'new,run':
+        new(app, args, env)
+    if command == 'clean' or command == 'clean,run':
+        clean(app)
+    if command == 'new,run' or command == 'clean,run' or command == 'run':
+        run(app, args)
+    if command == 'test':
+        test(app, args)
+    if command == 'auto-test' or command == 'autotest':
+        autotest(app, args)
+
+def new(app, args, env):
+    withModules = []
+    application_name = None
+    try:
+        optlist, args = getopt.getopt(args, '', ['with=', 'name='])
+        for o, a in optlist:
+            if o in ('--with'):
+                withModules = a.split(',')
+            if o in ('--name'):
+                application_name = a
+    except getopt.GetoptError, err:
+        print "~ %s" % str(err)
+        print "~ Sorry, unrecognized option"
+        print "~ "
+        sys.exit(-1)
+    if os.path.exists(app.path):
+        print "~ Oops. %s already exists" % app.path
+        print "~"
+        sys.exit(-1)
+
+    md = []
+    for m in withModules:
+        dirname = None
+        if os.path.exists(os.path.join(env["basedir"], 'modules/%s' % m)) and os.path.isdir(os.path.join(env["basedir"], 'modules/%s' % m)):
+            dirname = m
+        else:
+            for f in os.listdir(os.path.join(env["basedir"], 'modules')):
+                if os.path.isdir(os.path.join(env["basedir"], 'modules/%s' % f)) and f.find('%s-' % m) == 0:
+                    dirname = f
+                    break
+        
+        if not dirname:
+            print "~ Oops. No module %s found" % m
+            print "~ Try to install it using 'play install %s'" % m
+            print "~"
+            sys.exit(-1)
+
+        md.append(dirname)
+
+    print "~ The new application will be created in %s" % os.path.normpath(app.path)
+    if application_name is None:
+        application_name = raw_input("~ What is the application name? [%s] " % os.path.basename(app.path))
+    if application_name == "":
+        application_name = os.path.basename(app.path)
+    shutil.copytree(os.path.join(env["basedir"], 'resources/application-skel'), app.path)
+    app.check()
+    replaceAll(os.path.join(app.path, 'conf/application.conf'), r'%APPLICATION_NAME%', application_name)
+    replaceAll(os.path.join(app.path, 'conf/application.conf'), r'%SECRET_KEY%', secretKey())
+    print "~"
+
+    for m in md:
+        mn = m
+        if mn.find('-') > 0:
+            mn = mn[:mn.find('-')]
+        replaceAll(os.path.join(app.path, 'conf/application.conf'), r'# ---- MODULES ----', '# ---- MODULES ----\nmodule.%s=${play.path}/modules/%s' % (mn, m) )
+
+    print "~ OK, the application is created."
+    print "~ Start it with : play run %s" % sys.argv[2]
+    print "~ Have fun!"
+    print "~"
+
+def run(app, args):
+    app.check()
+    disable_check_jpda = False
+    if args.count('-f') == 1:
+        disable_check_jpda = True
+        args.remove('-f')
+
+    print "~ Ctrl+C to stop"
+    print "~ "
+    java_cmd = app.java_cmd(args)
+    if app.readConf('application.mode') == 'dev':
+        if not disable_check_jpda: app.check_jpda()
+        java_cmd.insert(2, '-Xdebug')
+        java_cmd.insert(2, '-Xrunjdwp:transport=dt_socket,address=%s,server=y,suspend=n' % app.jpda_port)
+        java_cmd.insert(2, '-Dplay.debug=yes')
+    try:
+        subprocess.call(java_cmd, env=os.environ)
+    except OSError:
+        print "Could not execute the java executable, please make sure the JAVA_HOME environment variable is set properly (the java executable should reside at JAVA_HOME/bin/java). "
+        sys.exit(-1)
+    print
+
+def clean(app):
+    app.check()
+    print "~ Deleting %s" % os.path.normpath(os.path.join(app.path, 'tmp'))
+    if os.path.exists(os.path.join(app.path, 'tmp')):
+        shutil.rmtree(os.path.join(app.path, 'tmp'))
+    print "~"
+
+def show_modules(args):
+    check_application()
+    modules = app.modules()
+    if len(modules):
+        print "~ Application modules are:"
+        print "~ "
+        for module in modules:
+            print "~ %s" % module
+    else:
+        print "~ No modules installed in this application"
+    print "~ "
+    sys.exit(0)
+
+def test(app, args):
+    app.check()
+    disable_check_jpda = False
+    if args.count('-f') == 1:
+        disable_check_jpda = True
+    java_cmd = app.java_cmd(args)
+    print "~ Running in test mode"
+    print "~ Ctrl+C to stop"
+    print "~ "
+    app.check_jpda()
+    java_cmd.insert(2, '-Xdebug')
+    java_cmd.insert(2, '-Xrunjdwp:transport=dt_socket,address=%s,server=y,suspend=n' % app.jpda_port)
+    java_cmd.insert(2, '-Dplay.debug=yes')
+    try:
+        subprocess.call(java_cmd, env=os.environ)
+    except OSError:
+        print "Could not execute the java executable, please make sure the JAVA_HOME environment variable is set properly (the java executable should reside at JAVA_HOME/bin/java). "
+        sys.exit(-1)
+    print
+
+def autotest(app, args):
+    app.check()
+    print "~ Running in test mode"
+    print "~ Ctrl+C to stop"
+    print "~ "
+
+    print "~ Deleting %s" % os.path.normpath(os.path.join(app.path, 'tmp'))
+    if os.path.exists(os.path.join(app.path, 'tmp')):
+        shutil.rmtree(os.path.join(app.path, 'tmp'))
+    print "~"
+
+    # Kill if exists
+    http_port = app.readConf('http.port')
+    try:
+        proxy_handler = urllib2.ProxyHandler({})
+        opener = urllib2.build_opener(proxy_handler)
+        opener.open('http://localhost:%s/@kill' % http_port);
+    except Exception, e:
+        pass
+
+    # Run app
+    test_result = os.path.join(app.path, 'test-result')
+    if os.path.exists(test_result):
+        shutil.rmtree(test_result)
+    sout = open(os.path.join(app.log_path(), 'system.out'), 'w')
+    java_cmd = app.java_cmd(args)
+    try:
+        play_process = subprocess.Popen(java_cmd, env=os.environ, stdout=sout)
+    except OSError:
+        print "Could not execute the java executable, please make sure the JAVA_HOME environment variable is set properly (the java executable should reside at JAVA_HOME/bin/java). "
+        sys.exit(-1)
+    soutint = open(os.path.join(app.log_path(), 'system.out'), 'r')
+    while True:
+        if play_process.poll():
+            print "~"
+            print "~ Oops, application has not started?"
+            print "~"
+            sys.exit(-1)
+        line = soutint.readline().strip()
+        if line:
+            print line
+            if line.find('Listening for HTTP') > -1:
+                soutint.close()
+                break
+
+    # Run FirePhoque
+    print "~"
+
+    fpcp = [os.path.join(app.play_env["basedir"], 'modules/testrunner/lib/play-testrunner.jar')]
+    fpcp_libs = os.path.join(app.play_env["basedir"], 'modules/testrunner/firephoque')
+    for jar in os.listdir(fpcp_libs):
+        if jar.endswith('.jar'):
+           fpcp.append(os.path.normpath(os.path.join(fpcp_libs, jar)))
+    cp_args = ':'.join(fpcp)
+    if os.name == 'nt':
+        cp_args = ';'.join(fpcp)    
+    java_cmd = [app.java_path(), '-classpath', cp_args, '-Dapplication.url=http://localhost:%s' % http_port, 'play.modules.testrunner.FirePhoque']    
+    try:
+        subprocess.call(java_cmd, env=os.environ)
+    except OSError:
+        print "Could not execute the headless browser. "
+        sys.exit(-1)
+
+    print "~"
+    time.sleep(1)
+    if os.path.exists(os.path.join(app.path, 'test-result/result.passed')):
+        print "~ All tests passed"
+        print "~"
+    if os.path.exists(os.path.join(app.path, 'test-result/result.failed')):
+        print "~ Some tests have failed. See file://%s for results" % test_result
+        print "~"
+    
+    kill(play_process.pid)
+
+def id(play_env):
+    if not play_env["id"]:
+        print "~ framework ID is not set"
+    new_id = raw_input("~ What is the new framework ID (or blank to unset)? ")
+    if new_id:
+        print "~"
+        print "~ OK, the framework ID is now %s" % new_id
+        print "~"
+        open(play_env["id_file"], 'w').write(new_id)
+    else:
+        print "~"
+        print "~ OK, the framework ID is unset"
+        print "~"
+        if os.path.exists(play_env["id_file"]):
+            os.remove(play_env["id_file"])
+
+# ~~~~~~~~~ UTILS
+
+def kill(pid):
+    if os.name == 'nt':
+        import ctypes
+        handle = ctypes.windll.kernel32.OpenProcess(1, False, int(pid))
+        if not ctypes.windll.kernel32.TerminateProcess(handle, 0):
+            print "~ Cannot kill the process with pid %s (ERROR %s)" % (pid, ctypes.windll.kernel32.GetLastError())
+            print "~ "
+            sys.exit(-1)
+    else:
+        try:
+            os.kill(int(pid), 15)
+        except OSError:
+            print "~ Play was not running (Process id %s not found)" % pid
+            print "~"
+            sys.exit(-1)

=== added file 'framework/pym/play/commands/check.py'
--- framework/pym/play/commands/check.py	1970-01-01 00:00:00 +0000
+++ framework/pym/play/commands/check.py	2010-09-16 22:21:08 +0000
@@ -0,0 +1,55 @@
+import os, os.path
+import shutil
+
+from play.utils import *
+import play.launchpad as launchpad
+
+COMMANDS = ['check']
+
+HELP = {
+    'check': 'Check for a release newer than the current one'
+}
+
+def execute(**kargs):
+    args = kargs.get("args")
+    play_env = kargs.get("env")
+
+    if len(sys.argv) == 3:
+        version = sys.argv[2]
+    else:
+        version = playVersion(play_env)
+
+    lpPlay = launchpad.Project("play")
+
+    if len(version) > 2:
+        series = lpPlay.getSeries(name=version[0:3])
+    if series is None:
+        print "~ Error: unable to determine series for version " + version + "."
+        print "~"
+        sys.exit(-1)
+
+    lpSeries = launchpad.Entry(series["self_link"])
+    releases = filter(lambda x: x["type"] == "release", lpSeries.get_timeline()["landmarks"])
+
+    if len(releases) == 0:
+        print "~ No release for the requested series. Are you on a development branch?"
+    elif isRelease(version, releases):
+        if releases[0]["name"] == version:
+            print "~ You are using the latest version of the serie (" + version + ")."
+        else:
+            print "~  ***** NEW RELEASE: " + releases[0]["name"] + " *****"
+            print "~      released on " + releases[0]["date"]
+            print "~"
+            print "~ Please upgrade: https://launchpad.net" + releases[0]["uri"]
+    else:
+        print "~ You don't seem to be using an official release."
+        print "~ Latest release is " + releases[0]["name"] + ", released on " + releases[0]["date"]
+
+    print "~"
+
+def isRelease(version, releases):
+    for release in releases:
+        if release["name"] == version:
+            return True
+    return False
+

=== added file 'framework/pym/play/commands/classpath.py'
--- framework/pym/play/commands/classpath.py	1970-01-01 00:00:00 +0000
+++ framework/pym/play/commands/classpath.py	2010-09-16 22:21:08 +0000
@@ -0,0 +1,16 @@
+# Show the computed classpath for the application
+
+COMMANDS = ['cp', 'classpath']
+
+HELP = {
+    'classpath': 'Display the computed classpath'
+}
+
+def execute(**kargs):
+    command = kargs.get("command")
+    app = kargs.get("app")
+    args = kargs.get("args")
+    print "~ Computed classpath is:"
+    print "~ "
+    print app.getClasspath()
+    print "~ "

=== added file 'framework/pym/play/commands/daemon.py'
--- framework/pym/play/commands/daemon.py	1970-01-01 00:00:00 +0000
+++ framework/pym/play/commands/daemon.py	2010-09-16 22:21:08 +0000
@@ -0,0 +1,147 @@
+import os, os.path
+import subprocess
+from play.utils import *
+
+COMMANDS = ['start', 'stop', 'restart', 'pid', 'out']
+
+HELP = {
+    'start': 'Start the application in the background',
+    'stop': 'Stop the running application',
+    'restart': 'Restart the running application',
+    'pid': 'Show the PID of the running application',
+    'out': 'Follow logs/system.out file'
+}
+
+def execute(**kargs):
+    command = kargs.get("command")
+    app = kargs.get("app")
+    args = kargs.get("args")
+    play_env = kargs.get("env")
+
+    if command == 'start':
+        start(app, args)
+    if command == 'stop':
+        stop(app)
+    if command == 'restart':
+        restart(app, args)
+    if command == 'pid':
+        pid(app)
+    if command == 'out':
+        out(app)
+
+def start(app, args):
+    app.check()
+    if os.path.exists(app.pid_path()):
+        print "~ Oops. %s is already started! (or delete %s)" % (os.path.normpath(app.path), os.path.normpath(app.pid_path()))
+        print "~"
+        sys.exit(1)
+
+    sysout = app.readConf('application.log.system.out')
+    sysout = sysout!='false' and sysout!='off'
+    if not sysout:
+      sout = None
+    else:
+      sout = open(os.path.join(app.log_path(), 'system.out'), 'w')
+    try:
+        pid = subprocess.Popen(app.java_cmd(args), stdout=sout, env=os.environ).pid
+    except OSError:
+        print "Could not execute the java executable, please make sure the JAVA_HOME environment variable is set properly (the java executable should reside at JAVA_HOME/bin/java). "
+        sys.exit(-1)
+    print "~ OK, %s is started" % os.path.normpath(app.path)
+    if sysout:
+      print "~ output is redirected to %s" % os.path.normpath(os.path.join(app.log_path(), 'system.out'))
+    pid_file = open(app.pid_path(), 'w')
+    pid_file.write(str(pid))
+    print "~ pid is %s" % pid
+    print "~"
+
+def stop(app):
+    app.check()
+    if not os.path.exists(app.pid_path()):
+        print "~ Oops! %s is not started (server.pid not found)" % os.path.normpath(app.path)
+        print "~"
+        sys.exit(-1)
+    pid = open(app.pid_path()).readline().strip()
+    os.remove(app.pid_path())
+    kill(pid)
+    print "~ OK, %s is stopped" % app.path
+    print "~"
+
+
+def restart(app, args):
+    app.check()
+    if not os.path.exists(app.pid_path()):
+        print "~ Oops! %s is not started (server.pid not found)" % os.path.normpath(app.path)
+        print "~"
+    else:
+        pid = open(app.pid_path()).readline().strip()
+        os.remove(app.pid_path())
+        kill(pid)
+
+    sysout = app.readConf('application.log.system.out')
+    sysout = sysout!='false' and sysout!='off'
+    java_cmd = app.java_cmd(args)
+    if not sysout:
+      sout = None
+    else:
+      sout = open(os.path.join(app.log_path(), 'system.out'), 'w')
+    try:
+        pid = subprocess.Popen(java_cmd, stdout=sout, env=os.environ).pid
+    except OSError:
+        print "Could not execute the java executable, please make sure the JAVA_HOME environment variable is set properly (the java executable should reside at JAVA_HOME/bin/java). "
+        sys.exit(-1)
+    print "~ OK, %s is restarted" % os.path.normpath(app.path)
+    if sysout:
+      print "~ output is redirected to %s" % os.path.normpath(os.path.join(app.log_path(), 'system.out'))
+    pid_file = open(app.pid_path(), 'w')
+    pid_file.write(str(pid))
+    print "~ New pid is %s" % pid
+    print "~"
+    sys.exit(0)
+
+
+def pid(app):
+    app.check()
+    if not os.path.exists(app.pid_path()):
+        print "~ Oops! %s is not started (server.pid not found)" % os.path.normpath(app.path)
+        print "~"
+        sys.exit(-1)
+    pid = open(app.pid_path()).readline().strip()
+    print "~ PID of the running applications is %s" % pid
+    print "~ "
+
+def out(app):
+    app.check()
+    if not os.path.exists(os.path.join(app.log_path(), 'system.out')):
+        print "~ Oops! %s not found" % os.path.normpath(os.path.join(app.log_path(), 'system.out'))
+        print "~"
+        sys.exit(-1)
+    sout = open(os.path.join(app.log_path(), 'system.out'), 'r')
+    try:
+        sout.seek(-5000, os.SEEK_END)
+    except IOError:
+        sout.seek(0)
+    while True:
+        where = sout.tell()
+        line = sout.readline().strip()
+        if not line:
+            time.sleep(1)
+            sout.seek(where)
+        else:
+            print line
+
+def kill(pid):
+    if os.name == 'nt':
+        import ctypes
+        handle = ctypes.windll.kernel32.OpenProcess(1, False, int(pid))
+        if not ctypes.windll.kernel32.TerminateProcess(handle, 0):
+            print "~ Cannot kill the process with pid %s (ERROR %s)" % (pid, ctypes.windll.kernel32.GetLastError())
+            print "~ "
+            sys.exit(-1)
+    else:
+        try:
+            os.kill(int(pid), 15)
+        except OSError:
+            print "~ Play was not running (Process id %s not found)" % pid
+            print "~"
+            sys.exit(-1)

=== added file 'framework/pym/play/commands/eclipse.py'
--- framework/pym/play/commands/eclipse.py	1970-01-01 00:00:00 +0000
+++ framework/pym/play/commands/eclipse.py	2010-09-16 22:21:08 +0000
@@ -0,0 +1,115 @@
+import os, os.path
+import shutil
+import time
+
+from play.utils import *
+
+COMMANDS = ['eclipsify', 'ec']
+
+HELP = {
+    'eclipsify': 'Create all Eclipse configuration files'
+}
+
+def execute(**kargs):
+    app = kargs.get("app")
+    args = kargs.get("args")
+    play_env = kargs.get("env")
+
+    app.check()
+    app.check_jpda()
+    modules = app.modules()
+    classpath = app.getClasspath()
+
+    application_name = app.readConf('application.name')
+    if application_name:
+        application_name = application_name.replace("/", " ")
+    else:
+        application_name = os.path.dirname(app.path)
+    dotProject = os.path.join(app.path, '.project')
+    dotClasspath = os.path.join(app.path, '.classpath')
+    dotSettings = os.path.join(app.path, '.settings')
+    eclipse = os.path.join(app.path, 'eclipse')
+    if os.path.exists(eclipse):
+        shutil.rmtree(eclipse)
+        if os.name == 'nt':
+            time.sleep(1)
+
+    if os.path.exists(dotSettings):
+        shutil.rmtree(dotSettings)
+        if os.name == 'nt':
+            time.sleep(1)
+
+    shutil.copyfile(os.path.join(play_env["basedir"], 'resources/eclipse/.project'), dotProject)
+    shutil.copyfile(os.path.join(play_env["basedir"], 'resources/eclipse/.classpath'), dotClasspath)
+    shutil.copytree(os.path.join(play_env["basedir"], 'resources/eclipse'), eclipse)
+    shutil.copytree(os.path.join(play_env["basedir"], 'resources/eclipse/.settings'), dotSettings)
+    replaceAll(dotProject, r'%PROJECT_NAME%', application_name)
+
+    playJarPath = os.path.join(play_env["basedir"], 'framework','play.jar')
+    playSourcePath = os.path.dirname(playJarPath)
+    if os.name == 'nt':
+        playSourcePath=playSourcePath.replace('\\','/').capitalize()
+
+    cpJarToSource = {}
+    for el in classpath:
+        if os.path.basename(el) != "conf" and el.endswith('-sources.jar'):
+            cpJarToSource[el.replace('-sources', '')] = el
+
+    cpXML = ""
+    for el in classpath:
+        if os.path.basename(el) != "conf":
+            if el == playJarPath:
+                cpXML += '<classpathentry kind="lib" path="%s" sourcepath="%s" />\n\t' % (os.path.normpath(el) , playSourcePath)
+            else:
+                if cpJarToSource.has_key(el):
+                    cpXML += '<classpathentry kind="lib" path="%s" sourcepath="%s"/>\n\t' % (os.path.normpath(el), cpJarToSource[el])
+                else:
+                    cpXML += '<classpathentry kind="lib" path="%s"/>\n\t' % os.path.normpath(el)
+
+    replaceAll(dotClasspath, r'%PROJECTCLASSPATH%', cpXML)
+
+    if len(modules):
+        lXML = ""
+        cXML = ""
+        for module in modules:
+            lXML += '<link><name>%s</name><type>2</type><location>%s</location></link>\n' % (os.path.basename(module), os.path.join(module, 'app').replace('\\', '/'))
+            if os.path.exists(os.path.join(module, "conf")):
+                lXML += '<link><name>conf/%s</name><type>2</type><location>%s/conf</location></link>\n' % (os.path.basename(module), module.replace('\\', '/'))
+            if os.path.exists(os.path.join(module, "public")):
+                lXML += '<link><name>public/%s</name><type>2</type><location>%s/public</location></link>\n' % (os.path.basename(module), module.replace('\\', '/'))
+            cXML += '<classpathentry kind="src" path="%s"/>' % (os.path.basename(module))
+        replaceAll(dotProject, r'%LINKS%', '<linkedResources>%s</linkedResources>' % lXML)
+        replaceAll(dotClasspath, r'%MODULES%', cXML)
+    else:
+        replaceAll(dotProject, r'%LINKS%', '')
+        replaceAll(dotClasspath, r'%MODULES%', '')
+
+    replaceAll(os.path.join(app.path, 'eclipse/debug.launch'), r'%PROJECT_NAME%', application_name)
+    replaceAll(os.path.join(app.path, 'eclipse/debug.launch'), r'%PLAY_BASE%', play_env["basedir"])
+    replaceAll(os.path.join(app.path, 'eclipse/debug.launch'), r'%PLAY_ID%', play_env["id"])
+    replaceAll(os.path.join(app.path, 'eclipse/debug.launch'), r'%JPDA_PORT%', str(app.jpda_port))
+
+    replaceAll(os.path.join(app.path, 'eclipse/test.launch'), r'%PROJECT_NAME%', application_name)
+    replaceAll(os.path.join(app.path, 'eclipse/test.launch'), r'%PLAY_BASE%', play_env["basedir"])
+    replaceAll(os.path.join(app.path, 'eclipse/test.launch'), r'%PLAY_ID%', play_env["id"])
+    replaceAll(os.path.join(app.path, 'eclipse/test.launch'), r'%JPDA_PORT%', str(app.jpda_port))
+
+    replaceAll(os.path.join(app.path, 'eclipse/connect.launch'), r'%PROJECT_NAME%', application_name)
+    replaceAll(os.path.join(app.path, 'eclipse/connect.launch'), r'%JPDA_PORT%', str(app.jpda_port))
+
+    os.rename(os.path.join(app.path, 'eclipse/connect.launch'), os.path.join(app.path, 'eclipse/Connect JPDA to %s.launch' % application_name))
+    os.rename(os.path.join(app.path, 'eclipse/test.launch'), os.path.join(app.path, 'eclipse/Test %s.launch' % application_name))
+    os.rename(os.path.join(app.path, 'eclipse/debug.launch'), os.path.join(app.path, 'eclipse/%s.launch' % application_name))
+
+    # Module-specific modifications
+    for module in modules:
+        commands = os.path.join(module, 'commands.py')
+        if os.path.exists(commands):
+            execfile(commands)
+
+    print "~ OK, the application is ready for eclipse"
+    print "~ Use File/Import/General/Existing project to import %s into eclipse" % os.path.normpath(app.path)
+    print "~"
+    print "~ Use eclipsify again when you want to update eclipse configuration files."
+    print "~ However, it's often better to delete and re-import the project into your workspace since eclipse keeps dirty caches..."
+    print "~"

=== added file 'framework/pym/play/commands/help.py'
--- framework/pym/play/commands/help.py	1970-01-01 00:00:00 +0000
+++ framework/pym/play/commands/help.py	2010-09-16 22:21:08 +0000
@@ -0,0 +1,55 @@
+# Display help
+
+import sys, os
+
+COMMANDS = ['help']
+
+HELP = {
+    'help': 'Display help on a specific command'
+}
+
+def execute(**kargs):
+    command = kargs.get("command")
+    app = kargs.get("app")
+    args = kargs.get("args")
+    play_env = kargs.get("env")
+    cmdloader = kargs.get("cmdloader")
+
+    if len(sys.argv) == 3:
+        cmd = sys.argv[2]
+        help_file = os.path.join(play_env["basedir"], 'documentation', 'commands', 'cmd-%s.txt' % cmd)
+        if os.path.exists(help_file):
+            print open(help_file, 'r').read()
+        else:
+            print '~ Oops, command \'%s\' not found. Try just \'play help\' to list all commands.' % cmd
+            print '~'
+            sys.exit(-1)
+    else:
+        main_help(cmdloader.commands, play_env)
+
+def main_help(commands, play_env):
+    modules_commands = []
+    print "~ For all commands, if the application is not specified, the current directory is used"
+    print "~ Use 'play help cmd' to get more help on a specific command"
+    print "~"
+    print "~ Core commands:"
+    print "~ ~~~~~~~~~~~~~~"
+    for cmd in sorted(commands):
+        if not isCore(commands[cmd], play_env):
+            modules_commands.append(cmd)
+            continue
+        if 'HELP' in dir(commands[cmd]) and cmd in commands[cmd].HELP:
+            print "~ " + cmd + (' ' * (16 - len(cmd))) + commands[cmd].HELP[cmd]
+    if len(modules_commands) > 0:
+        print "~"
+        print "~ Modules commands:"
+        print "~ ~~~~~~~~~~~~~~~~~"
+        for cmd in modules_commands:
+            if 'HELP' in dir(commands[cmd]) and cmd in commands[cmd].HELP:
+                print "~ " + cmd + (' ' * (20 - len(cmd))) + commands[cmd].HELP[cmd]
+    print "~"
+    print "~ Also refer to documentation at http://www.playframework.org/documentation"
+    print "~"
+
+def isCore(mod, play_env):
+    return mod.__file__.find(play_env["basedir"]) == 0

=== added file 'framework/pym/play/commands/intellij.py'
--- framework/pym/play/commands/intellij.py	1970-01-01 00:00:00 +0000
+++ framework/pym/play/commands/intellij.py	2010-09-16 22:21:08 +0000
@@ -0,0 +1,40 @@
+import os, os.path
+import shutil
+
+from play.utils import *
+
+COMMANDS = ['idealize', 'idea']
+
+HELP = {
+    'idealize': 'Create all IntelliJ Idea configuration files'
+}
+
+def execute(**kargs):
+    command = kargs.get("command")
+    app = kargs.get("app")
+    args = kargs.get("args")
+    play_env = kargs.get("env")
+
+    app.check()
+    modules = app.modules()
+    classpath = app.getClasspath()
+
+    application_name = app.readConf('application.name')
+    imlFile = os.path.join(app.path, application_name + '.iml')
+    shutil.copyfile(os.path.join(play_env["basedir"], 'resources/idea/imlTemplate.xml'), imlFile)
+    cpXML = ""
+
+    replaceAll(imlFile, r'%PLAYHOME%', play_env["basedir"].replace('\\', '/'))
+
+    if len(modules):
+        lXML = ""
+        cXML = ""
+        for module in modules:
+            lXML += '    <content url="file://%s">\n      <sourceFolder url="file://%s" isTestSource="false" />\n    </content>\n' % (module, os.path.join(module, 'app').replace('\\', '/'))
+        replaceAll(imlFile, r'%LINKS%', lXML)
+    else:
+        replaceAll(imlFile, r'%LINKS%', '')
+
+    print "~ OK, the application is ready for Intellij Idea"
+    print "~ Use File/New Module/Import Existing module"
+    print "~"

=== added file 'framework/pym/play/commands/javadoc.py'
--- framework/pym/play/commands/javadoc.py	1970-01-01 00:00:00 +0000
+++ framework/pym/play/commands/javadoc.py	2010-09-16 22:21:08 +0000
@@ -0,0 +1,43 @@
+import os, os.path
+import shutil
+import subprocess
+
+from play.utils import *
+
+COMMANDS = ['javadoc', 'jd']
+
+HELP = {
+    'javadoc': 'Generate your application Javadoc'
+}
+
+def execute(**kargs):
+    command = kargs.get("command")
+    app = kargs.get("app")
+    args = kargs.get("args")
+    play_env = kargs.get("env")
+
+    app.check()
+    modules = app.modules()
+    if not os.environ.has_key('JAVA_HOME'):
+        javadoc_path = "javadoc"
+    else:
+        javadoc_path = os.path.normpath("%s/bin/javadoc" % os.environ['JAVA_HOME'])
+
+    fileList = []
+    def add_java_files(app_path):
+        for root, subFolders, files in os.walk(os.path.join(app_path, 'app')):
+            for file in files:
+                if file.endswith(".java"):
+                    fileList.append(os.path.join(root, file))
+    add_java_files(app.path)
+    for module in modules:
+        add_java_files(os.path.normpath(module))
+    outdir = os.path.join(app.path, 'javadoc')
+    sout = open(os.path.join(app.log_path(), 'javadoc.log'), 'w')
+    serr = open(os.path.join(app.log_path(), 'javadoc.err'), 'w')
+    if (os.path.isdir(outdir)):
+        shutil.rmtree(outdir)
+    javadoc_cmd = [javadoc_path, '-classpath', app.cp_args(), '-d', outdir] + fileList
+    print "Generating Javadoc in " + outdir + "..."
+    subprocess.call(javadoc_cmd, env=os.environ, stdout=sout, stderr=serr)
+    print "Done! You can open " + os.path.join(outdir, 'overview-tree.html') + " in your browser."

=== added file 'framework/pym/play/commands/modulesrepo.py'
--- framework/pym/play/commands/modulesrepo.py	1970-01-01 00:00:00 +0000
+++ framework/pym/play/commands/modulesrepo.py	2010-09-16 22:21:08 +0000
@@ -0,0 +1,447 @@
+import os
+import sys
+import re
+import zipfile
+import urllib2
+import shutil
+import string
+import imp
+import time
+import urllib
+
+from play.utils import *
+
+NM = ['new-module']
+LM = ['list-modules', 'lm']
+BM = ['build-module', 'bm']
+AM = ['add']
+IM = ['install']
+
+COMMANDS = NM + LM + BM + IM + AM
+
+HELP = {
+    'build-module': "Build and package a module",
+    'list-modules': "List modules available from the central modules repository",
+    'install': "Install a module"
+}
+
+DEFAULT_REPO = 'http://www.playframework.org'
+
+def load_module(name):
+    base = os.path.normpath(os.path.dirname(os.path.realpath(sys.argv[0])))
+    mod_desc = imp.find_module(name, [os.path.join(base, 'framework/pym')])
+    return imp.load_module(name, mod_desc[0], mod_desc[1], mod_desc[2])
+
+json = load_module('simplejson')
+
+repositories = []
+
+def execute(**kargs):
+    global repositories
+
+    command = kargs.get("command")
+    app = kargs.get("app")
+    args = kargs.get("args")
+    env = kargs.get("env")
+
+    repositories = get_repositories(env['basedir'])
+
+    if command in NM:
+        new(app, args, env)
+    elif command in LM:
+        list(app, args)
+    elif command in BM:
+        build(app, args, env)
+    elif command in IM:
+        install(app, args, env)
+    elif command in AM:
+        add(app, args, env)
+
+def get_repositories(play_base):
+    repopath = os.path.join(play_base, 'repositories')
+    if os.path.exists(repopath):
+        repos = []
+        f = file(repopath)
+        for line in f:
+            if not re.match("^\s*#", line) and not line.strip() == "":
+                repos.append(line.strip())
+        if len(repos) > 0:
+            return repos
+    return [DEFAULT_REPO]
+
+class Downloader(object):
+    before = .0
+    history = []
+    cycles = 0
+    average = lambda self: sum(self.history) / (len(self.history) or 1)
+
+    def __init__(self, width=55):
+        self.width = width
+        self.kibi = lambda bits: bits / 2 ** 10
+        self.proc = lambda a, b: a / (b * 0.01)
+
+    def retrieve(self, url, destination, callback=None):
+        self.size = 0
+        time.clock()
+        try: urllib.urlretrieve(url, destination, self.progress)
+        except KeyboardInterrupt:
+            print '\n~ Download cancelled'
+            print '~'
+            for i in range(5):
+                try:
+                    os.remove(destination)
+                    break
+                except:
+                    time.sleep(.1)
+            else: raise
+            if callback: callback()
+            sys.exit()
+        print ''
+        return self.size
+
+    def progress(self, blocks, blocksize, filesize):
+        self.cycles += 1
+        bits = min(blocks*blocksize, filesize)
+        done = self.proc(bits, filesize) if bits != filesize else 100
+        bar = self.bar(done)
+        if not self.cycles % 3 and bits != filesize:
+            now = time.clock()
+            elapsed = now-self.before
+            if elapsed:
+                speed = self.kibi(blocksize * 3 / elapsed)
+                self.history.append(speed)
+                self.history = self.history[-4:]
+            self.before = now
+        average = round(sum(self.history[-4:]) / 4, 1)
+        self.size = self.kibi(bits)
+        print '\r~ [%s] %s KiB/s  ' % (bar, str(average)),
+
+    def bar(self, done):
+        span = self.width * done * 0.01
+        offset = len(str(int(done))) - .99
+        result = ('%d%%' % (done,)).center(self.width)
+        return result.replace(' ', '-', int(span - offset))
+
+class Unzip:
+    def __init__(self, verbose = False, percent = 10):
+        self.verbose = verbose
+        self.percent = percent
+
+    def extract(self, file, dir):
+        if not dir.endswith(':') and not os.path.exists(dir):
+            os.mkdir(dir)
+        zf = zipfile.ZipFile(file)
+        # create directory structure to house files
+        self._createstructure(file, dir)
+        num_files = len(zf.namelist())
+        percent = self.percent
+        divisions = 100 / percent
+        perc = int(num_files / divisions)
+        # extract files to directory structure
+        for i, name in enumerate(zf.namelist()):
+            if self.verbose == True:
+                print "Extracting %s" % name
+            elif perc > 0 and (i % perc) == 0 and i > 0:
+                complete = int (i / perc) * percent
+            if not name.endswith('/'):
+                outfile = open(os.path.join(dir, name), 'wb')
+                outfile.write(zf.read(name))
+                outfile.flush()
+                outfile.close()
+
+    def _createstructure(self, file, dir):
+        self._makedirs(self._listdirs(file), dir)
+
+    def _makedirs(self, directories, basedir):
+        """ Create any directories that don't currently exist """
+        for dir in directories:
+            curdir = os.path.join(basedir, dir)
+            if not os.path.exists(curdir):
+                os.makedirs(curdir)
+
+    def _listdirs(self, file):
+            """ Grabs all the directories in the zip structure
+            This is necessary to create the structure before trying
+            to extract the file to it. """
+            zf = zipfile.ZipFile(file)
+            dirs = []
+            for name in zf.namelist():
+                    dn = os.path.dirname(name)
+                    dirs.append(dn)
+            dirs.sort()
+            return dirs
+
+def new(app, args, play_env):
+    if os.path.exists(app.path):
+        print "~ Oops. %s already exists" % app.path
+        print "~"
+        sys.exit(-1)
+
+    print "~ The new module will be created in %s" % os.path.normpath(app.path)
+    print "~"
+    application_name = os.path.basename(app.path)
+    shutil.copytree(os.path.join(play_env["basedir"], 'resources/module-skel'), app.path)
+    # check_application()
+    replaceAll(os.path.join(app.path, 'build.xml'), r'%MODULE%', application_name)
+    replaceAll(os.path.join(app.path, 'commands.py'), r'%MODULE%', application_name)
+    replaceAll(os.path.join(app.path, 'conf/messages'), r'%MODULE%', application_name)
+    replaceAll(os.path.join(app.path, 'conf/routes'), r'%MODULE%', application_name)
+    replaceAll(os.path.join(app.path, 'conf/routes'), r'%MODULE_LOWERCASE%', string.lower(application_name))
+    os.mkdir(os.path.join(app.path, 'app/controllers/%s' % application_name))
+    os.mkdir(os.path.join(app.path, 'app/models/%s' % application_name))
+    os.mkdir(os.path.join(app.path, 'app/views/%s' % application_name))
+    os.mkdir(os.path.join(app.path, 'app/views/tags/%s' % application_name))
+    os.mkdir(os.path.join(app.path, 'src/play/modules/%s' % application_name))
+
+    print "~ OK, the module is created."
+    print "~ Start using it by adding this line in the application.conf modules list: "
+    print "~ module.%s=%s" % (application_name, os.path.normpath(app.path))
+    print "~"
+    print "~ Have fun!"
+    print "~"
+
+def list(app, args):
+    print "~ You can also browse this list online at:"
+    for repo in repositories:
+        print "~    %s/modules" % repo
+    print "~"
+
+    modules_list = load_module_list()
+
+    for mod in modules_list:
+        print "~ [%s]" % mod['name']
+        print "~   %s" % mod['fullname']
+        print "~   %s/modules/%s" % (mod['server'], mod['name'])
+        
+        vl = ''
+        i = 0
+        for v in mod['versions']:
+            vl += v["version"]
+            i = i+1
+            if i < len(mod['versions']):
+                vl += ', '
+
+        if vl:
+            print "~   Versions: %s" % vl
+        else:
+            print "~   (No versions released yet)"
+        print "~"
+
+    print "~ To install one of these modules use:"
+    print "~ play install module-version (eg: play install scala-1.0)"
+    print "~"
+    print "~ Or you can just install the default release of a module using:"
+    print "~ play install module (eg: play install scala)"
+    print "~"
+
+def build(app, args, env):
+    ftb = env["basedir"]
+
+    try:
+        optlist, args = getopt.getopt(args, '', ['framework='])
+        for o, a in optlist:
+            if o in ('--framework'):
+                ftb = a
+    except getopt.GetoptError, err:
+        print "~ %s" % str(err)
+        print "~ "
+        sys.exit(-1)
+
+    version = raw_input("~ What is the module version number? ")
+    fwkMatch = raw_input("~ What are the playframework versions required? ")
+
+    build_file = os.path.join(app.path, 'build.xml')
+    if os.path.exists(build_file):
+        print "~"
+        print "~ Building..."
+        print "~"
+        os.system('ant -f %s -Dplay.path=%s' % (build_file, ftb) )
+        print "~"
+
+    mv = '%s-%s' % (os.path.basename(app.path), version)
+    print("~ Packaging %s ... " % mv)
+
+    dist_dir = os.path.join(app.path, 'dist')
+    if os.path.exists(dist_dir):
+        shutil.rmtree(dist_dir)
+    os.mkdir(dist_dir)
+
+    manifest = os.path.join(app.path, 'manifest')
+    manifestF = open(manifest, 'w')
+    manifestF.write('version=%s\nframeworkVersions=%s\n' % (version, fwkMatch))
+    manifestF.close()
+
+    zip = zipfile.ZipFile(os.path.join(dist_dir, '%s.zip' % mv), 'w', zipfile.ZIP_STORED)
+    for (dirpath, dirnames, filenames) in os.walk(app.path):
+        if dirpath == dist_dir:
+            continue
+        if dirpath.find('/.') > -1 or dirpath.find('/tmp/') > -1  or dirpath.find('/test-result/') > -1 or dirpath.find('/logs/') > -1 or dirpath.find('/eclipse/') > -1 or dirpath.endswith('/test-result') or dirpath.endswith('/logs')  or dirpath.endswith('/eclipse') or dirpath.endswith('/nbproject'):
+            continue
+        for file in filenames:
+            if file.find('~') > -1 or file.endswith('.iml') or file.startswith('.'):
+                continue
+            zip.write(os.path.join(dirpath, file), os.path.join(dirpath[len(app.path):], file))
+    zip.close()
+
+    os.remove(manifest)
+
+    print "~"
+    print "~ Done!"
+    print "~ Package is available at %s" % os.path.join(dist_dir, '%s.zip' % mv)
+    print "~"
+
+def install(app, args, env):
+    if len(sys.argv) < 3:
+        help_file = os.path.join(env["basedir"], 'documentation/commands/cmd-install.txt')
+        print open(help_file, 'r').read()
+        sys.exit(0)
+
+    name = cmd = sys.argv[2]
+    groups = re.match(r'^([a-zA-Z0-9]+)([-](.*))?$', name)
+    module = groups.group(1)
+    version = groups.group(3)
+    
+    modules_list = load_module_list()
+    fetch = None
+
+    for mod in modules_list:
+        if mod['name'] == module:
+            for v in mod['versions']:
+                if version == None and v['isDefault']:
+                    print '~ Will install %s-%s' % (module, v['version'])
+                    print '~ This module is compatible with: %s' % v['matches']
+                    ok = raw_input('~ Do you want to install this version (y/n)? ')
+                    if not ok == 'y':
+                        print '~'
+                        sys.exit(-1)
+                    print '~ Installing module %s-%s...' % (module, v['version'])
+                    fetch = '%s/modules/%s-%s.zip' % (mod['server'], module, v['version'])
+                    break
+                if version  == v['version']:
+                    print '~ Will install %s-%s' % (module, v['version'])
+                    print '~ This module is compatible with: %s' % v['matches']
+                    ok = raw_input('~ Do you want to install this version (y/n)? ')
+                    if not ok == 'y':
+                        print '~'
+                        sys.exit(-1)
+
+                    print '~ Installing module %s-%s...' % (module, v['version'])
+                    fetch = '%s/modules/%s-%s.zip' % (mod['server'], module, v['version'])
+                    break
+
+    if fetch == None:
+        print '~ No module found \'%s\'' % name
+        print '~ Try play list-modules to get the modules list'
+        print '~'
+        sys.exit(-1)
+    
+    archive = os.path.join(env["basedir"], 'modules/%s-%s.zip' % (module, v['version']))
+    if os.path.exists(archive):
+        os.remove(archive)
+
+    print '~'
+    print '~ Fetching %s' % fetch
+    Downloader().retrieve(fetch, archive)
+
+    if not os.path.exists(archive):
+        print '~ Oops, file does not exist'
+        print '~'
+        sys.exist(-1)
+
+    print '~ Unzipping...'
+
+    if os.path.exists(os.path.join(env["basedir"], 'modules/%s-%s' % (module, v['version']))):
+        shutil.rmtree(os.path.join(env["basedir"], 'modules/%s-%s' % (module, v['version'])))
+    os.mkdir(os.path.join(env["basedir"], 'modules/%s-%s' % (module, v['version'])))
+
+    Unzip().extract(archive, os.path.join(env["basedir"], 'modules/%s-%s' % (module, v['version'])))
+    os.remove(archive)
+    print '~'
+    print '~ Module %s-%s is installed!' % (module, v['version'])
+    print '~ You can now use it by add adding this line to application.conf file:'
+    print '~'
+    print '~ module.%s=${play.path}/modules/%s-%s' % (module, module, v['version'])
+    print '~'
+    sys.exit(0)
+
+def add(app, args, env):
+    app.check()
+
+    try:
+        optlist, args = getopt.getopt(args, '', ['module='])
+        for o, a in optlist:
+            if o in ('--module'):
+                m = a
+    except getopt.GetoptError, err:
+        print "~ %s" % str(err)
+        print "~ "
+        sys.exit(-1)
+
+    if m is None:
+        print "~ Usage: play add --module=<modulename>"
+        print "~ "
+        sys.exit(-1)
+
+    appConf = os.path.join(app.path, 'conf/application.conf')
+    if not fileHas(appConf, '# ---- MODULES ----'):
+        print "~ Line '---- MODULES ----' missing in your application.conf. Add it to use this command."
+        print "~ "
+        sys.exit(-1)
+
+    mn = m
+    if mn.find('-') > 0:
+        mn = mn[:mn.find('-')]
+
+    if mn in app.module_names():
+        print "~ Module %s already declared in application.conf, not doing anything." % mn
+        print "~ "
+        sys.exit(-1)
+
+    replaceAll(appConf, r'# ---- MODULES ----', '# ---- MODULES ----\nmodule.%s=${play.path}/modules/%s' % (mn, m) )
+    print "~ Module %s add to application %s." % (mn, app.name())
+    print "~ "
+
+def load_module_list():
+
+    def addServer(module, server):
+        module['server'] = server
+        return module
+
+    def any(arr, func):
+        for x in arr:
+            if func(x): return True
+        return False
+
+    modules = None
+    rev = repositories[:] # clone
+    rev.reverse()
+    for repo in rev:
+        result = load_modules_from(repo)
+        if modules == None:
+            modules = map(lambda m: addServer(m, repo), result['modules'])
+        else:
+            for module in result['modules']:
+                if not any(modules, lambda m: m['name'] == module['name']):
+                    modules.append(addServer(module, repo))
+    return modules
+
+def load_modules_from(modules_server):
+    try:
+        url = '%s/modules' % modules_server
+        proxy_handler = urllib2.ProxyHandler({})
+        req = urllib2.Request(url)
+        req.add_header('Accept', 'application/json')
+        opener = urllib2.build_opener(proxy_handler)
+        result = opener.open(req)
+        return json.loads(result.read())
+    except urllib2.HTTPError, e:
+        print "~ Oops,"
+        print "~ Cannot fetch the modules list from %s (%s)..." % (url, e.code)
+        print "~"
+        sys.exit(-1)
+    except urllib2.URLError, e:
+        print "~ Oops,"
+        print "~ Cannot fetch the modules list from %s ..." % (url)
+        print "~"
+        sys.exit(-1)
+

=== added file 'framework/pym/play/commands/netbeans.py'
--- framework/pym/play/commands/netbeans.py	1970-01-01 00:00:00 +0000
+++ framework/pym/play/commands/netbeans.py	2010-09-16 22:21:08 +0000
@@ -0,0 +1,50 @@
+import os, os.path
+import shutil
+
+from play.utils import *
+
+COMMANDS = ['netbeansify', 'nb']
+
+HELP = {
+    'netbeansify': 'Create all NetBeans configuration files'
+}
+
+def execute(**kargs):
+    command = kargs.get("command")
+    app = kargs.get("app")
+    args = kargs.get("args")
+    play_env = kargs.get("env")
+
+    app.check()
+    classpath = app.getClasspath()
+    modules = app.modules()
+    application_name = app.readConf('application.name')
+    if not application_name:
+        application_name = os.path.dirname(app.path)
+    nbproject = os.path.join(app.path, 'nbproject')
+    if os.path.exists(nbproject):
+        shutil.rmtree(nbproject)
+        if os.name == 'nt':
+            time.sleep(1)
+    shutil.copytree(os.path.join(play_env["basedir"], 'resources/_nbproject'), nbproject)
+    replaceAll(os.path.join(nbproject, 'project.xml'), r'%APPLICATION_NAME%', application_name)
+    replaceAll(os.path.join(nbproject, 'project.xml'), r'%ANT_SCRIPT%', os.path.normpath(os.path.join(play_env["basedir"], 'framework/build.xml')))
+    replaceAll(os.path.join(nbproject, 'project.xml'), r'%APPLICATION_PATH%', os.path.normpath(app.path))
+    if os.name == 'nt':
+        replaceAll(os.path.join(nbproject, 'project.xml'), r'%PLAY_CLASSPATH%', ';'.join(classpath + ['nbproject\\classes']))
+    else:
+        replaceAll(os.path.join(nbproject, 'project.xml'), r'%PLAY_CLASSPATH%', ':'.join(classpath + ['nbproject/classes']))
+    mr = ""
+    for module in modules:
+        mr += "<package-root>%s</package-root>" % os.path.normpath(os.path.join(module, 'app'))
+    replaceAll(os.path.join(nbproject, 'project.xml'), r'%MODULES%', mr)
+    mr = ""
+    for dir in os.listdir(app.path):
+        if os.path.isdir(os.path.join(app.path, dir)) and dir not in ['app', 'conf', 'test', 'test-result', 'public', 'tmp', 'logs', 'nbproject', 'lib']:
+            mr = '<source-folder style="tree"><label>%s</label><location>%s</location></source-folder>' % (dir, dir)
+    replaceAll(os.path.join(nbproject, 'project.xml'), r'%MORE%', mr)
+    print "~ OK, the application is ready for netbeans"
+    print "~ Just open %s as a netbeans project" % os.path.normpath(app.path)
+    print "~"
+    print "~ Use netbeansify again when you want to update netbeans configuration files, then close and open you project again."
+    print "~"

=== added file 'framework/pym/play/commands/precompile.py'
--- framework/pym/play/commands/precompile.py	1970-01-01 00:00:00 +0000
+++ framework/pym/play/commands/precompile.py	2010-09-16 22:21:08 +0000
@@ -0,0 +1,31 @@
+import os, os.path
+import shutil
+import subprocess
+
+from play.utils import *
+
+COMMANDS = ['precompile']
+
+HELP = {
+    'precompile': 'Precompile all Java sources and templates to speed up application start-up'
+}
+
+def execute(**kargs):
+    command = kargs.get("command")
+    app = kargs.get("app")
+    args = kargs.get("args")
+    play_env = kargs.get("env")
+
+    app.check()
+    java_cmd = app.java_cmd(args)
+    if os.path.exists(os.path.join(app.path, 'tmp')):
+        shutil.rmtree(os.path.join(app.path, 'tmp'))
+    if os.path.exists(os.path.join(app.path, 'precompiled')):
+        shutil.rmtree(os.path.join(app.path, 'precompiled'))
+    java_cmd.insert(2, '-Dprecompile=yes')
+    try:
+        subprocess.call(java_cmd, env=os.environ)
+    except OSError:
+        print "Could not execute the java executable, please make sure the JAVA_HOME environment variable is set properly (the java executable should reside at JAVA_HOME/bin/java). "
+        sys.exit(-1)
+    print

=== added file 'framework/pym/play/commands/secret.py'
--- framework/pym/play/commands/secret.py	1970-01-01 00:00:00 +0000
+++ framework/pym/play/commands/secret.py	2010-09-16 22:21:08 +0000
@@ -0,0 +1,17 @@
+from play.utils import *
+
+COMMANDS = ['secret']
+
+HELP = {
+    'secret': 'Generate a new secret key'
+}
+
+def execute(**kargs):
+    app = kargs.get("app")
+
+    app.check()
+    print "~ Generating the secret key..."
+    sk = secretKey()
+    replaceAll(os.path.join(app.path, 'conf', 'application.conf'), r'application.secret=.*', 'application.secret=%s' % sk, True)
+    print "~ Keep the secret : %s" % sk
+    print "~"

=== added file 'framework/pym/play/commands/status.py'
--- framework/pym/play/commands/status.py	1970-01-01 00:00:00 +0000
+++ framework/pym/play/commands/status.py	2010-09-16 22:21:08 +0000
@@ -0,0 +1,68 @@
+import os, os.path
+import shutil
+import getopt
+import hmac
+import urllib2
+from hashlib import sha1 as sha
+
+from play.utils import *
+
+COMMANDS = ['status', 'st']
+
+HELP = {
+    'status': 'Display the running application\'s status'
+}
+
+def execute(**kargs):
+    app = kargs.get("app")
+    args = kargs.get("args")
+    play_env = kargs.get("env")
+
+    url = ''
+    secret_key = ''
+
+    try:
+        optlist, args2 = getopt.getopt(args, '', ['url=', 'secret='])
+        for o, a in optlist:
+            if o in ('--url'):
+                if a.endswith('/'):
+                    url = a + '@status'
+                else:
+                    url = a + '/@status'
+            if o in ('--secret'):
+                secret_key = a
+    except getopt.GetoptError, err:
+        print "~ %s" % str(err)
+        print "~ "
+        sys.exit(-1)
+
+    if not url or not secret_key:
+        app.check()
+        if not url:
+            http_port = int(app.readConf('http.port'))
+            url = 'http://localhost:%s/@status' % http_port
+        if not secret_key:
+            secret_key = app.readConf('application.secret')
+
+    hm = hmac.new(secret_key, '@status', sha)
+    authorization = hm.hexdigest()
+
+    try:
+        proxy_handler = urllib2.ProxyHandler({})
+        req = urllib2.Request(url)
+        req.add_header('Authorization', authorization)
+        opener = urllib2.build_opener(proxy_handler)
+        status = opener.open(req);
+        print '~ Status from %s,' % url
+        print '~'
+        print status.read()
+        print '~'
+    except urllib2.HTTPError, e:
+        print "~ Cannot retrieve the application status... (%s)" % (e.code)
+        print "~"
+        sys.exit(-1)
+    except urllib2.URLError, e:
+        print "~ Cannot contact the application..."
+        print "~"
+        sys.exit(-1)
+    print

=== added file 'framework/pym/play/commands/war.py'
--- framework/pym/play/commands/war.py	1970-01-01 00:00:00 +0000
+++ framework/pym/play/commands/war.py	2010-09-16 22:21:08 +0000
@@ -0,0 +1,46 @@
+import sys
+import os
+import getopt
+import shutil
+import zipfile
+
+from play.utils import *
+
+COMMANDS = ["war"]
+
+HELP = {
+    'war': 'Export the application as a standalone WAR archive'
+}
+
+def execute(**kargs):
+    command = kargs.get("command")
+    app = kargs.get("app")
+    args = kargs.get("args")
+    env = kargs.get("env")
+
+    war_path = None
+    war_zip_path = None
+    try:
+        optlist, args = getopt.getopt(args, 'o:', ['output=', 'zip'])
+        for o, a in optlist:
+            if o in ('-o', '--output'):
+                war_path = os.path.normpath(os.path.abspath(a))
+        for o, a in optlist:
+            if o in ('--zip'):
+                war_zip_path = war_path + '.war'
+    except getopt.GetoptError, err:
+        print "~ %s" % str(err)
+        print "~ Please specify a path where to generate the WAR, using the -o or --output option"
+        print "~ "
+        sys.exit(-1)
+        
+    package_as_war(app, env, war_path, war_zip_path)
+    
+    print "~ Done !"
+    print "~"
+    print "~ You can now load %s as a standard WAR into your servlet container" % (os.path.normpath(war_path))
+    print "~ You can't use play standard commands to run/stop/debug the WAR application..."
+    print "~ ... just use your servlet container commands instead"
+    print "~"
+    print "~ Have fun!"
+    print "~"

=== added file 'framework/pym/play/launchpad.py'
--- framework/pym/play/launchpad.py	1970-01-01 00:00:00 +0000
+++ framework/pym/play/launchpad.py	2010-09-16 22:21:08 +0000
@@ -0,0 +1,24 @@
+# The official launchpad lib is too heavy with dependancies, let's just implement only what we need
+
+from urllib2 import urlopen, Request
+import simplejson as json
+
+BASE_URL = 'https://api.edge.launchpad.net/1.0/'
+
+class Entry:
+    def __init__(self, baseUrl):
+        self.baseUrl = baseUrl
+
+    def __getattr__(self, method, *args, **kwargs):
+        return lambda *args, **kwargs: _doCall(self.baseUrl, method, kwargs)
+
+class Project(Entry):
+    def __init__(self, name):
+        Entry.__init__(self, BASE_URL + name)
+
+def _doCall(baseUrl, method, parameters):
+    url = baseUrl + "?ws.op=" + method
+    for key in parameters:
+        url += ("&" + key + "=" + parameters[key])
+    return json.loads(urlopen(Request(url)).read())
+

=== added file 'framework/pym/play/utils.py'
--- framework/pym/play/utils.py	1970-01-01 00:00:00 +0000
+++ framework/pym/play/utils.py	2010-09-16 22:21:08 +0000
@@ -0,0 +1,186 @@
+import sys
+import os, os.path
+import re
+import random
+import fileinput
+import getopt
+import shutil
+
+def playVersion(play_env):
+    play_version_file = os.path.join(play_env["basedir"], 'framework', 'src', 'play', 'version')
+    return open(play_version_file).readline().strip()
+
+def replaceAll(file, searchExp, replaceExp, regexp=False):
+    if not regexp:
+        replaceExp = replaceExp.replace('\\', '\\\\')
+        searchExp = searchExp.replace('$', '\\$')
+        searchExp = searchExp.replace('{', '\\{')
+        searchExp = searchExp.replace('}', '\\}')
+        searchExp = searchExp.replace('.', '\\.')
+    for line in fileinput.input(file, inplace=1):
+        line = re.sub(searchExp, replaceExp, line)
+        sys.stdout.write(line)
+
+def fileHas(file, searchExp):
+    # The file doesn't get closed if we don't iterate to the end, so
+    # we must continue even after we found the match.
+    found = False
+    for line in fileinput.input(file):
+        if line.find(searchExp) > -1:
+            found = True
+    return found
+
+def secretKey():
+    return ''.join([random.choice('ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789') for i in range(64)])
+
+def isParentOf(path1, path2):
+    if len(path2) < len(path1) or len(path2) < 2:
+        return False
+    if (path1 == path2):
+        return True
+    return isParentOf(path1, os.path.dirname(path2))
+
+def isParentOf(path1, path2):
+    if len(path2) < len(path1) or len(path2) < 2:
+        return False
+    if (path1 == path2):
+        return True
+
+def getWithModules(args, env):
+    withModules = []
+    try:
+        optlist, newargs = getopt.getopt(args, '', ['with=', 'name='])
+        for o, a in optlist:
+            if o in ('--with='):
+                withModules = a.split(',')
+    except getopt.GetoptError:
+        pass # Other argument that --with= has been passed (which is OK)
+    md = []
+    for m in withModules:
+        dirname = None
+        candidate = os.path.join(env["basedir"], 'modules/%s' % m)
+        if os.path.exists(candidate) and os.path.isdir(candidate):
+            dirname = candidate
+        else:
+            for f in os.listdir(os.path.join(env["basedir"], 'modules')):
+                if os.path.isdir(os.path.join(env["basedir"], 'modules/%s' % f)) and f.find('%s-' % m) == 0:
+                    dirname = os.path.join(env["basedir"], 'modules/%s' % f)
+                    break
+        md.append(dirname)
+    return md
+
+def package_as_war(app, env, war_path, war_zip_path):
+    app.check()
+    modules = app.modules()
+    classpath = app.getClasspath()
+
+    if not war_path:
+        print "~ Oops. Please specify a path where to generate the WAR, using the -o or --output option"
+        print "~"
+        sys.exit(-1)
+
+    if os.path.exists(war_path) and not os.path.exists(os.path.join(war_path, 'WEB-INF')):
+        print "~ Oops. The destination path already exists but does not seem to host a valid WAR structure"
+        print "~"
+        sys.exit(-1)
+
+    if isParentOf(app.path, war_path):
+        print "~ Oops. Please specify a destination directory outside of the application"
+        print "~"
+        sys.exit(-1)
+
+    print "~ Packaging current version of the framework and the application to %s ..." % (os.path.normpath(war_path))
+    if os.path.exists(war_path): shutil.rmtree(war_path)
+    if os.path.exists(os.path.join(app.path, 'war')):
+        shutil.copytree(os.path.join(app.path, 'war'), war_path)
+    else:
+        os.mkdir(war_path)
+    if not os.path.exists(os.path.join(war_path, 'WEB-INF')): os.mkdir(os.path.join(war_path, 'WEB-INF'))
+    if not os.path.exists(os.path.join(war_path, 'WEB-INF/web.xml')):
+        shutil.copyfile(os.path.join(env["basedir"], 'resources/war/web.xml'), os.path.join(war_path, 'WEB-INF/web.xml'))
+    application_name = app.readConf('application.name')
+    replaceAll(os.path.join(war_path, 'WEB-INF/web.xml'), r'%APPLICATION_NAME%', application_name)
+    if env["id"] is not "":
+        replaceAll(os.path.join(war_path, 'WEB-INF/web.xml'), r'%PLAY_ID%', env["id"])
+    else:
+        replaceAll(os.path.join(war_path, 'WEB-INF/web.xml'), r'%PLAY_ID%', 'war')
+    if os.path.exists(os.path.join(war_path, 'WEB-INF/application')): shutil.rmtree(os.path.join(war_path, 'WEB-INF/application'))
+    shutil.copytree(app.path, os.path.join(war_path, 'WEB-INF/application'))
+    if os.path.exists(os.path.join(war_path, 'WEB-INF/application/war')):
+        shutil.rmtree(os.path.join(war_path, 'WEB-INF/application/war'))
+    if os.path.exists(os.path.join(war_path, 'WEB-INF/application/logs')):
+        shutil.rmtree(os.path.join(war_path, 'WEB-INF/application/logs'))
+    shutil.copytree(os.path.join(app.path, 'conf'), os.path.join(war_path, 'WEB-INF/classes'))
+    if os.path.exists(os.path.join(war_path, 'WEB-INF/lib')): shutil.rmtree(os.path.join(war_path, 'WEB-INF/lib'))
+    os.mkdir(os.path.join(war_path, 'WEB-INF/lib'))
+    for jar in classpath:
+        if jar.endswith('.jar') and jar.find('provided-') == -1:
+            shutil.copyfile(jar, os.path.join(war_path, 'WEB-INF/lib/%s' % os.path.split(jar)[1]))
+    if os.path.exists(os.path.join(war_path, 'WEB-INF/framework')): shutil.rmtree(os.path.join(war_path, 'WEB-INF/framework'))
+    os.mkdir(os.path.join(war_path, 'WEB-INF/framework'))
+    shutil.copytree(os.path.join(env["basedir"], 'framework/templates'), os.path.join(war_path, 'WEB-INF/framework/templates'))
+    
+    # modules
+    for module in modules:
+        to = os.path.join(war_path, 'WEB-INF/modules/%s' % os.path.basename(module))
+        shutil.copytree(module, to)
+        if os.path.exists(os.path.join(to, 'src')):
+            shutil.rmtree(os.path.join(to, 'src'))
+        if os.path.exists(os.path.join(to, 'dist')):
+            shutil.rmtree(os.path.join(to, 'dist'))
+        if os.path.exists(os.path.join(to, 'samples-and-tests')):
+            shutil.rmtree(os.path.join(to, 'samples-and-tests'))
+        if os.path.exists(os.path.join(to, 'build.xml')):
+            os.remove(os.path.join(to, 'build.xml'))
+        if os.path.exists(os.path.join(to, 'commands.py')):
+            os.remove(os.path.join(to, 'commands.py'))
+        if os.path.exists(os.path.join(to, 'lib')):
+            shutil.rmtree(os.path.join(to, 'lib'))
+        if os.path.exists(os.path.join(to, 'nbproject')):
+            shutil.rmtree(os.path.join(to, 'nbproject'))
+        if os.path.exists(os.path.join(to, 'documentation')):
+            shutil.rmtree(os.path.join(to, 'documentation'))
+    pm = app.readConfs('module.')
+    for m in pm:
+        nm = os.path.basename(m)
+        replaceAll(os.path.join(war_path, 'WEB-INF/application/conf/application.conf'), m, '../modules/%s' % nm)
+
+    if not os.path.exists(os.path.join(war_path, 'WEB-INF/resources')): os.mkdir(os.path.join(war_path, 'WEB-INF/resources'))
+    shutil.copyfile(os.path.join(env["basedir"], 'resources/messages'), os.path.join(war_path, 'WEB-INF/resources/messages'))
+
+    deleteFrom(war_path, app.readConf('war.exclude').split("|"))
+
+    if war_zip_path:
+        print "~ Creating zipped archive to %s ..." % (os.path.normpath(war_zip_path))
+        if os.path.exists(war_zip_path):
+            os.remove(war_zip_path)
+        zip = zipfile.ZipFile(war_zip_path, 'w', zipfile.ZIP_STORED)
+        dist_dir = os.path.join(app.path, 'dist')
+        for (dirpath, dirnames, filenames) in os.walk(war_path):
+            if dirpath == dist_dir:
+                continue
+            if dirpath.find('/.') > -1:
+                continue
+            for file in filenames:
+                if file.find('~') > -1 or file.startswith('.'):
+                    continue
+                zip.write(os.path.join(dirpath, file), os.path.join(dirpath[len(war_path):], file))
+
+        zip.close()
+
+# Recursively delete all files/folders in root whose name equals to filename
+# We could pass a "ignore" parameter to copytree, but that's not supported in Python 2.5
+
+def deleteFrom(root, filenames):
+    for f in os.listdir(root):
+        fullpath = os.path.join(root, f)
+        if f in filenames:
+            delete(fullpath)
+        elif os.path.isdir(fullpath):
+            deleteFrom(fullpath, filenames)
+
+def delete(filename):
+    if os.path.isdir(filename):
+        shutil.rmtree(filename)
+    else:
+        os.remove(filename)
\ No newline at end of file

=== modified file 'framework/src/ehcache.xml'
--- framework/src/ehcache.xml	2009-05-23 21:02:57 +0000
+++ framework/src/ehcache.xml	2010-09-16 22:21:08 +0000
@@ -1,4 +1,4 @@
-<ehcache xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:noNamespaceSchemaLocation="../config/ehcache.xsd">
+<ehcache xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:noNamespaceSchemaLocation="../config/ehcache.xsd" updateCheck="false">
 
     <defaultCache
             maxElementsInMemory="10000"

=== modified file 'framework/src/play/CorePlugin.java'
--- framework/src/play/CorePlugin.java	2010-05-11 11:01:32 +0000
+++ framework/src/play/CorePlugin.java	2010-09-16 22:21:08 +0000
@@ -39,21 +39,20 @@
                 }
             }
             return o.toString();
-        } else {
-            StringBuffer dump = new StringBuffer();
-            for (PlayPlugin plugin : Play.plugins) {
-                try {
-                    String status = plugin.getStatus();
-                    if (status != null) {
-                        dump.append(status);
-                        dump.append("\n");
-                    }
-                } catch (Throwable e) {
-                    dump.append(plugin.getClass().getName() + ".getStatus() has failed (" + e.getMessage() + ")");
+        }
+        StringBuffer dump = new StringBuffer();
+        for (PlayPlugin plugin : Play.plugins) {
+            try {
+                String status = plugin.getStatus();
+                if (status != null) {
+                    dump.append(status);
+                    dump.append("\n");
                 }
+            } catch (Throwable e) {
+                dump.append(plugin.getClass().getName() + ".getStatus() has failed (" + e.getMessage() + ")");
             }
-            return dump.toString();
         }
+        return dump.toString();
     }
 
     /**
@@ -78,15 +77,14 @@
                 response.print(computeApplicationStatus(request.path.contains(".json")));
                 response.status = 200;
                 return true;
+            }
+            response.status = 401;
+            if(response.contentType.equals("application/json")) {
+                response.print("{\"error\": \"Not authorized\"}");
             } else {
-                response.status = 401;
-                if(response.contentType.equals("application/json")) {
-                    response.print("{\"error\": \"Not authorized\"}");
-                } else {
-                    response.print("Not authorized");
-                }
-                return true;
+                response.print("Not authorized");
             }
+            return true;
         }
         return super.rawInvocation(request, response);
     }

=== modified file 'framework/src/play/Invoker.java'
--- framework/src/play/Invoker.java	2010-06-02 10:08:08 +0000
+++ framework/src/play/Invoker.java	2010-09-16 22:21:08 +0000
@@ -2,9 +2,11 @@
 
 import com.jamonapi.Monitor;
 import com.jamonapi.MonitorFactory;
-import java.util.HashMap;
+import java.util.Arrays;
 import java.util.HashSet;
+import java.util.List;
 import java.util.Map;
+import java.util.concurrent.ConcurrentHashMap;
 import java.util.concurrent.Future;
 import java.util.concurrent.ScheduledThreadPoolExecutor;
 import java.util.concurrent.ThreadPoolExecutor;
@@ -30,7 +32,7 @@
      * @param invocation The code to run
      * @return The future object, to know when the task is completed
      */
-    public static Future invoke(final Invocation invocation) {
+    public static Future<?> invoke(final Invocation invocation) {
         Monitor monitor = MonitorFactory.getMonitor("Invoker queue size", "elmts.");
         monitor.add(executor.getQueue().size());
         invocation.waitInQueue = MonitorFactory.start("Waiting for execution");
@@ -40,13 +42,13 @@
     /**
      * Run the code in a new thread after a delay
      * @param invocation The code to run
-     * @param seconds The time to wait before
+     * @param millis The time to wait before, in milliseconds
      * @return The future object, to know when the task is completed
      */
-    public static Future invoke(final Invocation invocation, int seconds) {
+    public static Future<?> invoke(final Invocation invocation, long millis) {
         Monitor monitor = MonitorFactory.getMonitor("Invocation queue", "elmts.");
         monitor.add(executor.getQueue().size());
-        return executor.schedule(invocation, seconds, TimeUnit.SECONDS);
+        return executor.schedule(invocation, millis, TimeUnit.MILLISECONDS);
     }
 
     /**
@@ -61,10 +63,10 @@
                 retry = false;
             } else {
                 try {
-                    if (invocation.retry.task != null) {
-                        invocation.retry.task.get();
+                    if (invocation.retry.tasks != null) {
+                        for(Future<?> f : invocation.retry.tasks) f.get();
                     } else {
-                        Thread.sleep(invocation.retry.timeout * 1000);
+                        Thread.sleep(invocation.retry.timeout);
                     }
                 } catch (Exception e) {
                     throw new UnexpectedException(e);
@@ -127,6 +129,12 @@
         }
 
         /**
+         * Things to do when the whole invocation has succeeded (before + execute + after)
+         */
+        public void onSuccess() throws Exception {
+        }
+
+        /**
          * Things to do if the Invocation code thrown an exception
          */
         public void onException(Throwable e) {
@@ -147,8 +155,8 @@
          * @param suspendRequest
          */
         public void suspend(Suspend suspendRequest) {
-            if (suspendRequest.task != null) {
-                WaitForTasksCompletion.waitFor(suspendRequest.task, this);
+            if (suspendRequest.tasks != null) {
+                WaitForTasksCompletion.waitFor(suspendRequest.tasks, this);