DEV Community: Alexandre

Criando plug-in em c para gimp

Alexandre — Mon, 01 May 2023 19:20:07 +0000

Bem, hoje vamos criar um plug-in em c para automatizar algumas tarefas repetitivas e chatas.

Antes de começar fazer o código, é necessário instalar o gimptool.

Então, vamos instalar ele.

Instalando o gimptool

Antes de continuarmos, tenho que esclarecer que eu vou fazer isso em Linux, pois eu não uso o Window, então se você não sabe onde achar o gimptool para Window.

Mas não se preocupe, eu vou te ajudar onde pode estar esse gimptool no Window, de acordo com strontic, Ele diz que o arquivo pode está localizado no C:\program files\GIMP 2\bin\gimptool-2.0.exe.

Então, se você conseguiu localizar o arquivo, com isso, você já pode partir para a criação de plug-in.

Agora vamos instalar o Gimptool no Linux, no caso Ubuntu/Debian.

Basta ir ao terminal executar o comando: sudo apt install libgimp2.0-dev.

Pronto, é só isso, agora vamos criar um plug-in.

Criando um plug-in

Beleza, antes de criar o plug-in, eu vou explicar o eu vou fazer.

Para não dificultar o processo de aprendizado, eu vou fazer um plug-in bem simples, mas bem simples mesmo.

É basicamente colocar uma guide(guia).

Se você não sabe o que é guide. Abra o gimp e vá ao menu "Image" Ou "Imagem", se estiver português, e verá ele aí.

Passando o mouse em cima, você verá 4 opções.

Aqui está uma captura de tela.

Clicando na primeira opção, vai aparecer uma tela para escolher a direção e inserir um valor da posição da guia.

Então, colocando na direção vertical e posição 50%, vai aparecer uma linha azul no meio da imagem, por exemplo, nessa captura de tela.

Eu quero automatizar isso, pois é chato fica abrindo a telinha e inserindo os valores.

Então, primeiro, vamos criar um arquivo chamado add_guias.c.

Eu vou colocar o código inteiro logo de vez para fazer um teste, e então, depois vou explicando ao pouco.

#include <libgimp/gimp.h>

static void query (void);
static void run (
    const gchar *name,
    gint nparams,
    const GimpParam *param,
    gint *nreturn_vals,
    GimpParam **return_vals);

GimpPlugInInfo PLUG_IN_INFO = {
    NULL, // init
    NULL, // quit
    query,
    run
};

static void query (void) {

  static GimpParamDef args[] = {
    {
      GIMP_PDB_INT32, // Tipo de variável
      "run-mode", // Nome da variável
      "Run mode" // Descrição da variável
    },
    {
      GIMP_PDB_IMAGE, // Tipo de variável
      "image", // Nome da variável
      "Input image" // Descrição da variável
    },
    {
      GIMP_PDB_DRAWABLE, // Tipo de variável
      "drawable", // Nome da variável
      "Input drawable" // Descrição da variável
    }
  };

  gimp_install_procedure (
    "plug-in-add_guias", // Nome do procedure
    "Adiciona guia", // Uma pequena descrição do que o procedure faz
    "Ele adiciona uma guia no meio da imagem", // Uma descrição completa
    "Alexandre dos Santos Alves", // Seu nome
    "Copyright Alexandre", // Licença
    "2023", // Ano que foi criado
    "_Adicona Guia", // Nome que vai aparece no menu
    "RGB*, GRAY*", // Tipo de imagem que o procedure vai trabalhar
    GIMP_PLUGIN, // Tipo de procedure
    G_N_ELEMENTS (args), // Tamanho do parâmetro
    0, // Tamanho do retorno
    args, // o parâmetro do procedure
    NULL); // o retorno do procedure.

  gimp_plugin_menu_register ("plug-in-add_guias",
                               "<Image>/Tools/");
}

static void run (
    const gchar      *name,
    gint              nparams,
    const GimpParam  *param,
    gint             *nreturn_vals,
    GimpParam       **return_vals)
    {

    // A variável que vai ser retornado
    static GimpParam  values[1];
    GimpPDBStatusType status = GIMP_PDB_SUCCESS; 
    GimpRunMode       run_mode;
    GimpDrawable     *drawable;

    /* Definindo valores de saída obrigatórios    */
    *nreturn_vals = 1;
    *return_vals  = values;

    /* É obrigatório isso */
    values[0].type = GIMP_PDB_STATUS;
    values[0].data.d_status = status;

    run_mode = param[0].data.d_int32;
    gint image = param[1].data.d_image;
    drawable = gimp_drawable_get(param[2].data.d_drawable);

    gdouble metade_do_tamanho_da_image = (gimp_image_width(image) * 0.5);

    gimp_image_add_vguide(image, metade_do_tamanho_da_image);

    gimp_displays_flush ();
}

MAIN()

Com esse código, copie e cole no arquivo e execute o comando no qual o arquivo está localizado.

Se for Window, C:\program files\GIMP 2\bin\gimptool-2.0.exe --install add_guias.c.
Se for Linux, gimptool-2.0 --install add_guias.c.

Se por acaso, aparecer isso aqui embaixo, pode ignorar.

add_guias.c:92:2: warning: ‘gimp_drawable_get’ is deprecated: Use 'gimp_drawable_get_buffer' instead [-Wdeprecated-declarations]
   92 |  drawable = gimp_drawable_get(param[2].data.d_drawable);
      |  ^~~~~~~~
In file included from /usr/include/gimp-2.0/libgimp/gimp.h:41,
                 from add_guias.c:1:
/usr/include/gimp-2.0/libgimp/gimpdrawable.h:52:16: note: declared here
   52 | GimpDrawable * gimp_drawable_get                    (gint32         drawable_ID);
      |                ^~~~~~~~~~~~~~~~~

Se não houver erro, além desse aviso, agora, ele vai aparece no Gimp, então feche o Gimp e abra novamente e você verá no menu Tools(Ferramentas) um item com nome Adiciona Guia.

Crie uma nova imagem e clique nele para ver o que acontece.

Bem, Se apareceu a linha azul, então ele funcionou, se não, aí é com você para resolver.

Mentira, comente no comentário, o problema.

Mas, agora, vamos entender o código.

Na primeira linha, estamos incluindo uma biblioteca essencial para construção do plug-in, então não tem muito o que explicar sobre isso.

Em baixo disso, podemos ver duas funções, query e run.

...

static void query (void);
static void run (
    const gchar *name,
    gint nparams,
    const GimpParam *param,
    gint *nreturn_vals,
    GimpParam **return_vals);

GimpPlugInInfo PLUG_IN_INFO = {
    NULL, // init
    NULL, // quit
    query,
    run
};

...

Mas antes de explicar essas funções, vamos pular essa parte e ver a variável PLUG_IN_INFO.

Essa variável pode guardar 4 valores.

Mas o que são esses valores?

São funções que o Gimp vai chamar.

Ou seja, o primeiro valor é uma função que vai ser chamado durante a inicialização do Gimp, no meu caso, eu coloquei NULL, pois não quero fazer nada durante a inicialização.

O segundo é quit, que vai ser chamado durante o fechamento do Gimp, que no meu caso, está NULL.

Esses dois valores que citei, são opcionais, ou seja, não é necessário ter uma função, basta colocar NULL.

Agora os dois próximos que vou citar são obrigatórios.

O terceiro é query, não sei muito o que explicar sobre isso, pois a documentação não diz muito sobre isso, mas no meu entendimento, suponho que é usado para instalar o plug-in, mas vamos tenta entender mais, quando estivemos na dentro função query().

O quarto e último é run, é peça central do código, pois ele vai ser rodado, quando for chamado, seja pelo menu, ou pelo script fu, ou Python fu.

Agora, sabendo disso, vamos partir para aquelas duas funções criada para entender os parâmetros.

static void query (void);
static void run (
    const gchar *name, // Nome do plug-in
    gint nparams, // Quantidade de parâmetro
    const GimpParam *param, // O parâmetro do plug-in
    gint *nreturn_vals, // Quantidade de retorno
    GimpParam **return_vals); // O retorno do plug-in

Não tem muito que o explicar sobre o parâmetro do query, então vamos para run.

O primeiro parâmetro é o nome do plug-in.
O segundo é a quantidade de parâmetro.
O terceiro é o parâmetro do plug-in.
O quarto é a quantidade de retorno.
O quinto é o retorno do plug-in.

Beleza, sabendo quais são os parâmetros.

Agora, vamos entender ver o que dentro da função query(void).

static void query (void) {

  static GimpParamDef args[] = {
    {
      GIMP_PDB_INT32, // Tipo de variável
      "run-mode", // Nome da variável
      "Run mode" // Descrição da variável
    },
    {
      GIMP_PDB_IMAGE, // Tipo de variável
      "image", // Nome da variável
      "Input image" // Descrição da variável
    },
    {
      GIMP_PDB_DRAWABLE, // Tipo de variável
      "drawable", // Nome da variável
      "Input drawable" // Descrição da variável
    }
  };

  gimp_install_procedure (
    "plug-in-add_guias", // Nome do procedure
    "Adiciona guia", // Uma pequena descrição do que o procedure faz
    "Ele adiciona uma guia no meio da imagem", // Uma descrição completa
    "Alexandre dos Santos Alves", // Seu nome
    "Copyright Alexandre", // Licença
    "2023", // Ano que foi criado
    "_Adicona Guia", // Nome que vai aparece no menu
    "RGB*, GRAY*", // Tipo de imagem que o procedure vai trabalhar
    GIMP_PLUGIN, // Tipo de procedure
    G_N_ELEMENTS (args), // Tamanho do parâmetro
    0, // Tamanho do retorno
    args, // o parâmetro do procedure
    NULL); // o retorno do procedure.

  gimp_plugin_menu_register ("plug-in-add_guias", // nome do plug-in
                               "<Image>/Tools/"); // Localização dele no menu
}

Primeiro, declaramos uma variável static GimpParamDef args[], ela possibilita saber quais são os valores do parâmetro que o plug-in recebe.

No nosso caso, vamos apenas manter o padrão, que são run-mode, image e drawable.

