DEV Community: Alef Ojeda de Oliveira

Competências Essenciais para um Desenvolvedor Ruby on Rails

Alef Ojeda de Oliveira — Mon, 17 Nov 2025 00:13:09 +0000

1. Fundamentos da Linguagem Ruby

Sintaxe, classes, módulos e mixins
Orientação a objetos aplicada
Blocks, Procs e Lambdas
Enumeráveis e coleções
Metaprogramação prática
Tratamento de exceções

2. Arquitetura Ruby on Rails

MVC completo (Models, Views, Controllers)
Active Record e callbacks
Active Model e validations
Active Support (concerns, inflectors, helpers)
Action Controller e filtros
Action View e helpers

3. Banco de Dados

SQL avançado
Migrations
Associação entre modelos (belongs_to, has_many, has_one, has_many :through, etc.)
Indexação, performance e EXPLAIN
Transações e locking
Uso de PostgreSQL (JSONB, CTEs, funções)
Uso de Oracle/MySQL conforme necessidade

4. Active Record Avançado

Arel e construção de queries
Scopes e ransackers
Otimização: includes, preload, eager_load
Joins complexos
Queries com CTEs
Estratégias de N+1

5. APIs e Serviços

Rails API mode
Versionamento de API
Serializers: Blueprinter, ActiveModelSerializers, JBuilder
Autenticação e autorização (Devise, JWT, OAuth2, Cancancan, Pundit)
Padrões REST e padrões de mercado

6. Background Jobs

Active Job
Sidekiq, Resque, Delayed Job
Retries, idempotência e fila

7. Testes

RSpec e Minitest
Testes unitários, de request, de modelo e integração
Factories (FactoryBot)
Mocking, stubbing e testes de serviços
Cobertura de testes

8. Front-end Integrado

Hotwire (Turbo + Stimulus)
ERB, HAML ou Slim
Importmap ou Webpacker / Vite no legado

9. Segurança

CSRF, XSS, SQL Injection
Sanitização de parâmetros
Configurações de cookies e sessions
Proteções nativas do Rails

10. Deploy e Infraestrutura

Docker e docker-compose
Kubernetes e Helm charts
Kamal
DigitalOcean, Heroku, AWS (EC2, RDS, S3)
Nginx/Apache
CI/CD (GitHub Actions, GitLab CI, CircleCI)

11. Observabilidade

Logs estruturados
Monitoração (Grafana, Prometheus)
Sentry, Bugsnag, Honeybadger
Métricas e tracing

12. Boas Práticas de Código

SOLID aplicado ao Rails
KISS, YAGNI, DRY
Service Objects, Form Objects, Query Objects
Decorators e Presenters
Padrão Repository quando necessário

13. Arquiteturas Avançadas

Engines Rails e aplicações modulares
Monolito modular
Microservices (somente quando necessário)
Event-driven architecture

14. Performance

Cache com Redis e Memcached
HTTP caching
Otimização de consultas
Benchmarking e profiling

15. Ferramentas comumente usadas

rbenv, asdf ou RVM
Bundler
Rubocop
Brakeman
Overmind/Foreman

16. Modernizações

Rails 7+ Hotwire
Rails 8 e Kamal
ActiveRecord Async Queries
Multi-DB e replicação

17. Cultura de Desenvolvimento

GitFlow, trunk-based e práticas de versionamento
Pull Requests, code review
Documentação de endpoints (RSwag, OAS-Rails)

18. Conhecimentos Complementares

Linux básico
Redes e HTTP
Noções de arquitetura de software
Containerização

19. Carreira

Júnior: fundamentos de Ruby, Rails, MVC, ActiveRecord, APIs simples
Pleno: domínio de SQL, otimizações, serviços, testes, Docker
Sênior: arquitetura, engines, escalabilidade, performance, liderança técnica

Rails Helper Link: "link_to_if and link_to_unless"

Alef Ojeda de Oliveira — Mon, 03 Feb 2025 12:14:24 +0000

Exploring the link_to_if and link_to_unless Helpers in Rails

The link_to_if and link_to_unless helpers in Ruby on Rails are valuable tools for conditionally generating links in your application. They help avoid unnecessary if/else structures, making the code cleaner and more readable.

`link_to_if`

The link_to_if helper creates a link only if the provided condition is true; otherwise, it renders the specified alternative content.

Example:

<%= link_to_if user_signed_in?, "Profile", profile_path, class: "btn btn-primary" %>

If the user is logged in, the link to the profile will be generated. Otherwise, only the text "Profile" will be displayed without being a link.

We can customize the content when the condition is false:

