Doctrator Symfony Live 2011 San Francisco

Doctrator
Pablo Díez

Symfony Live 2011 - San Francisco

Pablo Díez
Creator of Mondongo
ODM for MongoDB and PHP
http://mondongo.es (in English :)
Creator of Mondator
Class generator for PHP
Creator of Doctrator

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

Doctrator = Doctrine2 + Mondator

Agile Development

ActiveRecord

Agile Development

ActiveRecord optional

Agile Development
ActiveRecord
Behaviors

Agile Development
ActiveRecord
Behaviors

Doctrator saves you a lot of time! ;)

How does Doctrine2 work?

“Doctrine2 provides transparent persistence for PHP objects.”

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

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

namespace Model;

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

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;

/**
*/
public $email;
}


With YAML

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


With XML

<?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="ModelUser" 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 PHP

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

'fieldName' => 'username',
'type' => 'string'
));

'fieldName' => 'email',
'type' => 'string'
));


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 = 'pablodip@gmail.com';

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

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

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

You have to create methods to access to the properties.

Setters & Getters

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;

What do you need to work with this simple table?

user
id integer
username string
password string
email string

namespace Model;

class User
{
}

Class

user
id integer
username string
password string
email string

namespace Model;

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

Class
Properties
user
id integer
username string
password string
email string

namespace Model;

protected $email;

Class
Properties
user
id integer
username string
{

}
$this->id = $id;
password string
{
return $this->id;
email string
}

{
$this->username = $username; Setters/Getters
}

{
}