Mas se por acaso, seu plug-in precisa de mais valores, eu vou colocar uma lista de cada tipo de variável para facilitar para você.

Tipo de variável	Descrição
GIMP_PDB_INT32	32-bit integer
GIMP_PDB_INT16	16-bit integer
GIMP_PDB_INT8	8-bit integer
GIMP_PDB_FLOAT	Float
GIMP_PDB_STRING	String
GIMP_PDB_INT32ARRAY	Array of INT32
GIMP_PDB_INT16ARRAY	Array of INT16
GIMP_PDB_INT8ARRAY	Array of INT8
GIMP_PDB_FLOATARRAY	Array of floats
GIMP_PDB_STRINGARRAY	Array of strings
GIMP_PDB_COLOR	Color
GIMP_PDB_ITEM	Item ID
GIMP_PDB_DISPLAY	Display ID
GIMP_PDB_IMAGE	Image ID
GIMP_PDB_LAYER	Layer ID
GIMP_PDB_CHANNEL	Channel ID
GIMP_PDB_DRAWABLE	Drawable ID
GIMP_PDB_SELECTION	Selection ID
GIMP_PDB_COLORARRAY	Array of colors
GIMP_PDB_VECTORS	Vectors (psath) ID
GIMP_PDB_PARASITE	Parasite
GIMP_PDB_STATUS	Procedure return status
GIMP_PDB_END	Marker for last enum value

Beleza, Já entendemos sobre o args[], agora vamos para função que estamos chamando gimp_install_procedure.

Não tem muito o que explicar, pois se você ler o comentário ao lado do parâmetro, já dá pra ter uma noção, mas o que ele basicamente faz é instalar o plug-in no gimp.

Então, vamos para outra função que é gimp_plugin_menu_register. Como o nome diz, ele vai registrar o plug-in no Menu, que no nosso caso, vai ser colocado no Tools.

Aqui nós terminamos a função query().

Vamos para função run(), por ser um código um pouco grande, eu vou colocar a explicação dentro do código.

...

static void run (
    const gchar      *name,
    gint              nparams,
    const GimpParam  *param,
    gint             *nreturn_vals,
    GimpParam       **return_vals)
    {

    // A variável que vai ser retornado
    static GimpParam  values[1];

    // Como o nome diz é o status
    GimpPDBStatusType status = GIMP_PDB_SUCCESS; 

    // O run_mode é usado para saber se estar no modo interativo ou não
    // Não irei explicar isso nesse blog
    GimpRunMode       run_mode;

    // Variável que, por padrão, é o layer(camada) atual.
    GimpDrawable     *drawable;

    /* Definindo valores de saída obrigatórios    */
    *nreturn_vals = 1; // definindo o tamanho da variável values
    *return_vals  = values;

    /* É obrigatório isso */
    values[0].type = GIMP_PDB_STATUS;
    values[0].data.d_status = status;

    // Aqui temos uma forma de pegar os valores passados no parâmetro
    // Eu vou colocar lista de tipos de variáveis abaixo fora do código
    // Sobre o índices da variável 'param', ele está na mesma ordem
    // que você declarou na função 'query' da variável 'args'
    run_mode = param[0].data.d_int32;
    gint image = param[1].data.d_image;
    drawable = gimp_drawable_get(param[2].data.d_drawable);

    // Agora, a partir daqui, são os códigos que você pode fazer
    // Aqui estamos pegando a metade do tamanho da imagem
    // Para poder colocar a guia no meio
    gdouble metade_do_tamanho_da_image = (gimp_image_width(image) * 0.5);

    // essa função coloca a guia, primeiro parâmetro é a imagem
    // o segundo é a posição dessa guia
    gimp_image_add_vguide(image, metade_do_tamanho_da_image);

    // Essa função serve para atualizar o que você fez no código,
    // mas não é necessário para o nosso caso,
        // Não estamos alterando a imagem
    gimp_displays_flush ();
}

...

Tipos de variáveis	membro
gint32	d_int32
gint16	d_int16
guint8	d_int8
gdouble	d_float
gchar	d_string
gint32	d_int32array
gint16	d_int16array
guint8	d_int8array
gdouble	d_floatarray
gchar	d_stringarray
GimpRGB	d_colorarray
GimpRGB	d_color
gint32	d_display
gint32	d_image
gint32	d_item
gint32	d_layer
gint32	d_layer_mask
gint32	d_channel
gint32	d_drawable
gint32	d_selection
gint32	d_boundary
gint32	d_vectors
gint32	d_unit
GimpParasite	d_parasite
gint32	d_tattoo
GimpPDBStatusType	d_status

Se você não entendeu essa lista ou não sabe usá-la, basta fazer assim param[i].data.membro, troque o membro para um item da lista.

E por último, temos que colocar o MAIN(), é obrigatório que tenha isso, e que fique no final do arquivo.

Pronto, com isso, você tem a base para construir um plug-in por si próprio, só que não, pois você ainda não sabe quais são os métodos disponíveis no Gimp.

Aqui está a documentação do Gimp.

Agora, sim, podemos terminar aqui.

Bem, então é isso e tchau!

O básico de Action Cable em Rails 7

Alexandre — Sun, 18 Dec 2022 18:56:50 +0000

Se você quer criar um chat em tempo real, ou então criar um joguinho multiplayer, então para fazer em Rails, será necessário usar o Action Cable.

Então, vamos lá.

O que é Action Cable?

Action Cable integra perfeitamente com WebSockets com o resto da sua aplicação Rails. Isso permite que recursos em tempo real sejam escritos em Ruby no mesmo estilo da sua aplicação, enquanto ainda é performático e escalável. Isso é uma oferecimento full-stack que providencia o framework Javascript do client-side e framework Ruby do server-side.

Agora, que nós sabe o que é Action Cable, vamos entender algumas termologias.

Termologias

Connections ou Conexões

Connections (Conexões) formam a base do relacionamento cliente-servidor. Um único servidor Action Cable pode lidar com várias instâncias de conexão. Um único usuário pode ter vários WebSockets abertos para seu aplicativo se usar várias abas do navegador ou dispositivos diferentes.

Consumers ou consumidores

O cliente de uma conexão WebSocket é chamado de consumer (consumidor). Em Action Cable, o consumer é criado pelo framework javascript do client-side

Channels ou Canais

Cada consumer pode, por sua vez, assinar vários channels.
Cada canal encapsula uma unidade lógica de trabalho, similar o que controller faz no típico MVC. Por exemplo, você pode ter um ChatChannel e um PresencaChannel e um consumer pode assinar um ou ambos canais. No minimo, o consumer deve assinar pelo menos um canal.

Subscribers ou Assinantes

Quando o consumer está assinado em um channel, ele pode agir como um subscriber (assinante). A conexão entre o subscriber e o channel é, surprise-surprise, chamado de assinatura. Um consumer pode agir como um subscriber de um determinado channel quantas vezes quiser. Por exemplo, um consumer pode assinar várias sala de conversa ao mesmo tempo.

Pub/Sub

Pub/Sub ou Publish-Subscribe (Publicar-Assinar) refere-se a uma paradigma de fila de messagens por meio do qual os remetentes de informações (publishers), enviam dados apara uma classe abstrata de destinatários (subscribers), sem especificar os destinatários individuais. Action Cable usa essa abordagem para comunicar entre o servidor e vários clientes.

Broadcastings ou Transmissões

Um broadcasting é um link pub/sub em que qualquer coisa transmitida pelo broadcaster é enviada diretamente para os subscribers do channel que estão transmitindo essa chamada broadcasting. Cada canal pode transmitir zero ou mais broadcastings.

Tendo o conhecimento das termologias, vamos criar uma aplicação.

Criando uma aplicação

O aplicativo que vou criar é um chat.

rails new chat
cd chat
rails g controller Chat index

Coloque a rota chat#index como root.

# config/routes.rb
Rails.application.routes.draw do
  root 'chat#index'
end

Abra o arquivo app/views/chat/index.html.erb e coloque o código abaixo.

<!-- app/views/chat/index.html.erb -->
<div>
  <textarea id="input"></textarea>
  <button id="button">enviar</button>
</div>
<div id="chat"></div>

Agora, vamos colocar o Action Cable.

Instalando o Action Cable

Como a nossa aplicação é um chat, então vamos criar um channel Chat.

Para criar, basta usar o generator.

rails g channel Chat

Tem um arquivo que fica no app/channels/application_cable/connection.rb que fica responsável pela conexão.

Porém, você tem fazer a parte de autenticação e autorização, mas como a minha aplicação não tem autenticação, então eu vou ignorar essa parte.

Mas eu vou deixar um exemplo do código de como seria se tivesse uma autenticação.

# app/channels/application_cable/connection.rb
module ApplicationCable
  class Connection < ActionCable::Connection::Base
    identified_by :current_user

    def connect
      self.current_user = find_verified_user
    end

    private
      def find_verified_user
        # se você estiver usando cookie para autenticação
        verified_user = User.find_by(id: cookies.encrypted[:user_id])
        # se você estiver usando session para autenticação
        verified_user = User.find_by(id: cookies.encrypted['_session']['user_id'])
        # se por acaso, você estiver usando uma gem para autenticação, terá pesquisar sobre isso.
        if verified_user
          verified_user
        else
          reject_unauthorized_connection
        end
      end
  end
end

Você pode observar o identified_by, ele cria um identificador de conexão, ou seja, você pode usar current_user para saber quem é o usuário que está conectado em uma conexão.

Agora, vamos focar no client-side.

Client Side

Abra o arquivo app/javascript/channels/chat_channel.js e coloque o código abaixo.

// app/javascript/channels/chat_channel.js
import consumer from "channels/consumer"

// o consumer vai ser criado aqui e vai tentar assinar no canal ChatChannel
consumer.subscriptions.create("ChatChannel", {
  connected() { // vai executar essa método se a conexão foi sucedida
    this.input = document.getElementById("input")
    this.chat = document.getElementById("chat")

    const button = document.getElementById("button")

    button.addEventListener("click", this.enviar_mensagem.bind(this))
  },

  received(dados) { // Aqui recebe os dados do server side
    this.chat.innerHTML += `<p>${dados.mensagem}</p>`
  },

  enviar_mensagem() { // Aqui vai enviar os dados para server side
    let dados = {mensagem: input.value}

    this.perform("mensagem", dados)
    // isso vai enviar os dados para action mensagem do server side

    input.value = ""
  }
});