<%= link_to_if user_signed_in?, "Profile", profile_path do %>
  <span class="text-muted">Log in to view the profile</span>
<% end %>

`link_to_unless`

The link_to_unless helper does the opposite of link_to_if: it creates a link only if the condition is false. If the condition is true, it displays the content normally.

Example:

<%= link_to_unless admin?, "Request Access", request_access_path %>

If the user is not an administrator, a link to "Request Access" will be generated. If the user is an administrator, the text will be displayed normally, without being a link.

Similarly to link_to_if, we can customize the alternative content:

<%= link_to_unless admin?, "Request Access", request_access_path do %>
  <span class="text-muted">You already have administrator access</span>
<% end %>

Conclusion

These helpers are very useful for simplifying the logic of displaying links in Rails applications, avoiding the need for if/else blocks in the template. This makes the code more elegant and easier to maintain.

Did you like the tip? Share it with other developers! 🚀

Instalando Keycloak usando Docker

Alef Ojeda de Oliveira — Wed, 16 Oct 2024 02:11:05 +0000

Instalando o Keycloak Usando Docker

Introdução

Keycloak é uma ferramenta de gerenciamento de identidade e acesso que permite a autenticação e autorização de usuários em aplicações modernas. Ele é uma solução open-source que facilita o controle de segurança em diversos sistemas. Neste guia, vamos aprender a instalar o Keycloak utilizando Docker, de forma rápida e prática.

Pré-requisitos

Antes de começarmos, você precisa garantir que seu ambiente esteja preparado. Você precisará dos seguintes itens:

Docker: Certifique-se de ter o Docker instalado em sua máquina. Você pode verificar se ele está instalado executando o comando docker --version. Caso não tenha, siga as instruções de instalação para o seu sistema operacional aqui.

Passo 1: Baixar a Imagem do Keycloak

Para instalar o Keycloak usando Docker, primeiro baixe a imagem oficial do Keycloak. Execute o seguinte comando no terminal:

docker pull quay.io/keycloak/keycloak:latest

Este comando irá baixar a versão mais recente da imagem do Keycloak do repositório oficial.

Passo 2: Iniciar o Container do Keycloak

Depois de baixar a imagem, você pode iniciar o Keycloak com o seguinte comando:

docker run -p 8080:8080 -e KEYCLOAK_ADMIN=admin -e KEYCLOAK_ADMIN_PASSWORD=admin quay.io/keycloak/keycloak:latest start-dev

Este comando possui as seguintes opções:

-p 8080:8080: Mapeia a porta 8080 do container para a porta 8080 do host, permitindo o acesso ao Keycloak pelo navegador.
-e KEYCLOAK_ADMIN=admin e -e KEYCLOAK_ADMIN_PASSWORD=admin: Define o usuário administrador (admin) e a senha (admin).
start-dev: Inicia o Keycloak no modo de desenvolvimento, que é mais adequado para testes e configurações iniciais.

Passo 3: Acessar o Keycloak

Depois de iniciar o container, você pode acessar o Keycloak pelo navegador. Basta ir para http://localhost:8080.

Use o nome de usuário admin e a senha admin (ou a senha que você definiu) para fazer login no painel administrativo do Keycloak.

Passo 4: Configuração Básica

Assim que estiver logado, você pode criar novos Realms (ambientes de autenticação isolados, que contêm configurações, usuários e permissões), Clients (aplicações que usam Keycloak para autenticação, como aplicativos web ou serviços backend) e configurar Usuários (indivíduos que serão autenticados no sistema).

Se precisar fazer ajustes mais avançados, recomendo explorar a documentação oficial do Keycloak: https://www.keycloak.org/documentation.

Passo 5: Como Criar um Realm

No painel administrativo do Keycloak, clique em Realms no menu à esquerda.
Clique em Add Realm.
Insira um nome para o novo Realm e clique em Create.

Um Realm permite que você isole a configuração de autenticação, usuários e permissões, facilitando a administração de diferentes ambientes ou aplicações.

Passo 6: Como Criar um Client

Dentro do Realm que você criou, clique em Clients no menu à esquerda.
Clique em Create para adicionar um novo Client.
Insira um identificador para o Client (como o nome da aplicação) e clique em Save.
Configure o Client Protocol e outras configurações relevantes, como Access Type (confira se deseja confidential ou public, dependendo do tipo de aplicação).

O Client representa uma aplicação que utilizará Keycloak para autenticação, como uma aplicação web ou um serviço backend.

Passo 7: Como Criar um Usuário

