Compondo estruturas com PHP

como ser produtivo sem criar (muita) desordem

/me

William Correa

@wilcorrea

wilcorrea.dev

github.com/wilcorrea
sourcerer.io/wilcorrea

profile.codersrank.io/user/wilcorrea

t.me/wilcorrea
twitter.com/wilcorrea

recursos

exemplos de como o PHP é poderoso

dinâmicos

<?php

$variable = 'value';
$value = 100;
echo $$variable; // 100
ㅤ

variable variables

documentação

# RECURSOS DINÂMICOS

<?php

class Bar
{
    function foo() {
        echo "This is bar->foo()", PHP_EOL;
    }
}
$function = 'foo';
(new Bar)->{$function}(); // This is bar->foo()
ㅤ

variable functions

documentação

# RECURSOS DINÂMICOS

magic methods

documentação

 __construct() __destruct() __call() __callStatic() __get() __set() __isset() __unset() __sleep() __wakeup() __serialize() __unserialize() __toString() __invoke() __set_state() __clone() __debugInfo()

# RECURSOS DINÂMICOS

show me the code

# RECURSOS DINÂMICOS

<?php

abstract class DataTransferObject
{
    private array $data;
    
    private function __construct(array $data)
    {
        $this->data = $data;
    }
    
    public static function create(array $data): static
    {
        return new static($data);
    }

    public function __set(string $name, mixed $value)
    {
        $this->data[$name] = $value;
    }

    public function __get(string $name)
    {
        return $this->data[$name] ?? null;
    }
}
ㅤ

visibilidade de construtores

# RECURSOS DINÂMICOS

<?php

abstract class DataTransferObject
{
    // ...
    
    private function __construct(array $data)
    {
        $this->data = $data;
    }
    
    final public static function create(array $data): static
    {
        return new static($data);
    }

    // ...
}
ㅤ

magic methods

# RECURSOS DINÂMICOS

<?php

abstract class DataTransferObject
{
    // ...

    public function __set(string $name, mixed $value)
    {
        $this->data[$name] = $value;
    }

    public function __get(string $name)
    {
        return $this->data[$name] ?? null;
    }
}
ㅤ

dynamic access

# RECURSOS DINÂMICOS

<?php

final class UserDTO extends DataTransferObject {}

$userDTO = UserDTO::create(['name' => 'William']);
echo $userDTO->name; // William
ㅤ

access via magic method

# RECURSOS DINÂMICOS

traceability

# RECURSOS DINÂMICOS

<?php

abstract class DataTransferObject
{
    // ...

    public function set(string $name, mixed $value): void
    {
        $this->data[$name] = $value;
    }

    public function get(string $name): mixed
    {
        return $this->data[$name] ?? null;
    }
}
ㅤ

instance method

# RECURSOS DINÂMICOS

<?php

final class UserDTO extends DataTransferObject {}

$userDTO = UserDTO::create(['name' => 'William']);
echo $userDTO->get('name'); // William
ㅤ

indo além

# RECURSOS DINÂMICOS

<?php

final class UserDTO extends DataTransferObject
{
    protected array $validations = [
        'name' => 'required|string|min:3|max:40',
        'email' => 'required|email',
        'password' => 'required|password',
    ];
}
ㅤ

immutability

# RECURSOS DINÂMICOS

<?php

final class UserDTO extends DataTransferObjectImutable
{
    protected array $validations = [
        'name' => 'required|string|min:3|max:40',
        'email' => 'required|email',
        'password' => 'required|password',
    ];
}
ㅤ

importante

# RECURSOS DINÂMICOS

protected

public

private

static

abstract

final

Ou seja

# RECURSOS DINÂMICOS

amole o machado

antes da lida

contratos

o poder precisa de organização

definindo

contratos explícitos

# DEFININDO CONTRATOS

<?php

interface DataTransferObjectContract
{
    public function get(string $property): mixed;
    
    public function set(string $property, mixed $value): void;
}
ㅤ

interfaces

documentação