Server side

Abra o arquivo app/channels/chat_channel.rb e coloque o código abaixo.

# app/channels/chat_channel.rb
class ChatChannel < ApplicationCable::Channel
  # vai executar esse método se o usuário vai fazer uma conexão
  def subscribed
    # o stream_from vai assina em um broadcasting com nome 'chat', isso é útil para criar grupo. 
    stream_from "chat"
  end

  # aqui é a action que recebe os dados do client side
  def mensagem dados
    # isso vai envia a dados para os subscribers (assinantes). O primeiro argumento é o nome do broadcasting, como você pode ver que é igual ao argumento do `stream_from`.
    ActionCable.server.broadcast("chat", dados)
  end
end

Agora, execute o rails server e abre duas abas do navegador com a url localhost:3000, tente manda uma mensagem e verá que a outra aba vai receber a mensagem.

Com isso, nós terminamos por aqui, porém eu vou fazer, um dia, um post, em que vou aprofundar mais o action cable criando um joguinho simples.

Então é isso, tchau!

Usando Action Text em Rails 7

Alexandre — Fri, 16 Dec 2022 15:33:03 +0000

Hoje, nós vamos aprender a integrar um editor WYSIWYG com rapidez e facilidade na nossa aplicação Rails.

Observação: Será necessário instalar alguns software de terceiro para processamento de imagem.

libvips v8.6+ e/ou ImageMagick para analise e transformação de imagem.

O que é Action Text?

Action Text nos dá a capacidade de criar conteúdo de rich text. Ele usa o editor Trix para lidar com tudo, desde a formatação a links, citações, listas, imagens incorporadas. O conteúdo rich text gerado pelo editor Trix é salvo em seu próprio model RichText associado a qualquer model Active Record existente no aplicativo. E também, quaisquer anexos incorporadas são armazenadas automaticamente usando o Active Storage e associadas ao model RichText.

Bem, chega de papo e vamos construir nossa aplicação.

Criando uma aplicação

A aplicação que vou criar é um simples blog.

rails new blog
cd blog

Agora, vamos instalar o Action Text

Instalando o Action Text

Para instalar, é bem simples, basta executar o comando abaixo.

rails action_text:install

Pronto, com isso, o Action Text está instalado.

Vamos criar o model e controller.

Eu vou usar o scaffold, para nos livrar do trabalho.

rails g scaffold Publicacao titulo conteudo:rich_text
railos db:migrate

Perceba que eu criei o conteudo do tipo rich_text, com isso, o action text está associado com o model Publicacao.

Beleza, mas se eu tiver um model criado, o que eu faço?

É bem simples, basta colocar o código has_rich_text :nome_do_atributo no seu model.

Por exemplo, vamos abrir o arquivo app/models/publicacao.rb

class Publicacao < ApplicationRecord
  has_rich_text :conteudo
end

Perceba que o generator colocou para gente, não tem muito segredo em fazer isso.

Antes de rodar o servidor, vamos observar o arquivo view, para saber como que colocar o editor no form.

Abra o arquivo app/views/publicacaos/_form.html.erb e foque em uma parte do código.

...
  <div>
    <%= form.label :conteudo, style: "display: block" %>
    <%= form.rich_text_area :conteudo %>
  </div>
...

Então, para usar o editor Trix, basta colocar o rich_text_area :nome_do_atributo.

Então, vamos ver essa coisa funcionando, rode o servidor e vá para localhost:3000/publicacaos/new.

E verá um editor WYSIWYG, então divirta-se brincando com ele, coloque imagem, use a formatação, etc.

Bem, nós acabamos por aqui.

Então é isso, tchau!

O básico de Stimulus em Rails

Alexandre — Thu, 15 Dec 2022 21:53:02 +0000

Talvez você tenha se perguntado a existência da gem stimulus que Rails instala por padrão, mas não se preocupe, que aqui você vai aprender sobre ele.

Observação: Esse post é necessário que tenha um conhecimento DOM. Se não, pode ser complicado em entender.

O que é Stimulus?

Eu vou traduzir a documentação, pois, sinceramente, não consigo explicar isso em outras palavras.

Stimulus é um framework Javascript com ambições modesta.
Ao contrário de outros frameworks front-end, Stimulus é projetado para aprimorar HTML estático ou renderizado pelo servidor - o "HTML que você possui" - conectando objetos Javascript a elementos da página usando anotações simples.

Esses objetos JavaScript são chamados de controllers, e o Stimulus monitora continuamente a página esperando que os atributos data-controller apareçam no HTML. Para cada atributo, o Stimulus examina o valor do atributo para encontrar uma classe controller correspondente, cria uma nova instância dessa classe e a conecta ao elemento.

Você pode pensar desta maneira: Assim como o atributo class é uma ponte que conecta HTML a CSS, o atributo data-controller do Stimulus é uma ponte que conecta HTML a Javascript

Além dos controllers, os outros três principais conceitos de Stimulus são:

actions, que conectam métodos do controller a eventos DOM usando atributos data-action;
targets, que localizam elementos de significado dentro de um controller;
values, que leem, escrevem e observam atributos de dados no elemento do controller.

O uso de atributos de dados pelo Stimulus ajuda a separar o conteúdo do comportamento da mesma forma que o CSS separa o conteúdo da apresentação. Além disso, as convenções do Stimulus naturalmente encorajam você a agrupar códigos relacionados por nome.

Por sua vez, o Stimulus ajuda você a criar controllers pequenos e reutilizáveis, fornecendo estrutura suficiente para evitar que seu código se transforme em uma “sopa de JavaScript”.

Talvez, com essa explicação, você não tenha entendido muito, então vamos para a prática para fixar isso.

Prática

Eu estava pensando que tipo de aplicação eu criaria para isso, porém, não consegui em pensar em nada. Então vai ser uma aplicação aleatória que possa aproveitar o máximo do Stimulus.

Então, execute os comandos abaixo para preparar o terreno.

rails new exemplo_stimulus
cd exemplo_stimulus
rails g controller Pagina index

Abra o arquivo config/routes.rb.

# config/routes.rb
Rails.application.routes.draw do
  root 'pagina#index'
end

Agora, o nosso terreno está pronto.

Controllers

Vá no arquivo app/views/pagina/index.html.erb e adicione o código abaixo.

<!-- app/views/pagina/index.html.erb -->
<div data-controller="hello"></div>

Rode o servidor e vá para URL localhost:3000 e veja a mágica acontecer.

Viu, apareceu o "Hello world!", mas como?

Antes de explicar, o que aconteceu, vamos, primeiro, entender sobre o atributo data-controller.

Como foi explicado lá em cima, que o Stimulus procura no html pelo o atributo data-controller para criar uma instância de classe e conectar com o elemento.

Só que a dúvida é, onde está essa classe?

Bem, na sua aplicação, procure o arquivo no diretório app/javascript/controllers e verá ele lá.

Achou? E qual é o nome do arquivo?

hello_controller.js é o nome do arquivo, ou seja, o Stimulus vai usar o valor do atributo para procurar um arquivo do diretório app/javascript/controllers.

Vamos fazer um teste, mude o valor do data-controller.

<!-- app/views/pagina/index.html.erb -->
<div data-controller="ola"></div>

Agora, reinicie a página e verá ...

Nada, obviamente, esperava o que?

Bem, por que não apereceu nada?

É que Stimulus está procurando um arquivo com nome ola_controller.js e esse arquivo não existe.

Então, vamos mudar o nome do arquivo hello_controller.js para ola_controller.js e reinicie a página.

Agora, funcionou.

Uma observação, é necessário que tenha o nome _controller.js no final do arquivo.

Bem, eu acho que você sacou como que funciona o data-controller.

Agora, vamos abrir o app/javascript/controllers/ola_controller e observar ele.

// app/javascript/controllers/ola_controller
import { Controller } from "@hotwired/stimulus"

export default class extends Controller {
  connect() {
    this.element.textContent = "Hello World!"
  }
}

Não tem muito segredo nesse arquivo, então eu vou só explicar o método connect, pois o resto dá para entender de boa.

O método connect é executado, quando usar o atributo data-controller.

Beleza, agora vamos nos aprofundar um pouco.

Actions

Vá para o arquivo app/views/pagina/index.html.erb e coloque o código abaixo.

<!-- app/views/pagina/index.html.erb -->
<div data-controller="ola">
  <input type="text" data-action="keyup->ola#mudarTexto">
  <p></p>
</div>

Ok, nós temos um novo atributo.

O data-action serve para lida com evento DOM do seu controller.

Vamos observar o valor do nosso atributo data-action.

Observando ele, você pode notar um padrão, que é, começa com evento DOM keyup e vai para o controller ola e execute o método mudarTexto.

Ou seja, é desse jeito o padrão evento->controller#método.

Não tem muito mistério sobre isso, basta lembrar desse padrão.

Então vamos para o arquivo app/javascript/controllers/ola_controller.js e colocar o novo método e remover o connect.

// app/javascript/controllers/ola_controller.js
import { Controller } from "@hotwired/stimulus"

export default class extends Controller {
  mudarTexto(event) {
    console.log(event.target.value);
  }
}

Pronto, reinicie a página e abra o dev tools para ver o console.

Viu, ele está imprimindo o valor do input.

Você pode pensar, nossa, que simples.

Sim, de fato, é muito simples.

Agora vamos mergulhar mais, que já estamos quase no fim.

Targets

Novamente, edite o arquivo, app/views/pagina/index.html.erb.

<!-- app/views/pagina/index.html.erb -->
<div data-controller="ola">
  <input type="text" data-action="keyup->ola#mudarTexto">
  <p data-ola-target="texto"></p>
</div>

Hum, um outro atributo.