{

namespace Model;

protected $email;

Class
Mapping
Properties
user
id integer
/**
* @Entity
username string */
{ /**

}
$this->id = $id;
password string * @Id
*/
{
return $this->id;
email string /**
}
*/
{
$this->username = $username; Setters/Getters /**
} */

{
}

{

namespace Model;

/**
* @Entity
*/
class User
{
/**
* @Id
*/
protected $id;

/**
* @Column(length="50")
*/

/**
*/

/**
user * @Column(length="100")
*/
protected $email;

id integer public function setId($id)
{
$this->id = $id;
}
username string public function getId()
{
return $this->id;
password string }

{
email string }

{
}

{
}

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

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

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

namespace Model;

/**
* @Entity
*/
class User
{
/**
* @Id
*/
protected $id;

/**
*/

/**
*/

/**
user * @Column(length="100")
*/
protected $email;

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

LORC
}
username string public function getId()
{
return $this->id;
password string }

{
email string }

{
}

{
}

{
}

{
$this->email = $email;
}

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

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?

...

Doctrator’s principle is to avoid writing LORC

What does Doctrator do?

Doctrator generates classes and maps them with Doctrine2

Doctrator generates classes and maps them with Doctrine2

You only have to tell it the conﬁguration of the classes.

In PHP

array(
'ModelUser' => 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 YAML

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

ModelUser:
columns:

This generates your object. This maps your object.
class User
{

protected $id;

/**
* @Entity
protected $email;
*/
{
$this->id = $id;
} /**
public function getId() * @Id
{
return $this->id; * @Column(type="integer")
}
*/
{
} /**
public function getUsername() * @Column(length=50)
{
*/
}

{
/**
}
$this->password = $password; * @Column(length=100)
*/
{
}


ModelUser:
columns:

You can start to work.

$user = new ModelUser();
$user->setUsername('pagafantas');
$user->setEmail('pagafantas@gmail.com');

$entityManager->persist($user);

How does Doctrator work?

Doctrator uses Mondator to generate the classes for you.

Mondator deﬁnes PHP classes.

namespace Model;

class User
{

{
}

{
}
}

namespace Model; Deﬁnition

class User
{ Properties

{
}

{
}
}
Methods

use MondongoMondatorDefinitionDefinition;
use MondongoMondatorDefinitionProperty;
use MondongoMondatorDefinitionMethod;

namespace Model;

class User
{
}
Full Class Name

$definition = new Definition('ModelUser');


Visibility Name

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

{
}

Visibility Name Arguments Code

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

You can deﬁne any PHP class.

Parent class
$definition->setParentClass('ModelBaseUser');

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

Abstract
$definition->setIsAbstract(true);

Default value
$property->setValue($defaultValue);

Static
$property->setIsStatic(true);

Abstract
$method->setIsAbstract(true);

Static
$method->setIsStatic(true);

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

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

Then you can export them with the Dumper.

use MondongoMondatorDumper;

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

echo $classCode;

/**
* User entity.
*/
class User
{

/**
* Set the username.
*
* @param string $username The username.
*/
{
}

/**
* Returns the username.
*
* @return string The username.
*/
{
}
}

And save them in ﬁles.

file_put_contents($file, $codeClass);

Mondator Extensions

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

The Mondator Extensions process the conﬁg classes
to deﬁne what classes will be generated.

ModelUser:
columns:

The Mondator Extensions process the conﬁg classes
to deﬁne what classes will be generated.

MondongoMondatorDefinitionDefinition

ModelUser:
columns:

use MondongoMondatorExtension;

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

$this->definitions;
}
}

ModelUser:
columns:


{
{
$this->class;
$this->configClass;

$this->definitions;
}
} Deﬁnitions to generate

An extension can generate any deﬁnition.

use MondongoMondatorDefinitionDefinition;

{
{
$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);

}


$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 deﬁnition.

{
{
$definition = new Definition($this->class);
$this->definitions['entity'] = $defintion;

$this->processColumns();
}
}

class ArrayAccess extends Extension
{
{
$this->definitions['entity']->addInterface('ArrayAccess');

$method = new Method('public', 'offsetGet', '$name', $code);
$this->definitions['entity']->addMethod($method);

// ...
}
}

An extension can have options.

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

{
if ($this->getOption('columns')) {
$this->processColumns();
}

if ($this->getOption('array_access')) {
$this->processArrayAccess();
}
}
}

You can process the extensions that you want.

$mondator = new MondongoMondatorMondator();
$mondator->setConfigClasses($configClasses);
$mondator->setExtensions(array(
new DoctratorExtensionCore($options),
));
$mondator->process();

new DoctratorExtensionArrayAccess(),
));

new DoctratorExtensionArrayAccess(),
));

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

//new DoctratorExtensionArrayAccess(),
));


An extension can change the conﬁg class to extend
another extension.

{
{
// ...
}
}
}

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

You can even use extensions in the conﬁg classes.

ModelArticle:
columns:
title: { type: string, length: 100 }
behaviors:
-
class: DoctratorBehaviorTimestampable
options: { }

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

Generated code is not necessarily magic code.

Doctrator’s generated code is really simple, non-
magical code.

You can use IDE Autocompletion.

Doctrator Extensions

Core

ArrayAccess PropertyOverloading ActiveRecord Behaviors

Core

Generates and maps objects with Doctrine2.

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

ModelUser
namespace Model;

class User extends ModelBaseUser
{
// your code
}

namespace ModelBase;

class User
{
// generated code
}

ModelArticle:
table_name: articles
columns:
slug: { type: string, length: 100 }
content: { type: string }
is_active: { type: boolean, default: true }
date: { type: date }
many_to_one:
category: { class: ModelCategory, inversed: articles }
indexes:
slug: { columns: ['slug'], unique: true }
date: { columns: ['is_active', 'date'] }
events:
preUpdate: ['updateDate']

Associations
ModelArticle:
table_name: articles one_to_one
one_to_many
columns:
many_to_one
id: { id: auto,many_to_many
type: integer }
slug: { type: string, length: 100 }
name
content: { type: string class
}
mapped
date: { type: date }inversed
many_to_one:
indexes:
events:

