Doctrator = Doctrine2 + Mondator

Doctrator
Pablo Díez

Symfony Live 2011 - Paris

viernes 4 de marzo de 2011

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


What is Doctrator?


Agile Development


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?


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 good 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?

...


What does Doctrator do?


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?


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


Even with comments.


$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 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),
new DoctratorExtensionArrayAccess(),
));
$mondator->process();

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


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



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 Extensions


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



Core

Useful methods.


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


print_r($article);

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

Doctrator entities are clean even with ActiveRecord!


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


Behaviors


Behaviors

Reuse features.


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


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 = Doctrine2 + Mondator

Recomendados

Recomendados

Mais conteúdo relacionado

Mais procurados

Mais procurados (20)

Destaque

Destaque (20)

Semelhante a Doctrator = Doctrine2 + Mondator

Semelhante a Doctrator = Doctrine2 + Mondator (20)

Último

Último (20)

Doctrator = Doctrine2 + Mondator