Doctrator Symfony Live 2011 Paris

DoctratorPablo Díez

Symfony Live 2011 - Paris

viernes 4 de marzo de 2011

Pablo DíezCreator of Mondongo

ODM for MongoDB and PHPhttp://mondongo.es (in English :)

Creator of MondatorClass generator for PHP

Creator of Doctrator

http://twitter.com/pablodiphttp://github.com/pablodip


http://mondongo.es

http://mondongo.es

http://twitter.com/pablodip




What is Doctrator?


Doctrator = Doctrine2 + Mondator


Agile Development


Agile Development

ActiveRecord


ActiveRecord optional

Agile Development


ActiveRecord

Behaviors

Agile Development


Doctrator saves you a lot of time! ;)

ActiveRecord

Behaviors

Agile Development


How does Doctrine2 work?


“Doctrine2 provides transparent persistence for PHP objects.”

How does Doctrine2 work?

http://www.doctrine-project.org/docs/orm/2.0/en/reference/introduction.html




namespace Model;

class User{ public $id; public $username; public $email;}

That is, persist PHP objects without restrictions of a base class, properties, methods.


You only have to tell Doctrine2 (map) what you want to persist.


With Docblock Annotations

/** * @Entity */class User{ /** * @Id * @Column(type="integer") */ public $id; /** * @Column(length=50) */ public $username; /** * @Column(length=100) */ public $email;}



Entities\User: type: entity fields: id: { type: integer, id: true } username: { type: string(50) } email: { type: string(50) }

With YAML



<?xml version="1.0" encoding="UTF-8"?><doctrine-mapping xmlns="http://doctrine-project.org/schemas/orm/doctrine-mapping" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://doctrine-project.org/schemas/orm/doctrine-mapping http://www.doctrine-project.org/schemas/orm/doctrine-mapping.xsd">

<entity name="Model\User" table="user">

<id name="id" type="integer" column="id"> <generator strategy="AUTO"/> </id>

<field name="username" type="string" length="50" /> <field name="email" type="string" length="100" />

</entity>

</doctrine-mapping>

With XML



http://doctrine-project.org/schemas/orm/doctrine-mapping


http://www.w3.org/2001/XMLSchema-instance

http://www.w3.org/2001/XMLSchema-instance



http://www.doctrine-project.org/schemas/orm/doctrine-mapping.xsd

http://www.doctrine-project.org/schemas/orm/doctrine-mapping.xsd

$metadata->mapField(array( 'id' => true, 'fieldName' => 'id', 'type' => 'integer'));

$metadata->mapField(array( 'fieldName' => 'username', 'type' => 'string'));

$metadata->mapField(array( 'fieldName' => 'email', 'type' => 'string'));

With PHP



Then you are able to persist those objects.



Then you are able to persist those objects.

$user = new User();$user->username = 'pablodip';$user->password = 'pa$$word';$user->email = '[email protected]';

$entityManager->persist($user);$entityManager->flush();


mailto:[email protected]


class User{ protected $id; protected $username; protected $password; protected $email;}

A Doctrine2 good practice is to use non public properties in the entities.


Setters & Getters

You have to create methods to access to the properties.

public function setId($id){ $this->id = $id;}

public function getId(){ return $this->id;}

public function setUsername($username){ $this->username = $username;}

public function getUsername(){ return $this->username;}

public function setPassword($password){ $this->password = $password;


useruser

id integer

username string

password string

email string

What do you need to work with this simple table?


useruser

id integer

username string

password string

email string

namespace Model;

class User{}

Class


useruser

id integer

username string

password string

email string

namespace Model;

class User{}

protected $id;protected $username;protected $password;protected $email;

ClassProperties


useruser

id integer

username string

password string

email string

namespace Model;

class User{}


ClassProperties






Setters/Getters


useruser

id integer

username string

password string

email string

namespace Model;

class User{}


ClassProperties






Setters/Getters

/** * @Entity */

/** * @Id * @Column(type="integer") */ /** * @Column(length=50) */ /** * @Column(length=100) */

Mapping


useruser

id integer

username string

password string

email string

namespace Model;

/** * @Entity */class User{ /** * @Id * @Column(type="integer") */ protected $id; /** * @Column(length="50") */ protected $username; /** * @Column(length="40") */ protected $password; /** * @Column(length="100") */ protected $email;

public function setId($id) { $this->id = $id; }

public function getId() { return $this->id; }

public function setUsername($username) { $this->username = $username; }

public function getUsername() { return $this->username; }

public function setPassword($password) { $this->password = $password; }

public function getPassword() { return $this->password; }

public function setEmail($email) { $this->email = $email; }

public function getEmail() { return $this->email; }}


useruser

id integer

username string

password string

email string

namespace Model;

/** * @Entity */class User{ /** * @Id * @Column(type="integer") */ protected $id; /** * @Column(length="50") */ protected $username; /** * @Column(length="40") */ protected $password; /** * @Column(length="100") */ protected $email;







public function setEmail($email) { $this->email = $email; }

public function getEmail() { return $this->email; }}

LORC


LORC

Lines Of Repetitive Code


LORC

Lines Of Repetitive Code

... and we still don’t have any features! :)


