Merge pull request #18 from decebals/release-0.6.0

decebals · decebals · commit 1a56911683d8 · 2015-07-01T16:47:16.000+03:00
update to release 0.6.0
diff --git a/_posts/2015-03-17-reverse-routing.md b/_posts/2015-03-17-reverse-routing.md
@@ -44,7 +44,40 @@ parameters.put("action", "new");
 String url = routeContext.uriFor("/contacts/{id}", parameters);
 ```
 
-By default (via `DefaultRouter`) the `uriFor` method automatically encode the parameters values.
+Are some scenarios when it's more ease to use the route name for `uriFor()`.  
+In few words I can add a route (in an hypothetical blog application) that render a template with:
+
+```java
+GET("/blogs/{year}/{month}/{day}/{title}", (routeContext) -> { routeContext.render("myTemplate")});
+```
+
+It's hard to create the reverse routing using the `uriPattern`:
+
+```java
+Map<String, Object> parameters = ...
+routeContext.uriFor("/blogs/{year}/{month}/{day}/{title}", parameters);
+```
+
+The simplest solution is to add a `name` to our route and to use this name when we build the URL(reverse routing) to that route:
+
+```java
+GET("/blogs/{year}/{month}/{day}/{title}", (routeContext) -> { routeContext.render("myTemplate")}).named("blog");
+```
+
+The new code becomes more short and readable:
+
+```java
+Map<String, Object> parameters = ...
+routeContext.uriFor("blog", parameters);
+```
+
+Advantages:
+
+- it is often more descriptive than hard-coding the `uriPattern`
+- it allows you to change `uriPattern` in one go, without having to remember to change URLs all over the place.
+
+
+**Note:** By default (via `DefaultRouter`) the `uriFor` method automatically encode the parameters values.
 
 In conclusion if you want to create links to routes or controllers you must use `Router.uriFor` methods.
 
diff --git a/_posts/2015-03-17-server.md b/_posts/2015-03-17-server.md
@@ -53,6 +53,7 @@ Pippo comes (out of the box) with some web servers:
 
 - [Jetty](http://eclipse.org/jetty) `pippo-jetty`
 - [Undertow](http://undertow.io) `pippo-undertow`
+- [Tomcat](http://tomcat.apache.org) `pippo-tomcat`
 - [TJWS](http://tjws.sourceforge.net) `pippo-tjws`
 
 To use one of these servers just add a dependency in your project:
@@ -83,5 +84,5 @@ public interface WebServer {
 
 If you want to make your embedded server plugable for Pippo than you must add file 
 `ro.pippo.core.WebServer` in _src/main/resources/META-INF/services_ folder with your class name that implements 
-WebServer as content (for an hypothetical Tomcat integration the content file should be _ro.pippo.tomcat.TomcatServer_).
+WebServer as content (for a Tomcat integration the content file should be _ro.pippo.tomcat.TomcatServer_).
 
diff --git a/_posts/2015-03-17-static-files.md b/_posts/2015-03-17-static-files.md
@@ -19,11 +19,19 @@ For example:
 
 ```java
 Pippo pippo = new Pippo();
-pippo.getApplication().GET(new PublicResourceHandler());
-pippo.getApplication().GET(new WebjarsResourceHandler());
+pippo.getApplication().addPublicResourceRoute();
+pippo.getApplication().addWebjarsResourceRoute();
 ```
 
-You can use multiple `FileResourceHandler` but it is nonsense to use more `PublicResourceHandler` or more `WebjarsResourceHandler`.  
+or more verbose:
+
+```java
+Pippo pippo = new Pippo();
+pippo.getApplication().addResourceRoute(new PublicResourceHandler());
+pippo.getApplication().addResourceRoute(new WebjarsResourceHandler());
+```
+
+You can use multiple `FileResourceRoute` but it is nonsense to use more `PublicResourceRoute` or more `WebjarsResourceRoute`.  
 
 The [CrudNgDemo]({{ site.demourl }}/pippo-demo-crudng) (demo pippo-angularjs integration) is a good application that demonstrates the concept of static files. 
 In `src/main/resources` we created a folder __public__ and we put all assets in that folder (imgs, css, js, fonts, ...).
@@ -52,12 +60,21 @@ In this demo, the html template page (freemarker engine) contains a head section
     <meta content="IE=edge" http-equiv="X-UA-Compatible">
     <meta name="viewport" content="width=device-width, initial-scale=1.0">
 
-    <link href="${webjarsAt('bootstrap/3.3.1/css/bootstrap.min.css')}" rel="stylesheet">
-    <link href="${webjarsAt('font-awesome/4.2.0/css/font-awesome.min.css')}" rel="stylesheet">
+    <link href="${webjarsAt('bootstrap/css/bootstrap.min.css')}" rel="stylesheet">
+    <link href="${webjarsAt('font-awesome/css/font-awesome.min.css')}" rel="stylesheet">
     <link href="${publicAt('css/style.css')}" rel="stylesheet">
 </head>
 ```
 
