DEV Community: Iago Effting

Configurando NeoVim + Elixir

Iago Effting — Tue, 21 May 2024 18:20:25 +0000

Introdução

De idas e vindas acabei trabalhando muito tempo com elixir no VS Code. Até então tudo certo. De um tempo para cá, comecei a sentir lentidão no autocomplete e dificuldade de utilizar algumas ferramentas. Isso me levou a fazer essa pergunta no twitter / X.

// Detect dark theme var iframe = document.getElementById('tweet-1791535928894230872-963'); if (document.body.className.includes('dark-theme')) { iframe.src = "https://platform.twitter.com/embed/Tweet.html?id=1791535928894230872&theme=dark" }

Trabalhei a alguns anos atrás com VIM e no geral gostava dele, mas achava complexo a configuração e customização. Com isso em mente fui ver como funcionava a configuração do Nvim que muitos comentaram na thread. Fui atras também de um jeito fácil de configurar e encontrei o Astronvim que me interessou bastante. Tendo isso em mãos, iniciei o setup.

Configuração

NeoVim
AstroNvim
Elixir-tools

Instalações

Requisitos

Requisitos	Versão
neovim	0.9.5+

NeoVim

A versão estável atual do Nvim é o 0.7.x, porém, Astronvim pede 0.8+. Isso buscando das versões não estáveis. Tendei diretamente pelo repositório unstable e instalar a versão nighty. Porém, me trouxe muitos problemas que não tive paciência para ir em frente. Foi então que me lembrei do gerencias asdf e por ele ficou mais simples

Repositório: https://github.com/richin13/asdf-neovim



asdf plugin add neovim
asdf install neovim 0.10.0

Feito. Nvim instalado. Porém, se você rodar o nvim agora, ele vai receber o erro



No version is set for command nvim

Precisamos definir a versão padrão para a ferramenta. Caso não exista, precisamos criar o arquivo no root do seu usuário. ~/.tool-versions e adicione no conteúdo a ferramenta e a versão



neovim 0.10.0

Com isso, podemos rodar o comando e abrir a ferramenta



nvim

AstroNvim

Astro é uma ferramenta que une extensibilidade com gerenciamento de plugin utilizando o Mason. Ele facilita a adição de novos plugins e o gerenciamento de dependencia e configurações, por isso decidi usar ele.

E tive uma boa impressão. ele é simples de rodar, basta seguir o guia oficial e tudo funciona como deveria.

A configuração é simples



git clone --depth 1 https://github.com/AstroNvim/template ~/.config/nvim # baixa e coloca a configuração no local certo
rm -rf ~/.config/nvim/.git # Remove o .git do que foi clonado

⚠ Uma atualização no AstroLSP está quebrando o template acima. Para resolver isso simplesmente substitui pela configuração da doc. Caso você tenha feito alguma alteração, vai precisar fazer um de para =D

Depois disso, bastou rodar o nvim e ele já saiu funcionando



nvim

Você pode receber o erro que não encontrou o compilador C. Para isso precisa ter as dependêmncias base. No linux temos o pacote essencial.



 sudo apt-get install build-essential

Depois disso só abrir novamente o nvim e o erro deve ter sumido.

Ao abrir, ele começa a instalar as dependências automaticamente. Lindo demais <3

Talvez você tenha problema com a font e icones. Para isso, instale a nerdfonts no link.

Eu instalei a font 0xProto Nerd Font e ficou bom para mim =D

Elixir-tools

Precisei adicionar suporte a linguagem. Para minha surpresa, foi fácil. Existe esse plugin para NeoVim que da suporte a tudo que precisamos do elixir o Elixir-tools

Para isso precisamos acessar a pasta de configuração do nvim, mesmo lugar que fizemos o clone do astro.



cd ~/.config/nvim

Essa é a estrutura das configurações



.nvim/
├─ lua/
│  ├─ plugins/
│  │  ├─ ...
│  ├─ community.lua
│  ├─ lazy_setup.lua
│  ├─ polish.lua
.neoconf.json
.stylua.toml
init.lua
lazy-lock.json
neovim.yml
README.md
selene.toml