ModelArticle: Events
table_name: articles
columns: prePersist
postPersist
preUpdate
slug: postUpdate
{ type: string, length: 100 }
preRemove
postRemove
postLoad
many_to_one:
indexes:
events:

$category = new ModelCategory();
$category->setName('Class Generator');
$entityManager->persist($category);

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


Set & Get by string

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

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

fromArray & toArray

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

$array = $article->toArray();

ArrayAccess

Implements the ArrayAccess interface in the entities.

PropertyOverloading

Allows you access to entity data like properties.

$article->title = 'Doctrator';
echo $article->title; // Doctrator

ActiveRecord

Implements the ActiveRecord pattern in your entities.

$article->save();

$article->refresh();

$article->delete();

print_r($article);

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

Doctrator entities are clean even with ActiveRecord!

Doctrator uses a global object to save the EntityManager

use DoctratorEntityManagerContainer;

EntityManagerContainer::set($entityManager);

$em = ModelArticle::entityManager();
$articleRepository = ModelArticle::repository();
$queryBuilder = ModelArticle::queryBuilder();

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

$articles = ModelArticle::repository()->findAll();
$article = ModelArticle::repository()->find($id);

A behavior is simply a Mondator extension.

A behavior can

Have options
Change conﬁg classes:
• Columns
• Associations
• Indexes
• Events
• ...
Add new generated classes
Add properties and methods
• Entities
• Repositories
• ...

Timestampable

Saves the created and updated date.
created TRUE
created_column created_at
updated TRUE
updated_column updated_at

ModelArticle:
columns:
title: { type: name, length: 100 }
behaviors:
- DoctratorBehaviorTimestampable

$article->save();

echo $article->getCreatedAt(); // now
echo $article->getUpdatedAt(); // null

$article->setContent('Rocks!');
$article->save();

echo $article->getCreatedAt(); // before
echo $article->getUpdatedAt(); // now

Ipable

Saves the created and updated ip.
created TRUE
created_column created_from
updated TRUE
updated_column updated_from

Hashable
Ipable

Saves a unique hash in each entity.
column hash

ModelArticle:
columns:
behaviors:
- DoctratorBehaviorHashable

$article = new Article();

$entityManager->persist();

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

Timestampable
Sluggable

Saves a slug from a ﬁeld.
from_column *
slug_column slug
unique TRUE
update FALSE

ModelArticle:
columns:
behaviors:
-
class: DoctratorBehaviorSluggable
options: { from_column: title }

$article->setTitle('Doctrator Rocks!');
$article->save();

echo $article->getSlug(); // doctrator-rocks

Sortable

Allows you to sort your entities.
column position
new_position bottom

$articles = array();
for ($i = 0; $i <= 10; $i++) {
$articles[$i] = $a = new ModelArticle();
$a->setTitle('Article '.$i);
$a->save();
}

echo $articles[3]->getPosition(); // 3
echo $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();

Taggable
Sortable

Allows you to save tags in the entities.

$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();

Translatable
Taggable
Sortable

Allows you to translate entity columns.
columns *

ModelArticle:
columns:
behaviors:
-
class: DoctratorBehaviorTranslatable
options: { columns: ['title', 'content'] }

$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.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

Conﬁg Classes

app/conﬁg/doctrator/*.yml
*Bundle/Resources/doctrator/*.yml

Standard Namespace

ModelArticle:
columns:

ModelDoctratorUserBundleUser:
columns:

ModelArticle:
validation:
- MyArticleClassValidator: ~
columns:
content: { type: string, validation: [MaxLength: 2000] }

Validation integrated

php app/console doctrator:generate

Questions?

http://mondongo.es (English :)

You can contact me for Mondongo, Doctrator, consulting, development
pablodip@gmail.com

Doctrator Symfony Live 2011 San Francisco

More Related Content

What's hot

Viewers also liked

Similar to Doctrator Symfony Live 2011 San Francisco

Recently uploaded

Doctrator Symfony Live 2011 San Francisco