Uma carta de amor ao Ruby on Rails pt.2

1/13/2026 7 min de leitura

#ruby #rails #programacao #web #aplicacao

Depois do projeto fiscal, resolvi criar algo mais simples, mas igualmente útil. A ideia era fazer uma aplicação que eu mesmo pudesse usar no dia a dia. Algo para calcular preço por hora de serviços ou produtos. Parece simples, mas foi uma ótima oportunidade para explorar mais as facilidades do Rails e ver como ele facilita criar aplicações práticas rapidamente.

O Ruby Price Per Hour é exatamente isso: uma aplicação web que calcula o preço por hora baseado em diferentes variáveis - custo total, horas trabalhadas, margem de lucro desejada. Parece básico, mas foi interessante ver como o Rails permite criar algo funcional e útil em pouco tempo.

E foi aí que percebi uma coisa: às vezes, os melhores projetos são os mais simples. Não precisa ser complexo para ser útil. Não precisa ter mil funcionalidades para resolver um problema real.

O Projeto

A ideia do projeto é simples: você tem um serviço ou produto, precisa calcular quanto cobrar por hora, e quer fazer isso de forma rápida e organizada. Em vez de ficar fazendo contas na calculadora ou em planilhas, você tem uma aplicação web que faz isso para você.

A aplicação permite:

Calcular preço por hora baseado em custo total e horas trabalhadas
Adicionar margem de lucro desejada
Salvar cálculos para referência futura
Visualizar histórico de cálculos

É simples, mas útil. E foi perfeito para continuar aprendendo Rails de forma prática.

Rails: Criando Aplicações Rápidas

Uma das coisas que mais me impressionou no Rails foi a velocidade com que você consegue criar algo funcional. Em Java/Spring, criar uma aplicação web básica requer configuração de múltiplos arquivos, dependências, configurações de banco de dados, e por aí vai. No Rails, você roda alguns comandos e já tem uma aplicação funcionando.

Scaffold: Gerando Código Automaticamente

O Rails tem um comando chamado scaffold que gera automaticamente modelos, controllers, views e migrations. É impressionante:

rails generate scaffold Calculation cost:decimal hours:decimal margin:decimal price_per_hour:decimal

Um comando, e você tem:

Modelo Calculation com validações básicas
Controller com ações CRUD completas
Views para listar, criar, editar e deletar
Migration para criar a tabela no banco
Rotas configuradas automaticamente

É claro que você vai precisar ajustar e customizar, mas a base está pronta. Em Java, isso levaria muito mais tempo e código.

Active Record: Queries Simples e Poderosas

Para calcular o preço por hora, preciso buscar cálculos anteriores, fazer filtros, ordenações. Com Active Record, isso é trivial:

# Buscar cálculos recentes
Calculation.order(created_at: :desc).limit(10)

# Buscar cálculos com margem acima de 20%
Calculation.where("margin > ?", 20)

# Calcular média de preços por hora
Calculation.average(:price_per_hour)

É código Ruby que se lê quase como português. Não precisa escrever SQL, não precisa de configuração complexa. É simples e funciona.

Callbacks: Lógica Automática

Uma das coisas mais úteis que aprendi foram os callbacks do Active Record. Eles permitem executar código automaticamente em momentos específicos do ciclo de vida de um objeto:

class Calculation < ApplicationRecord
  before_save :calculate_price_per_hour

  private

  def calculate_price_per_hour
    return if cost.nil? || hours.nil? || hours.zero?

    base_price = cost / hours
    margin_amount = base_price * (margin / 100.0)
    self.price_per_hour = base_price + margin_amount
  end
end

Antes de salvar, o cálculo é feito automaticamente. Não preciso me preocupar em chamar um método manualmente, não preciso lembrar de fazer o cálculo em múltiplos lugares. O callback cuida disso.

É uma forma elegante de garantir que a lógica de negócio seja executada sempre que necessário, sem precisar confiar que você vai lembrar de chamar o método certo no lugar certo.

Validações: Garantindo Dados Corretos

Rails facilita muito a validação de dados. Em vez de escrever código de validação manual em múltiplos lugares, você define as regras no modelo:

class Calculation < ApplicationRecord
  validates :cost, presence: true, numericality: { greater_than: 0 }
  validates :hours, presence: true, numericality: { greater_than: 0 }
  validates :margin, presence: true, numericality: { greater_than_or_equal_to: 0, less_than_or_equal_to: 100 }