No painel administrativo, clique em Users no menu à esquerda.
Clique em Add User para criar um novo usuário.
Preencha os campos obrigatórios, como Username, e clique em Save.
Depois de salvar, vá até a aba Credentials para definir uma senha para o usuário. Insira a senha desejada e clique em Set Password.

Com usuários criados, você poderá realizar testes de autenticação e configurar permissões específicas para cada um.

Comandos Úteis

Para parar o container:

  docker stop <container_id>

Substitua <container_id> pelo ID do container que você deseja parar. Você pode obter o ID do container usando o comando docker ps.

Para ver os logs:

  docker logs -f <container_id>

Substitua <container_id> pelo ID do container para visualizar os logs em tempo real.

Considerações Finais

Utilizando o Docker, o Keycloak pode ser instalado de maneira muito rápida e prática. Como próximos passos, considere explorar integrações com outras ferramentas, como um servidor LDAP ou uma aplicação backend. Além disso, para ambientes de produção, é altamente recomendável configurar medidas de segurança adicionais, como o uso de certificados SSL e ajustes nas permissões de acesso. Com isso, você tem uma infraestrutura poderosa de autenticação pronta para ser integrada a seus projetos.

Lembre-se de sempre manter o Keycloak e os componentes associados atualizados, garantindo assim maior segurança e estabilidade no seu sistema.

Ruby on Rails: Autenticação utilizando Devise + Keycloak

Alef Ojeda de Oliveira — Wed, 16 Oct 2024 01:56:36 +0000

Se você deseja adicionar uma camada de autenticação robusta e simplificar o gerenciamento de usuários na sua aplicação Ruby on Rails, você está no lugar certo! Neste guia, vou te mostrar como integrar o Devise com o Keycloak de forma prática e direta, para que sua aplicação tenha uma autenticação segura e fácil de manter.

Vamos começar juntos passo a passo, para garantir que tudo funcione perfeitamente e você consiga aproveitar o melhor dessas ferramentas.

1. Preparando o Ambiente

Antes de começar, certifique-se de ter o Keycloak rodando localmente ou em um servidor. Keycloak é uma solução de identidade e acesso muito poderosa que suporta autenticação via OAuth2 e OpenID Connect.

Link guia basico: Instalação Keycloak via Docker

2. Adicionando Dependências ao Projeto

No seu arquivo Gemfile, adicione as seguintes gems:

# Gemfile
gem 'devise'
gem 'omniauth-keycloak'
gem 'omniauth-rails_csrf_protection'

Depois, rode bundle install para instalar as dependências.

3. Configurando o Devise

Em seguida, configure o Devise. Se ainda não instalou o Devise na sua aplicação, execute:

rails generate devise:install

E depois crie um modelo de usuário:

rails generate devise User

4. Configurando o OmniAuth com Keycloak

Você precisará adicionar uma configuração personalizada para o OmniAuth para que ele possa se comunicar com o Keycloak. No arquivo config/initializers/devise.rb, configure o OmniAuth para usar o Keycloak:

Devise.setup do |config|
  # Outras configurações do Devise...

  config.omniauth :keycloak, 'CLIENT_ID', 'CLIENT_SECRET',
                  client_options: {
                    site: 'https://SEU_DOMINIO_DO_KEYCLOAK/auth',
                    realm: 'NOME_DO_SEU_REALM',
                    base_url: '',
                    redirect_uri: "http://localhost:3000/users/auth/keycloakopenid/callback"
                  },
                  provider_ignores_state: true,
                  scope: "openid,profile,email",
                  strategy_class: OmniAuth::Strategies::KeycloakOpenId
end

Substitua 'CLIENT_ID', 'CLIENT_SECRET', 'SEU_DOMINIO_DO_KEYCLOAK' e 'NOME_DO_SEU_REALM' pelos valores apropriados para a sua configuração do Keycloak.

5. Atualizando as Rotas

Você também precisa configurar as rotas para que o Devise possa lidar com a autenticação via OmniAuth. Além disso, você pode gerar o controller omniauth_callbacks automaticamente com o seguinte comando:

rails generate devise:controllers users -c omniauth_callbacks

No arquivo config/routes.rb, adicione:

devise_for :users, controllers: { omniauth_callbacks: 'users/omniauth_callbacks' }

6. Criando o Callback Controller

Você precisará criar um controller para lidar com os callbacks do OmniAuth. Crie o arquivo app/controllers/users/omniauth_callbacks_controller.rb com o seguinte conteúdo:

class Users::OmniauthCallbacksController < Devise::OmniauthCallbacksController
  def keycloak
    @user = User.from_omniauth(request.env['omniauth.auth'])

    if @user.persisted?
      sign_in_and_redirect @user, event: :authentication
      set_flash_message(:notice, :success, kind: 'Keycloak') if is_navigational_format?
    else
      session['devise.keycloak_data'] = request.env['omniauth.auth']
      redirect_to new_user_registration_url
    end
  end

  def failure
    redirect_to root_path
  end