+If you want to have more control over webjars artifact version you can use this declaration:
+
+```html
+<head>
+	<link href="${webjarsAt('bootstrap/3.3.1/css/bootstrap.min.css')}" rel="stylesheet">
+	<link href="${webjarsAt('font-awesome/4.2.0/css/font-awesome.min.css')}" rel="stylesheet">
+</head>
+```
+
 Sure in your pom.xml file (if you use Maven) you must declare the dependencies to these webjars:
 
 ```xml
@@ -75,12 +92,12 @@ Sure in your pom.xml file (if you use Maven) you must declare the dependencies t
 </dependency>
 ```
 
-If you want to serve static files that are not on the classpath then you may use the `FileResourceHandler`.
+If you want to serve static files that are not on the classpath then you may use the `FileResourceRoute`.
 
 ```java
 Pippo pippo = new Pippo();
 // make available some files from a local folder (try a request like 'src/main/resources/simplelogger.properties')
-pippo.getApplication().GET(new FileResourceHandler("/src", "src"));
+pippo.getApplication().addFileResourceRoute("/src", "src");
 ```
 
-From security reason the `FileResourceHandler` doesn't serve resources from outside it's base directory by using relative paths such as `../../../private.txt`.
+From security reason the `FileResourceRoute` doesn't serve resources from outside it's base directory by using relative paths such as `../../../private.txt`.
diff --git a/_posts/2015-03-17-templates.md b/_posts/2015-03-17-templates.md
@@ -20,6 +20,7 @@ Pippo comes (out of the box) with some template engines:
 - [Groovy](/doc/templates/groovy.html) `pippo-groovy`
 - [Pebble](/doc/templates/pebble.html) `pippo-pebble`
 - [Trimou](/doc/templates/trimou.html) `pippo-trimou`
+- [Velocity]({{ site.codeurl }}/pippo-velocity) `pippo-velocity`
 
 To use one of these template engines just add a dependency in your project:
 
