Continue reading »]]> Like every developer, I like to have the most beautiful architecture when I work on a project.

For me, a beautiful architecture allow me to add useful informations on views withouth dependencies. For example : an administration page show every action possible, like simple member edition features. When a new bundle is added to the project, it should automatically add possible actions (widgets) in administration page, like the Parameters app in iOS. This bundle should also be removable withouth any modifications on other bundles code.

To do so, I created ElendevWidgetBundle, This bundle provide a simple twig method which include widgets in templates. The widgets are identified with a tag and are added to specifics places on views.

1
2
3

<div>My template with some html...</div>
<div>My widgets place : {{ widgets('my_tag') }}</div>
<div>End of my template...</div>

In the example above, every widget with the tag my_tag is added in the view. The widget is a simple tagged service method.

This bundle allow to create widgets places in existing views and when a new feature is added, it can plug widgets everywhere it’s needed withouth current view modification.

For more informations, you can take a look at the ElendevWidgetBundle’s GitHub.
 

Continue reading »]]> Frtrains.com is a website about trains (mainly french and swiss trains). You will find some articles about trains, but first of all, you’ll be able to buy trains through the Shop.

The first version was quite old and I’ve worked hard to develop a version 2. Now the Shop v2 is out and in production, using Symfony2.

For more informations, you can read this.

Take a look and maybe buy something ^^

Continue reading »]]> Presentation

The AppManager help you manage your application. You can have multiple versions of an application online (for tests and rollback purpose), the App Manager allow you to choose which one is the one in production.

This application is really useful in mutual hosting, where you can’t go with SSH to launch Symfony2 commands. You are able to clear/warmup cache, dump assets, install assetics directly from the web interface.

In other words : you can easily have a good control of your application.

Current status

The AppManagerBundle is actually under heavy developments but is already used on production. I will provide a standalone application (provide a symfony2 application including AppManagerBundle) as soon as the bundle is table enough.

Official informations

To keep as much as possible informations in the same place, I decided to create the official application page on GitHub instead of having a page on my blog. For more informations, you can go to the official project page or access directly the GitHub repository.

Enjoy !

Continue reading »]]> For my projects (actually the two Symfony 2 bundles I develop, ElendevImageBundle and ElendevCheckoutBundle), I used Google Code under Git as source management.

Lots of projects I use (Symfony 2 and some Symfony 2 bundles) use GitHub. Version 2.1 of Symfony now use Composer as dependency manager and Composer use mainly http://packagist.org/ as repository.

I found that packagist can use GitHub to provide packages and the final goal is to provide my bundles through Composer to make them easier to include into applications.

 New access

You can now access the ElendevCheckoutBundle at https://github.com/Elendev/ElendevCheckoutBundle.

And the ElendevImageBundle at https://github.com/Elendev/ElendevImageBundle.

The both pages (ElendevCheckoutBundle and ElendevImageBundle)  are updated with new configuration.

Continue reading »]]> Introduction

In this article I’ll present the routing mechanism inside my home-made php framework : Plevin.

The routing mechanism inside Plevin is quite simple. Every controller (named here handler) is market with an annotation and a file is generated at website initialisation.

Controller (handler) class

Here you can see a simple example of controller. The CategoryHandler class is marked as handler and manage specified urls.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

/**
 * @HandleURL(pattern="/categories")
 */
class CategoryHandler{
    /**
     * @Injection(id="Logger")
     * @var Plevin\logging\Logger
     */
    private $logger;
 
    /**
     * @HandleURL(pattern="/$")
     */
    public function showMain(){
        echo "Show main page";
    }
 
    /**
     * @HandleURL(pattern="/{category}")
     */
    public function showCategory($categoryName = "main") {
        echo "Template content for category $categoryName";
    }
 
    /**
     * Show the specified object, from the specified category
     * @HandleURL(pattern="/{category}/{object}$")
     */
    public function showObject($categoryName, $objectName) {
        echo "Template content for category $categoryName, object $objectName";
    }
}

The handler class has a function for every managed url. Each function can receive url parameters and have to generate a template.

In the example above a simple injection is made, the handler receive a reference to the framework’s logger.

Generated file

On first execution, the CategoryHandler is analysed and the corresponding generated cached file is visible here :

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