end

7. Atualizando o Modelo User

Finalmente, você precisará adicionar um método ao seu modelo User para lidar com as informações recebidas do Keycloak:

class User < ApplicationRecord
  devise :database_authenticatable, :registerable,
         :recoverable, :rememberable, :validatable,
         :omniauthable, omniauth_providers: %i[keycloak]

  def self.from_omniauth(auth)
    where(provider: auth.provider, uid: auth.uid).first_or_create do |user|
      user.email = auth.info.email
      user.password = Devise.friendly_token[0, 20]
    end
  end
end

8. Testando a Integração

Com tudo configurado, você agora deve ser capaz de acessar a página de login e ver a opção para se autenticar com o Keycloak.

Para testar a autenticação, você também pode criar um endpoint protegido que requer que o usuário esteja autenticado. Por exemplo, adicione o seguinte método no seu controller:

class DashboardController < ApplicationController
  before_action :authenticate_user!

  def index
    render plain: 'Bem-vindo ao painel, você está autenticado!'
  end
end

Em config/routes.rb, adicione a rota:

get 'dashboard', to: 'dashboard#index'

Ao acessar /dashboard sem estar autenticado, você será redirecionado automaticamente para a página de login do Devise. Certifique-se de que as configurações do Keycloak estão corretas, incluindo o cliente configurado para suportar redirect_uri adequado.

Conclusão

A integração do Keycloak com Devise oferece uma solução segura e flexível para autenticação em aplicações Rails. Isso é especialmente útil para aplicações que precisam gerenciar autenticação de usuários em múltiplos sistemas.

Se tiver alguma dúvida ou quiser mais detalhes sobre algum passo, deixe um comentário!

Guia básico sobre lambda em Ruby

Alef Ojeda de Oliveira — Wed, 15 Mar 2023 01:26:16 +0000

Lambdas em Ruby são objetos que representam funções anônimas. Eles são úteis quando você precisa passar uma função como argumento para outra função ou quando deseja criar funções curtas e expressivas. Aqui está um guia prático sobre como usar lambdas em Ruby:

Criando uma lambda

Lambdas são criados usando a palavra-chave lambda ou ->. Aqui está um exemplo:

my_lambda = lambda { |x| x * 2 }
# ou
my_lambda = ->(x) { x * 2 }

Agora my_lambda é um objeto que representa uma função que multiplica seu argumento por 2.

Chamando uma lambda

Lambdas são chamados da mesma forma que uma função normal, usando a sintaxe lambda.call(argumento) ou simplesmente lambda(argumento). Aqui está um exemplo:

my_lambda = ->(x) { x * 2 }
resultado = my_lambda.call(3)
puts resultado # output: 6

Ou ainda, mais curto:

my_lambda = ->(x) { x * 2 }
resultado = my_lambda.(3)
puts resultado # output: 6

Passando uma lambda como argumento

Lambdas são frequentemente usados como argumentos de outras funções. Isso é especialmente útil quando você deseja passar uma função personalizada para uma função de ordem superior (como map, filter ou reduce). Aqui está um exemplo:

my_lambda = ->(x) { x * 2 }

# A função double_values aplica a função lambda em cada elemento do array
def double_values(array, fn)
  array.map { |x| fn.call(x) }
end

valores = [1, 2, 3, 4]
resultado = double_values(valores, my_lambda)
puts resultado # output: [2, 4, 6, 8]

Capturando variáveis em uma lambda

Lambdas também podem capturar variáveis do escopo em que foram criados. Isso pode ser útil para criar funções que têm acesso a variáveis locais ou de instância. Aqui está um exemplo:

def create_lambda
  mensagem = "Olá, mundo!"
  -> { puts mensagem }
end

# Cria uma lambda que imprime "Olá, mundo!"
my_lambda = create_lambda()
my_lambda.call()

Nesse exemplo, a lambda captura a variável mensagem do escopo em que foi criada. Quando a lambda é chamada, ela imprime a mensagem "Olá, mundo!".

Conclusão

As lambdas em Ruby são objetos poderosos que podem ajudar a tornar seu código mais conciso e expressivo. Com este guia prático, você deve ter uma boa compreensão de como criar, chamar e passar lambdas como argumentos. Experimente criar suas próprias lambdas e usá-las em suas funções!

How use the gem 'run_database_backup'

Alef Ojeda de Oliveira — Sat, 25 Feb 2023 12:45:12 +0000