# DEFININDO CONTRATOS

<?php

namespace Asgard;

use Midgard\Other;

interface Foo extends Other {}
ㅤ

<?php

namespace Midgard;

interface Other {}
ㅤ

namespace Cybertron;

use Asgard\Foo;

class Bar extends Foo
{
    protected function awesome(): bool
    {
        return true;
    }
}
ㅤ

class abstraction

# DEFININDO CONTRATOS

namespace Asgard;

abstract class Foo
{
    abstract protected function awesome(): bool;
}
ㅤ

documentação

type hint / return type

documentação

# DEFININDO CONTRATOS

<?php

namespace Asgard;

interface Foo {}
ㅤ

<?php

namespace Midgard;

interface Other {}
ㅤ

<?php

class Bar implements Foo, Other {}

function magic(Foo $variable): Other
{
    return $variable;
}
echo get_class(magic(new Bar));
// Cybertron\Bar
ㅤ

type hint / return type

# DEFININDO CONTRATOS

<?php

namespace Cybertron;

use Asgard\Foo;
use Midgard\Other;

class Bar implements Foo, Other {}
ㅤ

documentação

function ragnarok(Foo $variable): Other
{
    return $variable;
}
ragnarok(new \stdClass);

// Fatal error: Uncaught TypeError: Cybertron\magic():
// Argument #1 ($variable) must be of type Asgard\Foo, stdClass given
ㅤ

not in my watch!

# DEFININDO CONTRATOS

documentação

function ragnarok(mixed $variable): Other
{
    return $variable;
}
ragnarok(new \stdClass);

// Fatal error: Uncaught TypeError: Cybertron\magic(): 
// Return value must be of type Midgard\Other, stdClass returned
ㅤ

<?php

namespace Asgard;

interface Foo {}
ㅤ

contratos implícitos

# DEFININDO CONTRATOS

<?php

namespace Midgard;

interface Other {}
ㅤ

<?php

echo new Bar instanceof Foo  ? 'yes' : 'no';
// yes
ㅤ

instanceof

documentação

# DEFININDO CONTRATOS

<?php

namespace Cybertron;

use Asgard\Foo;
use Midgard\Other;

class Bar implements Foo, Other {}
ㅤ

instanceof

# DEFININDO CONTRATOS

<?php

// ...
class Handler extends ExceptionHandler
{
    // ...
    public function render($request, Throwable $e): Response
    {
        // ...
        $data = ['error' => $e->getMessage()];
        if ($e instanceof ErrorContract) {
            $data['details'] = $e->getDetails();
        }
        // ...
    }
}
ㅤ

echo method_exists(Bar::class, 'awesome') ? 'yup' : 'nope';
// yup
ㅤ

method_exists

documentação

# DEFININDO CONTRATOS

<?php

namespace Cybertron;

use Asgard\Foo;
use Midgard\Other;

class Bar implements Foo, Other
{
    public function awesome(): void {}
}
ㅤ

method_exists

# DEFININDO CONTRATOS

<?php

// ...
class Handler extends ExceptionHandler
{
    // ...
    public function render($request, Throwable $e): Response
    {
        // ...
        $status = 500;
        if (method_exists($e, 'getStatusCode')) {
            $status = $e->getStatusCode();
        }
        return response()->json($data, $status);
    }
}
ㅤ

<?php

$implements = class_implements(Bar::class);

echo implode(', ', array_keys($implements)), PHP_EOL;
// Asgard\Foo, Midgard\Other

echo isset($implements[Foo::class]) ? 'yes' : 'no';
// yes
ㅤ

class_implements

documentação

# DEFININDO CONTRATOS

<?php

namespace Cybertron;

use Asgard\Foo;
use Midgard\Other;

class Bar implements Foo, Other {}
ㅤ

<?php

$reflection = new ReflectionClass(Bar::class);
$interfaces = array_keys($reflection->getInterfaces());
echo in_array(Foo::class, $interfaces)  ? 'yes' : 'no';
// yes
ㅤ