De forma visual, fica fácil saber onde adicionar um plugin, não? Criei um novo arquivo dentro de .nvim/lua/plugins/ e o chamei de elixir.lua.

Dentro da documentação do plugin elixir-tools, tem uma seção de configuração usando o lazy.nvim, resolvi usar ele.

Dentro do arquivo .nvim/lua/plugins/elixir.lua adicionei a configuração para o lazy e um retorno para devolver a configuração



return {
  "elixir-tools/elixir-tools.nvim",
  version = "*",
  event = { "BufReadPre", "BufNewFile" },
  config = function()
    local elixir = require("elixir")
    local elixirls = require("elixir.elixirls")

    elixir.setup {
      nextls = {enable = false},
      credo = {},
      elixirls = {
        enable = true,
        settings = elixirls.settings {
          dialyzerEnabled = false,
          enableTestLenses = true,
        },
        on_attach = function(client, bufnr)
          vim.keymap.set("n", "<space>fp", ":ElixirFromPipe<cr>", { buffer = true, noremap = true })
          vim.keymap.set("n", "<space>tp", ":ElixirToPipe<cr>", { buffer = true, noremap = true })
          vim.keymap.set("v", "<space>em", ":ElixirExpandMacro<cr>", { buffer = true, noremap = true })
        end,
      }
    }
  end,
  dependencies = {
    "nvim-lua/plenary.nvim",
  },
}

feito isso, fechei meu nvim e abri ele diretamente em um arquivo elixir.



nvim some_place/file.ex

Ele começou a perguntar se queria instalar o

nextls
Credo Language Server
ElixirLS

E eu, so aceitei. Feito isso, tudo funcionou bem.

Problemas

Versão do NeoVim 0,11+ me dava muitos warnings que resolvi voltando para a 0.10 usando asdf
Tive problema de permissão também, resolvido mudando a permissão da pasta.

Agradecimentos

A thread teve vários comentários e queria agradecer todos que participaram <3

Dicas e truques Elixir lang

Iago Effting — Thu, 03 Nov 2022 13:00:56 +0000

Última atualização: 01/10/2022
Elixir: 1.14

Uma rápida e importante introdução

Esse artigo está vivo! Vou revisita-lo no momento onde achar conveniente, seja quando precisar atualizar ou corrigir algo. Se algo mudar na linguagem onde possamos tirar um maior proveito, eu irei reescrever parte do artigo e não criarei um segundo, utilizarei sempre esse =D

Bora lá!

Dicas&Truques

Funções anónimas e Pattern match
Utilizando pipeline e with
Guard clause

Pattern match e Funções anónimas

Quando seu código precisa se mover livremente, de acordo com o tipo e/ou valor de dados de entrada, a primeira coisa que brota em nossas cabeças são condicionais, certo? O que faz total sentido. Por exemplo:

# usando condicional case
users = [
  %{role: :admin},
  %{role: :customer},
  %{role: :member}
]

Enum.map(users, fn user -> 
  case user do
    %{role: :admin} -> :admin,
    %{role: :customer} -> :customer,
    _user -> :unknown
  end
end)

Já utilizamos pattern match ali em cima na condição de cada case, mas podemos extrair um pouco mais dele quando utilizamos funções anónimas.

Temos um truque que deixa as coisas mais emocionante e conciso. Você não precisa do escopo da função definido, basta resolver tudo diretamente nos parâmetros dela:

# usando pattern match na função anónima
users = [
  %{role: :admin},
  %{role: :customer},
  %{role: :member}
]

Enum.map(users, fn
  %{role: :admin} -> :admin
  %{role: :customer} -> :customer
  _user -> :unknown           
 end)

⚠ Lembrando ⚠: Isso só funciona com funções anónimas. Funções nomeadas precisam da definição de seu escopo.

Declaração With e legibilidade