Esse atributo é bem diferente, se prestar atenção, você pode ver o nome do controller no meio, ou seja, para usar ele, tem que seguir esse padrão, data-nome_do_controller-target.

Mas a questão é, o que ele faz?

Como o nome diz, ele é um alvo do controller.

O uso dele seria equivalente a GetElementById, só que mais simples.

Vamos para o arquivo app/javascript/controllers/ola_controller.js.

// app/javascript/controllers/ola_controller.js
import { Controller } from "@hotwired/stimulus"

export default class extends Controller {
  static targets = [ "texto" ]

  mudarTexto(event) {
    this.textoTarget.textContent = `olá, ${event.target.value}`
  }
}

Pode notar que existe uma variável targets, em que, está atribuindo um array com um valor "texto", ou seja, tem ter o valor igual, onde foi posto no HTML.

Agora, se você observar o this.textoTarget, ele é o elemento, a qual você colocou o atributo data-ola-target.

Então reinicie a página, e veja a mágica acontecer.

Values

O último conceito do Stimulus, então, abra o arquivo index novamente.

<!-- app/views/pagina/index.html.erb -->
<div data-controller="ola" data-ola-nome-value="Zulano" >
  <input type="text" data-action="keyup->ola#mudarTexto">
  <p data-ola-target="texto"></p>
</div>

Beleza, antes de explicar esse atributo, vamos primeiro para o arquivo javascript.

// app/javascript/controllers/ola_controller.js.
import { Controller } from "@hotwired/stimulus"

export default class extends Controller {
  static targets = [ "texto" ]
  static values = {
    nome: String
  }

  mudarTexto(event) {
    console.log(this.nomeValue)
    this.textoTarget.textContent = `olá, ${event.target.value}`
  }
}

Pode notar que ele meio que equivalente ao target, o que muda é que o targets aceita um array, enquanto o values é um JSON.

O padrão do atributo é data-nome_do_controller-chave-value.

Novamente, reinicie a página e veja o console do dev tools.

Bem, eu vou acabar por aqui, isso é o básico do Stimulus.

Eu sinto que esse post foi um desastre, mas se houver qualquer dúvida, pode comentar que vou responder.

Bem, então é isso, tchau!

Uma introdução de Active Storage em Rails 7

Alexandre — Wed, 14 Dec 2022 21:04:46 +0000

Se você quer que sua aplicação Rails seja capaz de lidar arquivos, como imagens, videos, pdfs, etc. Você está no lugar certo.

Hoje, nós vamos aprender sobre Active Storage.

O que é Active Storage

Active Storage é uma ferramenta que facilita o upload de arquivos para serviço de armazenamento em nuvem como Amazon S3, Google Cloud Storage ou Microsoft Azure e anexa esses arquivos a objetos Active Record. Ele também vem com um serviço baseado em disco local para desenvolvimento e teste e suporta espelhamento de arquivos para serviços subordinados para backups e migrações.

Observação: Eu não vou mostrar como que integrar o Active Storage com o serviço de armazenamento em nuvem. Eu só vou focar em ambiente de desenvolvimento.

Mas, antes de instalar Active Storage na sua aplicação, é necessário alguns software de terceiro para ter suporte em analise e processamento de arquivos.

Eu vou deixar uma lista de software.

libvips v8.6+ ou ImageMagick para analise e transformação de imagem.
ffmpeg v3.4+ para pré-visualizações de vídeo e ffprobe para analise de video/audio
poppler ou muPDF para pré-visualizações de PDF

E também é necessário colocar uma gem image_processing, se sua aplicação vai usar arquivo do tipo imagem.

Antes de instalar e usar software de terceiros, certifique-se de compreender as implicações de licenciamento de fazê-lo. O MuPDF, em particular, é licenciado sob AGPL e requer uma licença comercial para alguns usos.

Eu vou ensinar a instalar o Active Storage criando uma aplicação, porque eu acho muito mais melhor você ver a construção da aplicativo.

Então vamos criar aplicação

Criando uma aplicação

A aplicação que eu vou criar vai ser um simples armazenamento de arquivos, em que vai ter dois models e controllers, Usuario e Arquivo.

rails new armazenamento
cd armazenamento

Vamos colocar uma gem no Gemfile para que possa ter suporte de imagem.

echo "gem 'image_processing'" >> Gemfile
bundle install

Com gem instalado, vamos instalar o Active Storage.

rails active_storage:install

Esse comando cria uma migração, em que tem três tabelas active_storage_blobs, active_storage_attachments e active_storage_variant_records.

Eu não vou explicar cada um dele, mas saiba que são essas tabelas que vai armazenar os arquivos.

Como ele gerou uma migração, vamos migrar ele.

rails db:migrate

Agora, vamos criar os models e os controllers.

Antes de criar um model, tenho que falar que existe duas maneiras de anexar o arquivo no model, uma é usando o generator e outro é colocando o código na mão, o que não é complicado de fazer.

Primeiro, vamos usar o generator no model Usuario.

rails g model Usuario email senha avatar:attachment

Como você pode ver o tipo attachment, ele indica que esse model vai ter um anexo, ou seja, vai ter somente um arquivo, se você quer que seja vários arquivos, basta usar o tipo attachments.

Beleza, vamos ver o que ele gerou para nós, vá para o arquivo app/models/usuario.rb.

# app/models/usuario.rb
class Usuario < ApplicationRecord
  has_one_attached :avatar
end

O has_one_attached é uma macro que configura uma relação um para um entre o registro e o arquivo, ou seja, cada registro só pode ter um arquivo.

Isso é perfeito para gente, pois nós queremos que seja uma imagem do usuário.

E o que generator gerou foi isso, ou seja, se eu não quiser usar o generator, basta colocar esse código no model e pronto.

Então, vamos criar um model sem usar o tipo attachment ou attachments e colocar o código na mão.

rails g model Arquivo

Agora abra no arquivo app/models/arquivo.rb para colocar o código.

# app/models/arquivo.rb
class Arquivo < ApplicationRecord
  has_many_attached :arquivos
end

Você pode ter percebido que eu escrevi diferente do código de cima.

O has_many_attached é uma macro que configura uma relação de um para muitos entre o registro e os arquivos, ou seja, cada registro pode ter mais de um arquivo.

Viu, é simples implementar sem o generator.

Agora que criamos os models, vamos migrar eles.

rails db:migrate

Com models criado e migrado, vamos criar os controllers.

rails g controller Usuarios index show new edit
rails g controller Arquivos index show new edit

Agora vamos editar esses controllers. vamos primeiro para app/cotrollers/usuarios_controller.rb.

# app/cotrollers/usuarios_controller.rb
class UsuariosController < ApplicationController
  before_action :define_usuario, except: [:index, :new, :create]

  def index
    @usuarios = Usuario.all
  end

  def show
  end

  def new
    @usuario = Usuario.new
  end

  def create
    @usuario = Usuario.new(usuario_params)

    if @usuario.save
      redirect_to usuario_path(@usuario)
    else
      render :new
    end
  end

  def edit
  end

  def update
    if @usuario.update(arquivo_params)
      redirect_to usuario_path(@usuario)
    else
      render :edit
    end
  end

  def destroy
    if @usuario.destroy
      redirect_to usuarios_path
    end
  end

  private 

  def usuario_params
    params.require(:usuario).permit(:email, :senha, :avatar)
  end

  def define_usuario
    begin
      @usuario = Usuario.find(params[:id])
    rescue ActiveRecord::RecordNotFound
      redirect_to usuarios_path, status: :not_found
    end
  end
end

Como você viu o código que eu escrevi, não tem nada demais, ou seja, a imagem vai ser salva, se o usuário colocar uma imagem no form.

Só que a história muda um pouquinho, quando nós estamos lidando em que aceita vários arquivos.

Então abra o arquivo app/controllers/arquivos_controller.rb e coloque o código abaixo.

# app/controllers/arquivos_controller.rb
class ArquivosController < ApplicationController
  before_action :define_arquivo, except: [:index, :new, :create]

  def index
    @arquivos = Arquivo.all
  end

  def show
  end

  def new
    @arquivo = Arquivo.new
  end

  def create
    @arquivo = Arquivo.new(arquivo_params)

    if @arquivo.save
      redirect_to arquivo_path(@arquivo)
    else
      render :new
    end
  end

  def edit
  end

  def update
    if @arquivo.update(arquivo_params)
      redirect_to arquivo_path(@arquivo)
    else
      render :edit
    end
  end

  def destroy
    if @arquivo.destroy
      redirect_to arquivos_path
    end
  end

  private 

  def arquivo_params
    params.require(:arquivo).permit(arquivos: [])
  end

  def define_arquivo
    @arquivo = Arquivo.where(id: params[:id]).includes(arquivos_attachments: :blob)
    @arquivo = @arquivo[0]
    redirect_to arquivos_path, status: :not_found if @arquivo.nil?
  end
end

Se você observar o código, talvez você vai ver algo que nunca tenha visto antes, percebeu?

Se não percebeu, observe no método arquivo_params e me diz o que tem diferente do controller Usuario e Arquivo?

No controller usuario, o avatar está igual aos outros atributos, enquanto no controller arquivo, ele está com um array.

Então, lembre-se de que se você estiver lidando com muitos arquivos, coloque o array, se não, use um symbol.

E também outra diferença, no método define_arquivo, eu utilizei o where e o includes. O motivo de fazer isso foi para evitar o problema de n+1, se não sabe sobre esse problema, eu recomendo que pesquise sobre isso.

Agora, com controllers criado, vamos editar as rotas, abra o arquivo config/routes.rb.

# config/routes.rb
Rails.application.routes.draw do
  resources :arquivos
  resources :usuarios
end

Com models, controllers e rotas editado, agora faltam os views.

Primeiro, vamos editar views de usuarios.

<!-- app/views/usuarios/index.html.erb -->
<% @usuarios.each do |usuario| %>
  <%= link_to usuario.email, usuarios_path(usuario)%>
<% end %>

<%= link_to "new", new_usuario_path %>