Introduction

Data is a critical aspect of any application, and it's essential to have a reliable backup strategy in place to protect your data in case of a disaster or data loss. Fortunately, the "run_database_backup" gem provides an easy way to create backups of your MongoDB, PostgreSQL, and MySQL databases from within your Rails application.

In this guide, we'll walk you through the basic steps for using the "run_database_backup" gem to create backups of your databases.

Usage

Add the "run_database_backup" gem to your Gemfile:

gem 'run_database_backup'

Install the gem by running the following command:

bundle install

This will add the three backup tasks to your application.

To create a backup of your MongoDB database, run the following command:

rails mongo:backup[uri,database_name,backup_directory]

Replace "uri" with the URI for your MongoDB database (e.g. "mongodb://localhost:27017"), "database_name" with the name of the MongoDB database you want to back up, and "backup_directory" with the directory where you want to store the backup file.

For example, to create a backup of a MongoDB database called "app_database" running on the local machine and store the backup file in the "./tmp" directory, you would run:

rails mongo:backup['mongodb://localhost:27017','app_database','./tmp']

To create a backup of your PostgreSQL database, run the following command:

rails postgresql:backup[uri,database_name,backup_directory]

Replace "uri" with the URI for your PostgreSQL database (e.g. "postgresql://localhost"), "database_name" with the name of the PostgreSQL database you want to back up, and "backup_directory" with the directory where you want to store the backup file.

For example, to create a backup of a PostgreSQL database called "app_database" running on the local machine and store the backup file in the "./tmp" directory, you would run:

rails postgresql:backup['postgresql://localhost','app_database','./tmp']

Note that you will need to have the "pg_dump" utility installed on your machine in order to create a backup of a PostgreSQL database.

To create a backup of your MySQL database, run the following command:

rails mysql:backup[uri,database_name,backup_directory]

Replace "uri" with the URI for your MySQL database (e.g. "mysql2://localhost"), "database_name" with the name of the MySQL database you want to back up, and "backup_directory" with the directory where you want to store the backup file.

For example, to create a backup of a MySQL database called "app_database" running on the local machine and store the backup file in the "./tmp" directory, you would run:

rails mysql:backup['mysql2://localhost','app_database','./tmp']

Note that you will need to have the "mysqldump" utility installed on your machine in order to create a backup of a MySQL database.

Conclusion

In this guide, we've walked you through the basic steps for using the "run_database_backup" gem to create backups of your MongoDB, PostgreSQL, and MySQL databases from within your Rails application. By following these steps, you can quickly and easily create backups of your databases to protect your data in case of a disaster or data loss.

Remember to store your backup files in a secure location and to regularly test your backup strategy to ensure that you can restore your data when you need it.

To learn more about the "run_database_backup" gem, visit the gem's repository on GitHub: https://github.com/nemuba/run_database_backup

Happy backing up!

Pattern Service Objects em Ruby

Alef Ojeda de Oliveira — Fri, 24 Feb 2023 00:33:47 +0000

O padrão de design Service Objects é uma técnica útil e popular em Ruby on Rails para gerenciar a lógica de negócios complexa em seus aplicativos. O objetivo deste padrão é separar a lógica de negócios do controlador ou modelo e colocá-la em classes independentes chamadas de Service Objects. Esses objetos de serviço são responsáveis por executar uma tarefa específica ou um conjunto de tarefas relacionadas, tornando o código mais modular, legível e fácil de testar.

Vamos ver como implementar o padrão Service Objects em Ruby on Rails com um exemplo prático.

Suponha que temos um aplicativo que permite aos usuários reservar quartos de hotel. Quando um usuário faz uma reserva, precisamos verificar se o quarto está disponível e, em seguida, atualizar a disponibilidade do quarto e criar um registro de reserva no banco de dados.

Em vez de colocar toda a lógica de reserva em um controlador ou modelo, podemos criar um Service Object chamado ReservationService para gerenciar o processo de reserva. Aqui está um exemplo de implementação:

class ReservationService
  def initialize(room, user, start_date, end_date)
    @room = room
    @user = user
    @start_date = start_date
    @end_date = end_date
  end

  def call
    raise ArgumentError, 'Room is not available for these dates' unless room_available?

    create_reservation
  end

  private

  attr_reader :room, :user, :start_date, :end_date

  def room_available?
    # Check if room is available for the given dates
    !Reservation.exists?(room: room, end_date >= start_date, start_date <= end_date)
  end

  def create_reservation
    # Create reservation record in the database
    Reservation.create(room: room, user: user, start_date: start_date, end_date: end_date)
  end