Quando encontramos algo novo que gostamos, usamos em todos os lugares ou mostramos para todas as pessoas.

Pipes foram assim para mim. Achei eles tão bonitos que queria usar para tudo. Mas ai coisas assim aconteciam:

# usando pipes
def update(id, params) do
  id
  |> get_user()
  |> validate_user(params)
  |> update_user()
  |> handle_response()
end

A primeira vista é bonito, passa rapidamente o propósito dos pipes e o que queremos atingir, mas nos trás algumas complicações.

O dado que passa por todos os pipes devem ser o mesmo ou a próxima função do pipe deve saber qual é a resposta da anterior. Então Pablito sabe demais.
O tratamento de erro vai para dentro da próxima função ou o pipe quebra. Caso get_user retorne um {:error, reason} quem irá tratar vai ser o validate_user o que é estranho.

Caso sintam algum desses problemas, o elixir consegue nos ajudar. Existe uma função chamada with que irá nos dar uma mão.

A mesma lógica, mas feita com with:

# usando with com tratamento de erros
def update(id, params) do
  with {:ok, user} <- get_user(id),
       {:ok, user_validate} <- validate_user(user, params),
       {:ok, user_updated} <- update_user(user_validated) do
    {:ok, user_updated} # <-- aqui está nossa resposta do with
  else
    {:error, :not_found} -> {:error, "User not found"}
    {:error, :unprocessable_entity} -> {:error, "Params are wrong"}
    {:error, :duplicated_user} -> {:error, "User need to be unique"} 
    error -> error
  end
end

O código se torna maior, mas ganhamos algumas coisas:

as funções subsequentes não precisam entender nada das anteriores e vice-versa.
O tratamento de erro sai da função. Uma vez que a pattern match não se satisfazer pela definição do with como no exemplo with {:ok, user} <- get_user(id) o with vai parar e cair no escopo else onde podemos fazer tratamentos utilizando diretamente o pattern match.

Também podemos isolar os erros, onde o tratamento passa a ser feito por outro modulo. O phoenix faz isso com os controllers, chamando a estratégia de fallback_controller deixando o código limpo e claro.

Resultado:

# usando with simplificado
def update(id, params) do
  with {:ok, user} <- get_user(id),
       {:ok, user_validate} <- validate_user(user, params),
       {:ok, user_updated} <- update_user(user_validated) do
    {:ok, user_updated} # <-- aqui está nossa resposta do with
  end
end

Obs.: Gosto de pipes, de verdade. Mas utilizo eles onde tenho um controle mais restrito, isso é um gosto meu. Não seria um problema para mim, por exemplo, utilizar o pipe dentro de user_validate onde eu tenho controle de tudo. Mas uma vez que eu pegue funções de módulos diferente, acabo tentando tentando desacoplar lógica de dentro das funções que não a pertencem. É uma escolha minha e que me ajudou até então. Existem outras formas, essa é apenas uma delas.

Guard clause

Eu particularmente gosto dessa. Vamos supor que precisamos que um dado dentro de um map e esse dado esteja bem dentro, uns 3 níveis. Com esse dado eu tenho que saber o que irei fazer em seguida. O fluxo se alteraria dependendo dele. Como podemos resolver isso? A forma mais clássica é utilizando cond.

Vamos a um exemplo.

# usando condicional cond
def func(data) do
  cond do
    is_integer(data.inside.far.away) -> IO.inspect("Integer: #{data.inside.far.away}")
    is_bitstring(data.inside.far.away) -> IO.inspect("String: #{data.inside.far.away}")
    _ -> IO.inspect("I don't know what hack is that: #{data.inside.far.away}")
  end
end

Relativamente elegante, porém meio grande certo? Utiliza boas funções para fazer o desvio de fluxo. Porém, alguns problemas aparecem:

Essa função vai crescer com a quantidade de N tratamentos que precisarmos (se fosse por aqui o SOLID iria ferir o open/close principle, mas falaremos disso talvez uma outra hora).
Fazer dessa forma pode dificultar a criação de tests devido a dificuldade de gerar o cenário (ainda esta simples ali, mas pense nas infinitas possibilidades)
Também teremos que nos certificar de que quando essa função mudar, todos os cenários podem mudar junto, mesmo não tendo uma relação.
em alguma hora a leitura será prejudicada também. Facilmente vejo essa função crescer pra mais de 200 linhas and beyond.

Podemos resolver isso usando algo chamado guard clause diretamente na definição da função. E a leitura fica linda:

# utilizando guard clause e pattern match
def func(%{data: %{inside: value}}) when is_integer(value) do
  IO.inspect("Integer: #{value}")
end

def func(%{data: %{inside: value}}) when is_bitstring(value) do
  IO.inspect("String: #{value}")
end

def func(data) do
  IO.inspect("I don't know what the hack is that: #{value}")
end

o interessante disso é:

A leitura fica simples
Podemos facilmente trocar de módulos cada um deles, caso a implementação cresça
Mantemos um contrato claro do que precisamos para a função funcionar.

⚠ Lembrando ⚠: Guard clause so funcionam com tipos primitivos e não funcionam com funções de módules, como por exemplo:

# exemplos de utilização de guard clause
def display(a) when is_integer(a), do: # ... ✅
def display(a) when is_integer(a), do: # ... ✅
def display(a) when a > 10, do: # ... ✅

def display(a) when MyModule.check(a), do: # ... ❌

Aqui esta uma lista do que ele permite.

Conclusão

Todas essas dicas devem ser pensadas e levado em consideração o cenário que será utilizado. O importante é facilitar a vida do programador ao realizar alguma manutenção (não so você, como todo o seu time e futuro membros). Se a escolha for consciente, você estará bem para ir, caso não, você vai se transformar em um desenvolvedor que deseja fazer tudo inline ou com menos código, e isso é muito sério, você mata a facilidade de entendimento e leitura de código por causa de ego. Não seja assim.

Caso você esteja consciente disso, divirta-se refatornando trechos de códigos difíceis de ler e veja se alguma dessas dicas lhe foi útil, caso tenha sido, conte para nós nos comentários.

Já que você chegou até aqui, se inscreva no Café com Elixir uma newsletter semanal de Elixir focado em conteúdos da comunidade brasileira.

Me sigam também no twitter @iagoEffting lá sou mais ativo =D

E se inscrevam no canal no youtube

Como utilizar generators no Phoenix

Iago Effting — Thu, 27 Oct 2022 19:22:00 +0000

Quando acordamos de manhã cedo e pensamos em fazer nossa mais nova ideia milionária, sempre vem na cabeça (pelo menos na minha) em colocar esse produto em uma aplicação web, para facilitar o acesso.

No mundo Elixir uma das melhores ferramentas para construir isso é o Phoenix Framework. Ele possui todas as funcionalidades que precisamos e muito mais.

Convenhamos que ideias vem o tempo todo e queremos faze-las e valida-las o mais rápido possível antes que percamos o foco (ou a vontade). Mas, como podemos acelerar o processo de criação?

Phoenix possui uma gama de generators que podem te ajudam a gerar código de problemas comuns, que basicamente se repetem ao longo da história e é sobre os generators que eu falarei aqui.

O que veremos?

Gerando uma nova aplicação web com mix phx.new ...
Gerando contexto, controller, views e html com mix phx.gen.html
Gerando autenticação com mix phx.gen.auth
Protegendo rotas com autenticação

Para iniciar, essa é a ideia milionária:

Desafio de hoje: Na nossa mais nova ideia, precisamos criar um painel administrativo onde possamos cadastrar filmes. Os campos necessários são title e description. Nossos usuários precisarão estar logado para interagir com o sistema.

Requisitos tecnológicos

Criando nossa aplicação

Nossa aplicação terá a necessidade de um banco de dados (utilizaremos o postgres), também o suporte a HTML.

O primeiro gerador que utilizaremos dará conta dissoPodemos passar comandos simples para o cli do phoenix configurar isso para nós:

mix phx.new my_movies --database postgres --no-live

...
* creating my_movies/lib/my_movies/mailer.ex
* creating my_movies/lib/my_movies_web/gettext.ex
* creating my_movies/priv/gettext/en/LC_MESSAGES/errors.po
* creating my_movies/priv/gettext/errors.pot
* creating my_movies/assets/css/phoenix.css
* creating my_movies/assets/css/app.css
* creating my_movies/assets/js/app.js
* creating my_movies/priv/static/robots.txt
* creating my_movies/priv/static/images/phoenix.png
* creating my_movies/priv/static/favicon.ico

Fetch and install dependencies? [Yn]

O --no-live diz para nosso gerador que não utilizaremos live view. O --database seta para nós o banco que utilizaremos (potgres é o default, então não precisaria dele ali, mas para deixar mais claro, adicionei. Também da suporte a mysql a mssql, sqlite3 e outros.

No fim da operação o terminal ira perguntar se quer instalar as dependências. Pode ser feito depois, mas eu ja apertei Y aqui enquanto tomava um gole de café.

Fetch and install dependencies? [Yn] Y
* running mix deps.get
* running mix deps.compile

We are almost there! The following steps are missing:

    $ cd my_movies

Then configure your database in config/dev.exs and run:

    $ mix ecto.create

Start your Phoenix app with:

    $ mix phx.server

You can also run your app inside IEx (Interactive Elixir) as:

    $ iex -S mix phx.server

Finalizando o processo devemos entrar na pasta do projeto.

cd my_movies

Agora falta so configurar o banco de dados em config/dev.exs. Eu uso para fins de estudo o default, então meu está igual ao gerado.

config :my_movies, MyMovies.Repo,
  username: "postgres",
  password: "postgres",
  hostname: "localhost",
  database: "my_movies_dev",
  stacktrace: true,
  show_sensitive_data_on_connection_error: true,
  pool_size: 10

De volta ao terminal, precisamos rodar o setup da aplicação para conseguir executar ela. Utilizarei o comando mix setup onde ele ja vai fazer para mim o mix deps.get e mix ecto.setup (que vai criar o banco para nós e rodar a migration caso tenha)

mix setup

Compiling 14 files (.ex)
Generated my_movies app
The database for MyMovies.Repo has already been created

14:25:38.948 [info] Migrations already up

Não se preocupe com o warning do gettext ele não morde. Porém se voce se incomodar com o warning pode ir no mix.exs e remover ele do compilers.

Pronto, tudo configurado e bom para ir. Para garantir vitória so executar o comando de inicializar o nosso server:

mix phx.server

[info] Running MyMoviesWeb.Endpoint with cowboy 2.9.0 at 127.0.0.1:4000 (http)
[debug] Downloading esbuild from https://registry.npmjs.org/esbuild-darwin-64/-/esbuild-darwin-64-0.14.29.tgz
[info] Access MyMoviesWeb.Endpoint at http://localhost:4000
[watch] build finished, watching for changes..

Podemos então abrir nossa aplicação no browser http://localhost:4000. Vai, clica ai, confia.

Proximo passo: Criar nossa página para cadastrar, ler, editar e deletar um filme. (famoso CRUD)

e ai que entra nosso primeiro generate.

Segura ai, ainda não iremos tocar no código.

Na documentação do Phoenix temos outros generators que podem nos ser útil. Em nosso CRUD precisamos do pacote completo:

schema: A estrutura de nosso Filme
migration: O comando para criar a sua tabela no banco de dados
context: um lugar para ele viver
controller: um lugar para acessar ele
view: uma forma de alterar sua exibição

Dois generator atendem a esse requisito:

phx.gen.json
phx.gen.html

Agora vai de você escolher como voce vai expor seu programa. Nós aqui iremos utilizar HTML, logo phx.gen.html será utilizado.

Nossa regra para isso será:

Temos um catalogo
No catalogo podemos adicionar, ver, listar e deletar filmes
os filmes terão titulo e descrição apenas
os filmes serão salvos na tabela movies no banco de dados

Bora para o terminal:

mix phx.gen.html Catalog Movie movies title:string description:string

* creating lib/my_movies_web/controllers/movie_controller.ex
* creating lib/my_movies_web/templates/movie/edit.html.heex
* creating lib/my_movies_web/templates/movie/form.html.heex
* creating lib/my_movies_web/templates/movie/index.html.heex
* creating lib/my_movies_web/templates/movie/new.html.heex
* creating lib/my_movies_web/templates/movie/show.html.heex
* creating lib/my_movies_web/views/movie_view.ex
* creating test/my_movies_web/controllers/movie_controller_test.exs
* creating lib/my_movies/catalog/movie.ex
* creating priv/repo/migrations/20221027161657_create_movies.exs
* creating lib/my_movies/catalog.ex
* injecting lib/my_movies/catalog.ex
* creating test/my_movies/catalog_test.exs
* injecting test/my_movies/catalog_test.exs
* creating test/support/fixtures/catalog_fixtures.ex
* injecting test/support/fixtures/catalog_fixtures.ex

Add the resource to your browser scope in lib/my_movies_web/router.ex:

    resources "/movies", MovieController


Remember to update your repository by running migrations:

    $ mix ecto.migrate

No final do comando ele pede para fazer algumas ações.

Adicionar o resources "/movies", MovieController em nossas rotas lib/my_movies_web/router.ex. Iremos colocar em acesso publico (sem restrição por não estar logado)

# ...
scope "/", MyMoviesWeb do
  pipe_through :browser

  get "/", PageController, :index
  resources "/movies", MovieController # adicione essa linha
end
# ...

rodar a migração que o gerador criou para nós.

mix ecto.migrate

13:26:53.578 [info] == Running 20221027161657 MyMovies.Repo.Migrations.CreateMovies.change/0 forward

13:26:53.581 [info] create table movies

13:26:53.597 [info] == Migrated 20221027161657 in 0.0s

O gerador fez bastante coisa né? Sugiro dar uma olhada no que foi adicionado e criado.

Uma nota: nem sempre vem como queremos, tendo muitas vezes que fazer mudanças. Os generators são uma base para adiantarmos nosso trabalho, ele não vai te entregar exatamente o que você precisa.

A não ser que você queira um CRUD simples e esse é o nosso caso! Rode a aplicação para ver o que aconteceu.

mix phx.server

E vamos entrar na nova rota criada: http://localhost:4000/books, aperta ai ;)

A segunda etapa do nosso sistema esta pronto. Podemos criar, listar. editar e deletar filmes. 🎉

Mas está meio estranho esse admin ter acesso por todos sem um login e senha não? 🤔

Sim e vamos resolver agora!

Gerando autenticação

Podemos também gerar essa parte do sistema, adiantando e muito nosso sistema. Utilizaremos o phx.gen.auth para isso.

A regra para isso sera:

Precisamos que nosso usuário tenha uma conta com email e senha
Precisamos validar via link se o e-mail existe de fato.
Precisamos realizar o loggin do usuario
Precisamos dar a possibilidade do logout
Precisamos proteger nossa rota de filmes.

Let's go

O phx.gen.auth funciona muito parecido com o phx.gen.html que usamos. Primeiro passamos o contexto, depois o schema e por fim a tabela.

mix phx.gen.auth Account user users

...
* creating lib/my_movies_web/controllers/user_settings_controller.ex
* creating test/my_movies_web/controllers/user_settings_controller_test.exs
* creating lib/my_movies/accounts.ex
* injecting lib/my_movies/accounts.ex
* creating test/my_movies/accounts_test.exs
* injecting test/my_movies/accounts_test.exs
* creating test/support/fixtures/accounts_fixtures.ex
* injecting test/support/fixtures/accounts_fixtures.ex
* injecting test/support/conn_case.ex
* injecting config/test.exs
* injecting mix.exs
* injecting lib/my_movies_web/router.ex
* injecting lib/my_movies_web/router.ex - imports
* injecting lib/my_movies_web/router.ex - plug
* injecting lib/my_movies_web/templates/layout/root.html.heex

Please re-fetch your dependencies with the following command:

    $ mix deps.get

Remember to update your repository by running migrations:

    $ mix ecto.migrate

Once you are ready, visit "/users/register"
to create your account and then access "/dev/mailbox" to
see the account confirmation email.

Duas ações são necessárias

gerir dependencias mix deps.get
rodar migrations mix ecto.migrate

e voce esta bem para ir.

Mas vamos analisar a parte final que é interessante:

...
Once you are ready, visit "/users/register"
to create your account and then access "/dev/mailbox" to
see the account confirmation email.

O generate ja trás para nossas as funções de register, login e também confirmation para saber que o e-mail está correto e assim ativar sua conta.

Existe diversas configurações que podem ser feitas aqui, recomendo a leitura da documentação e procurar na internet outras formas de customizar isso, é bem interessante e prático.

continuando...

Rode novamente o servidor phoenix mix phx.server e voce verá algumas mudanças no cabeçalho.

Agora você pode ver no lado direito o register e o Log in e server para exatamente isso =D

Faça o register para ver o que acontece. Uma vez cadastrado as opções la em cima mudam:

Você já possui um sistema de autenticação para usar. Os arquivos gerados estão na sua codebase e você pode alterar a vontade, para suprir suas necessidades.

Um detalhe interessante, quando se faz o cadastro é enviado um e-mail, mas já que estamos local ele não vai para o mundo externo. Em vez disso ele é pego no meio do caminho e você pode ver ele aqui http://localhost:4000/dev/mailbox e fazer a confirmação sem precisar mandar para um provedor de e-mail. Muito util e rápido para testar, não?

Booa, bastante coisa pronta não? Mas faltou uma ultima etapa. Se voce acessar o /movies sem estar logado ainda poderá realizar as operações, vamos resolver isso.

Protegendo rotas privadas

Ao ter gerado a autenticação o seu arquivo router.ex mudou e agora você tem la alguns plugs e escopos novos.

Para os recursos de filmes estarem configurados de forma a não deixar pessoas não autenticadas acessar, você precisa usar o plug :require_authenticated_user no pipe do escopo.

Depois de gerar a autenticação, foi configurado novas rotas automaticamente (que ja acessamos, como register e Log in). Basta agora mover o resources "/movies", MovieController para o escopo que já está utilizando o plug ou criar um novo escopo para você. Irei optar por isso:

# lib/my_movies_web/router.ex
# ...

scope "/admin", MyMoviesWeb do
  pipe_through [:browser, :require_authenticated_user]

  resources "/movies", MovieController
end

# ...

No código acima, colocamos o recurso de filmes abaixo do escopo admin, então o acesso na URL mudou sendo agora http://localhost:4000/admin/movies

Caso esteja logado você conseguirá ver a página normalmente, mas caso não esteja, você será redirecionado para a página de login e uma mensagem será exibida:

Basta fazer o login e você será enviado novamente para a listagem de filmes.

Agora sim! Tudo pronto 🎉🎉

Conclusão

Geradores podem causar grandes discussões no mundo do desenvolvimento e por uma boa razão.

Quando os utilizamos só por utilizar, sem uma consciência do que esta acontecendo, tende a deixar as coisas mais confusas e criar funcionalidades que nunca serão utilizadas. Isso é ruim a longo prazo, onde se torna difícil manter.

Mas se você está fazendo as escolhas consciente, analisando os impactos que isso possa causar e alterando o código gerado para se adequar ao seu produto, não a mau em utiliza-lo, eles te pouparão um grande tempo.

Espero que tenham gostado ;)

Já que você chegou até aqui, se inscreva no Café com Elixir uma newsletter semanal de Elixir focado em conteúdos da comunidade brasileira.

Me sigam também no twitter @iagoEffting lá sou mais ativo =D

E se inscrevam no canal no youtube