<!-- app/views/usuarios/new.html.erb -->
<%= form_with model: @usuario, url: usuarios_path do |form| %>
  <%= form.label :email %>
  <%= form.text_field :email %>

  <%= form.label :senha %>
  <%= form.password_field :senha %>

  <%= form.label :avatar %>
  <%= form.file_field :avatar %>

  <%= form.submit %>
<% end %>

Para que possa enviar um arquivo a partir de um form, você pode usar o file_field.

<!-- app/views/usuarios/show.html.erb -->
avatar: <%= image_tag(@usuario.avatar) %> <br>
email: <%= @usuario.email %>

Para poder exibir uma imagem, você pode usar o image_tag.

Agora rode o servidor e vai para url localhost:3000/usuarios e crie um usuario com imagem e veja a coisa funciona.

Agora, vamos editar os views de arquivos.

<!-- app/views/arquivos/index.html.erb -->
<% @arquivos.each do |arquivo| %>
  <%= link_to arquivo.id, arquivo_path(arquivo)%>
<% end %>

<%= link_to "new", new_arquivo_path %>

<!-- app/views/arquivos/new.html.erb -->
<%= form_with model: @arquivo, url: arquivos_path do |form| %>
  <%= form.label :arquivos %>
  <%= form.file_field :arquivos, multiple: true %>

  <%= form.submit %>
<% end %>

Pode perceber que file_field é diferente do usuario, o multiple: true indica que esse campo aceita vários arquivos.

<!-- app/views/arquivos/show.html.erb -->
<% @arquivo.arquivos.each do |arquivo| %>
  <% if arquivo.content_type.start_with? "image" %>
    <%= image_tag arquivo %>
  <% elsif arquivo.content_type.start_with? "video" %>
    <%= video_tag( url_for(arquivo), controls: true ) %>
        <!-- o video_tag recebe o primeiro argumento uma url do arquivo e esse controls é para ativar o controle do video -->
  <% else %>
    <!-- Se não for uma imagem e nem video, baixe ele -->
    <%= link_to(arquivo.filename, rails_blob_path(arquivo, disposition: "attachment")) %>
    <!-- o arquivo.filename mostra o nome do arquivo -->
    <!-- o rails_blob_path cria um link de download -->
  <% end %>
  <br>
<% end %>

Agora vá para url localhost:3000/arquivos e adicione vários arquivos de tipo diferente.

Você pode notar, se você colocou um arquivo que não seja imagem e video, ao clicar no arquivo, ele vai fazer download.

E nós acabamos por aqui.

Então, espero que tenha ajudado e tchau!

Como usar o Active Job em Rails 7

Alexandre — Tue, 13 Dec 2022 15:54:18 +0000

Quando você está desenvolvendo uma aplicação, em que o usuário pode se cadastrar, e quando se faz o cadastro, o usuário recebe um email da aplicação.

Só que a minha pergunta é?

Você faria a aplicação enviar o email imediatamente?

E se, por acaso, a aplicação demorar mais do que esperado para enviar o email? Isso pode ser uma experiência nada agradável para usuário, pois ele fez o cadastro e ainda está no loading, sendo que deveria está na página principal.

Então, para resolver isso, basta que o email seja enviado em background (segundo plano). Ao fazer isso, ele vai ser enqueued (enfileirado) para ser enviado depois, e dessa forma, quando o usuário se cadastrar, ele vai ser imediatamente redirecionado para página principal, ao invés, de ficar esperando.

Beleza, então como que faz isso?

Bem, antes de fazer isso, primeiro, vamos saber o que é Active Job.

O que é Active Job

Active Job é um framework para declarar jobs (tarefas) e executá-las em uma variedade de queuing back-ends (back-ends de enfileiramento).

Esses jobs (tarefas) podem ser o exemplo que citei em cima de enviar o email, mas também como, fazer cobrança de um produto, ou então executar um código que pode levar um tempo, como usar um API de terceiro.

Agora vamos entender a proposta do Active Job.

A proposta do Active Job

Eu vou traduzir o que tem na documentação oficial.

O ponto principal é garantir que todos os aplicativos Rails tenham uma infraestrutura de job (tarefa) instalada. Podemos então ter recursos de estrutura e outras gems construídas sobre isso, sem ter que nos preocupar com as diferenças de API entre vários executores de jobs (tarefas), como Delayed Job e Resque. Então escolher seu back-end de filas torna-se mais uma preocupação operacional. E você poderá alternar entre eles sem precisar reescrever seus jobs.

Por padrão, o Rails vem com uma implementação de enfileiramento assíncrono que executa jobs (tarefas) com um pool de encadeamentos em processo. Os trabalhos serão executados de forma assíncrona, mas todos os trabalhos na fila serão descartados na reinicialização.

Ou seja, simplificando a explicação, ele tira a necessidade de ficar mudando o código, caso você queira usar uma gem diferente de executadores de jobs (tarefas).

Por exemplo, você está usando o Delayed Job, porém ele não tem o que você quer e então troca para Resque e isso sem ter que se preocupar de mudar o código.

É claro que vai haver algumas coisas para configurar, mas isso é irrelevante.

Beleza, agora que nós sabemos sobre Active Job e a proposta dele, vamos pôr a mão na massa.

Criando um job

rails g job Tarefa

Abra o arquivo app/jobs/tarefa_job.rb.

def perform nome
  # faça alguma coisa aqui
end

Beleza, não tem muita coisa que falar sobre esse código, somente o queue_as e perform.

Vamos falar sobre queue_as. Esse método serve para indicar qual fila usar para esse job, isso é útil, para caso em que você tem vários jobs diferentes e não quer executar todos eles em uma única fila e sim em filas diferentes.

Agora sobre o perform, eu não sei como explicar ele.

Só saiba que é nesse método que você coloca o código para ser executado usando o perform_now ou perform_later.

E uma coisa, não modifique o nome do método, se não vai funcionar o código, mas você pode tirar ou adicionar mais argumentos.

Pronto, Com a explicação dada, vamos enfileirar o job.

Enfileirando o job

Para enfileirar o job que nós criamos, basta usar o perform_later.

TarefaJob.perform_later "Alexandre"

O método perform_later enfileirar o job na fila e vai executar o job, somente se a fila estiver livre.

Você pode definir que hora ou dias ele vai ser executado, usando o set, veja um exemplo.

TarefaJob.set(wait: 1.week).perform_later "Alexandre"

O job vai ser enfileirado para ser executado daqui uma semana.

E é isso. Nós terminamos por aqui.

Eu sei que está faltando sobre os back-ends, como Sidekiq, Resque, Delayed Job, e outros.

Mas como eu disse lá em cima na proposta de Active Job, não vai ser necessário mudar o código, só basta configurar a gem que você vai ser capaz de usar ele.

Eu vou fazer um post no futuro, testando cada um dele, se for possível.

Então é isso, Tchau!

Uma introdução sobre Action Mailer em Rails 7

Alexandre — Mon, 12 Dec 2022 13:11:27 +0000

Nessa introdução, eu vou ensinar a usar action mailer.

O que é Action Mailer?

O Action Mailer é um recurso de Rails que permite enviar email da sua aplicação.

Uma característica bem interessante do Action Mailer é que ele é bem similar ao Controller, ou seja, tudo que você aprendeu sobre Controller, pode ser aplicado em Mailer.

Vamos ver quais são as semelhanças entre Controller e Mailer:

Actions e views.
Variáveis de instância que é acessível no views.
A capacidade de usar layouts e partials.
A capacidade de acessar um hash de parâmetros.

Agora que você sabe o que é Mailer, vamos pôr em prática.

Pondo em prática

Vamos criar uma aplicação simples de autenticação de usuário.

Se quiser acompanhar, basta executar os comandos abaixo.

Primeiro, vamos criar um projeto.

rails new mailer_introducao
cd mailer_introducao

Com projeto criado, vamos usar o scaffold para criar o model e controller de uma vez.

rails g scaffold Usuario nome email senha

Com isso, nós temos um projeto para ação.

Como nós podemos criar o mailer?

Bem, o jeito mais rápido seria usar o generator.

Então vamos usar o generator.

Criando mailer

Eu quero que a aplicação envie um email de saudação para o usuário que cadastrou na aplicação.

Então vamos criar o mailer.

rails g mailer Usuario bem_vindo

O mailer foi criado com nome Usuario e o bem_vindo é a action dele.

Vamos ver o arquivo app/mailers/usuario_mailer.rb para ver o que o generator gerou.

# app/mailers/usuario_mailer.rb
class UsuarioMailer < ApplicationMailer
  def bem_vindo
    @greeting = "Hi"

    mail to: "to@example.org"
  end
end

O método bem_vindo que é a action que nós colocamos no generator e você pode notar que ele também criou um view para essa action, veja no app/views/usuario_mailer/.

O método mail cria uma mensagem de email atual. O to: "to@example.org" é o email para quem a aplicação vai enviar.

Agora vamos tirar o código gerado do método e colocar o que queremos para que possa enviar o email.

# app/mailers/usuario_mailer.rb
class UsuarioMailer < ApplicationMailer
  def bem_vindo
    @usuario = params[:usuario]

    mail(to: @usuario.email, subject: 'Bem vindo ao meu site')
  end
end

Podemos percebe que no método mail, existe outra argumento além do to. O subject é o assunto do email.

Agora, Vamos editar a view, pois nós queremos fazer uma mensagem de saudação.

Abra o arquivo app/views/usuario_mailer/bem_vindo.html.erb.

<!-- app/views/usuario_mailer/bem_vindo.html.erb -->
<p><%= @usuario.nome %>, bem vindo ao meu site.</p>

<p>Espero que goste do conteúdo do site.</p>

Agora vamos editar o controller, para que envie o email ao criar o usuário.

Abra o arquivo app/controllers/usuarios_controller.rb.

# app/controllers/usuarios_controller.rb
class UsuariosController < ApplicationController
  ...
  def create
    @usuario = Usuario.new(usuario_params)

    respond_to do |format|
      if @usuario.save
        UsuarioMailer.with(usuario: @usuario).bem_vindo.deliver_later
        format.html { redirect_to usuario_url(@usuario), notice: "Usuario was successfully created." }
        format.json { render :show, status: :created, location: @usuario }
      else
        format.html { render :new, status: :unprocessable_entity }
        format.json { render json: @usuario.errors, status: :unprocessable_entity }
      end
    end
  end