How many LORC do we need in a real database?


How many LORC do we need in a real database?

...


What does Doctrator do?


Doctrator generates classes and maps them with Doctrine2

What does Doctrator do?


You only have to tell it the configuration of the classes.

Doctrator generates classes and maps them with Doctrine2


array( 'Model\User' => array( 'columns' => array( 'id' => array('id' => 'auto', 'type' => 'integer'), 'username' => array('type' => 'string', 'length' => 50), 'password' => array('type' => 'string', 'length' => 40), 'email' => array('type' => 'string', 'length' => 100), ), ),);

In PHP


Model\User: columns: id: { id: auto, type: integer } username: { type: string, length: 50 } password: { type: string, length: 40 } email: { type: string, length: 100 }

In YAML



This generates your object.

class User{

protected $id;

protected $username;

protected $password;

protected $email;







public function setEmail($email)

This maps your object.

/** * @Entity */

/** * @Id * @Column(type="integer") */ /** * @Column(length=50) */ /** * @Column(length=100) */



You can start to work.

$user = new \Model\User();$user->setUsername('pagafantas');$user->setEmail('[email protected]');

$entityManager->persist($user);$entityManager->flush();




How does Doctrator work?


Doctrator uses Mondator to generate the classes for you.

How does Doctrator work?


Mondator defines PHP classes.


namespace Model;

class User{ protected $username; public function setUsername($username) { $this->username = $username; } public function getUsername() { return $this->username; }}


namespace Model;

class User{ protected $username; public function setUsername($username) { $this->username = $username; } public function getUsername() { return $this->username; }}

Definition

Properties

Methods


use Mondongo\Mondator\Definition\Definition;use Mondongo\Mondator\Definition\Property;use Mondongo\Mondator\Definition\Method;


namespace Model;

class User{}

$definition = new Definition('Model\User');

Full Class Name


protected $username;

$property = new Property('protected', 'username');$definition->addProperty($property);

Visibility Name



$method = new Method('public', 'setUsername', '$username', <<<EOF \$this->username = \$username;EOF);$definition->addMethod($method);

Visibility Name Arguments Code


You can define any PHP class.


$definition->setParentClass('\Model\Base\User');

$definition->addInterface('\ArrayAccess');

$definition->setIsAbstract(true);

Parent class

Interfaces

Abstract


$property->setValue($defaultValue);

$property->setIsStatic(true);

Default value

Static


$method->setIsAbstract(true);

$method->setIsStatic(true);

Abstract

Static


Even with comments.


$definition->setDocComment(<<<EOF/** * User Class. */EOF);

$method->setDocComment(<<<EOF /** * Set the username. * * @param string \$username The username. */EOF);


use \Mondongo\Mondator\Dumper;

$dumper = new Dumper($definition);$classCode = $dumper->dump();

echo $classCode;

Then you can export them with the Dumper.


/** * User entity. */class User{ protected $username; /** * Set the username. * * @param string $username The username. */ public function setUsername($username) { $this->username = $username; } /** * Returns the username. * * @return string The username. */ public function getUsername() { return $this->username; }}


And save them in files.

file_put_contents($file, $codeClass);


Mondator Extensions


Mondator uses extensions to generate similar classes in a powerful and flexible way.

Mondator Extensions


The Mondator Extensions process the config classes to define what classes will be generated.


The Mondator Extensions process the config classes to define what classes will be generated.


Mondongo\Mondator\Definition\Definition



use Mondongo\Mondator\Extension;

class Doctrator extends Extension{ protected function doClassProcess() { $this->class; $this->configClass; $this->definitions; }}



use Mondongo\Mondator\Extension;

class Doctrator extends Extension{ protected function doClassProcess() { $this->class; $this->configClass; $this->definitions; }} Definitions to generate


An extension can generate any definition.


use Mondongo\Mondator\Extension;use Mondongo\Mondator\Definition\Definition;

class Doctrator extends Extension{ protected function doClassProcess() { $definition = new Definition($this->class); $this->definitions['entity'] = $definition;

$definition = new Definition($this->class.'Repository'); $this->definitions['repository'] = $definition; }}


foreach ($this->configClass['columns'] as $name => $column) {

$property = new Property('protected', $name);

$this->definitions['entity']->addProperty($property);

}


foreach ($this->configClass['columns'] as $name => $column) { $setterName = 'set'.Inflector::camelize($name); $setter = new Method('public', $setterName, '$value', <<<EOF \$this->$name = \$value;EOF );

$this->definitions['entity']->addMethod($setter);}


Different extensions can modify the same definition.


class Doctrator extends Extension{ protected function doClassProcess() { $definition = new Definition($this->class); $this->definitions['entity'] = $defintion; $this->processColumns(); }}

class ArrayAccess extends Extension{ protected function doClassProcess() { $this->definitions['entity']->addInterface('\ArrayAccess'); $method = new Method('public', 'offsetGet', '$name', $code); $this->definitions['entity']->addMethod($method); // ... }}


An extension can have options.


class Doctrator extends Extension{ protected function setUp() { $this->addOptions(array( 'columns' => true, 'array_access' => true, )); }

protected function doClassProcess() { if ($this->getOption('columns')) { $this->processColumns(); } if ($this->getOption('array_access')) { $this->processArrayAccess(); } }}


You can process the extensions that you want.


$mondator = new \Mondongo\Mondator\Mondator();$mondator->setConfigClasses($configClasses);$mondator->setExtensions(array( new \Doctrator\Extension\Core($options), new \Doctrator\Extension\ArrayAccess(),));$mondator->process();

$article['title'] = 'Doctrator';echo $article['title']; // Doctrator


$mondator = new \Mondongo\Mondator\Mondator();$mondator->setConfigClasses($configClasses);$mondator->setExtensions(array( new \Doctrator\Extension\Core($options), //new \Doctrator\Extension\ArrayAccess(),));$mondator->process();

$article['title'] = 'Doctrator';echo $article['title']; // Doctrator


An extension can change the config class to extend another extension.


class Doctrator extends Extension{ protected function doClassProcess() { foreach ($this->configClass['columns'] as $name => $column) { // ... } }}

class DateColumn extends Extension{ protected function doConfigClassProcess() { $this->configClass['columns']['date'] = array( 'type' => 'date', ) }}


You can even use extensions in the config classes.


Model\Article: columns: id: { id: auto, type: integer } title: { type: string, length: 100 } behaviors: - class: Doctrator\Behavior\Timestampable options: { }


And you can combine all these things to do what you want.


Generated code is not necessarily magic code.


Doctrator Extensions


Core

ActiveRecordArrayAccess PropertyOverloading Behaviors

Doctrator Extensions


Core

Generates and maps objects with Doctrine2.


Doctrator uses base classes to separate generated code from your code.


Model\Usernamespace Model;

class User extends \Model\Base\User{ // your code}

namespace Model\Base;

class User{ // generated code}


Model\Article: table_name: articles columns: id: { id: auto, type: integer } title: { type: string, length: 100 } slug: { type: string, length: 100 } content: { type: string } is_active: { type: boolean, default: true } date: { type: date } many_to_one: category: { class: Model\Category, inversed: articles } indexes: slug: { columns: ['slug'], unique: true } date: { columns: ['is_active', 'date'] } events: preUpdate: ['updateDate']



Associations

one_to_oneone_to_manymany_to_one

many_to_many

nameclass

mappedinversed



Events

prePersistpostPersistpreUpdatepostUpdatepreRemovepostRemove

postLoad


$category = new \Model\Category();$category->setName('Class Generator');$entityManager->persist($category);

$article = new \Model\Article();$article->setTitle('Doctrator');$article->setDate(new \DateTime('now'));$article->setCategory($category);$entityManager->persist($article);

$entityManager->flush();


Useful methods.

Core


$article->set('title', 'Doctrator');

echo $article->get('title'); // Doctrator

Set & Get by string


$article->fromArray(array( 'title' => 'Doctrator', 'date' => new \DateTime('now')));

$array = $article->toArray();

fromArray & toArray


Implements the ArrayAccess interface in the entities.

ArrayAccess


$article = new \ModelArticle();$article['title'] = 'Doctrator';echo $article['title']; // Doctrator


Allows you access to entity data like properties.

PropertyOverloading


$article = new \ModelArticle();$article->title = 'Doctrator';echo $article->title; // Doctrator


Implements the ActiveRecord pattern in your entities.

ActiveRecord


$article = new \Model\Article();$article->setTitle('Doctrator');$article->save();

$article->refresh();

$article->delete();


print_r($article);


Model\Article Object( [id:protected] => 1 [title:protected] => Doctrator [content:protected] => Rocks!)

Doctrator entities are clean even with ActiveRecord!

print_r($article);


$em = \Model\Article::entityManager();$articleRepository = \Model\Article::repository();$queryBuilder = \Model\Article::queryBuilder();


$articles = \Model\Article::repository()->findAll();$article = \Model\Article::repository()->find($id);

$articles = $entityManager->getRepository('Model\Article')->findAll();$article = $entityManager->getRepository('Model\Article')->find($id);


Behaviors


Behaviors

Reuse features.


A behavior is simply a Mondator extension.


A behavior can

Have optionsChange config classes:• Columns• Associations• Indexes• Events• ...

Add new generated classesAdd properties and methods• Entities• Repositories• ...


Saves the created and updated date.

Timestampable

created TRUE

created_column created_at

updated TRUE

updated_column updated_at


Model\Article: columns: id: { id: auto, type: integer } title: { type: name, length: 100 } behaviors: - Doctrator\Behavior\Timestampable


$article = new \Model\Article();$article->setTitle('Doctrator');$article->save(); echo $article->getCreatedAt(); // nowecho $article->getUpdatedAt(); // null $article->setContent('Rocks!');$article->save(); echo $article->getCreatedAt(); // beforeecho $article->getUpdatedAt(); // now


Saves the created and updated ip.

Ipable

created TRUE

created_column created_from

updated TRUE

updated_column updated_from


Saves a unique hash in each entity.

IpableHashable

column hash


Model\Article: columns: id: { id: auto, type: integer } title: { type: name, length: 100 } behaviors: - Doctrator\Behavior\Hashable


$article = new Article();$article->setTitle('Doctrator');

$entityManager->persist();$entityManager->flush();

echo $article->getHash();// da39a3ee5e6b4b0d3255bfef95601890afd80709


Saves a slug from a field.

TimestampableSluggable

from_column *

slug_column slug

unique TRUE

update FALSE


Model\Article: columns: id: { id: auto, type: integer } title: { type: name, length: 100 } behaviors: - class: Doctrator\Behavior\Sluggable options: { from_column: title }


$article = new \Model\Article();$article->setTitle('Doctrator Rocks!');$article->save(); echo $article->getSlug(); // doctrator-rocks


Allows you to sort your entities.

column position

new_position bottom

Sortable


$articles = array();for ($i = 0; $i <= 10; $i++) { $articles[$i] = $a = new \Model\Article(); $a->setTitle('Article '.$i); $a->save();} echo $articles[3]->getPosition(); // 3echo $articles[6]->getPosition(); // 6


// some methods$articles[1]->isFirst();$articles[1]->isLast();$articles[1]->getNext();$articles[1]->getPrevious();$articles[1]->swapWith($articles[2]);$articles[1]->moveUp();$articles[1]->moveDown(); $repository->getMinPosition();$repository->getMaxPosition();


Allows you to save tags in the entities.

SortableTaggable


$article = new \Model\Article();$article->setTitle('My Title');$article->save(); // methods$article->addTags('foobar, barfoo');$article->removeTags('foobar');$article->removeAllTags(); // saved and not saved$article->getSavedTags();$article->getTags(); // saved and not saved$article->setTags(array('foo', 'bar'));$article->saveTags(); $repository->getTags();$repository->getTagsWithCount();


Allows you to translate entity columns.

columns *

SortableTaggableTranslatable


Model\Article: columns: id: { id: auto, type: integer } title: { type: string, length: 100 } content: { type: string } date: { type: date } behaviors: - class: Doctrator\Behavior\Translatable options: { columns: ['title', 'content'] }


$article = new \Model\Article();$article->setDate(new \DateTime()); // en$article->translation('en')->setTitle('My Title');$article->translation('en')->setContent('My Content'); // es$article->translation('es')->setTitle('Mi Título');$article->translation('es')->setContent('Mi Contenido'); $article->save();


Doctrator in Symfony2


DoctratorBundle


doctrator.config: extensions: array_access: false property_overloading: false active_record: true behaviors: true

validation: true


doctrator.config: extensions: array_access: false property_overloading: false active_record: true behaviors: true

validation: true

my_extension_id: true


*Bundle/Resources/doctrator/*.yml

Config Classes

app/config/doctrator/*.yml


Model\Article: columns: id: { id: auto, type: integer } title: { type: string, length: 100 } content: { type: string }

Model\DoctratorUserBundle\User: columns: id: { id: auto, type: integer } username: { type: string, length: 20 }

Standard Namespace


Model\Article: validation: - MyArticleClassValidator: ~ columns: id: { id: auto, type: integer } title: { type: string, length: 100 } content: { type: string, validation: [MaxLength: 2000] }

Validation integrated


php app/console doctrator:generate


Questions?

[email protected]

http://mondongo.es (English :)

You can contact me for Mondongo, Doctrator, consulting, development




http://mondongo.es

http://mondongo.es

Doctrator Symfony Live 2011 Paris

Technology

Transcript of Doctrator Symfony Live 2011 Paris