end

Neste exemplo, o construtor do ReservationService recebe o quarto, o usuário e as datas de início e término da reserva. O método call é o ponto de entrada para o Service Object e é responsável por executar as tarefas de reserva.

O método room_available? verifica se o quarto está disponível para as datas da reserva. Ele usa a consulta ActiveRecord exists? para verificar se há alguma reserva que esteja ocorrendo durante as datas solicitadas.

O método create_reservation é responsável por criar o registro de reserva no banco de dados usando o modelo Reservation.

Agora, podemos chamar o ReservationService no controlador para processar as solicitações de reserva:

class ReservationsController < ApplicationController
  def create
    @room = Room.find(params[:room_id])
    @reservation = ReservationService.new(@room, current_user, params[:start_date], params[:end_date]).call

    if @reservation.persisted?
      flash[:notice] = 'Reservation successfully created'
      redirect_to @reservation
    else
      flash.now[:alert] = 'Error creating reservation'
      render 'rooms/show'
    end
  end
end

Neste exemplo, o controlador chama o ReservationService com o quarto, o usuário atual e as datas de início e término da reserva. Se a reserva for criada com sucesso, o usuário é redirecionado para a página de detalhes da reserva. Caso contrário, uma mensagem de erro é exibida.

Conclusão:

O padrão de design Service Objects é uma técnica poderosa para manter a lógica de negócios do seu aplicativo separada do controlador ou modelo. Isso ajuda a tornar seu código mais modular, legível e fácil de testar. Além disso, ele oferece uma solução escalável e flexível para gerenciar a lógica de negócios complexa.

No exemplo acima, criamos um Service Object chamado ReservationService para gerenciar o processo de reserva de quartos de hotel. Ao separar a lógica de negócios em um objeto separado, podemos testá-lo de forma isolada e alterá-lo sem afetar o resto do código. Isso torna o processo de desenvolvimento mais eficiente e mais fácil de manter.

Embora este exemplo seja específico para reservas de quartos de hotel, você pode usar o padrão Service Objects para gerenciar qualquer tipo de lógica de negócios em seu aplicativo. Espero que este exemplo prático ajude você a entender melhor como usar o padrão de design Service Objects em seus projetos Ruby on Rails.

Ruby - Similarity

Alef Ojeda de Oliveira — Thu, 19 Jan 2023 18:12:14 +0000

Existem várias maneiras de fazer comparação de similaridade entre strings em Ruby. Algumas das maneiras mais comuns incluem:

Levenshtein distance: É uma medida da distância entre duas strings, baseada na quantidade mínima de operações (inserção, deleção ou substituição de um caractere) necessárias para transformar uma string em outra. A biblioteca text possui um método levenshtein_distance que pode ser usado para calcular a distância de Levenshtein entre duas strings.
Jaro-Winkler distance: É uma medida da similaridade entre duas strings, baseada na quantidade de caracteres comuns nas primeiras posições das strings e na distância entre os caracteres comuns. A biblioteca amatch possui um método jaro_winkler que pode ser usado para calcular a distância de Jaro-Winkler entre duas strings.
Cosine similarity: É uma medida da similaridade entre duas strings baseada no cosseno do ângulo entre vetores que representam as strings. A biblioteca text-similarity possui um método cosine_similarity que pode ser usado para calcular a similaridade cosseno entre duas strings.
Fuzzy matching: É uma técnica de correspondência aproximada que permite comparar duas strings e encontrar similaridades, mesmo se elas não forem idênticas. A biblioteca fuzzy_match é uma boa opção para fazer correspondência fuzzy.
Shingling: É uma técnica de comparação de strings baseada em dividir as strings em conjuntos de caracteres consecutivos (shingles) e comparando a presença desses conjuntos entre as strings. A biblioteca shingles é uma boa opção para fazer comparação de similaridade baseado em shingling.

Essas são algumas das maneiras mais comuns de fazer comparação de similaridade entre strings em Ruby, mas existem outras técnicas e bibliotecas disponíveis. É importante escolher a técnica e a biblioteca mais adequadas para o seu caso de uso específico.

A técnica mais utilizada para comparação de similaridade entre strings varia de acordo com o caso de uso específico e as necessidades do projeto.

A distância de Levenshtein é amplamente utilizada para a comparação de strings curtas e é uma boa escolha para casos onde a precisão é mais importante do que a velocidade de processamento.

A distância de Jaro-Winkler é amplamente utilizada para a comparação de strings de nomes e é uma boa escolha para casos onde as strings são similares mas não são idênticas.

