
Quando estamos começando a desenvolver e salvar nossos projetos em um repositório temos uma dificuldade muito grande em realizar os commits de forma organizada e clara, para que outros desenvolvedores ou nós mesmo passamos ver aquilo que está acontecendo no projeto. Com as convenções [SemVer](https://semver.org/lang/pt-BR/) e o [Conventional Commits](https://www.conventionalcommits.org/pt-br/v1.0.0-beta.4/) fica mais claro de entender a melhor maneira de administrarmos nosso repositório.

O uso de tais praticas trás diversas vantagens para nosso projeto, como por exemplo um histórico de alterações mais clara sendo mais facil localizar uma mudança no projeto, alem disso conseguimos distribuir nosso sistemas utilizando as tags sendo mais facil para quem utilizar identificar as atualizações realidas ou disponiveis.

O primeiro passo é ter commits e suas mensagens claras e expecificas, ou seja, sempre que um novo codigo for adicionado no repositório deve conter o seguinte formato em sua mensagem.

```bash
<tipo>(<funcionalidade>): <descrição>

<descrição (opcional)>

<Rodapé (opcional)>
```

### Exemplos

#### Commit de uma nova funcionalidar

```bash
feat: add new feature x
```

#### Commit de rafatoração de um codigo

```bash
refactor!: refactor class user
```

#### Commit de documentaçãofuncionalidade

```bash
docs: correct spelling of CHANGELOG
```

#### Commit de uma parte de uma funcionalidade

```bash
feat(lang): add portuguese language
```

Seguindo esta organização conseguimos localizar em nosso projeto as alterações realizadas

![Commits seguindo convencional commits](/assets/img/posts/commits-seguindo-converncional-commits.png)

### Bibliografia

- [SemVer](https://semver.org/lang/pt-BR/)
- [Convencional commit](https://www.conventionalcommits.org/pt-br/v1.0.0-beta.4/)


Commit Semântico e Versionamento


#### Sobre

> Sou pai, marido e engenheiro de software, tenho mais de 10 anos de experiência na criação e manutenção de diferentes sistemas. Atualmente, trabalho sobretudo com Python, GO Lang e NodeJS no back-end, já em front-end utilizo VueJS e TypeScript, no banco de dados aplico PostgreSQL e MongoDB, para mensageria utilizo Benthos e Kafka e, para gestão dos serviços opero Docker, GitHub Action e Kubernetes. Percebo com facilidade as soluções mais adequadas para cada projeto e continuo buscando evolução pessoal e profissional.

#### Resumo de qualificações de linguagens e ferramentas

- Programação back-end (Python, Ruby, PHP, Go Lang, NodeJS);
- Programação front-end (JavaScript, TypeScript, HTML5, CSS3);
- Frameworks (Fast API, Ruby on Rails, Laravel, Bootstrap, VueJS);
- Banco de dados (PostgreSQL, MySQL, MongoDB, Rabbitmq, Redis);
- Trabalhos em segundo plano  (Benthos, Celery, Sidekiq);
- Ferramentas de versionamento (Git, GitHub, GitLab, Bitbucket);
- Monitoria (New Relic, Datadog, Grafana);
- Ferramentas DevOps (Docker, Ansible, Kubernetes).

#### Experiência em treinamentos

- Instrutor de AWS para equipe de gerentes de dados, Editora UNIPRO, 2016.
- Palestrante no Workshop “Técnicas de SEO”, Evento Organizers RJ, 2015.

#### Experiência

- Facily - Software Engineering Specialist

> Sou responsável pela arquitetura e organização do time encarregado da reestruturação do e-commerce da empresa, desenvolvendo o carrinho de compra, gerenciamento dos cupons, controle de estoque integrado com Oracle, gestão dos usuários internos e externos e o sistema de administração dos anúncios, clientes e pedidos.
> Criei microserviços para otimizar o desenvolvimento de outros projetos, gerando uma grande economia financeira para a empresa, por exemplo, o desenvolvimento de uma API para consulta e validação de CEP, baseada na base dos Correios (Brasil) agregada com a geolocalização do Google e com algumas informações fiscais do país, facilitanto a validação e reduzindo a consulta em APIs externas que possuiam alto custo; outro bom exemplo foi a criação de um gateway de comunicação responsável por gerenciar o envio de mensagens (email, sms e push), centralizando a integração com os serviços externos tornando mais fácil o gerenciamento de uso e seus custos.

- Locaweb - Analista de Sistemas Sênior

> Realizei a arquitetura e o desenvolvimento de uma nova estrutura multitenancy para o back-end de email, tornando-a mais dinamica e aplicável para o produto existente e para a revenda desta estrutura. Iniciei o desenvolvimento de um provisionador integrado a grandes players do mercado de email, como Google (Workspace) e Microsoft (Office 365). Atualizei o front-end de email, onde foi necessario uma alteração de linguagem, framework e infraestrutura, adicionei novas funcionalidades, como por exemplo integração da agenda e contatos com o Google e Outlook.
> Fui responsável por manter e aprimorar o front-end e o provisionador de email, atendendo as demandas de negocio e aos chamados dos clientes que até então, não possuiam soluções, sempre atento a possiveis problemas de segurança e performance em nossa plataforma, como por exemplo XSS e lentidão no front-end.

- Novax Telecom - Desenvolvedor de software

> Atuei como desenvolvedor e arquiteto na criação de novos produtos da empresa, tais como PABX, Speech Analytics, Agente virtual com processamento de linguagem natural e análise de sentimento do atendimento. Converti o produto principal da empresa para cloud, utilizando CI/CD e infraestrutura como código, possibilitando assim uma economia e mais eficiência na instalação e atualização do produto para o cliente. Contruímos um CRM para controle e gestão interna da empresa, funcionários, folha de pagamento, controle ativo de estoque e atendimento dos incidentes reportados pelos clientes.


About

Filipe Crespo Dev

name

email

subject

message

consent

Get in Touch

Home


## O que é Git

---

###### Criado pelo Linus Torvalds, em 2005 para o desenvolvimento do Kernel do Linux veja a hitória completa na talk [Linus Torvalds on Git](https://www.youtube.com/watch?v=4XpnKHJAok8).

{%youtube 4XpnKHJAok8 %}

---

## Git != GitHub

---

GitHub trata-se de uma interface para a criação e administração de repositórios GIT, alem de adicionar algumas funcionalidades como os Merge Requetes e os Pull Requests de forma mais simples do que apenas pelo terminal.

---

## Alternativas

bitbucket | Gitlab

---

## Versionamento Semântico

---

##### O formato padrão para uma tag é ++Major.Minor.Patchs++, sendo:

* Major => Representa a versão principal do projeto;
* Minor => Representa as adições de novas funcionalidades;
* Patchs => Representa correções de bugs no sistema.

Veja mais em: [semver.org](https://semver.org/lang/pt-BR/)

---

## Convencional Commit

---

Convenção baseada no Versionamento Semântico
definindo regras para a criação de um histórico de commits deixando  mais explícitos o que está sendo modificado.

Veja mais em: [conventionalcommits.org](https://www.conventionalcommits.org/pt-br/v1.0.0-beta.4/)

---

#### Exemplos:

```=
<tipo>[escopo opcional]: <descrição>

[corpo opcional]

[rodapé opcional]
```

`----`

```=
Feat(translate): adiciona tradução para inglês
```

```=
Feat(translate): adiciona tradução para espanhol 
```

---

++Changelog++ é o arquivo que contem o histórico das alterações de cada versão

```=50
## [1.1.0] - 2020-06-20
## Added
- adiciona tradução para inglês
- adiciona tradução para espanhol

## [1.1.1] - 2020-06-20
### Fixed
- Resolvido erro de timeout
```

---

## Usando Git

---

- [ ] git init
- [ ] git add
- [ ] git commit
- [ ] git rebase
- [ ] git reset
- [ ] git push

---

### git reset

Utilizando o **--soft** possibilita a reorganização da árvore de commits.

```bash=
git reset --soft d60329e
```

---

### git add

O add nos permite adicionar todos os arquivos alterados ou para melhor organização adicionar apenas 1 ou mais arquivos específicos. Além disso permite também selecionar parte da modificação de um arquivo. 

```=
git add --all
```

```=
git add -p <arquivo>
```

---

## GitHub Actions

---

Primeiro precisamos criar o diretório ==.github/workflows/==, dentro dele podemos adicionar as actions necessárias  para nosso sistema. Como por exemplo o Teste e o Deploy. 

---

### Teste

```yml=
name: Test
on: push
jobs:
  test:
    runs-on: ubuntu-latest
    steps:
    - uses: actions/checkout@v2
    - name: Set up Ruby
      uses: ruby/setup-ruby@v1
      with:
        node-version: 12
    - name: Install dependencies
      run: npm install
    - name: Run tests
      run: npm run test
```

---

### Deploy

```yml=
name: Deploy
on:
  push:
    branches: [ master ]
  pull_request:
    branches: [ master ]

jobs:
  build:
    runs-on: ubuntu-latest
    steps:
    - uses: actions/checkout@v2
    - name: Push to server
      uses: appleboy/ssh-action@master
      with:
        host: ${{ secrets.HOST }}
        USERNAME: ${{ secrets.USERNAME }}
        PORT: 22
        KEY: ${{ secrets.SSHKEY }}
        script: cd /var/www/blog-cpantiguidade && git pull && npm run build
```

---

## Automatizando o trabalho
`----`
~/.gitconfig

---

Podemos ter em nosso config do git algumas configurações que nos ajudam no dia a dia.

```=
[branch]
  autosetuprebase = always
[merge]
  ff = no
  commit = no
[pull]
  rebase = preserve
[push]
  default = current
```

---

Além das configurações podemos ter atalhos para os comando mais utlizados.

```=
[alias]
    c = checkout
    a = add
    s = status
    p = pull
    r = rebase
```


A Rotina com Git e GitHub



Após termos clonado um projeto para nossa conta do Github ou GitLab o nosso projeto pode ficar desatualizado em relação ao projeto original.

Isso pode causar dois problemas na realização de pull requests pois a sua branch não vai estar igual a banch de destido no PR.

O outro problema é conseguir atualizar o seu projeto de novas atualizações ou correções no projeto.
Para isso precisamos configurar em nosso local o endereço remoto do projeto original como upstream nas configurações do `.git/config` na pasta do projeto.

Utilizamos o seguinte comando:

```bash
git remote add upstream https://github.com/usuario/projeto.git
```

Com isso nosso `.git/config` ficará da seguinte forma:

```vim
[core]
  repositoryformatversion = 0
  filemode = true
  bare = false
  logallrefupdates = true
[remote "origin"]
  url = git@github.com:<seu usuario>/projeto.git
  fetch = +refs/heads/*:refs/remotes/origin/*
[branch "master"]
  remote = origin
  merge = refs/heads/master
  rebase = true
[remote "upstream"]
  url = https://github.com/<usuario original>/projeto.git
  fetch = +refs/heads/*:refs/remotes/upstream/*
```

O proximo passo é atualizar nosso local com as informações do repositório original. Para isso podemos rodar o seguinte comando:

```bash
git fetch upstream
```

Certifique-se de que você está no branch master:

```bash
git checkout master
```

Reescreva o seu branch master, de forma que os seus commits que não estão no projeto original apareçam, e que os seus commits fiquem no topo da lista:

```bash
git rebase upstream/master
```

Caso o seu projeto não contenha commit adicinais, ou não queira mantelos e sim atulizar sua master com o projeto original pode utilizar o seguinte comando:

```bash
git reset --hard upstream/master
```

Se você não quiser reescrever o histórico do seu branch master (talvez porque alguém já o tenha clonado) então você deve substituir o último comando por um

```bash
git merge upstream/master
```

Por fim pode atulizar seu repositório remoto com as alterações

```bash
git push origin master
```

Como Atualizar um Projeto Forcado

images/posts/desenvolvendo_com_containers_e_php.jpg


## Ajuda ou complica?

```yaml=
- Facilidade de replicar o ambiente
- Desenvolver em diversas versões da mesma biblioteca
- Não precisar de todas as dependências dos projetos
- “Na minha máquina funcionava”
- Versionar a configuração para executar o serviço
```

---

## Docker

---

Localizar imagens - https://hub.docker.com/


---

#### Principais comandos

```bash=
# Listar as imagens locais
docker images
```

```bash=
# Rodar um container
docker run php:7.4
```

```bash=
# Listar os containers ativos
docker ps
```

---

```bash=
# Executar comandos dentro do container
docker exec meu_container top
```

```bash=
# Entrar no container
docker exec -it meu_container bash
```

```bash=
# Parar a execução de um container
docker stop meu_container
```

```bash=
# Remover um container
docker rm meu_container
```

---

## Dockerfile

---

#### Principais instruções

```yaml
FROM # Imagem base 
WORKDIR # Diretorio base dentro do container
RUN # Executar comando dentro do container
ADD # Adicionar um arquivo para dentro do container
EXPOSE # Expor a porta do serviço para fora do container
ENV # Adicionar variável de ambiente dentro do container
CMD # Comando que será a saida do container
```

---

```bash=
# Salvando uma imagem
docker build -t filipecrespo/ruby_node:1.0.0 .
```


```bash=
# Publicando a imagem no Dockerhub
docker push filipecrespo/ruby_node:1.0.0
```

---

## docker-compose

---

```yaml
version # Versão do docker-composer
services # Serviços necessários (banco, front, back, etc)
image # Imagem que o serviço utiliza
build # Indicar qual arquivo dockerfile vai utilizar
working_dir # Diretorio base dentro do container
links # Conecta os containers na rede do docker
depends on # Cria dependencia entre os containers
volumes # Diretorio compartilhado com o container
ports # Porta que será publicada fora do container
env_file # Arquivo com as variáveis de ambiente
environment # Variáveis de ambiente
```

---

```bash=
# Build todos os serviços do docker-composer.yml
docker-compose build
```

```bash=
# Iniciar todos os serviços do docker-composer.yml
docker-compose up
```

```bash=
# Desligando os serviç
#
# os do docker-composer.yml
docker-compose down
```

---

### Extra

newrelic-sysmond \
  newrelic-php5

```bash=
docker-compose run --service-porun --service-ports --rm $(app_env) webrts --rm $(app_env) web
```


Desenvolvendo com containers


### Linux

---

Debian, CentOS

---

Debian 9

---

Update e Upgrade

---

Apache2

```shell=
apt install apache2
```

--- 

Para testar basta acessar o IP do servidor.

![](https://i.imgur.com/PbvPHD5.png)

---

MariaDB

```shell=
apt install mariadb-server
```

---

```shell=
mysql_secure_installation
```
Change the root password? [Y/n] N
Remove anonymous users? [Y/n] Y
Disallow root login remotely? [Y/n] Y
Remove test database and access to it? [Y/n] Y
Reload privilege tables now? [Y/n] Y

---

PHP7

```shell=
apt install php libapache2-mod-php php-mysql
```

---

Substituir o arquivo 
`/etc/apache2/mods-enabled/dir.conf`

```
DirectoryIndex  index.html index.cgi index.pl index.php index.xhtml index.htm
```

por 

```
DirectoryIndex index.php index.html index.cgi index.pl index.xhtml index.htm
```


Virtual host

Criar os arquivos de configuração de cada site que ficará no servidor

/etc/apache2/sites-available

pizza43.com.conf
pao43.com.conf

```
<VirtualHost *:80>
	ServerName pizza43.com
    ServerAlias www.pizza43.com
	DocumentRoot /var/www/pizza43.com
	ErrorLog ${APACHE_LOG_DIR}/error_pizza43.log
	CustomLog ${APACHE_LOG_DIR}/access_pizza43.log combined
</VirtualHost>
```

```
<VirtualHost *:80>
	ServerName pao43.com
    ServerAlias www.pao43.com
	DocumentRoot /var/www/pao43.com
	ErrorLog ${APACHE_LOG_DIR}/error_pao43.log
	CustomLog ${APACHE_LOG_DIR}/access_pao43.log combined
</VirtualHost>

```

a2ensite pizza43.com.conf
a2ensite pao43.com.conf


Instalando LAMP na VPS


### Quando utilizar?

* #### O que é um framework?
* #### O que classifica o framework como bom?
* #### Por que escolher um framework ou outro?
* #### O que estou desenvolvendo ?

---

## Composer

---

![](https://i.imgur.com/93vnLKV.png =150x)
### [Packagist](https://packagist.org)

---

Composer.json

```json=
{
"name": "dhgouveia/blog-api",
"description": "Simple Blog Api",
"type": "project",
"autoload": {
    "psr-4": {
        "App\\": "App/"
    }
},
"license": "MIT",
"scripts": {
    "test": [
        "./vendor/bin/phpcs --standard=psr2 App/",
        "./vendor/bin/peridot Test/"
    ]
},
"require": {
    "monolog/monolog": "1.25.1"
},
"require-dev": {
    "squizlabs/php_codesniffer": "^3.4",
    "peridot-php/peridot": "^1.19",
    "eloquent/phony-peridot": "^2.0",
    "peridot-php/leo": "^1.6"
}
}

``` 

---

Index

```php=
<?php
require __DIR__ . '/vendor/autoload.php';

use App\Lib\App;
use App\Lib\Router;
use App\Lib\Request;
use App\Lib\Response;
use App\Controller\HomeController;
use App\Model\Posts;

Posts::load();

Router::get('/', function () {
    (new HomeController())->indexAction();
});

Router::get('/post', 
            function (Request $req, Response $res) {
    $res->toJSON(Posts::all());
});

Router::post('/post', 
            function (Request $req, Response $res) {
    $post = Posts::add($req->getJSON());
    $res->status(201)->toJSON($post);
});

Router::get('/post/([0-9]*)', 
            function (Request $req, Response $res) {
    $post = Posts::findById($req->params[0]);
    if ($post) {
        $res->toJSON($post);
    } else {
        $res->status(404)
            ->toJSON(['error' => "Not Found"]);
    }
});

App::run();
```

---

App

```php=
<?php namespace App\Lib;

class App
{
    public static function run()
    {
        Logger::enableSystemLogs();
    }
}
```

---

Model Posts

```php=
<?php namespace App\Model;

use App\Lib\Config;

class Posts
{
    private static $DATA = [];

    public static function all()
    {
        return self::$DATA;
    }

    public static function add($post)
    {
        $post->id = count(self::$DATA) + 1;
        self::$DATA[] = $post;
        self::save();
        return $post;
    }

    public static function findById(int $id)
    {
        foreach (self::$DATA as $post) {
            if ($post->id === $id) {
                return $post;
            }
        }
        return [];
    }

    public static function load()
    {
        $DB_PATH = Config::get('DB_PATH', __DIR__ . '/../../db.json');
        self::$DATA = json_decode(file_get_contents($DB_PATH));
    }

    public static function save()
    {
        $DB_PATH = Config::get('DB_PATH', __DIR__ . '/../../db.json');
        file_put_contents($DB_PATH, json_encode(self::$DATA, JSON_PRETTY_PRINT));
    }
}
```

---

## Laravel

---

```bash=
php artisan make:model -a --api post
```

---

![](https://i.imgur.com/HRMBQvc.png =700x)

---

![](https://i.imgur.com/KcEwkNl.png =700x)


---

![](https://i.imgur.com/T74Lvbd.png =700x)

---

Composer.json

```json=
{
"name": "laravel/laravel",
"type": "project",
"description": "The Laravel Framework.",
"keywords": [
    "framework",
    "laravel"
],
"license": "MIT",
"require": {
    "php": "^7.3",
    "fideloper/proxy": "^4.2",
    "fruitcake/laravel-cors": "^2.0",
    "guzzlehttp/guzzle": "^7.0.1",
    "laravel/framework": "^8.0",
    "laravel/tinker": "^2.0"
},
"require-dev": {
    "facade/ignition": "^2.3.6",
    "fzaninotto/faker": "^1.9.1",
    "mockery/mockery": "^1.3.1",
    "nunomaduro/collision": "^5.0",
    "phpunit/phpunit": "^9.3"
},
"config": {
    "optimize-autoloader": true,
    "preferred-install": "dist",
    "sort-packages": true
},
"extra": {
    "laravel": {
        "dont-discover": []
    }
},
"autoload": {
    "psr-4": {
        "App\\": "app/",
        "Database\\Factories\\": "database/factories/",
        "Database\\Seeders\\": "database/seeders/"
    }
},
"autoload-dev": {
    "psr-4": {
        "Tests\\": "tests/"
    }
},
"minimum-stability": "dev",
"prefer-stable": true,
"scripts": {
    "post-autoload-dump": [
        "Illuminate\\Foundation\\ComposerScripts::postAutoloadDump",
        "@php artisan package:discover --ansi"
    ],
    "post-root-package-install": [
        "@php -r \"file_exists('.env') || copy('.env.example', '.env');\""
    ],
    "post-create-project-cmd": [
        "@php artisan key:generate --ansi"
    ]
}
}
```

---

## Symfony

---

```bash=
php bin/console generate:doctrine:crud \
    AcmeBlogBundle:Post
```

---

Composer.json

```json=
{
"type": "project",
"license": "proprietary",
"require": {
    "php": ">=7.2.5",
    "ext-ctype": "*",
    "ext-iconv": "*",
    "symfony/console": "5.1.*",
    "symfony/dotenv": "5.1.*",
    "symfony/flex": "^1.3.1",
    "symfony/framework-bundle": "5.1.*",
    "symfony/yaml": "5.1.*"
},
"require-dev": {
    "symfony/maker-bundle": "^1.21"
},
"config": {
    "optimize-autoloader": true,
    "preferred-install": {
        "*": "dist"
    },
    "sort-packages": true
},
"autoload": {
    "psr-4": {
        "App\\": "src/"
    }
},
"autoload-dev": {
    "psr-4": {
        "App\\Tests\\": "tests/"
    }
},
"replace": {
    "paragonie/random_compat": "2.*",
    "symfony/polyfill-ctype": "*",
    "symfony/polyfill-iconv": "*",
    "symfony/polyfill-php72": "*",
    "symfony/polyfill-php71": "*",
    "symfony/polyfill-php70": "*",
    "symfony/polyfill-php56": "*"
},
"scripts": {
    "auto-scripts": {
        "cache:clear": "symfony-cmd",
        "assets:install %PUBLIC_DIR%": "symfony-cmd"
    },
    "post-install-cmd": [
        "@auto-scripts"
    ],
    "post-update-cmd": [
        "@auto-scripts"
    ]
},
"conflict": {
    "symfony/symfony": "*"
},
"extra": {
    "symfony": {
        "allow-contrib": false,
        "require": "5.1.*"
    }
}
}
```

---

Positivos 

* Tudo pronto
* Iniciar um projeto é muito fácil
* Resolução de bugs/atualização constantes

---

Nagativos 

* Mais pesado
* Você não sabe o que estão fazendo por baixo dos panos
* Você está usando tudo que tem nele?

---

![](https://i.imgur.com/1JfFbLZ.png =500x)

---

Concluindo!

* Utilizarei o quê o framework me oferece?
* Preciso de banco de dados?
* Preciso de rotas?
* Será uma api ou um monolito?

---

Referências

* https://kevinsmith.io/modern-php-without-a-framework
* https://tableless.com.br/composer-para-iniciantes/
* https://dev.to/dhgouveia/write-modern-php-without-a-framework-5409
* https://www.cloudways.com/blog/php-libraries/



Por que usar framework?


No começo sua aplicação era perfeita

---

Sua aplicação vai mudar. E pode virar uma bagunça.

---

O design pode salvá-lo

Mas como?

![Design Stamina Hypothesis](/images/posts/design_stamina_hypothesis.png)

### Quais são os indicios de um design ruim?

*Rígido*

Difícil de mudar (cada mudança causa muitas mudanças em outras partes do sistema)

*Frágil*

Facilmente quebrável (Cada mudança quebra coisas distantes e não relacionadas)

*Imóvel*

Reutilizar é impossível (o código está irremediavelmente emaranhado)

*Viscoso*

Dureza na preservação do design (fazer as coisas certas é mais difícil do que fazer as coisas erradas)

### O que é SOLID

Isso nos ajuda a escrever um código com:

- Injeção de dependência
- Responsabilidade única
- Pode ser reorganizado
- Reutilizável
- Facilmente testável

- *S*ingle Responsibility
- *O*pen Closed
- *L*iskov Substitution
- *I*nterface Segregation
- *D*ependency Inversion

### Principio da Responsábilidade unica

Nunca deve haver mais de um motivo para uma classe mudar.

```ruby
class FinancialReportMailer
  def initialize(transactions, account)
    @transactions = transactions
    @account = account
    @report = ''
  end

  def generate_report!
    @report = @transactions.map {
      |t| "amount: #{t.amount} type: #{t.type} date: #{t.created_at}"
    }.join("\n")
  end

  def send_report
    Mailer.deliver(
      from: 'reporter@example.com',
      to: @account.email,
      subject: 'your report',
      body: @report
    )
  end
end

mailer = FinancialReportMailer.new(transactions, account)
mailer.generate_report!
mailer.send_report
```

```ruby
class FinancialReportMailer
  def initialize(report, account)
    @report = report
    @account = account
  end

  def deliver
    Mailer.deliver(
      from: 'reporter@example.com',
      to: @account.email,
      subject: 'Financial report',
      body: @report
    )
  end
end

class FinancialReportGenerator
  def initialize(transactions)
    @transactions = transactions
  end

  def generate
    @transactions.map { |t| "amount: #{t.amount} type: #{t.type} date: #{t.created_at}"
    }.join("\n")
  end
end

report = FinancialReportGenerator.new(transactions).generate
FinancialReportMailer.new(report, account).deliver
```

### Principio Aberto-Fechado
[Open Closed Principle]

* Um módulo deve ser aberto para extensão, mas fechado para modificação

```ruby
class Logger
  def initialize(format, delivery)
    @format = format
    @delivery = delivery
  end

  def log(string)
    deliver format(string)
  end

  private

  def format(string)
    case @format
    when :raw
      string
    when :with_date
      "#{Time.now} #{string}"
    when :with_date_and_details
      "Log was creates at #{Time.now}, please check details #{string}"
    else
      raise NotImplementedError
    end
  end

  def deliver(text)
    case @delivery
    when :by_email
      Mailer.deliver(
        from: 'emergency@example.com',
        to: 'admin@example.com',
        subject: 'Logger report',
        body: text
      )
    when :by_sms
      client = Twilio::REST::Client.new('ACXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX', 'your_auth_token')
      client.account.messages.create(
        from: '+15017250604',
        to: '+15558675309',
        body: text
      )
    when :to_stdout
      STDOUT.write(text)
    else
      raise NotImplementedError
    end
  end
end

logger = Logger.new(:raw, :by_sms)
logger.log('Emergency error! Please fix me!')
```

```ruby
class Logger
  def initialize(formatter: DateDetailsFormatter.new, sender: LogWriter.new)
    @formatter = formatter
    @sender = sender
  end

  def log(string)
    @sender.deliver @formatter.format(string)
  end
end

class LogSms
  def initialize
    @account_sid = 'ACXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX'
    @auth_token = 'your_auth_token'
    @from = '+15017250604'
    @to = '+15558675309'
  end

  def deliver(text)
    client.account.messages.create(from: @from, to: @to, body: text)
  end

  private

  def client
    @client ||= Twilio::REST::Client.new(@account_sid, @auth_token)
  end
end

class LogMailer
  def initialize
    @from = 'emergency@example.com'
    @to = 'admin@example.com'
    @sublect = 'Logger report'
  end

  def deliver(text)
    Mailer.deliver(
      from: @from,
      to: @to,
      subject: @sublect,
      body: text
    )
  end
end

class LogWriter
  def deliver(log)
    STDOUT.write(text)
  end
end

class DateFormatter
  def format(string)
    "#{Time.now} #{string}"
  end
end

class DateDetailsFormatter
  def format(string)
    "Log was creates at #{Time.now}, please check details #{string}"
  end
end

class RawFormatter
  def format(string)
    string
  end
end

logger = Logger.new(formatter: RawFormatter.new, sender: LogSms.new)
logger.log('Emergency error! Please fix me!')
```

### Principio da substituição de Liskov
[Liskov Substitution Principle]

As subclasses devem ser substituíveis por suas classes base

```ruby
class UserStatistic
  def initialize(user)
    @user = user
  end

  def posts
    @user.blog.posts
  end
end

class AdminStatistic < UserStatistic
  def posts
    user_posts = super

    string = ''
    user_posts.each do |post|
      string += "title: #{post.title} author: #{post.author}\n" if post.popular?
    end

    string
  end
end
```

```ruby
class UserStatistic
  def initialize(user)
    @user = user
  end

  def posts
    @user.blog.posts
  end
end

class AdminStatistic < UserStatistic
  def posts
    user_posts = super
    user_posts.select { |post| post.popular? }
  end

  def formatted_posts
    posts.map { |post| "title: #{post.title} author: #{post.author}" }.join("\n")
  end
end
```

### Principio da segregação da interface
[Interface Segregation Principle]

Muitas interfaces específicas do cliente são melhores do que uma interface de propósito geral

```ruby
class CoffeeMachineInterface
  def select_drink_type
      # select drink type logic
  end

  def select_portion
     # select portion logic
  end

  def select_sugar_amount
     # select sugar logic
  end

  def brew_coffee
     # brew coffee logic
  end

  def clean_coffee_machine
    # clean coffee machine logic
  end

  def fill_coffee_beans
    # fill coffee beans logic
  end

  def fill_water_supply
    # fill water logic
  end

  def fill_sugar_supply
    # fill sugar logic
  end
end

class Person
  def initialize
    @coffee_machine = CoffeeMachineInterface.new
  end

  def make_coffee
    @coffee_machine.select_drink_type
    @coffee_machine.select_portion
    @coffee_machine.select_sugar_amount
    @coffee_machine.brew_coffee
  end
end

class Staff
  def initialize
    @coffee_machine = CoffeeMachineInterface.new
  end

  def serv
    @coffee_machine.clean_coffee_machine
    @coffee_machine.fill_coffee_beans
    @coffee_machine.fill_water_supply
    @coffee_machine.fill_sugar_supply
  end
end
```

```ruby
class CoffeeMachineUserInterface
  def select_drink_type
      # select drink type logic
  end

  def select_portion
     # select portion logic
  end

  def select_sugar_amount
     # select sugar logic
  end

  def brew_coffee
     # brew coffee logic
  end
end

class CoffeeMachineServiceInterface
  def clean_coffee_machine
    # clean coffee machine logic
  end

  def fill_coffee_beans
    # fill coffee beans logic
  end

  def fill_water_supply
    # fill water logic
  end

  def fill_sugar_supply
    # fill sugar logic
  end
end

class Person
  def initialize
    @coffee_machine = CoffeeMachineUserInterface.new
  end

  def make_coffee
    @coffee_machine.select_drink_type
    @coffee_machine.select_portion
    @coffee_machine.select_sugar_amount
    @coffee_machine.brew_coffee
  end
end

class Staff
  def initialize
    @coffee_machine = CoffeeMachineServiceInterface.new
  end

  def serv
    @coffee_machine.clean_coffee_machine
    @coffee_machine.fill_coffee_beans
    @coffee_machine.fill_water_supply
    @coffee_machine.fill_sugar_supply
  end
end
```

### Principio da inversão da dependencia
[Dependency Inversion Principle]

Depende de abstrações. Não dependa de concreções

```ruby
class Printer
  def initialize(data)
    @data = data
  end

  def print_pdf
    PdfFormatter.new.format(@data)
  end

  def print_html
    HtmlFormatter.new.format(@data)
  end
end

class PdfFormatter
  def format(data)
    # format data to Pdf logic
  end
end

class HtmlFormatter
  def format(data)
    # format data to Html logic
  end
end
```

```ruby
class Printer
  def initialize(data)
    @data = data
  end

  def print(formatter: PdfFormatter.new)
    formatter.format(@data)
  end
end

class PdfFormatter
  def format(data)
    # format data to Pdf logic
  end
end

class HtmlFormatter
  def format(data)
    # format data to Html logic
  end
end
```

### Porque Designer

*TDD* não é suficiente
*DRY* não é suficiente

*Projete* porque você espera que seu aplicativo tenha sucesso (e mude no futuro)

### Referências

[Sandy Metz - SOLID Design Principle in Ruby](https://www.youtube.com/watch?v=v-2yFMzxqwU)

[SOLID com TypeScript // Live #37](https://www.youtube.com/watch?v=899Qa6sQcRc)

[SOLID (O básico para você programar melhor) // Dicionário do Programador](https://www.youtube.com/watch?v=mkx0CdWiPRA)

[SOLID Object-Oriented Design Principles](https://rubygarage.org/blog/solid-principles-of-ood)

[SOLID Object-Oriented Design](https://speakerdeck.com/anildigital/solid-design-principles-in-ruby?slide=2)

Solid e Rails - Aplicando no dia a dia


## O que é Pattern

---

Design Patterns ou padrões de projetos são soluções generalistas para problemas recorrentes durante o desenvolvimento de um software. Não se trata de um framework ou um código pronto, mas de uma definição de alto nível de como um problema comum pode ser solucionado

---

![](https://i.imgur.com/28TXaiq.png)

https://refactoring.guru/

---

## O que é Repository

---

Faz a mediação entre o domínio e as camadas de mapeamento de dados usando uma interface semelhante a coleção para acessar objetos de domínio.

---

## Qual problema Resolve

---

* Modelos inchados 
* Teste unitários
* Dependency Injection

---

## Pontos positivos

* Chamadas de banco de dados separadas da lógica de negócios
* Interface agradável, descritiva e facilmente testável
* Modelos e controladores finos
* Responsabilidades únicas
* Separação de preocupações

---

## Melhor Ainda

* Divida repositórios em consultas e comandos
* Construa suas próprias entidades
* Livre-se completamente do ActiveRecord

---

## Como aplicar no meu porjeto 

---

```ruby=
class Post < ActiveRecord::Base
  has_many :comments, dependent: :destroy
end
```

```ruby=
class PostRepository
  
end
```

---

## Refatorando o codigo

---

```ruby=
class PostsController < ApplicationController
  def index
    render Post.list
  end
  
  def show
    render Post.show_with_domain(id)
  end
end
```

---

```ruby=
class Post < ActiveRecord::Base
  has_many :comments, dependent: :destroy

  def self.list
    self.select('posts.*, count(comments.id)')
        .joins(:comments)
        .order(created_at: :desc)
  end
  
  def self.show_with_domain(id)
    post = self.where(id: id)
    comments = self.joins(:comments)
                    .where(id: id)
      
    post.comments = comments
  end
end
```

---

```ruby=
class PostsController < ApplicationController
  def index
    render PostRepository.list
  end
  
  def show
    render PostRepository.show_with_domain(id)
  end
end
```

```ruby=
class Post < ActiveRecord::Base
  has_many :comments, dependent: :destroy
  belongs_to :author
end
```

---

```ruby=
class PostRepository
    class self
      def list
        Post.select('posts.*, count(comments.id), authors.name')
            .joins(:comment)
            .joins(:author)
            .order(created_at: :desc)
      end

      def show_with_domain(id)
        post = self.where(id: id)
        comments = self.joins(:comments)
                        .where(id: id)

        post.comments = comments
      end
  end
end
```

---

## Referências

https://www.monterail.com/blog/repository-pattern-active-record


----

Neste curso, ele utiliza a model com alguns metodos simples e cria um repositorio para colocar a regra de negocio, de instalação de atualização.

https://www.destroyallsoftware.com/screencasts/catalog/what-goes-in-active-records
https://www.destroyallsoftware.com/screencasts/catalog/what-goes-in-active-records-part-2

Apenas a descrição conseitual do Pattern

https://martinfowler.com/eaaCatalog/repository.html

Para de carregar o Active records no model e carrega parte dele no repository e parte no model

https://www.youtube.com/watch?v=36LB8bfEeVc

Neste, não tem nenhum codigo no modelo, apenas no repositoy

https://www.monterail.com/blog/repository-pattern-active-record

Neste, utiliza o repository junto com interfaces e registry

https://medium.com/@laertis.pappas/repository-pattern-in-ruby-i-decoupling-activerecord-and-persistence-e395e1b0cf69

Exemplo em Laravel - PHP

https://www.youtube.com/watch?v=CqsJPn6uNB8
https://www.youtube.com/watch?v=93ZhGkFIwbA

Livros

https://www.oreilly.com/library/view/patterns-of-enterprise/0321127420/

---

## Livros

![](https://i.imgur.com/hXSWilY.png =200x)

![](https://i.imgur.com/t4YZEuM.png =200x)


Utilizando Repository Pattern no Ruby on Rails


Thank you for contacting me! I will get back in touch with you soon.

**Have a great day!**