...
end

Vamos focar nesse comando UsuarioMailer.with(usuario: @usuario).bem_vindo.deliver_later.

O UsuarioMailer é classe que nós criamos.

O método with é usado para que você possa passar alguma variável para mailer, no nosso caso, nós estamos passando a variável @usuario e para acessar no mailer, basta usar o params[:nome_que_voce_passou_no_metodo].

O método bem_vindo está, obviamente, chamando o método que nós criamos.

E por último, temos o método deliver_later, o que ele faz é basicamente enviar o email assincronamente, ou seja, a aplicação não vai ficar esperando a execução de envio de email para poder executar os próximos comandos.

E se você não queira enviar o email depois, basta usar o deliver_now que ele vai enviar imediatamente.

Agora vamos rodar o servidor, para ver em ação.

Antes de rodar o servidor, migre o banco de dados.

rails db:migrate
rails server

Vá no navegador e acesse no http://127.0.0.1:3000/usuarios e crie um novo usuário, saiba que agora, a aplicação não vai enviar o email.

Assim que você criar o usuário, vá no terminal e você vai ver o html do view que nós editamos no app/views/usuario_mailer/bem_vindo.html.erb.

Isso significa que até aqui está funcionando.

Mas nós não queremos que aplicação mostre no terminal, queremos que a aplicação envie para Gmail do usuário.

Aqui, eu vou usar o Gmail para enviar, se você quer usar outros serviços, vai ter que pesquisar.

Enviando email usando Gmail

Vá no config/environments/development.rb e adicione o código abaixo.

require "active_support/core_ext/integer/time"

Rails.application.configure do
  config.action_mailer.delivery_method = :smtp
  config.action_mailer.smtp_settings = {
    address:              'smtp.gmail.com',
    port:                 587,
    user_name:            'SEU_EMAIL',
    password:             'SUA_SENHA',
    authentication:       'plain',
    enable_starttls_auto: true,
    open_timeout:         5,
    read_timeout:         5
  }
  ...
end

Em 15 de julho de 2014, o Google aumentou suas medidas de segurança para bloquear tentativas de aplicativos que considera menos seguros. Você pode alterar suas configurações do Gmail aqui para permitir as tentativas. Se sua conta do Gmail tiver autenticação de 2 fatores habilitada, você precisará definir uma senha de aplicativo e usá-la em vez de sua senha normal.

Com isso, você vai conseguir enviar o email, então tome cuidado para não enviar para um email de alguém aleatório.

Então é isso, nós acabamos por aqui, claro que tem muitas coisas que não citei, mas eu decidi que não era relevante assim na introdução, pois com isso, já é capaz de fazer muita coisa.

E tchau!

Testando routes em RSpec Rails

Alexandre — Sat, 10 Dec 2022 14:01:17 +0000

Bem, eu estava pensando que realmente vale a pena fazer esse post, tipo, é algo tão simples, mas tão simples que basta eu mostrar o código que você já entenderia o que está acontecendo.

Mas um certo alguém falou, "Melhor um código testado, por mais que seja bobo", e concordo com ele, vai que acontece algo imprevisível por esse motivo bobo?

Mas eu só vou mostrar o código e explicar o que esse código faz e pronto, só isso, porque não tem muito explicar, se você não entendeu, então prova que está faltando conhecimento em rotas em rails.

Se você quer saber mais de rotas, basta ler a documentação oficial do rails que tem português, aqui está o link, Rotas do Rails de Fora pra Dentro

Bem, aqui está o código.

require "rails_helper"

RSpec.describe "rotas para Produtos", :type => :routing do
  let(:produto) { Produto.create(name: "colar") }

  it "rotas /produtos para action index de controller Produtos" do
    expect(get("/produtos")).
      to route_to(:controller => "produtos", :action => "index")
  end

  it "rotas /produtos/:id para action show de controller Produtos" do
    expect(get("/produtos/#{produto.id}")).
      to route_to(:controller => "produtos", :action => "show", id: produto.id)
  end

  it "rotas /produtos/new para action new de controller Produtos" do
    expect(get("/produtos/new")).
      to route_to(:controller => "produtos", :action => "new")
  end

  it "rotas /produtos/:id/edit para action edit de controller Produtos" do
    expect(get("/produtos/#{produto.id}/edit")).
      to route_to(:controller => "produtos", :action => "edit", id: produto.id)
  end

  it "rotas /produtos para action create de controller Produtos" do
    expect(post("/produtos")).
      to route_to(:controller => "produtos", :action => "create")
  end

  it "rotas /produtos para action update de controller Produtos" do
    expect(put("/produtos/#{produto.id}")).
      to route_to(:controller => "produtos", :action => "update", id: produto.id)
  end

  it "rotas /produtos para action delete de controller Produtos" do
    expect(delete("/produtos/#{produto.id}")).
      to route_to(:controller => "produtos", :action => "destroy", id: produto.id)
  end
end

Bem, como que eu explico isso.

Serio, eu não sei como que explicar algo obvio.

Eu vou acabar aqui, justamente por isso, então se tiver algumas dúvidas, pode colocar no cometário, que eu vou responder e quem sabe eu coloco a resposta nessa postagem.

Então é isso, tchau!

Testando views em RSpec Rails

Alexandre — Fri, 09 Dec 2022 14:26:22 +0000

Até agora, nós testamos o model e request, ainda falta views, system, mailer, channel e routes.

Também existe outros, como controller, feature, helper, job e mailbox, porém alguns deles estão obsoleta ou é trivial para gente.

O nosso foco é Views.

Mas o que é que vamos testar nele?

Bem, o conteúdo.

Nós vamos testar se a view está de fato com informação que precisamos.

Lembre-se que esse teste não testa o javascript.

Mas talvez você se pergunte de o por quê desse teste.

Bem, vamos criar um situação aqui, imagine que você tem um e-commerce e então um usuário clica em um produto chamado "Camiseta de Boku no hero" e ele é redirecionado para outra página que tem mais detalhes sobre essa camiseta, porém o usuário descobre que a página está com informação errada, porque produto não é o que ele escolheu, pois o nome do produto está "Camiseta de Boku no pico" e convenhamos que isso é problemático.

Então, o que aconteceu?

Depende, existe muitos fatores que pode ter ocorrido para causar esse problema.

Mas como evitaria esse problema?

Bem, testando.

Se tivesse testado que o conteúdo está correto, talvez descobriria a fonte do problema, mas não, você decidiu que esse teste é irrelevante.

Bem, chega de papo, vamos construir a aplicação.

A nossa aplicação só vai ter um controller e um model, que é o produto, só isso.

Se quiser acompanhar a gente, basta executar os comandos abaixo.

rails new teste_views --skip-test
cd teste_views
rails db:create db:migrate
echo 'gem "rspec-rails", group: [:development, :test]' >> Gemfile
bundle install
rails g rspec:install

Bem, com a aplicação criada, vamos criar o model e o controller.

rails g model Produto nome preco:float descricao:text
rails db:migrate
rails g controller Produtos index

O nosso controller só vai ter uma action, pois, no nosso caso, não será necessário ter os show, new, create etc.

O nosso model tem nome, preço e descrição, e são eles que tem a informação que nós queremos testar.

Vamos para spec/views/produtos/index.html.erb_spec.rb e adiciona o teste.

# spec/views/produtos/index.html.erb_spec.rb
require 'rails_helper'

RSpec.describe "produtos/index.html.erb", type: :view do
  it "Deve mostrar todos os produtos" do
    Produto.create(
      nome: "Camiseta de Boku no hero",
      preco: 100,
      descricao: "Uma camiseta de Midoriya"
    )

    Produto.create(
      nome: "Camiseta de One piece",
      preco: 100,
      descricao: "Uma camiseta de Zoro"
    )

    assign(:produtos, Produto.all)

    render

    expect(rendered).to match "Camiseta de Boku no hero"
    expect(rendered).to match "Camiseta de One piece"
  end

  it "Não deve ter os produtos" do
    assign(:produtos, Produto.all)

    render

    expect(rendered).not_to match "Camiseta de Boku no hero"
    expect(rendered).not_to match "Camiseta de One piece"
  end
end

Bem, é pequeno, o teste.

E de fato, é pequeno, porque não tem muito o que testar além do conteúdo.

Bem, vamos analisar o código, o que podemos ver de coisas novas, se você acompanha essa série que fiz, são:

assign
render
rendered
match

Vamos de cada vez.

Eu não sei se você lembra do método assigns que usamos no teste de request, apesar de ter nome iguais, o que difere é a letra s no final, e a funcionalidade deles são diferentes.

O assigns pega o valor da variável de instância do controller, enquanto o assign atribui para uma variável de instância do controller.

Agora vamos ver os argumentos que eu passei, no primeiro argumento, eu passei um symbol do nome da variável, isso significa que ele vai atribuir o valor para o @produtos, e o segundo argumento é o valor e eu coloquei uma array de produtos.

Não tem muito segredo nesse método, então é isso.

O render é o método que renderizar a página, ou seja, ele vai criar a página web.

O rendered é a página renderizada pelo o render.

E o match é o método de busca de string em uma string.

Pronto, com explicação dada, vamos rodar o teste.

rspec

Finished in 0.55462 seconds (files took 4.11 seconds to load)
6 examples, 1 failure, 2 pending

Failed examples:

rspec ./spec/views/produtos/index.html.erb_spec.rb:4 # produtos/index.html.erb Deve mostrar todos os produtos

É obvio que falhou, porque não fizemos nada com a view e o controller.

Vamos primeiro para o controller, vá para app/controllers/produtos_controller.rb

class ProdutosController < ApplicationController
  def index
    @produtos = Produto.all
  end
end

Pronto, agora vamos para o app/views/produtos/index.html.erb e colocar os produtos.

# app/views/produtos/index.html.erb

<%= @produtos.each do |produto| %>
    <%= produto.nome %>
<% end %>

Vamos rodar o teste.

