Forem: Guilherme Yamakawa de Oliveira

pluck vs. select

Guilherme Yamakawa de Oliveira — Thu, 06 Oct 2022 09:49:29 +0000

pluck

In Rails, we have pluck, which returns an array with the values of the attributes you selected.

Doctor.pluck(:id)
   (0.9ms)  SELECT "doctors"."id" FROM "doctors"
=> [1, 3, 7, 8, 9, 5]

If you pass more than one attribute, the pluck returns an array of multiple attributes.

Doctor.pluck(:id, :updated_at)
   (0.5ms)  SELECT "doctors"."id", "doctors"."updated_at" FROM "doctors"
=> [[1, Wed, 23 Jan 2019 11:44:27.924159000 EST -05:00],
 [3, Tue, 29 Jan 2019 15:47:30.056920000 EST -05:00],
 [7, Thu, 28 May 2020 19:30:29.238601000 EDT -04:00],
 [8, Thu, 28 May 2020 19:30:29.251257000 EDT -04:00],
 [9, Sat, 26 Jun 2021 19:56:41.536687000 EDT -04:00],
 [5, Tue, 28 Jun 2022 16:49:45.091360000 EDT -04:00]]

The query is precise to get only the attributes you are asking for.

SELECT "doctors"."id", "doctors"."updated_at" FROM "doctors"

select

The select make the same query.

Doctor.select(:id, :updated_at)
  Doctor Load (0.3ms)  SELECT "doctors"."id", "doctors"."updated_at" FROM "doctors"

Doctor.pluck(:id, :updated_at)
   (0.3ms)  SELECT "doctors"."id", "doctors"."updated_at" FROM "doctors"

Doctor.select(:id, :updated_at)
  Doctor Load (0.6ms)  SELECT "doctors"."id", "doctors"."updated_at" FROM "doctors"