A Similaridade Cosseno é amplamente utilizada para a comparação de strings longas e é uma boa escolha para casos onde se deseja comparar documentos inteiros e encontrar similaridades entre eles.

Fuzzy matching é amplamente utilizada para a comparação de strings quando a precisão não é tão importante e é uma boa escolha para casos onde as strings podem conter erros de digitação ou variações.

Shingling é amplamente utilizada para a comparação de strings longas e é uma boa escolha para casos onde se deseja comparar documentos inteiros e encontrar similaridades entre eles.

É importante notar que cada técnica tem suas próprias limitações e vantagens e a escolha da técnica certa dependerá do seu caso de uso específico.

Exemplos

Para ficar mais ilustrativo aqui estão alguns exemplos de código Ruby que ilustram como calcular a similaridade entre strings usando as técnicas mencionadas anteriormente:

Levenshtein distance:

require 'text'
string1 = "kitten"
string2 = "sitting"
distance = Text::Levenshtein.distance(string1, string2)
puts "The Levenshtein distance between '#{string1}' and '#{string2}' is #{distance}"

Jaro-Winkler distance:

require 'amatch'
string1 = "DWAYNE"
string2 = "DUANE"
jaro = Amatch::Jaro.new(string1)
distance = jaro.match(string2)
puts "The Jaro-Winkler distance between '#{string1}' and '#{string2}' is #{distance}"

Cosine similarity:

require 'text-similarity'
string1 = "This is a test"
string2 = "This is a trial"
cosine = TextSimilarity::CosineSimilarity.new
similarity = cosine.getSimilarity(string1, string2)
puts "The cosine similarity between '#{string1}' and '#{string2}' is #{similarity}"

Fuzzy matching:

require 'fuzzy_match'
string1 = "fuzzy"
string2 = "fuzi"
fuzzy = FuzzyMatch.new([string1,string2])
match = fuzzy.find(string1)
puts "The fuzzy matching between '#{string1}' and '#{string2}' is #{match}"

Shingling:

require 'shingles'
string1 = "This is a test"
string2 = "This is a trial"
shingle = Shingles::Shingle.new(string1)
shingle2 = Shingles::Shingle.new(string2)
jaccard_distance = shingle.distance(shingle2)
puts "The jaccard distance between '#{string1}' and '#{string2}' is #{jaccard_distance}"

Considerações finais

Tenha em mente que esses são apenas exemplos básicos e você pode precisar personalizar esses códigos para atender às suas necessidades específicas. E também lembre-se de que essas bibliotecas podem ter dependências e precisam ser instaladas.

Otimizando consultas no banco de dados com o Rails

Alef Ojeda de Oliveira — Tue, 10 Jan 2023 00:55:10 +0000

O desempenho de um aplicativo é crucial para a experiência do usuário final e uma das principais áreas onde é possível fazer otimizações é na consulta ao banco de dados. O Ruby on Rails possui várias ferramentas embutidas que podem ajudar a minimizar o tempo de resposta das consultas e, consequentemente, melhorar o desempenho do aplicativo.

Uma das maneiras mais simples de otimizar consultas é através do uso de índices. Índices são estruturas de dados que são criadas em cima de uma ou mais colunas em uma tabela e servem para acelerar as buscas em um banco de dados. Por exemplo, se você tem uma tabela de usuários com milhões de linhas e precisa fazer uma consulta com base no e-mail do usuário, criar um índice na coluna de e-mail pode fazer com que a consulta seja muito mais rápida. Para criar um índice em uma coluna no banco de dados do Rails, basta adicionar a seguinte linha no seu modelo:

class User < ApplicationRecord
  # Adiciona um índice na coluna de e-mail
  add_index :users, :email
end

Outra maneira de otimizar consultas é através do uso de joins. Joins permitem que você faça consultas que combinam dados de duas ou mais tabelas. No entanto, é importante tomar cuidado ao utilizar joins, pois eles podem resultar em consultas muito lentas se não forem escritos de maneira eficiente. Por exemplo, a seguinte consulta utiliza um join ineficiente para obter os nomes dos usuários e os títulos de todos os posts que eles escreveram:

# Consulta ineficiente
users = User.joins(:posts).select("users.name, posts.title")

Em vez disso, você pode utilizar uma subconsulta para obter os mesmos resultados de maneira mais eficiente:

# Consulta mais eficiente
users = User.select("users.name").joins("INNER JOIN (SELECT * FROM posts) AS posts ON posts.user_id = users.id")