reflection

documentação

# DEFININDO CONTRATOS

<?php

namespace Cybertron;

use Asgard\Foo;
use Midgard\Other;

class Bar implements Foo, Other {}
ㅤ

PHP

Standard Recomendation

link

# DEFININDO CONTRATOS

aquilo que o mundo me pede

# DEFININDO CONTRATOS

não é mundo que me dá

comportamentos

manda quem pode, obedece quem tem juízo

gerindo

template method

# GERINDO COMPORTAMENTOS

interface MapperContract
{
    public function parse(array $data): array;
}
ㅤ

abstract class Decorator implements DecoratorContract
{
    abstract protected function handler(string $text): string;

    final public function parse(string $text): string
    {
        return "Decorated: {$this->handler($text)}";
    }
}
ㅤ

template method

# GERINDO COMPORTAMENTOS

final class BoldDecodator extends Decorator
{
    protected function handler(string $text): string
    {
        return "<strong>{$text}</strong>";
    }
}
ㅤ

final class ItalicDecorator extends Decorator
{
    protected function handler(string $text): string
    {
        return "<i>{$text}</i>";
    }
}
ㅤ

template method

# GERINDO COMPORTAMENTOS

$text = 'William';

echo (new BoldDecodator)->parse($text), PHP_EOL;
// Decorated: <strong>William</strong>

echo (new ItalicDecorator)->parse($text), PHP_EOL;
// Decorated: <i>William</i>
ㅤ

usando traits

# GERINDO COMPORTAMENTOS

interface GossipContract
{
    public function gossip(): void;
}
ㅤ

trait SpillTheBeans
{
    abstract protected function secret(): string;

    public function gossip(): void
    {
        echo "Their secret is: {$this->secret()}";
    }
}
ㅤ

usando traits

# GERINDO COMPORTAMENTOS

abstract class Gossipy implements GossipContract
{
    use SpillTheBeans;
}
ㅤ

final class Whisperous extends Gossipy
{
    protected function secret(): string
    {
        return 'PHP';
    }
}

(new Whisperous)->gossip();
// Their secret is: PHP
ㅤ

herança

herança sempre dá dor de cabeça?

composição

vs

inheritance vs composition

# COMPOSIÇÃO vs HERANÇA

class Animal
{
    function eat() {}

    function walk() {}
}

class Dog extends Animal {}

class Cat extends Animal {}
ㅤ

inheritance for exposure

<?php

use Illuminate\Database\Migrations\Migration;

# Expor uma classe que atua na borda da estrutura.
# Note que muitas vezes a classe que extende pode
# (ou deve) ser final.

final class CreateProductsTable extends Migration
{
    // ...
}

# COMPOSIÇÃO vs HERANÇA

inheritance for exposure

namespace Slim;

use Psr\Log\AbstractLogger;

# Expor uma classe que atua na borda da estrutura
# forçando algum método abstrato

class Logger extends AbstractLogger
{
    public function log($level, $message, array $context = []): void
    {
    	// ...
    }
}

namespace Psr\Log;

// ...
abstract class AbstractLogger implements LoggerInterface
{
    use LoggerTrait;
}

# COMPOSIÇÃO vs HERANÇA

composition

namespace Symfony\Bundle\WebProfilerBundle\Controller;
// ...
class RouterController
{
    // ...
    public function __construct(
        Profiler $profiler,
        Environment $twig,
        UrlMatcherInterface $matcher,
        RouteCollection $routes,
        iterable $expressionLanguageProviders = []
    ) {
        $this->profiler = $profiler;
        $this->twig = $twig;
        $this->matcher = $matcher;
        $this->routes = (null === $routes && $matcher instanceof RouterInterface) ? $matcher->getRouteCollection() : $routes;
        $this->expressionLanguageProviders = $expressionLanguageProviders;
    }
    // ...
}

# COMPOSIÇÃO vs HERANÇA

inheritance vs composition

class Fish
{
    protected Animal $animal;
    protected Swimable $swimmable;