if(preg_match("@^/categories@", $query)){
    if(!file_exists("/path/to/app/Site/handler/CategoryHandler.php") || filemtime(__FILE__) < filemtime("/path/to/app/Site/handler/CategoryHandler.php"))
        throw new \Plevin\cache\CacheOutOfDateException("Class Shop2\handler\CategoryHandler out of date !");
    if(preg_match("@^/categories/$@", $query, $params)){
        $injection = new \Plevin\injection\InjectionProxy("\handler\CategoryHandler");
        array_shift($params);
        $injection->__call("showMain", $params);
        return true;
    }
    if(preg_match("@^/categories/((?:[a-zA-Z0-9]|_|-)+)$@", $query, $params)){
        $injection = new \Plevin\injection\InjectionProxy("\handler\CategoryHandler");
        array_shift($params);
        $injection->__call("showCategory", $params);
        return true;
    }
    if(preg_match("@^/categories/((?:[a-zA-Z0-9]|_|-)+)/((?:[a-zA-Z0-9]|_|-)+)$@", $query, $params)){
        $injection = new \Plevin\injection\InjectionProxy("\handler\CategoryHandler");
        array_shift($params);
        $injection->__call("showObject", $params);
        return true;
    }
}

First of all, the generated file check if the handler has been modified since last file generation. When the generated file is older than the handler, an CacheOutOfDateException is thrown and the framework generate a new cache file.

The controller routing is managed with some simple preg_match function. Before any call to the handler’s method, a new instance of InjectionProxy is created and the correct handler’s method class is made through the newly generated InjectionProxy. Every dependency injection is managed by the InjectionProxy (in this case, the logger is injected if necessary). For more informations about dependency injection, an article will be available soon.

The generated file return true when an url is recognized and managed by a handler. When no handler manage a given url, false is returned and a simpl 404 error is generated.

Link creation

Plevin framework provide a great flexibility in link management. A link to a specific page is a link to a specific controller’s method with specific parameters. An URLManager is provided to help developer creating links. The code below show how to create a link to a specific controller’s method :

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

/**
 * @HandleURL(pattern="/inscription")
 */
class InscriptionHandler {
 
    /**
     * @Injection(id="URLManager")
     */
    private $urlManager;
 
    /**
     * @HandleURL(pattern="/$")
     */
    public function showInscriptionForm() {
        ...
        $link = $this->urlManager->getURL("App\handler\CategoryHandler->showCategory", array("category" => $currentCategory));
        ...
    }
}

In the code above, the $link variable contains the path to the showCategory() method of the CategoryHandler controller. When urls contain parameters, they can be given through getURL() second argument.

The generated url is based on the @HandleURL annotation of the targeted method.

Conclusion

The url management provided by Plevin is flexible enough to change easly controllers’ paths. The main disadvantage of this operating way is the high dependency to the destination handler’s name (on refactoring you have to recreate every links).

A better method is the one used by Symfony 2 : an url file containing an id for every link. Every id target a controller’s method and links are made with a reference to a specific id.

Continue reading »]]> Introduction

I actually work, on my spare-time, on an e-commerce website. As I had to implement Paypal ExpressCheckout payment method and because I didn’t found any CheckoutBundle matching to my needs, I decided to create one and to provide it with Apache 2 licence. Thus was born ElendevCheckoutBundle.

This bundle is still under development and only Paypal ExpressCheckout is provided. The ElendevCheckoutBundle bundle can support lots of checkout services and I plan to implement Google Checkout API and eventually Swiss post payment API.

The ElendevCheckoutBundle is available on google code and more informations are available at ElendevCheckoutBundle page.

Conclusion

The ElendevCheckoutBundle is still under heavy development but it’s already used on some of my projects. I plan to extend the bundle and add as much checkout services as possible.

Continue reading »]]> Introduction

During works on some websites, I often encountered the necessity to create thumbnails of existing images. Its allways the same problem : I need to save thumbnails on some specific directories, manage thumbnails creations on file upload and so on. So I decided to create the ElendevImageBundle for Symfony 2.

The template designer specify the image properties (size, rotation, grey scale or colored, …) and a corresponding image file is generated and saved in a cache directory. Every further call of same image with same properties returns the previously cached file.

It’s designed to be very efficient. You can find more informations on the dedicated page of ElendevImageBundle.

Conclusion

The ElendevImageBundle is still under development but the actual ElendevImageBundle is already used on some of my projects. It’s an easy way to manage image (particulary image resizing) regardless of new image files storage or specific image size management.

Continue reading »]]> Introduction

Plevin means Plug Evolution In. It’s a little bit pretentious but when I started working on it I had a lot of ambitions. I’ve done a lot of great work around my home made MVC framework in PHP but I had a severe lack of time.