diff --git a/_posts/2015-04-03-freemarker.md b/_posts/2015-04-03-freemarker.md
@@ -76,16 +76,16 @@ pippo-freemarker supports context-aware url generation for your classpath resour
 <script src="${publicAt('js/main.js')}"></script>
 ```
 
-**NOTE:** Use of these methods require that you have registered a `WebjarsResourceHandler` and/or a `PublicResourcehandler`.
+**NOTE:** Use of these methods require that you have registered a `WebjarsResourceRoute` and/or a `PublicResourceRoute`.
 
 ```java
 public class MyApplication extends Application {
 
 	@Override
     protected void onInit() {
-        // add classpath resource handlers
-        GET(new WebjarsResourceHandler());
-        GET(new PublicResourceHandler());
+		// add routes for static content
+        addPublicResourceRoute();
+        addWebjarsResourceRoute();
         ...
     }
     
diff --git a/_posts/2015-04-03-groovy.md b/_posts/2015-04-03-groovy.md
@@ -75,16 +75,16 @@ script(src: webjarsAt('bootstrap/3.3.1/js/bootstrap.min.js')) {}
 script(src: publicAt('js/main.js')) {}
 ```
 
-**NOTE:** Use of these methods require that you have registered a `WebjarsResourceHandler` and/or a `PublicResourcehandler`.
+**NOTE:** Use of these methods require that you have registered a `WebjarsResourceRoute` and/or a `PublicResourceRoute`.
 
 ```java
 public class MyApplication extends Application {
 
 	@Override
     protected void onInit() {
-        // add classpath resource handlers
-        GET(new WebjarsResourceHandler());
-        GET(new PublicResourceHandler());
+		// add routes for static content
+        addPublicResourceRoute();
+        addWebjarsResourceRoute();    
         ...
     }
     
diff --git a/_posts/2015-04-03-jade.md b/_posts/2015-04-03-jade.md
@@ -76,16 +76,16 @@ script(src=pippo.webjarsAt('bootstrap/3.3.1/js/bootstrap.min.js'))
 script(src=pippo.publicAt('js/main.js'))
 ```
 
-**NOTE:** Use of these methods require that you have registered a `WebjarsResourceHandler` and/or a `PublicResourcehandler`.
+**NOTE:** Use of these methods require that you have registered a `WebjarsResourceRoute` and/or a `PublicResourceRoute`.
 
 ```java
 public class MyApplication extends Application {
 
 	@Override
     protected void onInit() {
-        // add classpath resource handlers
-        GET(new WebjarsResourceHandler());
-        GET(new PublicResourceHandler());
+		// add routes for static content
+        addPublicResourceRoute();
+        addWebjarsResourceRoute();
         ...
     }
     
diff --git a/_posts/2015-04-03-pebble.md b/_posts/2015-04-03-pebble.md
@@ -79,16 +79,16 @@ pippo-pebble supports context-aware url generation for your classpath resources
 {% endraw %}
 ```
 
-**NOTE:** Use of these methods require that you have registered a `WebjarsResourceHandler` and/or a `PublicResourcehandler`.
+**NOTE:** Use of these methods require that you have registered a `WebjarsResourceRoute` and/or a `PublicResourceRoute`.
 
 ```java
 public class MyApplication extends Application {
 
 	@Override
     protected void onInit() {
-        // add classpath resource handlers
-        GET(new WebjarsResourceHandler());
-        GET(new PublicResourceHandler());
+		// add routes for static content
+        addPublicResourceRoute();
+        addWebjarsResourceRoute();
         ...
     }
     
diff --git a/_posts/2015-04-03-trimou.md b/_posts/2015-04-03-trimou.md
@@ -84,16 +84,16 @@ pippo-trimou supports context-aware url generation for your classpath resources
 {% endraw %}
 ```
 
-**NOTE:** Use of these methods require that you have registered a `WebjarsResourceHandler` and/or a `PublicResourcehandler`.
+**NOTE:** Use of these methods require that you have registered a `WebjarsResourceRoute` and/or a `PublicResourceRoute`.
 
 ```java
 public class MyApplication extends Application {
 
 	@Override
     protected void onInit() {
-        // add classpath resource handlers
-        GET(new WebjarsResourceHandler());
-        GET(new PublicResourceHandler());
+		// add routes for static content
+        addPublicResourceRoute();
+        addWebjarsResourceRoute();
         ...
     }
     
diff --git a/_posts/2015-05-05-routes.md b/_posts/2015-05-05-routes.md
@@ -56,3 +56,18 @@ If you want to be more riguros you can use something like:
 ```java
 GET("/contact/{id: [0-9]+}", (routeContext) -> { ... });
 ```
+
+`Named` routes make referring to routes when generating redirects or URLs more convenient. You may specify a name for a route like so:
+
+```java
+GET("/blogs/{year}/{month}/{day}/{title}", (routeContext) -> { routeContext.render("myTemplate")}).named("blog");
+```
+
+Now, you may use the route's name when generating URLs or redirects:
+
+```java
+Map<String, Object> parameters = ...
+routeContext.uriFor("blog", parameters);
+// or
+routeContext.redirect("blog", parameters);
+```
diff --git a/_posts/2015-05-28-quickstart.md b/_posts/2015-05-28-quickstart.md
@@ -16,7 +16,7 @@ Creating a quickstart provides only a very basic starting point for your Pippo p
 
 To create your project you must follow these steps:
 
-- install [pippo-quickstart]({{ projecturl }}/maven-archetypes/quickstart) archetype on your computer (this step is **OPTIONAL**; the archetype is also available on Maven Central Repository):
+- install [pippo-quickstart](https://github.com/decebals/pippo/tree/master/maven-archetypes/quickstart) archetype on your computer (this step is **OPTIONAL**; the archetype is also available on Maven Central Repository):
 
 ```
 cd <PIPPO_HOME>/maven-archetypes/quickstart
diff --git a/_posts/2015-06-26-cdi.md b/_posts/2015-06-26-cdi.md
@@ -0,0 +1,75 @@
+---
+layout: page
+title: "CDI"
+category: mod
+date: 2015-06-26 20:07:29
+order: 17
+---
+
+Pippo can be used together with [CDI](http://www.cdi-spec.org/), using [Weld](http://weld.cdi-spec.org) as the implementation mechanism.  
+When Pippo creates new instances of your various `Controller` subclasses it delegates the instance creation to a `ControllerFactory`.
+The module [pippo-weld]({{ site.codeurl }}/pippo-weld) contains [WeldControllerFactory]({{ site.codeurl }}/pippo-weld/src/main/java/ro/pippo/weld/WeldControllerFactory.java) that it's 
+a `ControllerFactory` implementation that delegates to the Weld container to instantiate a given `Controller` class. This allows for the instance to be configured via dependency injection.
+
+An example of such a Controller subclass could look as follows:
+
+```java
+public class ContactsController extends Controller {
+
+    @Inject
+    private ContactService contactService;
+
+    public void index() {
+        List<Contact> contacts = contactService.getContacts()
+        getResponse().bind("contacts", contacts).render("contacts");
+    }
+
+}
+```
+
+Pippo automatically creates the _ContactsController_ instance and pippo-weld injects the ContactService service bean, so basically you don’t have to worry about any of that stuff. 
+
+To activate pippo-weld integration in your Application you must add a `WeldControllerFactory` instance:
+
+```java
+public class MyApplication extends Application {
+
+    @Override
+    protected void onInit() {
+        Weld weld = new Weld();
+        WeldContainer container = weld.initialize();
+
+        // registering WeldControllerFactory
+        setControllerFactory(new WeldControllerFactory(container));
+
+        // add controller
+        GET("/", ContactsController.class, "index");        
+    }
+}
+```
+
+For our demo project the ContactService bean was available in the parent maven module so a Producer was required. For this a utility class was necessary.
+
+```java
+public class WeldBeanProducer {
+
+    @Produces
+    public ContactService contactService() {
+        return new InMemoryContactService();
+    }
+
+}
+```
+
+
+Don't forget to add pippo-weld as dependency in your project:
+
+```xml
+<dependency>
+    <groupId>ro.pippo</groupId>
+    <artifactId>pippo-weld</artifactId>
+    <version>${pippo.version}</version>
+</dependency>
+```
+
+You can see a demo [here]({{ site.demourl }}/pippo-demo-weld)
diff --git a/_posts/2015-06-26-css-preprocessors.md b/_posts/2015-06-26-css-preprocessors.md
@@ -0,0 +1,53 @@
+---
+layout: page
+title: "CSS pre-processors"
+category: mod
+date: 2015-06-26 21:31:52
+order: 18
+---
+
+Both Less and Sass are CSS pre-processors, meaning that both extends the CSS language, adding features that allow variables, mixins, functions,
+ and many other techniques that allow you to make CSS that is more maintainable, themable and extendable. 
+
+#### LESS
+
+Pippo uses [less4j](https://github.com/SomMeri/less4j) for Less compiler. Less4j is a compiler written in java that outputs the same as less.js.
+Any difference in output will be considered as a bug and will be fixed.
+Simply add the dependency like this:
+
+```xml
+<dependency>
+    <groupId>ro.pippo</groupId>
+    <artifactId>pippo-less4j</artifactId>
+    <version>${project.version}</version>
+</dependency>	
+```
+You can enable using the less4j handler in your Application.onInit method like this:
+
+```java
+addResourceRoute(new LessResourceHandler("/lesscss", "public/less"));
+```
+where `/lesscss` will be the context path that for the less folder files.
+
+#### SASS
+
+For Sass implementation Pippo used [sass-compiler](https://github.com/vaadin/sass-compiler). This is also a pure Java implementation of [http://sass-lang.com](http://sass-lang.com) compiler
+written for [Vaadin](https://vaadin.com/home) framework.
+Again add the dependecy like this:
+
+```xml
+<dependency>
+    <groupId>ro.pippo</groupId>
+    <artifactId>pippo-sasscompiler</artifactId>
+    <version>${project.version}</version>
+</dependency>	
+```
+
+Also you can enable using the sass handler in your Application.onInit method like this:
+
+```java
+addResourceRoute(new SassResourceHandler("/sasscss", "public/sass"));
+```
+where `/sasscss` will be the context path that for the sass folder files.
+
+Mixin both sass and less in your project is possible as you can see in the [demo](https://github.com/decebals/pippo/tree/master/pippo-demo/pippo-demo-css).
diff --git a/_posts/2015-06-26-issues.md b/_posts/2015-06-26-issues.md
diff --git a/index.md b/index.md