rspec

Finished in 0.60784 seconds (files took 5.35 seconds to load)
6 examples, 0 failures, 2 pending

Sem nenhuma falha.

E é isso, nós acabamos por aqui.

Como eu não tenho nada o que falar, tchau!

Testando Request em RSpec Rails

Alexandre — Fri, 09 Dec 2022 10:08:58 +0000

Anteriormente, nós fizemos teste para model, agora vamos fazer teste para requests.

O que é o request e porque é importante testar ele.

Antes de nós testar, primeiramente, nós temos que entender o request, que traduzindo seria, requisição.

Você deve saber, eu espero, que a nossa internet funciona com base de requisição e resposta, ou seja, no meu navegador, eu estou requisitando uma página web para um servidor, e o servidor, por sua vez, vai me dar uma resposta sobre a requisição.

O servidor pode aceitar a requisição, pode negar ou até mesmo pode dar erro.

E é esse o nosso objetivo, nós queremos testar o que acontece quando faço requisição de formato HTML ou JSON, ou então quando acesso em uma página não autorizada, etc.

Então, para começar, vamos criar uma aplicação do começo para que vocês consigam me acompanhar.

A nossa ideia da aplicação é um simples blog, onde vai ter um controller e um model que é o post.

Se você quiser me acompanhar, basta executar os comandos abaixo para criar a aplicação.

rails new blog --skip-test
cd blog
echo 'gem "rspec-rails", group: [:development, :test]' >> Gemfile
echo 'gem "rails-controller-testing", group: :test' >> Gemfile
bundle install
rails g rspec:install
rails g resource Post titulo corpo:text
rails db:create db:migrate

Pronto com isso, estamos pronto para testar.

Testando

Beleza, para testar os requests não é tão difícil assim.

vamos escrever os testes

# spec/requests/posts_spec.rb
require 'rails_helper'

RSpec.describe "Posts", type: :request do
  describe "GET posts" do
    it "deve retornar sucesso" do
      get posts_path

      expect(response).to have_http_status(:success)
    end
  end

  describe "GET post" do
    it "deve retornar sucesso" do
      post = Post.create(titulo: "Ólá", corpo: "bla bla bala")
      get post_path(post)

      expect(response).to have_http_status(:success)
    end

    it "deve ser redirecionado por não existir o post" do
      get post_path("não existo")

      expect(response).to have_http_status(:not_found)
    end
  end

  describe "GET new post" do
    it "deve retornar sucesso" do
      get new_post_path

      expect(response).to have_http_status(:success)
    end
  end

  describe "Post posts" do
    it "deve retornar created" do
      post posts_path, params: {
        post: {
          titulo: "Reza a lenda",
          corpo: "Ele está vindo"
        }
      }

      expect(response).to redirect_to(post_path(assigns(:post)))
    end
  end

  describe "GET edit post" do
    it "deve retornar sucesso" do
      post = Post.create(titulo: "Ólá", corpo: "bla bla bala")
      get edit_post_path(post)

      expect(response).to have_http_status(:success)
    end

    it "deve ser redirecionado por não existir o post" do
      get edit_post_path("não existo")

      expect(response).to have_http_status(:not_found)
    end
  end

  describe "PUT post" do
    it "deve retornar sucesso" do
      post = Post.create(titulo: "Ólá", corpo: "bla bla bala")
      put post_path(post), params: {
        post: {
          titulo: "sou eu o",
          corpo: "tiririca"
        }
      }

      expect(response).to redirect_to(post_path(assigns(:post)))
    end

    it "deve ser redirecionado por não existir o post" do
      put post_path("não existo"), params: {
        post: {
          titulo: "sou eu o",
          corpo: "tiririca"
        }
      }

      expect(response).to have_http_status(:not_found)
    end
  end

  describe "DELETE post" do
    it "deve retornar sucesso" do
      post = Post.create(titulo: "Ólá", corpo: "bla bla bala")
      delete post_path(post)

      expect(response).to have_http_status(:redirect)
    end

    it "deve ser redirecionado por não existir o post" do
      delete post_path("não existo")

      expect(response).to have_http_status(:not_found)
    end
  end
end

É meio grandinho, mas não tem muitas diferenças em teste de model, como nós fizemos antes.

Só vamos dar a atenção nesses métodos que vou citar.

get
post
put
delete
have_http_status
redirect_to
assigns

É só isso, porém existe mais métodos, como patch etc, mas raramente você usa ele.

Os primeiros quatros métodos são, obviamente, métodos de requisição HTTP, se não sabe sobre isso, eu recomendo que estude isso, porque isso é bastante importante.

Não tem muito o que explicar sobre eles, pois o próprio nome diz o que eles fazem.

Então vamos para have_http_status e redirect_to.

O have_http_status é um método para verificar se o argumento passado é equivalente ao "status code" da resposta do servidor.

Enquanto o redirect_to é o método para verificar se o argumento passado é equivalente ao página que o servidor redirecionou.

Não tem muito segredo, se você entende de protocolo HTTP.

Agora nós temos o método assigns, ele relaciona com a variável da instância, ou seja, vamos pegar o nosso caso, o argumento que eu passei foi :post, isso seria o equivalente o @post, isso é útil para caso em que você quer o id do post, que é o nosso caso, ou então saber que ele foi criado ou atualizado com sucesso.

Pronto, terminei com a explicação, agora vamos testar.

rspec

Finished in 0.4995 seconds (files took 4.57 seconds to load)
13 examples, 11 failures, 2 pending

Failed examples:

rspec ./spec/requests/posts_spec.rb:5 # Posts GET posts deve retornar sucesso
rspec ./spec/requests/posts_spec.rb:13 # Posts GET post deve retornar sucesso
rspec ./spec/requests/posts_spec.rb:20 # Posts GET post deve ser redirecionado por não existir o post
rspec ./spec/requests/posts_spec.rb:28 # Posts GET new post deve retornar sucesso
rspec ./spec/requests/posts_spec.rb:36 # Posts Post posts deve retornar created
rspec ./spec/requests/posts_spec.rb:49 # Posts GET edit post deve retornar sucesso
rspec ./spec/requests/posts_spec.rb:56 # Posts GET edit post deve ser redirecionado por não existir o post
rspec ./spec/requests/posts_spec.rb:64 # Posts PUT post deve retornar sucesso
rspec ./spec/requests/posts_spec.rb:76 # Posts PUT post deve ser redirecionado por não existir o post
rspec ./spec/requests/posts_spec.rb:89 # Posts DELETE post deve retornar sucesso
rspec ./spec/requests/posts_spec.rb:96 # Posts DELETE post deve ser redirecionado por não existir o post

Bem, nós esquecemos de criar as actions do controller e as views.

Vamos para app/controller/posts_controller.rb e criar as actions.

# app/controller/posts_controller.rb

class PostsController < ApplicationController
    before_action :define_post, except: [:index, :new, :create]

    def index
          @post = Post.all
    end

    def show
    end

    def new
    end

    def create
        @post = Post.new 

        if @post.save
            redirect_to post_path(@post)
        else
            render :new, status: :unprocessable_entity
        end
    end

    def edit
    end

    def update
        if @post.update post_params
            redirect_to post_path(@post)
        else
            render :edit
        end
    end

    def destroy
        if @post.destroy
            redirect_to posts_path
        end
    end

    private

    def post_params
        params.require(:post).permit(:titulo, :corpo)
    end

    def define_post
        begin
            @post = Post.find(params[:id])
        rescue ActiveRecord::RecordNotFound
            redirect_to posts_path, status: :not_found
        end
    end
end

Pronto, criamos as actions, agora vamos criar as views, basta executar os comandos abaixo.

touch app/views/posts/index.html.erb app/views/posts/show.html.erb app/views/posts/new.html.erb app/views/posts/edit.html.erb

Agora sim, nós estamos pronto, vamos rodar o teste.

rspec

Finished in 0.81536 seconds (files took 4.77 seconds to load)
13 examples, 0 failures, 2 pending

Passou.

E é isso, terminamos aqui, só que não, eu estava pensando aqui, será que vale a pena fazer um teste para uma aplicação de API? Pois é útil aprender como que testa as requisições do tipo JSON.

Mas não vale a pena, porque seria um copiar e colar e colocar um argumento header e testar se resposta é json.

Eu só vou fazer só um teste de requisição para ter noção.

Vamos para spec/requests/post_spec.rb.

# spec/requests/post_spec.rb
require 'rails_helper'

RSpec.describe "Posts", type: :request do
  describe "GET posts" do
    ...

    describe "requisição json" do
      it "deve retornar sucesso" do
        headers = { "ACCEPT": "application/json" }
        get posts_path, headers: headers

        expect(response.content_type).to eq("application/json; charset=utf-8")
        expect(response).to have_http_status(:success)
      end
    end
  end
  ...
end

Se nós analisamos o teste, vai perceber que não teve muita diferença o que a gente fez anteriormente, eu passei o argumento headers no get e testei se o tipo de conteúdo é JSON, só isso.

Se nós rodar o teste, é obvio que vai falhar, então para evitar isso, vamos para app/controller/post_controller.rb.

class PostsController < ApplicationController
  ...
  def index
    @posts = Post.all

    respond_to do |format|
      format.html
      format.json { render json: @posts }
    end
  end
  ...
end

Com isso, a nossa aplicação aceita a requisição HTML e JSON.

Agora, se nós rodar o teste, vai funcionar, e isso é o suficiente para nós testar a aplicação que atende requisição json.

Com isso, nós terminamos aqui.

Tchau!

Testando model em RSpec Rails.

Alexandre — Thu, 08 Dec 2022 21:55:29 +0000

Vamos aprender a testar o model em rails usando o RSpec.

Mas antes de aprender a testar, vamos criar uma aplicação para ter uma visualização a nossa aplicação.

Eu vou criar um simples blog, em que vai ter duas tabelas.

Post: titulo e corpo
Comentario: texto e post_id

Tendo a noção da minha aplicação, vamos criar ele.

Criando a aplicação