The framework have never been finished but there is a lot of good ideas I haven’t founded in other PHP frameworks. That’s why I will make articles presenting some of the main concepts of Plevin framework, focusing on some difficulties I’ve encountered and solutions I’ve founded.

I’ve initially based my work on Spring and JEE frameworks, using annotations in PHP class. At the time I’ve began working on this framework, PHP 5.3 just came out and provided very useful features like namespace support.

Annotation based configuration

Java, unlike PHP, support annotations in the code. Nevertheless, a simple way to use annotations in PHP is to use commented annotations. Annotations are added through comments (PHPComments, working like javadoc comments) and a simple parser is used to parse the class code and analyse annotations.

Every class (like controllers and available services) are marked with commented annotations. On first execution every file is scanned and annotations are analysed and saved into cached files. A simple example of commented annotations is visible here :

1
2
3
4
5
6

/**
 * @HandleURL(pattern="/categories")
 */
class CategoryHandler{
    ...
}

Cache system

Because of the lack of performance of PHP, the Plevin framework is based on a cache system. Every configuration (like class annotations, configuration file) is analysed and a cached version is created (most of the time it’s a simple PHP file with information in an array). A template system is available with fully cached translation system. Every page is created and cached in every language. When translation files are modified, the modified time is compared to the cached file creation time. When the cached file is older than the modified file, a new cached file is created.

The routing system is also based on cache. Every controller has an annotation containing the handled path. On first script execution, a cache file is created containing all available path routing to correct controller.

Dependency injection

An other important feature is the dependency injection system. This system is an annotation based dependency injection system. Every controllers and beans can add PHP annotations on member to have dependency injection (like @Autowire in Spring).

1
2
3
4
5
6
7
8

class CategoryHandler{
    /**
     * @Injection(id="Logger")
     */
    private $logger;
 
    ...
}

A configuration file contain services declaration :

1
2
3
4
5
6
7
8
9
10

<lookupClasses>
	<instance id="EntityManager" class="Plevin\db\ConfigAutoloadEntityManager"/>
	<instance id="TemplateFactory" class="Plevin\template\CacheLangTemplateFactory"/>
	<instance id="LanguageProvider" class="Plevin\language\Language"/>
	<instance id="PathManager" class="Plevin\DefaultPathManager"/>
	<instance id="URLManager" class="Plevin\url\DefaultURLManager"/>
	<instance id="SessionService" class="Plevin\session\SessionService"/>
	<instance id="Logger" class="Plevin\logging\Logger"/>
	<instance id="Translator" class="Plevin\language\DefaultTranslator"/>
</lookupClasses>

Many options exists for services, like statefull or stateless status. An article will be dedicated to the dependency injection mechanism.

Template system

A simple home made template engine is used to optimize translation system. A template file is compiled and cached for every available language. The template engine need to translate file only once per language. Some macros are also available, like __INSERT(…)__. The code below is a simple template example :

1
2
3
4
5
6
7
8
9
10
11

__INSERT("/main/template_header.html")__
<table width="100%">
__INSERT("/category/object_item.html")__
<tr>
    <td colspan="2">__TECHNICAL_INFORMATION__ :</td>
</tr>
<tr>
    <td colspan="2"><?php echo $object->getMainDescription();?></td>
</tr>
</table>
__INSERT("/main/template_footer.html")__

ORM

When I began the Plevin framework there was no class oriented ORM working with getters and setters, like JPA. I decided to create my own ORM layer, at first based on XML files for model description and, later, on class annotations. Class declaration and simple relations (one-to-one, one-to-many, many-to-one, bidirectionnal one-to-many) works well, database is correctly generated.

The difficulties arrived when I decided to implement bidirectional many-to-many relations with eager / lazy initialisation system and heritage.

At the same time, Doctrine 2 passed on beta version and is exactly what I was expecting from an ORM. I replaced the home made ORM with Doctrine 2.

Conclusion

Finally, Symfony 2 came out with lots of features I expected. Idecided to use it, mainly because of the Symfony 2 community support (managing a complete framework is a time-consuming task).

The work I’ve done on my home made framework wasn’t useless because I’ve learned a lots of things, that’s why I’ve decided to share my experience on my blog. I will write some articles to present some specific parts of Plevin.

Continue reading »]]> Introduction

As you certainly know, HTML5 bring some very useful features for web applications, like socket connection or browser storage capabilities. In this article, I make some kind of state of the art about browser storage capabilities.

If you plan to save data on a browser, there is three possibilities : LocalStorage, SQLite and IndexedDB. You probably want to know which one to choose. There is actually no right or wrong response. First of all, I will describe every possibility with it’s advantages and disadvantages.

