Object Calisthenics

Como ter códigos melhores com o uso de Object Calisthenics

Transcript

1. COMO TER CÓDIGOS MELHORES COM OBJECT CALISTHENICS
2. O que é Object Calisthenics? Inventado por Jeff Bay. Faz parte do livro The ThoughtWorks Anthology. São 9 exercícios de programação. Não se trata de regras mas sim de um guia.
3. Quais os benefícios? A prática desses exercícios ajudará a ter um código melhor. De fácil manutenção. Facilidade de se testar. Código legível e de fácil compreensão.
4. Somente 1 nível de indentação por método EXERCÍCIO 1
5. public function createPurchaseOrder($parameters) { $order = $this->orderService->create($data); // ... if (isset($parameters['products']) && count($parameters['products'])) { $products = $parameters['products']; foreach ($products as $product) { $productVariation = $this->productVariation->find($product['id']); if (!$productVariation->product->unitType->virtual) { // ... if (isset($product['lead_time'])) { $orderRowEtaDays = $product['lead_time']; } else { $orderRowEtaDays = 0; } // ... $orderRow->save($orderRowData); } } } return $order; } EXEMPLO 1
6. Refatoração Recomenda-se dividir os métodos. Utilizar o padrão Extract Method.
7. public function createPurchaseOrder($parameters) { $order = $this->orderService->create($data); // ... if (isset($parameters['products']) && count($parameters['products'])) { $orderRow = $this->orderRowService->create($parameters['products'], $order); $order->eta_date = $orderRow['order_eta']; } return $order; } EXEMPLO 1
8. public function productsWithDiscount($products) { $productsWithDiscount = []; if (isset($products) && count($products)) { foreach ($products as $product) { if ($product['has_discount']) { $productsWithDiscount[] = $product; } } } return $productsWithDiscount; } EXEMPLO 2
9. public function productsWithDiscount($products) { $productsWithDiscount = []; if (isset($products) && count($products)) { foreach ($products as $product) { if ($product['has_discount']) { $productsWithDiscount[] = $product; } } } return $productsWithDiscount; } EXEMPLO 2 remover condições desnecessárias
10. public function productsWithDiscount($products) { $productsWithDiscount = []; foreach ($products as $product) { if ($product['has_discount']) { $productsWithDiscount[] = $product; } } return $productsWithDiscount; } EXEMPLO 2
11. public function productsWithDiscount($products) { return array_filter($products, function ($product) { return $product['has_discount']; }); } EXEMPLO 2 apenas 1 nível de indentação
12. Quais os benefícios? Reduz a complexidade ciclomática. Fácil leitura. Favorece o SRP e KISS. Traz encorajamento.
13. Não existe ELSE EXERCÍCIO 2
14. EXEMPLO 1 public function authenticate($username, $password) { if ($this->isValid($username, $password)) { $user = $this->userService->authenticate($username, $password); if ($user) { $token = $this->generateToken(); $result = [ 'success' => true, 'token' => $token ]; } } else { $result = [ 'success' => false, 'message' => 'Please check your username and password' ]; } return new JsonResponse($result); }
15. EXEMPLO 1 public function authenticate($username, $password) { if ($this->isValid($username, $password)) { $user = $this->userService->authenticate($username, $password); if ($user) { $token = $this->generateToken(); $result = [ 'success' => true, 'token' => $token ]; } } else { $result = [ 'success' => false, 'message' => 'Please check your username and password' ]; } return new JsonResponse($result); } 3 níveis de indentação
16. EXEMPLO 1 public function authenticate($username, $password) { if ($this->isValid($username, $password)) { $user = $this->userService->authenticate($username, $password); $result = [ 'success' => true, 'token' => $user['token'] ]; } else { $result = [ 'success' => false, 'message' => 'Please check your username and password' ]; } return new JsonResponse($result); }
17. Early return Sair o mais rápido de um bloco de código. Abordagem defensiva ou otimista.
18. EXEMPLO 1 public function authenticate($username, $password) { // optimistic approach if ($this->isValid($username, $password)) { $user = $this->userService->authenticate($username, $password); return new JsonResponse([ 'success' => true, 'token' => $user['token'] ]); } return new JsonResponse([ 'success' => false, 'message' => 'Please check your username and password' ]); }
19. EXEMPLO 1 public function authenticate($username, $password) { // defensive approach if (!$this->isValid($username, $password)) { return new JsonResponse([ 'success' => false, 'message' => 'Please check your username and password' ]); } $user = $this->userService->authenticate($username, $password); return new JsonResponse([ 'success' => true, 'token' => $user['token'] ]); }
20. Diagrama de Atividade
21. Diagrama de Atividade
22. Encapsular todos os tipos primitivos e strings EXERCÍCIO 3
23. Encapsular todos os tipos primitivos e strings EXERCÍCIO 3 caso eles tenham comportamentos
24. Quais os benefícios? Evita o anti-pattern conhecido como primitive obsession. Evita duplicidade de código. Evita consumo de memória no PHP.
25. Primitive obsession é usar tipo de dados primitivos para representar ideias de domínio.
26. Exemplo: utilizar string para e-mail e float para valor monetário.
27. Deve ser usado quando um tipo possui validação, regras de negócio ou de comportamento.
28. Recomenda-se utilizar value objects no lugar de tipo primitivo como, por exemplo, Money, Id ou Email.
29. EXEMPLO 1 class Product { public static function find($id) { if ( ! is_string($id) || trim($id) === '') { throw new \InvalidArgumentException( 'The product ID must be a non-empty value' ); } // do something to find ... } public static function update($id, array $data) { if ( ! is_string($id) || trim($id) === '') { throw new \InvalidArgumentException( 'The product ID must be a non-empty value' ); } // do something to update ... } } Id possui um comportamento duplicidade de código
30. EXEMPLO 1 final class Id { private $value; public function __construct($value) { if ( ! is_string($value) || trim($value) === '') { throw new \InvalidArgumentException( 'The ID must be a non-empty string' ); } $this->value = $value; } public function getValue() { return $this->value; } }
31. EXEMPLO 1 class Product { public static function find(Id $id) { // do something to find ... } public static function update(Id $id, array $data) { // do something to find ... } }
32. EXEMPLO 2 class User { private $name; private $email; public function __construct($name, $email) { $this->name = $name; $this->email = $email; } } $user = new User('Dwight Lyman Moody', 'dl.moody@gmail.org'); // ok $user = new User('Charles Spurgeon', '19061834-31011892'); // ok
33. EXEMPLO 2 final class Email { private $value; public function __construct($value) { if ( ! filter_var($value, FILTER_VALIDATE_EMAIL)) { throw new \InvalidArgumentException( 'E-mail must be a valid format' ); } $this->value = $value; } public function getValue() { return $this->value; } }
34. EXEMPLO 2 // ok $user = new User('Dwight Lyman Moody', new Email(‘dl.moody@gmail.org')); // not ok $user = new User('Charles Spurgeon', new Email(‘19061834-31011892'));
35. Coleções de primeiro nível EXERCÍCIO 4
36. Qualquer classe que contenha uma coleção não deve conter outra propriedade.
37. Quais os benefícios? Single Responsibility Principle. Facilita a operação sobre a coleção. Usar classes de SPL.
38. EXEMPLO 1 class User { private $name; private $albumList; public function getPublicAlbumList() { $filteredAlbumList = []; foreach ($this->albumList as $album) { if ($album->isPublic()) { $filteredAlbumList[] = $album; } } return $filteredAlbumList; } }
39. EXEMPLO 1 class AlbumList extends Collection { public function getPublic() { $filteredAlbumList = []; foreach ($this->albumList as $album) { if ($album->isPublic()) { $filteredAlbumList[] = $album; } } return $filteredAlbumList; } }
40. EXEMPLO 1 class AlbumList extends Collection { public function getPublic() { return new ArrayCollection( array_filter($this->value, function ($album) { return $album->isPublic(); }) ); } }
41. EXEMPLO 1 class User { private $name; private $albumList = new AlbumList(); // ... } $publicAlbumList = $user->getAlbumList()->getPublic(); $albumList = $user->getAlbumList(); $albumList->add(new Album($name, $privacy));
42. Um operador do objeto por linha EXERCÍCIO 5
43. Um operador do objeto por linha EXERCÍCIO 5 a famosa “setinha” ( ->)
44. Chamadas de métodos não devem ser encadeadas. Com excessão de classes fluentes com método do mesmo nome.
45. $filterChain = new \Zend\Filter\FilterChain(); $filterChain->attach(new \Zend\I18n\Filter\Alpha()) ->attach(new \Zend\Filter\StringToLower()); EXEMPLO 1
46. EXEMPLO 1 public function attach($callback, $priority = self::DEFAULT_PRIORITY) { // ... $this->filters->insert($callback, $priority); return $this; }
47. Difícil de debugar e tratar exceções. Código deve ser todo estruturado para usar NullObjects.
48. Lei de Demeter Fale com seus amigos mais próximos e não fale com estranhos.
49. Quais os benefícios? Facilita o entendimento. Facilita o debug. Facilidade ao testar (criar mocks). Segue a Lei de Demeter.
50. EXEMPLO 2 // get supplier's invoice number $supInvoiceNo = $checkInEvent->order->closedOrder->sup_reference_no; E se “closedOrder” for null
51. EXEMPLO 2 if ( ! is_null($checkInEvent->order->closedOrder)) { $supInvoiceNo = $checkInEvent->order->closedOrder->sup_reference_no; } E se “order” for null
52. EXEMPLO 2 if ( ! is_null($checkInEvent->order)) { if ( ! is_null($checkInEvent->order->closedOrder)) { $supInvoiceNo = $checkInEvent->order->closedOrder->sup_reference_no; } }
53. EXEMPLO 2 $supInvoiceNo = ''; $closedOrder = $checkInEvent->getClosedOrder(); if ( ! is_null($closedOrder)) { $supInvoiceNo = $closedOrder->sup_reference_no; }
54. Prefira utilizar métodos e não propriedades. Propriedades são difíceis de “mockar”.
55. EXEMPLO 3 /** * @param $variations * @param $discountCode * @return bool */ private function hasBrand($variations, $discountCode) { $attachments = $discountCode->attachments; // ... foreach ($variations as $variation) { $brands = array_column($$attachments[‘brands'], 'id'); if (in_array($variation->product->manufacturer->id, $brands)) { $this->errorMessages[] = $variation->sku; } } // … }
56. EXEMPLO 3 /** * @param $variations * @param $discountCode * @return bool */ private function hasBrand($variations, $discountCode) { $attachments = $discountCode->attachments; // ... foreach ($variations as $variation) { $brands = array_column($$attachments[‘brands'], 'id'); if (in_array($variation->product->manufacturer->id, $brands)) { $this->errorMessages[] = $variation->sku; } } // … }
57. EXEMPLO 3 $manufacturer = \Mockery::mock(Manufacturer::class); $manufacturer->shouldReceive('getAttribute')->once()->with('id')->andReturn(1); $product = \Mockery::mock(Product::class); $product->shouldReceive('isBundle')->andReturn(false); $product->shouldReceive('getAttribute')->once()->with('manufacturer')->andReturn($manufacturer); $variation = \Mockery::mock(Variation::class); $variation->shouldReceive('getAttribute')->once()->with('product')->andReturn($product); $variation->shouldReceive(‘getAttribute’)->once()->with('sku')->andReturn('3000001');
58. Não abreviar EXERCÍCIO 6
59. Quais os benefícios? Facilita a comunicação. Facilita a manutenção. Facilita o codereview.
60. Por que abreviar nomes de variáveis e/ou métodos?
61. Escrever o mesmo nome repetidamente! Problema com duplicação de código.
62. Nome muito longo! Problema de múltiplas responsabilidades.
63. EXEMPLO 1 public function myFunction() { $p1 = new Product(); // ... $p2 = new Product(); // ... }
64. EXEMPLO 2 foreach ($productVariations as $pv) { // ... $pv->name; // ... }
65. EXEMPLO 2 foreach ($productVariations as $variation) { // ... $variation->name; // ... }
66. EXEMPLO 3 $p = $e instanceof HttpExceptionInterface; $q = $e instanceof MethodNotAllowedHttpException; $r = $e instanceof NotFoundHttpException; if ($p || $q || $r) { // ... }
67. EXEMPLO 3 if ( $e instanceof HttpExceptionInterface || $e instanceof MethodNotAllowedHttpException || $e instanceof NotFoundHttpException ) { // ... }
68. EXEMPLO 3 private function isInvalidException(Exception $e) { return ($e instanceof HttpExceptionInterface) || ($e instanceof MethodNotAllowedHttpException) || ($e instanceof NotFoundHttpException) } if ($this->isInvalidException($e)) { // ... }
69. EXEMPLO 3 private function isInvalidException(Exception $e) { if ($e instanceof HttpExceptionInterface) { if ($e->getStatusCode() == 500) { $this->logger->error('My message log.'); } return true; } if ($e instanceof MethodNotAllowedHttpException) { return true; } if ($e instanceof NotFoundHttpException) { return true; } return false; }
70. Mantenha suas classes pequenas EXERCÍCIO 7
71. Quais os benefícios? Encoraja o reuso. Favorece o SPR. Métodos claros e objetivos. Evita God Class.
72. God Class Classe que sabe de mais ou faz demais.
73. 100 linhas* por classe * Aumentado para incluir dockblocks
74. 5 propriedades de classe
75. 5 métodos por classe
76. 10 linhas por método
77. 10 linhas por método
78. 15 classes por namespace* * Geralmente organizamos namesapaces por pastas
79. Limite o número de variáveis de instância EXERCÍCIO 8
80. Quais os benefícios? Pouca dependência. Favorece o SPR. Melhor encapsulamento. Melhor testabilidade.
81. class MyRegistrationService { protected $userService; protected $passwordService; protected $logger; protected $translator; protected $entityManager; protected $imageCropper; } EXEMPLO 1 Interação com BD deve estar em $userService Pode ser usado um event listener
82. Use getters e setters EXERCÍCIO 9
83. Quais os benefícios? Facilita a leitura. Favorece o Open Closed Principle.
84. Open Closed Principle Uma entidade deve ser aberta para extensões e fechada para modificações.
85. LARAVEL: TIPS & TRICKS HOW TO IMPROVE YOUR APPLICATION USING THE S.O.L.I.D. PRINCIPLES https://goo.gl/y4bkzx
86. EXEMPLO 1 class BankAccount extends Model { protected $fillable = [ 'balance' ]; } Gera uma propriedade publica class BankAccount extends Model { public $balance; }
87. EXEMPLO 1 class BankAccountService { public function deposit($accountId, $amount) { $account = BankAccount::findOrFail($accountId); $account->balance = $account->balance + $amount; $account->save(); // do something to notify the client } public function withdraw($accountId, $amount) { $account = BankAccount::findOrFail($accountId); $account->balance = $account->balance - $amount; $account->save(); // do something to notify the client } }
88. Tell, don’t ask Não peça informações para fazer o seu trabalho, apenas diga para o objeto que possui a informação e ele fará o trabalho por você.
89. EXEMPLO 2 class BankAccount extends Model { protected $fillable = [ 'balance' ]; public function deposit($amount) { $this->balance += $amount; } public function withdraw($amount) { $this->balance -= $amount; } }
90. EXEMPLO 2 class BankAccountService { public function deposit($accountId, $amount) { $account = BankAccount::findOrFail($accountId); $account->deposit($amount); $account->save(); // do something to notify the client } public function withdraw($accountId, $amount) { $account = BankAccount::findOrFail($accountId); $account->withdraw($amount); $account->save(); // do something to notify the client } }
91. Perguntas? Obrigado