rails new testando_model --skip-test
cd testando_model
rails db:create db:migrate
echo 'gem "rspec-rails", group: [:development, :test]' >> Gemfile
bundle install
rails g rspec:install

Primeiro vamos criar o model Post e migrar ele.

rails g model Post titulo corpo:text
rails db:migrate

Pronto com isso, nós podemos testar.

Testando o model

Vamos abrir o arquivo spec/models/post_spec.rb e fazer um teste simples.

Então vamos fazer um teste simples.

# spec/models/post_spec.rb
require 'rails_helper'

RSpec.describe Post, type: :model do
  it "deve criar um post" do
    Post.create
    expect(Post.count).to equal(1)
    # traduzindo isso, seria desse jeito
    # Espero que a contagem do post seja igual 1
  end
end

O método it permite você passe o argumento de uma string que explique o seu teste e tem que utilizar o bloco para executar o seu teste.

O método expect recebe o argumento do valor atual, que o nosso caso é a contagem do post, e depois disso, tem o to que tenta comparar o valor atual de acordo com primeiro argumento, que é o método equal que contém o valor esperado.

Isso seria a mesma lógica que esse código que eu vou fazer, só que o meu código não foi feito para teste.

Post.count == 1

Bem, vamos rodar o teste.

rspec
.

Finished in 0.08076 seconds (files took 3.83 seconds to load)
1 example, 0 failures

O teste passou, isso significa que pelos menos é possível criar um post.

Agora vamos nos aprofundar um pouco.

Eu quero testar que não é possível criar um post sem título e corpo.

Também quero que tenha limite de caracteres do título e do corpo.

Então eu vou mudar o primeiro teste para que possa adaptar as condições que citei em cima e adiciona mais testes.

# spec/models/post_spec.rb
require 'rails_helper'

RSpec.describe Post, type: :model do
  it "deve ser valido um post com titulo e corpo" do
    post = Post.new(
      titulo: "Instalando rpsec",
      corpo: "Lero lero"
    )
    expect(post).to be_valid
    # espero que o post seja valido
  end

  it "não deve ser valido sem o titulo" do
    post = Post.new(
      titulo: nil,
      corpo: "Lero lero"
    )
    expect(post).not_to be_valid
    # espero que o post não seja valido
  end

  it "não deve ser valido sem um titulo" do
    post = Post.new(
      titulo: "instalando rpsec",
      corpo: nil
    )
    expect(post).not_to be_valid
    # espero que o post não seja valido
  end

  it "não deve ser valido com um titulo maior que 50 caracteres" do
    post = Post.new(
      titulo: "a"*51,
      corpo: nil
    )
    expect(post).not_to be_valid
    # espero que o post não seja valido
  end

  it "não deve ser valido com um corpo maior que 500 caracteres" do
    post = Post.new(
      titulo: "Como não ser burro",
      corpo: "o"*501
    )
    expect(post).not_to be_valid
    # espero que o post não seja valido
  end
end

Pronto, Vamos rodar o teste.

rspec

Finished in 0.15579 seconds (files took 4.44 seconds to load)
5 examples, 4 failures

Failed examples:

rspec ./spec/models/post_spec.rb:13 # Post não deve ser valido sem o titulo
rspec ./spec/models/post_spec.rb:22 # Post não deve ser valido sem um titulo
rspec ./spec/models/post_spec.rb:31 # Post não deve ser valido com um titulo maior que 50 caracteres
rspec ./spec/models/post_spec.rb:38 # Post não deve ser valido com um corpo maior que 500 caracteres

É, os testes falharam, isso significa que nossa aplicação não está seguindo do jeito que nós queríamos.

Então, vamos consertar a nossa aplicação.

Primeiro, vamos para o arquivo app/models/post.rb e adicionar algumas validação.

# app/models/post.rb
class Post < ApplicationRecord
  validates :titulo, presence: true, length: { maximum: 50 }
  validates :corpo, presence: true, length: { maximum: 500 } 
end

Agora, os testes devem passar.

rspec

.....

Finished in 0.08726 seconds (files took 4.24 seconds to load)
5 examples, 0 failures

Ta dã, os testes passaram, isso significa que no minimo, o seu código é minimamente confiável.

Mas vamos organizar ele, pois está feio.

# spec/models/post_spec.rb
require 'rails_helper'

RSpec.describe Post, type: :model do
  subject(:post) do
    Post.new( titulo: "Instalando rpsec", corpo: "Lero lero" )
  end

  context "é valido" do
    it "deve ser valido um post com titulo e corpo" do
      expect(post).to be_valid
    end
  end

  context "não está preenchido os campos" do
    it "não deve ser valido sem o titulo" do
      post.titulo = nil
      expect(post).not_to be_valid
    end

    it "não deve ser valido sem um titulo" do
      post.corpo = nil
      expect(post).not_to be_valid
    end
  end

  context "passou do limite de caracteres" do
    it "não deve ser valido com um titulo maior que 50 caracteres" do
      post.titulo = "a" * 51
      expect(post).not_to be_valid  end

    it "não deve ser valido com um corpo maior que 500 caracteres" do
      post.corpo = "o" * 501
      expect(post).not_to be_valid
    end
  end
end

Você pode notar algumas palavras novas nesse código, mas não se preocupa que eu vou explicar cada uma dela.

Explicando o subject e context

Primeiro, vamos começar com subject, nós podemos dizer que é o objeto que está sendo testado, que o nosso caso seria o objeto da classe Post.

Com isso, nós podemos usá-la em qualquer parte do código.

Agora vamos falar sobre o context, como o nome diz, é o contexto do bloco.

No primeiro context, eu defino que aquele bloco, só tem validação correta.

Enquanto o segundo context foi definido que aquele bloco só tem validação incorreta por falta de valores.

E o terceiro, a mesma coisa que segundo, porém com ultrapassagem do limite de caracteres.

E é só isso.

Agora vamos testar o código

rspec

.....

Finished in 0.07729 seconds (files took 3.84 seconds to load)
5 examples, 0 failures

Está funcionando.

Vamos tentar adicionar um teste que vai falhar com certeza absoluta.

Eu quero testar se o post tem comentário e quantos ele tem.

Eu vou omitir os outros testes para ocupar menos espaços.

# spec/models/post_spec.rb
...
  context "#tem_quantos_comentario" do
    it "deve ter dois comentario" do
      Comentario.create(texto: "Foda", post: post)
      Comentario.create(texto: "Gostei", post: post)

      expect(post.tem_quantos_comentario).to equal(2)
    end

    it "não deve ter nenhum comentario" do
      expect(post.tem_quantos_comentario).to equal(0)
    end
  end

  context "#tem_comentario?" do
    it "deve retornar true" do
      Comentario.create(texto: "Foda", post: post)

      expect(post.tem_comentario?).to be_truthy
    end

    it "deve retornar false" do
      expect(post.tem_comentario?).to be_falsey
    end
  end

Vcoê pode ter percebido esse # antes do nome no context.

Isso é um forma de dizer que esse contexto está testando o método da instância. Se você colocar um . antes do método, você está dizendo que o contexto é testar o método da classe.

Se nós rodar o código, obviamente vai falhar, porque ainda não existe o model Comentario e os métodos, então vamos criar eles.

rails g model Comentario texto post:references
rails db:migrate

Agora vamos criar os métodos e colocar associação do comentário com post.

# app/models/post.rb

class Post < ApplicationRecord
  has_many :comentarios

  validates :titulo, presence: true, length: { maximum: 50 }
  validates :corpo, presence: true, length: { maximum: 500 } 

  def tem_quantos_comentario
    self.comentarios.count
  end

  def tem_comentario?
    self.comentarios.count >= 1
  end
end

Agora vamos testar o código.

rspec

*.........

Pending: (Failures listed here are expected and do not affect your suite's status)

  1) Comentario add some examples to (or delete) /tmp/testando_model/spec/models/comentario_spec.rb
     # Not yet implemented
     # ./spec/models/comentario_spec.rb:4


Finished in 0.19358 seconds (files took 3.74 seconds to load)
10 examples, 0 failures, 1 pending

Está tudo funcionando.

Bem, eu não vou testar o comentário, porque não seria muito diferente do teste Post.

Então eu deixo você fazer o resto.

Pronto, com isso, nós podemos dar a segurança aos nossos models com esses testes.

É claro que os nossos testes feito aqui não o suficiente.

Nós temos que testar a associação, remoção de dados de banco de dados etc.

No próximo post, eu vou testar os requests.

E é isso, Tchau!

Instalando Rspec em Rails 7

Alexandre — Thu, 08 Dec 2022 21:53:38 +0000

Para que o seu código seja bom, é necessário que seu código seja testado, se não, o código não é bom, mesmo que que esteja organizado, legível, etc.

Então para testar os nossos códigos, nós vamos instalar a Rspec em Rails.

Antes de começar, vamos criar uma aplicação rápida.

rails new testando_codigo --skip-test
bin/rails db:create db:migrate

Esse comando --skip-test, serve para não criar o diretório test/.

Pronto, agora com aplicação criada, vamos colocar a gem.

Abra no arquivo Gemfile, e coloque a gem "rspec-rails" no grupo de desenvolvimento e teste, como você pode ver embaixo.

...
group :development, :test do
  ...
  gem "rspec-rails"
end
...

Agora, vamos executa o bundle install.

bundle install

Pronto, agora o rspec está instalado na aplicação, porém ainda falta uma coisa, os arquivos.

Para gerar os arquivos de rpsec, rode o código abaixo.

rails generate rspec:install

Isso vai criar o diretório spec/, e alguns arquivos necessários para teste.

Com isso, nós estamos pronto para testar.

Eu não vou mostrar como que testa, mas eu farei uma série de postagem de teste, como 'model', 'request', 'view', etc.

Bem, vamos continuar.

Vamos gerar um scaffold, para livrar o trabalho de escrever o teste.

rails g scaffold usuario nome

Pronto com scaffold gerado, execute o rspec.

rspec
.
.
.
Finished in 1.34 seconds (files took 7.56 seconds to load)
27 examples, 0 failures, 14 pending

Pronto, com rspec instalado, você pode testar que o seu código.

Então é isso, tchau!