    final public function __construct(
        AnimalContract $animal,
        SwimmableContract $swimable
    ) {
        $this->animal = $animal;
        $this->swimmable = $swimable;
    }
}

# COMPOSIÇÃO vs HERANÇA

modelar

é sempre sobre comportamentos

práticos

compondo estruturas práticas

exemplos

tudo por minha conta

evitar bater seco no framework

# EXEMPLOS PRÁTICOS

use Illuminate\Database\Eloquent\Model;

abstract class AbstractModel extends Model
{
    abstract public function construct(): void;

    final public function __construct(array $attributes = [])
    {
        $this->construct();

        parent::__construct($attributes);
        // ....
    }
}
ㅤ

trait ftw

# EXEMPLOS PRÁTICOS

abstract class AbstractManagerController extends AbstractController
{
    use Permission;
    use Persistence;
    use Answer;

    use Create;
    use Read;
    use Update;
    use Destroy;

    use Search;
    use Restore;
}
ㅤ

final class CategoryController extends AbstractManagerController
{
    protected function model(): ModelContract
    {
        return $this->model;
    }
}
ㅤ

conveniência

# EXEMPLOS PRÁTICOS

final class CategoryController extends AbstractManagerController
{
    public function __construct(CategoryService $service)
    {
        parent::__construct($service);
    }
}
ㅤ

garantindo contratos

# EXEMPLOS PRÁTICOS

trait ManagerControllerContracts
{
    abstract protected function getData(RequestContract $request): array;
}
ㅤ

trait Create
{
    use ManagerControllerContracts;
    use AnswerContracts;

    public function create(RequestContract $request): JsonResponse
    {
        $this->grant($this->repository()->domain(), Levels::LEVEL_ADD);
        $data = $this->getData($request);
        $created = $this->repository()->create($data);
        return $this->answer(['subject' => $created]);
    }
}
ㅤ

ninguém é de ferro

# EXEMPLOS PRÁTICOS

final class CategoryController extends AbstractController
{
    use Permission;
    use Persistence;
    use Answer;

    use Create;
    use Read;
    
    use Search;

    public function __construct(CategoryService $service)
    {
        parent::__construct($service);
    }
}
ㅤ

ninguém é de ferro

# EXEMPLOS PRÁTICOS

class Router extends Facade
{
    public static function provide(string $uri, string $controller): void
    {
        $actions = [
            // ...
            ['verb' => 'post', 'path' => $uri, 'method' => 'create'],
        ];
        
        foreach ($actions as $action) {
            ['verb' => $verb, 'path' => $path, 'method' => $method] = $action;
            if (method_exists($controller, $method)) {
                static::$verb($path, "{$controller}@{$method}");
            }
        }
}
ㅤ

Router::provide('/general/category', CategoryController::class);
ㅤ

evite ficar apenas na superfície

as linguagens de programações são ferramentas

Compondo estruturas com PHP

PHP é muito dinâmica

recursos

dinâmicos

variable variables

variable functions

magic methods

show me the code

visibilidade de construtores

magic methods

dynamic access

access via magic method

traceability

instance method

indo além

immutability

importante

protected

public

private

static

abstract

final

Ou seja

amole o machado

antes da lida

contratos

definindo

contratos explícitos

interfaces

class abstraction

type hint / return type

type hint / return type

not in my watch!

contratos implícitos

instanceof

instanceof

method_exists

method_exists

class_implements

reflection

PHP

Standard Recomendation

aquilo que o mundo me pede

não é mundo que me dá

comportamentos

gerindo

template method

template method

template method

usando traits

usando traits

herança

composição

vs

inheritance vs composition

inheritance for exposure

inheritance for exposure

composition

inheritance vs composition

modelar

é sempre sobre comportamentos

práticos

exemplos

evitar bater seco no framework

trait ftw

conveniência

garantindo contratos

ninguém é de ferro

ninguém é de ferro

evite ficar apenas na superfície

hora das palmas

perguntas?