Outra técnica útil para otimizar consultas é a utilização de tabelas temporárias. Às vezes, você pode precisar fazer uma consulta complexa que envolva muitas tabelas e operações. Em vez de escrever uma consulta complexa de uma só vez, você pode criar uma tabela temporária com os dados intermediários e, em seguida, fazer uma consulta mais simples na tabela temporária. Isso pode ajudar a reduzir o tempo de resposta da consulta, pois o banco de dados não precisa calcular os dados intermediários toda vez que a consulta é executada.

Por exemplo, suponha que você queira obter a média de todas as notas de um conjunto de estudantes. Em vez de calcular a média com uma única consulta, você pode criar uma tabela temporária com as notas de cada estudante e, em seguida, calcular a média dessa tabela:

# Cria uma tabela temporária com as notas de cada estudante
Student.connection.execute("CREATE TEMPORARY TABLE student_averages AS (SELECT student_id, AVG(grade) as average FROM grades GROUP BY student_id)")

# Calcula a média geral das notas
overall_average = Student.connection.execute("SELECT AVG(average) FROM student_averages").first.first

Essas são apenas algumas das maneiras de otimizar consultas no banco de dados com o Ruby on Rails. Existem muitas outras técnicas e ferramentas disponíveis, como o uso de cache, otimização de consultas explícitas e o uso de ferramentas de otimização de consultas, como o EXPLAIN. Utilizar essas técnicas pode ajudar a garantir que o seu aplicativo Ruby on Rails tenha um desempenho otimizado e uma experiência do usuário excelente.

SimpleTask using Ruby on Rails 7, Stimulus and TailwindCSS

Alef Ojeda de Oliveira — Thu, 30 Dec 2021 15:36:38 +0000

I created a SPA application to manage tasks using Ruby on Rails 7.

This project was just to study the new framework pattern with turbo-rails and stimulus-js.

It was an incredible experience, I found it very simple to develop with it!

Follow the link below from github with the code!

Hugs !
Link Heroku: http://simple-task-hotwire.herokuapp.com
Link Github: https://github.com/nemuba/simple_task
Twitter: https://twitter.com/OjedaAlef

Listing all tables and listing the columns of a respective database table of the a rails application!

Alef Ojeda de Oliveira — Tue, 30 Nov 2021 19:10:39 +0000

How to create download button for CSV and PDF using Ruby on Rails

Alef Ojeda de Oliveira — Sat, 20 Nov 2021 16:01:12 +0000

Hey Guys !

Let's cut to the chase, hands on code !

First generate scaffold

rails g scaffold Note title

run db:migrate

rails db:migrate

now we are going to install the gem to generate PDF, we will use the gem 'prawn' and the 'prawn-table':

bundle add prawn prawn-table

now we're going to add the route and buttons for downloads nor csv and pdf format:

# add route in file config/routes.rb
resources :notes
root 'notes#index'
post 'download/notes', to: 'notes#download'

# add method downlod in controller app/controllers/notes_controller.rb
def download
    respond_to do |format|
      format.csv { send_data Note.to_csv, filename: "notes-#{Date.today}.csv" }
      format.pdf { send_data Note.to_pdf, filename: "notes-#{Date.today}.pdf" }
    end
end

# adds concerns to the note model to export the data
class Note < ApplicationRecord
  include ExportCsv
  include ExportPdf
end

# now let's create the modules in app/models/concerns
# first export_csv.rb
# frozen_string_literal: true

# module ExportCSV
module ExportCsv
  extend ActiveSupport::Concern

  # module ClassMethods
  module ClassMethods
    def to_csv
      require 'csv'
      options = { col_sep: ';', encoding: 'utf-8' }
      headers = %i[id title]

      CSV.generate(headers: true, **options) do |csv|
        csv << headers

        all.each do |note|
          csv << [note.id, note.title]
        end
      end
    end
  end
end

# second export_pdf.rb
# frozen_string_literal: true

# module ExportPdf
module ExportPdf
  extend ActiveSupport::Concern

  # module ClassMethods
  module ClassMethods
    def to_pdf
      require 'prawn'
      require 'prawn/table'

      options = { position: :center, column_widths: [300, 300], width: 600 }

      header = %w[ID Title]
      data = all.map { |note| [note.id, note.title] }
      Prawn::Document.new do
        text 'All Notes', align: :center, size: 18, style: :bold
        table([header, *data], header: true, **options)
      end.render
    end
  end
end

# and finally add the links on the app/views/notes/index.html.erb page
<%= button_to "Download CSV", download_notes_path(request.params.merge(format: :csv)), data: {turbo: :false} %>
<%= button_to "Download PDF", download_notes_path(request.params.merge(format: :pdf)), data: {turbo: :false} %>

And that's it, we're done!

Github source: https://github.com/nemuba/import_export_file_rails