LocalStorage

The LocalStorage object is a simple key => value store. The key and the value are simple strings, it works like a dictionnary.

The main advantages of the LocalStorage is it’s simplicity and it’s support on lots of browsers.

The main disadvantage of the LocalStorage is it’s little storage capacity. After some little benchmarks, we can’t save up to 5MB of data.

SQLite

SQLite was, at first, designed as the de-facto browser storage standard. Now, the W3C don’t support SQLite anymore. The main reason is the incapacity for them to use a standard instead of an application. Lots of browsers where implementing a SQLite database accessible with JavaScript but the W3C wanted a standard describing the SQL language and the provided JavaScript API. There is a JavaScript API but no one were able to provide a SQL standard. Finally, the W3C don’t support the SQLite as browser storage anymore but it’s still implemented in some browsers. SQLite can save up to 1Go data on a desktop computer and up to 50MB data on a smartphone (depending on the browser configuration).

The main advantage of SQLite is it’s availability (it’s provided by mobile browsers on Android and iOS, by PhoneGap for mobile applications and by Chrome 15 and Safari 5).

The main disadvantage of SQLite is that the W3C don’t support SQLite anymore and some browsers, like Firefox, removed the SQLite support in their last versions.

IndexedDB

IndexedDB is the new standard provided by the W3C. It’s not a relationnal database but it’s a document based database. A database is composed of multiple stores, every store contain data in key => value format. The data are saved in object format. It’s possible, for the developer, to make a query on some specific properties of an object to get them back. Actually, Chrome 15 and Firefox 8 have an implementation of IndexedDB but the implementations are quite different. A script using IndexedDB on Chrome don’t work on Firefox and vice versa. The IndexedDB standard isn’t completely done and the API is still changing.

The main advantages of IndexedDB is the support of the W3C and it’s capability to save directly JavaScript objects instead of serialized objects and the capability to create request on saved objects.

The main disadvantage of IndexedDB is it’s young age : the standard is still changing and IndexedDB is only implemented in few browsers.

Conclusion

The next picture show the browser supports for LocalStorage, SQLite and IndexedDB.

Actual support of HTML5 browser storage by browser

The better solution actually is to use an intermediate layer for browser storage, supporting SQLite, LocalStorage and (in the futur) IndexedDB. In this way, developers will be able to create web application using browser storage capabilities with enough flexibility to work on every modern browser.

I’ve already developed an intermediate layer with query capabilities and I will introduce it in a next article.

Continue reading »]]> Introduction

Spring 3 is quite new and seems to support MVC and JSON with no configurations. That’s unfortunately not totaly exact. Spring 3 support JSON with few configurations, but not withouth any configuration.

JSON library dependency

First of all, a JSON library is needed. Here I use Jackson as JSON conversion service. If you don’t use maven, you just have to add Jackson jars and it’s dependencies to your path. If you use maven, you need to add this dependency on your pom.xml :

1
2
3
4
5

<dependency>
    <groupId>org.codehaus.jackson</groupId>
    <artifactId>jackson-jaxrs</artifactId>
    <version>1.9.2</version>
</dependency>

Spring configuration : appContext.xml

The second step is to tell Spring to look for annotations for mvc. Spring 3 will check Jackson package, find a correct conversion service and use it to return correct JSON objects. The file context.xml need to contain the  tag  :

1
2
3
4
5
6
7
8
9
10
11
12
13

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:mvc="http://www.springframework.org/schema/mvc"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="
        http://www.springframework.org/schema/beans 
        http://www.springframework.org/schema/beans/spring-beans-3.1.xsd
        http://www.springframework.org/schema/mvc 
        http://www.springframework.org/schema/mvc/spring-mvc-3.1.xsd">
    <!-- enable automatic check for conversion service -->
    <mvc:annotation-driven />
 
<beans>

Spring controller

Now, you are ready to return POJO on your controller class with @ResponseBody annotation. The @RequestBody annotation can be used to get directly POJOs from JSON input, automatically converted.

1
2
3
4
5
6
7
8
9
10
11
12
13
14

@Controller
public class MyController {
    @RequestMapping(value = "/someWhere", method = RequestMethod.GET)
    @ResponseBody
    public TestClass getSomeTestClass(){
        TestClass response = new TestClass();
        return response;
    }
 
    @RequestMapping(value = "/someArguments", method = RequestMethod.Post)
    public void saveSomeTestClass(@RequestBody TestClass myClass){
        //do somme stuff with myClass
    }
}

With the few configuration described in this article, Spring work well with JSON.

JSONView configuration