end

E pronto. O Rails valida automaticamente quando você tenta salvar. Se houver erro, o objeto não é salvo e você pode mostrar mensagens de erro na view. É simples, é direto, e funciona.

Views: HTML com Menos Código

As views do Rails usam ERB (Embedded Ruby), que permite misturar Ruby com HTML de forma natural:

<% @calculations.each do |calculation| %>
  <div class="calculation">
    <h3>Cálculo #<%= calculation.id %></h3>
    <p>Custo: R$ <%= number_to_currency(calculation.cost) %></p>
    <p>Horas: <%= calculation.hours %></p>
    <p>Margem: <%= calculation.margin %>%</p>
    <p><strong>Preço por Hora: R$ <%= number_to_currency(calculation.price_per_hour) %></strong></p>
  </div>
<% end %>

É limpo, é legível, e o Rails fornece helpers úteis como number_to_currency que formatam dados automaticamente. Não precisa escrever JavaScript para formatar números, não precisa se preocupar com internacionalização básica - o Rails já tem isso.

Rotas: Simples e Declarativas

O arquivo de rotas do Rails é uma delícia de ler:

Rails.application.routes.draw do
  root 'calculations#index'
  resources :calculations
end

Uma linha, resources :calculations, e você tem todas as rotas RESTful configuradas:

GET /calculations - lista todos
GET /calculations/new - formulário de criação
POST /calculations - cria novo
GET /calculations/:id - mostra um
GET /calculations/:id/edit - formulário de edição
PATCH /calculations/:id - atualiza
DELETE /calculations/:id - deleta

Em Java/Spring, você precisaria anotar cada método do controller, configurar cada rota manualmente. No Rails, é uma linha.

O Que Aprendi Neste Projeto

Simplicidade é uma virtude: Não precisa ser complexo para ser útil. Uma aplicação simples que resolve um problema real é melhor que uma aplicação complexa que ninguém usa.
Rails acelera desenvolvimento: As ferramentas que o Rails oferece - scaffold, Active Record, callbacks, validações - permitem criar aplicações funcionais muito rapidamente.
Convenção sobre configuração funciona: Seguir as convenções do Rails significa menos decisões, menos código, menos erros. Você não precisa decidir onde colocar cada arquivo, como nomear cada classe - o Rails já tem uma resposta.
Callbacks são poderosos: Usar callbacks para executar lógica automaticamente torna o código mais limpo e menos propenso a erros.
Validações no modelo são essenciais: Validar dados no modelo garante que as regras de negócio sejam aplicadas consistentemente, independente de onde os dados vêm.

Os Desafios

Pensar diferente: Vindo do Java, foi difícil me acostumar com a flexibilidade do Ruby e as convenções do Rails. Mas depois que você entende, tudo faz sentido.
Decidir o que customizar: O scaffold gera muito código. Decidir o que manter como está e o que customizar foi um aprendizado.
Entender os helpers: O Rails tem muitos helpers úteis, mas descobrir quais usar e quando foi um processo de tentativa e erro.

Para Quem Quer Ver o Código

O projeto está disponível no GitHub: ruby-price-per-hour. Lá você encontra:

Aplicação completa de cálculo de preço por hora
Uso de callbacks para cálculos automáticos
Validações no modelo
Interface web simples e funcional
Código organizado seguindo convenções do Rails

É um projeto simples, mas funcional. Perfeito para entender como o Rails facilita o desenvolvimento de aplicações web práticas.

O Fim da História

Este projeto me mostrou que Rails não é só para aplicações complexas. É também para aplicações simples que resolvem problemas reais. E às vezes, essas são as mais úteis.

A velocidade com que consegui criar algo funcional foi impressionante. Em Java, criar uma aplicação web básica requer muito mais configuração, muito mais código boilerplate. No Rails, você foca no que importa: a lógica de negócio e a experiência do usuário.

E no final das contas, foi uma experiência valiosa. Não só aprendi mais sobre Rails, mas também aprendi que simplicidade não é sinônimo de falta de qualidade. Uma aplicação simples, bem feita, que resolve um problema real, é muito mais valiosa que uma aplicação complexa que ninguém entende ou usa.

Fora isso… Obrgiado pela atenção, um abraço e até mais!