=>[#<Doctor:0x0000000111a2ec40 id: 1, updated_at: Wed, 23 Jan 2019 11:44:27.924159000 EST -05:00>,
 #<Doctor:0x0000000111a2eab0 id: 3, updated_at: Tue, 29 Jan 2019 15:47:30.056920000 EST -05:00>,
 #<Doctor:0x0000000111a2e998 id: 7, updated_at: Thu, 28 May 2020 19:30:29.238601000 EDT -04:00>,
 #<Doctor:0x0000000111a2e858 id: 8, updated_at: Thu, 28 May 2020 19:30:29.251257000 EDT -04:00>,
 #<Doctor:0x0000000111a2e4c0 id: 9, updated_at: Sat, 26 Jun 2021 19:56:41.536687000 EDT -04:00>,
 #<Doctor:0x0000000111a2e218 id: 5, updated_at: Tue, 28 Jun 2022 16:49:45.091360000 EDT -04:00>]

But select returns an ActiveRecord_Relation with objects from the model where it was called.

Doctor.select(:id, :updated_at).class
=> Doctor::ActiveRecord_Relation

that's all folks :)

[PT-BR] Organizando flash messages no Phoenix

Guilherme Yamakawa de Oliveira — Sun, 16 Feb 2020 18:30:27 +0000

Bom, comecei a fazer um sistema para entender melhor como funciona Elixir e aprender sobre o Phoenix.

O Phoenix é um framework para Elixir, assim como o Rails é um framework para o Ruby, ele tem como missão ser um framework produtivo e que não compromete a velocidade ou a capacidade de manutenção.

Sem mais delongas, decidi criar um CRUD simples em Elixir para eu registrar os livros que eu já li, utilizei os seguintes comandos:

# Cria a aplicação.
$ mix phx.new booklistx

# Entra no projeto criado
cd booklistsx

# Gerador do CRUD (estilo scaffold do rails)
mix phx.gen.html Books Book books title:string

# Cria o banco e cria a tabela de books
mix ecto.create
mix ecto.migrate

Defini como root da aplicação ser a listagem de livros.

# lib/booklistx_web/router.ex

defmodule BooklistxWeb.Router do
  use BooklistxWeb, :router

  pipeline :browser do
    plug :accepts, ["html"]
    plug :fetch_session
    plug :fetch_flash
    plug :protect_from_forgery
    plug :put_secure_browser_headers
  end

  pipeline :api do
    plug :accepts, ["json"]
  end

  scope "/", BooklistxWeb do
    pipe_through :browser

    # get "/", PageController, :index # <- Comentei essa linha!
    resources "/", BooksController    # <- Adicionei essa linha!
  end

  # Other scopes may use custom stacks.
  # scope "/api", BooklistxWeb do
  #   pipe_through :api
  # end
end

Executei o comando para iniciar a aplicação.

$ mix phx.server

Após isso estava pronto eu já podia adicionar livros e remover livros, foi ai que quando criei um livro mostrava uma flash message.

Utilizei o inspetor do browser para ver como era o html.

Ví que o html sempre vinha com as tags html de flash message.

<p class="alert alert-info" role="alert">Book updated successfully.</p>
<p class="alert alert-danger" role="alert"></p>

Tem apenas um truque simples de css para não mostrar nada caso não houver nenhum conteúdo na tag.

/* assets/css/phoenix.css */

.alert:empty {
  display: none;
}

Por padrão o arquivo vem assim, carregando as tags de alert mesmo que não tenha nenhuma flash message.

# lib/booklistx_web/layout/app.html.exx

<!DOCTYPE html>
<html lang="en">
  <head>
    <meta charset="utf-8"/>
    <meta http-equiv="X-UA-Compatible" content="IE=edge"/>
    <meta name="viewport" content="width=device-width, initial-scale=1.0"/>
    <title>Booklistx · Phoenix Framework</title>

    <link rel="stylesheet" href="<%= Routes.static_path(@conn, "/css/app.css") %>"/>
    <%= csrf_meta_tag() %>
  </head>

  <body>
    <header>
      <section class="container">
        <nav role="navigation">
          <ul>
            <li><a href="https://hexdocs.pm/phoenix/overview.html">Get Started</a></li>
          </ul>
        </nav>
        <a href="https://phoenixframework.org/" class="phx-logo">
          <img src="<%= Routes.static_path(@conn, "/images/phoenix.png") %>" alt="Phoenix Framework Logo"/>
        </a>
      </section>
    </header>
    <main role="main" class="container">
#->   <p class="alert alert-info" role="alert"><%= get_flash(@conn, :info) %></p>
#->   <p class="alert alert-danger" role="alert"><%= get_flash(@conn, :error) %></p>

      <%= render @view_module, @view_template, assigns %>
    </main>
    <script type="text/javascript" src="<%= Routes.static_path(@conn, "/js/app.js") %>"></script>
  </body>
</html>

Isso estava me incomodando, pesquisei sobre como funciona e encontrei em uma issue sugerindo para utilizar da seguinte forma.

# lib/booklistx_web/layout/app.html.exx
...
<%= if info = get_flash(@conn, :info) do %>
  <p class="alert alert-info" role="alert"><%= info %></p>
<% end %>

<%= if error = get_flash(@conn, :error) do %>
  <p class="alert alert-danger" role="alert"><%= error %></p>
<% end %>
...

Ele só vai mostrar agora caso tenha alguma flash message, porem essas variaveis no meio do código não ficou legal info e error.

Decidi fazer algo parecido com o que já fiz no Rails.

Acredito que deve ter várias outras formas de resolver isso e que deve ser melhor, porem essa foi a que eu mais gostei porque é simples e utiliza os conceitos que eu venho estudando.

Criei os seguintes arquivos:

# Cria o arquivo shared_view
$ touch lib/booklistx_web/shared_view.ex
# Cria a pasta shared
$ mkdir lib/booklistx_web/templates/shared
# Cria o arquivo _flash_message.html.exx
$ touch lib/booklistx_web/templates/shared/_flash_message.html.eex

# lib/booklistx_web/shared_view.ex

defmodule BooklistxWeb.SharedView do
  use BooklistxWeb, :view
  import BooklistxWeb.Router.Helpers

  def show_flash_message(conn) do
    conn
    |> get_flash
    |> flash_message
  end

  def flash_message(%{"info" => message}) do
    render "_flash_message.html", class: "primary", message: message
  end

  def flash_message(%{"error" => message}) do
    render "_flash_message.html", class: "danger", message: message
  end

  def flash_message(_), do: nil
end

Aqui eu estou utilizando coisas que eu aprendi como pipe e pipeline no método show_flash_message e pattern matching para o método flash_message.

Já a partial ficou da seguinte forma.

# lib/booklistx_web/templates/shared/_flash_message.html.eex

<p class="alert alert-<%= @class %>" role="alert">
  <%= @message %>
</p>

O nosso layout ficou da seguinte forma:

# lib/booklistx_web/layout/app.html.exx

<!DOCTYPE html>
<html lang="en">
  <head>
    <meta charset="utf-8"/>
    <meta http-equiv="X-UA-Compatible" content="IE=edge"/>
    <meta name="viewport" content="width=device-width, initial-scale=1.0"/>
    <title>Booklistx · Phoenix Framework</title>

    <link rel="stylesheet" href="<%= Routes.static_path(@conn, "/css/app.css") %>"/>
    <%= csrf_meta_tag() %>
  </head>

  <body>
    <header>
      <section class="container">
        <nav role="navigation">
          <ul>
            <li><a href="https://hexdocs.pm/phoenix/overview.html">Get Started</a></li>
          </ul>
        </nav>
        <a href="https://phoenixframework.org/" class="phx-logo">
          <img src="<%= Routes.static_path(@conn, "/images/phoenix.png") %>" alt="Phoenix Framework Logo"/>
        </a>
      </section>
    </header>
    <main role="main" class="container">
      <%= BooklistxWeb.SharedView.show_flash_message(@conn) %>

      <%= render @view_module, @view_template, assigns %>
    </main>
    <script type="text/javascript" src="<%= Routes.static_path(@conn, "/js/app.js") %>"></script>
  </body>
</html>

Conclusão

No meu ponto de vista, ficou bem melhor do que utilizarmos as variáveis (info e error) e aqueles IF direto no layout, acredito que deve ter soluções melhores, mas essa foi a que eu consegui fazer e mais me agradou. Consegui colocar em pratica algumas coisas que aprendi como o pipe, pipeline e pattern matching.

Vou deixar o link desse código que eu fiz no github.

https://github.com/guilhermeyo/booklistx

Fique a vontade para deixar um feedback e melhorias que posso realizar.

Referências

#23: Partial Templates with Phoenix
Elixir forum - Check for error and info alert in Phoenix
Issue phoenixframework - Add has_flash? functions. #1757

[PT-BR] Instalando Elixir com ASDF

Guilherme Yamakawa de Oliveira — Mon, 10 Feb 2020 02:09:26 +0000

Estou me aventurando no Elixir, mas antes de começar a fazer algo precisei instalar Elixir, como utilizo o asdf para gerenciar versões de linguagem, escrevi como eu fiz no meu computador.

Se você quiser saber mais sobre o asdf, eu falei sobre ele no meu primeiro post.

Configurando Ruby e Node.js com ASDF

Pra quem não sabe o Elixir é uma linguagem de programação open-source criada pelo José Valim na Plataformatec (empresa que foi comprada pelo Nubank).

Elixir é uma linguagem moderna, dinâmica e funcional. Utiliza VM Erlang, conhecida por executar sistemas de baixa latência, concorrência, tolerância a falha, distrubuição e escalabilidade (Mais informaçoes).

Vamos lá.

Para começar precisamos de instalar o asdf, é algo bem fácil, é só seguir o tutorial da página do projeto.

Tutorial para instalar o asdf

Com o asdf instalado e configurado, precisamos de instalar algumas dependências do Erlang.

# OSX
$ brew install autoconf

---

# Ubuntu / Debian
$ sudo apt-get -y install build-essential autoconf m4 libncurses5-dev libwxgtk3.0-dev libgl1-mesa-dev libglu1-mesa-dev libpng-dev libssh-dev unixodbc-dev xsltproc fop

Em outros sistemas operacionais eu não sei instalar com o asdf, porem é possível instalar Elixir de alguma forma, seja por docker ou algum executável.

Outras opções e outros SO.

Agora estamos preparados para instalar o Erlang.

# Adiciona o plugin de Erlang aonde tem todas as versões disponíveis.
$ asdf plugin-add erlang

# Mostra todas as versões disponíveis de Erlang.
$ asdf list-all erlang

# Instala o Erlang.
$ asdf install erlang 22.2.2

# Definimos a versão padrão do Erlang no SO.
$ asdf global erlang 22.2.2

# Pode demorar um pouco, pois vai compilar o Erlang.

Antes de prosseguirmos com a instalação do Elixir, é importante entender como as versões dos dois funcionam juntas ou não.

A versão do Erlang é frequentemente chamada de versão OTP. A versão do Elixir usada deve ser compilada especificamente para a versão do Erlang em uso.

Caso você utilize uma versão do Elixir compilada com uma versão diferente da versão (OTP) do Erlang, você pode ter problemas.

A versão que instalamos é a 22, caso você quer verificar a versão pelo console é bem simples.

Agora que confirmamos que é o OTP-22 vamos instalar o Elixir.

# Adiciona o plugin de Elixir aonde tem todas as versões disponíveis.
$ asdf plugin-add elixir

# Mostra todas as versões disponíveis de Elixir.
$ asdf list-all elixir

# Instala o Elixir.
$ asdf install elixir 1.9.4-otp-22

# Definimos a versão padrão do Elixir no SO.
$ asdf global elixir 1.9.4-otp-22

Bom agora vamos executar o comando elixir -v e confirmar as versões de ambos.

Após confirmar as versões é só executar o comando iex e ver se está tudo ok.

Conclusão

Tem outras formas de instalar o Elixir, porem gosto de deixar tudo que for possível concentrado no asdf como ruby, node, elixir, erlang, python, entre outras.

Ouço falar do Elixir desde quando surgiu e fiz pequenas coisas para brincar, porem nunca me aventurei de verdade e o que mais me motivou além do tanto de oportunidades de trabalho que vem surgindo no Brasil e no mundo, é a comunidade do Brasil e do mundo, todos são muito receptivos e adeptos a diversidade, o que no meu ponto de vista é tudo que precisa para fomentar e fazer a linguagem crescer cada vez mais.

Fontes:

Agradecimentos:

Muito obrigado Adolfo Neto, por me dar esse feedback importante sobre o OTP do Erlang e me passar o site Thinking Elixir, com certeza vou acompanhar.

[PT-BR] Utilizando o MinIO no Rails

Guilherme Yamakawa de Oliveira — Sun, 09 Feb 2020 14:41:54 +0000

Estou em um projeto aonde a configuração de upload de arquivos utilizada é o Active Storage com o Amazon S3. Porem
não tem nenhuma configuração feita para eu baixar os arquivos do S3 e utilizar eles em desenvolvimento.

Quando olhei a configuração do arquivo config/storage.yml vi a seguinte configuração:

local:
  service: Disk
  root: <%= Rails.root.join("storage") %>

Logo pensei que seria algo simples, apenas precisava trazer tudo que tem dentro do Bucket do S3 para dentro da minha pasta app/storage da aplicação.

Baixei o AWS-CLI e configurei com as minhas credenciais.

Após isso sincronizei os arquivos do S3 na minha pasta de app/storage com o comando:

$ aws s3 sync s3://bucket-name ~/Projects/selected-project/storage

Iniciei a aplicação e não deu certo 🙄.

No ActiveStorage quando o service configurado é Disk após o blob gerar a key o arquivo é salvo dentro de duas pastas e depois a key do blob.

Procurei o path do arquivo pelo console e ele me retornou o path seguinte:

> user = User.first
> ActiveStorage::Blob.service.send(:path_for, u.avatar.key)
=> "storage/jt/Y7/jtY7656jGPvfPMUUA8kX6Vb4"

Notei que essas pastas criadas era os 4 primeiros caracteres da key.

Pensei em algumas soluções:

Escrever um script para gerar essas sub-pastas e adicionar os arquivos nelas.

Não optei por essa opção, talvez ela poderia não funcionar e como não tenho experiencia com scripts em alterar o filesystem, achei que iria demorar muito com isso.
Verificar como o Active Storage gera esse path_for e falar pra ele gerar direto sem essas sub-pastas.

Pesquisei e não encontrei nenhum lugar aonde e conseguisse fazer isso.
Duplicar o bucket dentro do S3 e utilizar ele para desenvolvimento.

Não gostei dessa ideia pois iria ter que pagar o armazenamento de 2 buckets.
Utilizar o MinIO.

Foi a opção que acreditei ser mais rapída e com melhor custo x benefício.

O MinIO pra quem não conhece é um projeto Open Source em Go e foi projetado desde o início para ser o padrão no armazenamento de objetos na nuvem privada. Ele é um servidor de objetos nativo da nuvem com desempenho simultâneo, escalável e leve (Mais informações).

Assim preciso configurar o MinIO igual funciona o S3 pois minha aplicação precisa pensar que está no S3.
Baixei o MinIO pelo site deles e configurei as variaveis de ambiente.

export MINIO_ACCESS_KEY="minio_storage_development"
export MINIO_SECRET_KEY="minio_storage_development"
export MINIO_REGION_NAME="us-east-1"

Ele é configurado através das variáveis de ambientes. Você pode verificar quais são todas as configurações pela documentação dele. (Documentação MinIO)

Agora é apenas iniciar.

$ minio server ~/minio_storage

Endpoint:  http://xxx.xxx.xxx.xxx:9000  http://xxx.xxx.xxx.xxx:9000  http://127.0.0.1:9000
AccessKey: minio_storage_development
SecretKey: minio_storage_development
Region:    us-east-1

Browser Access:
  http://xxx.xxx.xxx.xxx:9000  http://xxx.xxx.xxx.xxx:9000  http://127.0.0.1:9000

Command-line Access: https://docs.min.io/docs/minio-client-quickstart-guide
  $ mc config host add myminio http://100.100.101.162:9000 minio_storage_development minio_storage_development

Obs: Escondi o meu IP com o xxx.xxx.xxx.xxx pois ele é fixo e não quero deixar exposto para a Web.

Pronto temos um servidor MinIO configurado rodando no seu computador.

Acessei ele através do meu navegador http://127.0.0.1:9000/ utilizando a Access Key e Secret Key e criei um Bucket chamado rails_app_bucket.

Nas configurações do rails que fica em config/storage.yml

local:
  service: S3
  endpoint: http://127.0.0.1:9000
  access_key_id: minio_storage_development
  secret_access_key: minio_storage_development
  region: us-east-1
  bucket: rails_app_bucket
  force_path_style: true

Movi os arquivos todos os arquivos que tinha baixado do Bucket do S3 para a pasta do Bucket MinIO.

$ mv ~/Projects/selected-project/storage/* ~/minio_storage/rails_app_bucket

Agora para sincronizar os arquivos do S3 utilizo o seguinte comando.

$ aws s3 sync s3://bucket-name ~/minio_storage/rails_app_bucket

Também deixei configurado no meu Procfile.development para iniciar o servidor do MinIO sempre que inicio a minha aplicação pelo foreman ficando assim:

# Procfile.development

server: bin/rails server
webpacker: bin/webpack-dev-server
redis: redis-server
sidekiq: bundle exec sidekiq
minio: minio server ~/minio_storage

Conclusão

Ficou muito simples para eu conseguir sincronizar os arquivos e não aparecer nenhum 404 de arquivos quando eu estou rodando aplicação, e muito menos algum erro do rails que mostrando que o arquivo não existe.

[PT-BR] Configurando ReactJS no Rails com o Webpacker

Guilherme Yamakawa de Oliveira — Thu, 06 Feb 2020 23:04:48 +0000

O Javascript moderno usa muitas bibliotecas e estruturas de processamento, incluindo NPM, Yarn e Webpack. Então, quando você usa o React, você precisa de todas essas ferramentas. O Rails tem asset pipeline há muito tempo e usou o Sprockets como a principal ferramenta.

Desde o Rails 5.1 existe uma alternativa ao Sprockets para Javascript, o Webpacker e no Rails 6.0, o Webpacker será o padrão. O Webpacker usa o Webpack para compilar todos os seus arquivos Javascript.

Uma das grandes vantagens do Webpack é que, em seu ambiente de desenvolvimento, ele oferece a opção de compilação ao vivo do Javascript via webpack-dev-server. Isso significa que você altera um arquivo e ele é automaticamente compilado e até mesmo enviado para o navegador. Isso permite um desenvolvimento muito rápido. É claro que, em produção, você deseja usar pré-compilação, compilando todos os arquivos Javascript em apenas um reduzido.

Aqui vou mostrar como criar uma aplicação Ruby on Rails do zero com Webpacker e configurar o ReactJS através do Webpacker.

O que vamos precisar?

Ruby 2.5.1 ou superior
Rails 5.2.1 ou superior
Webpacker 3.5.5 ou superior

Criando aplicação

rails new rails-com-reactjs --skip-test --webpack

Este comando cria o aplicativo e configura o Webpacker. Ele ignora a estrutura de testes.

bundle exec rails webpacker:install:react

Este comando instala e configura o ReactJS da seguinte forma:

Adiciona as configurações do babel no root
Cria um exemplo em app/javascript/packs/hello_react.jsx
Atualiza as configurações do Webpacker para aceitar arquivos com a extensão .jsx
Instala todas as dependencias que o React precisa

O exemplo criado hello_react.jsx insere um componente direto no <body> da aplicação, achei isso sem sentido, sem nenhuma estrutura, e se utilizarmos vai aparecer em todas as páginas, por isso eu sempre o ignoro e utilizo uma estrutura de pastas separando todos os componentes React dentro dela e para usar um componente eu utilizo um helper da gem 'react-rails'.

Configurando o ReactJS

Adicione no seu Gemfile.

gem 'react-rails'

Após salvar o arquivo não esqueça de executar o comando bundle install para baixar e instalar a gem na aplicação.

Instale o react_ujs com o comando:

yarn add react_ujs

O react_ujs é um driver do react-rails ele varrerá a página e montará os componentes usando data-react-class e data-react-props.

Agora vamos criar uma estrutura bem simples para deixarmos os componentes organizados e criar o nosso componente.

mkdir app/javascript/components
touch app/javascript/components/hello_world.jsx

Dentro do arquivo hello_world.jsx adicione o seguinte código:

import React, { Component } from 'react'

export default class HelloWorld extends Component {
  render() {
    return <h1>Hello World</h1>
  }
}

Para conseguirmos chamar o componente de dentro de uma página precisamos adicionar as seguintes configurações no final do arquivo:
app/javascript/packs/application.js

const componentRequireContext = require.context('components', true)
const ReactRailsUJS = require('react_ujs')
ReactRailsUJS.useContext(componentRequireContext)

No arquivo:
app/views/layouts/application.html.erb

# Remova o javascript do asset pipeline.
<%= javascript_include_tag 'application', 'data-turbolinks-track': 'reload' %>

# Adicione o javascript do webpacker.
<%= javascript_pack_tag 'application' %>

Utilizando o componente nas views

Agora vamos criar uma página para a mágica acontecer.

rails g controller pages index --no-helper --no-assets --no-controller-specs --no-view-specs

Este comando cria um controller chamado pages e uma action index. Ele ignora a estrutura de testes, assets e helpers.

No arquivo:
config/routes.rb

# Remover
get 'pages/index'

# Adicionar
root 'pages#index'

Chame na view o componente com o helper do react-rails.
app/views/pages/index.html.erb

<%= react_component 'hello_world' %>

Na hora de iniciar a aplicação utilize o comando:

rails s

Em outra aba do terminal execute:

bin/webpack-dev-server

Pronto, agora você pode criar componentes com ReactJS para auxiliar você no desenvolvimento da sua aplicação Rails, sem ter que utilizar o React como um Single Page Application.

Coloquei o exemplo do código feito no Github:

https://github.com/guilhermeyo/rails-com-reactjs

Fontes:

[PT-BR] Enviando SMS com Ruby com o Twilio

Guilherme Yamakawa de Oliveira — Thu, 06 Feb 2020 00:56:05 +0000

Eu nunca havia feito uma aplicação que fosse necessario enviar SMS para alguém, mas o último projeto que fizemos na firma precisou, conversei com um amigo sobre o assunto e ele me falou do Twilio, fiz uma pesquisa rápida sobre e achei a documentação bem completa e fácil de implementar.

Para quem não conhece o Twilio, ele é uma plataforma que possibilita integrar voz, mensagens de texto, vídeo, notificações entre outras facilidades na sua aplicação, através de uma API. As integrações são feitas com Ruby, Java, .NET, Node.js, PHP, entre outras.

Vou mostrar como é fácil enviar SMS pelo console do ruby e em breve pretendo fazer um screencast de como implementar essa funcionalidade em uma aplicação Ruby on Rails.

Passo 1 - Criar conta no Twilio:

Crie uma conta no Twilio e acesse o Console do Twilio.

Criar conta: https://www.twilio.com/try-twilio

Console: http://twilio.com/console

Ao criar a conta, é disponibilizado um Trial para realizar testes:

Não esqueça de cadastrar número verificado.
https://www.twilio.com/console/phone-numbers/verified

Observações: Os números verificados são obrigatórios para você conseguir enviar SMS com TRIAL.

Passo 2 - Enviar a SMS:

Instale a gem do Twilio com o comando:

gem install twilio-ruby -v 5.21.2

Abra um console ruby com o comando:

irb

Dentro do console nós importamos a gem "twilio-ruby", configuramos as variavéis e enviamos uma mensagem.

require 'twilio-ruby'

# Pegue seu SID e Auth Token de twilio.com/console
# PERIGO! Isso é inseguro.
account_sid = 'ACXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX'
auth_token = 'seu_auth_token'
numero = 'seu_numero' # Número que você alugou no twilio
@client = Twilio::REST::Client.new(account_sid, auth_token)

mensagem = @client.messages.create(
  from: numero, # +15017122661
  body: 'Minha primeira mensagem enviada com ruby.',
  to: '+5544999801281' # +5544998761234
)

puts mensagem.sid

Lembrando que isso é uma maneira insegura. É importante manter as credenciais, como o SID e o Auth Token, armazenando-as de maneira a impedir o acesso não autorizado.
Como é apenas um exemplo para testes utilizei elas no console mesmo.

Finalizando

Como você pode ver é muito fácil sair enviando SMS com Ruby.

O Twilio oferece muitos outros serviços e você pode ver e consultar o preço de todos acessando https://www.twilio.com/pricing.