DEV Community: Ernane Ferreira

Text Improvement Automation with AppleScript & Gemini API 🔧

Ernane Ferreira — Fri, 13 Sep 2024 20:06:58 +0000

I'm currently experimenting with improving my texts using AI tools and it seems to have already become a common practice. Whether it was to correct spelling or refine the tone of my writing, I found myself repeatedly jumping to these AI platforms. It was efficient, but it felt a little tiring to do it every time.

So, I decided to streamline this process and make it a bit more personal and integrated. Instead of going to an external site each time I needed text improvements, I thought, "Why not create an automation that does this on my system?"

The Concept

With the Gemini language model API from Google, I had a powerful tool at my disposal. I created a macOS automation using AppleScript to tap into this API and integrate it directly into my workflow. Here’s how I did it:

🛠️ How to Set Up Your Own Text Improvement Automation

1. Create the Automation with Automator

Open Automator on macOS.
Select "Workflow".
Set "The workflow receives current:" to "text" and "in:" to "any application".
In the sidebar, under Library, search for and drag the "Run AppleScript" block into the workflow.
Copy the AppleScript code from GitHub repository and paste it into the AppleScript block in Automator or simply copy the code below.

   on run {input, parameters}
     set selectedText to input as string
     set prompt to "Aprimore a escrita, ortografia e formalidade do seguinte texto a seguir. Seu retorno deve ser SOMENTE o texto ajustado sem conteúdo antes ou depois.\n"

     set apiKey to "<YOUR-GEMINI-API-KEY-HERE>"
     set curlCommand to "curl -s 'https://generativelanguage.googleapis.com/v1beta/models/gemini-1.5-flash:generateContent?key=" & apiKey & "' -H 'Content-Type: application/json' -X POST -d '{\"contents\": [{\"parts\": [{\"text\": \""& prompt &" "& selectedText & "\"}]}]}' | /opt/homebrew/bin/jq .candidates[0].content.parts[0].text"

     set jsonResponse to do shell script curlCommand

     set textResponse to do shell script "echo " & quoted form of jsonResponse & " | sed 's/^\\\"//; s/\\\"$//; s/\\\\n/\\n/g'"

     set creditMessage to "🛠️ Developed by https://github.com/ErnaneJ"
     set fullMessage to textResponse & return & return & creditMessage

     set dialogResponse to display dialog fullMessage buttons {"Copy", "Close"} default button "Close" with title "🤖 Result - Gemini (1.5 flash)"

     if button returned of dialogResponse is "Copy" then
       set the clipboard to textResponse
       display notification "Text copied to clipboard" with title "Copy"
     end if

     return textResponse
   end run

Modify the code:
- Prompt: Adjust the prompt variable to specify how you want the AI to process the text (e.g., level of formality or specific instructions).
- API Key: Replace "<YOUR-GEMINI-API-KEY-HERE>" with your own Gemini API key (you can get one here).

2. Install Dependencies

The script uses curl and jq for making requests and processing responses. Install them via Homebrew:

brew install curl jq

3. Set the `jq` Path

Find the path to the jq binary with:

which jq

Update the jq path in the script if necessary. Homebrew usually installs it to:

/opt/homebrew/bin/jq

4. Save and Run the Automation

Save the automation with the name "Improve Text With Gemini".
To use it, select text in any application with text field, go to the "Services" menu, and click "Improve Text With Gemini" or whatever name you gave to the file.
A popup will appear with the enhanced text, and you can copy it directly to your clipboard.

🔍 Example of the Popup

💡 Customization Tips

You can customize the script’s behavior by adjusting the prompt variable in the AppleScript:

set prompt to "......."

And make sure to replace <YOUR-GEMINI-API-KEY-HERE> with your actual API key.

🚀 Final Thoughts

Creating this automation was interesting because I had never done anything like this before. It simplified my writing process, saved time, and made everything a little more efficient. If you often use text enhancement tools, consider how you can integrate them into your workflow. Sometimes it's easier than you think!

Do you use similar tools? Share your experiences in the comments below! Feel free to check out the GitHub repository for more code details or suggestions for improvements.

Happy automation! 🤖

Build a Simple TODO List with Shell Script 🐚

Ernane Ferreira — Thu, 12 Sep 2024 13:26:56 +0000

Managing tasks directly from the terminal can be a breeze with the power of shell scripting! In this post, I'll walk you through creating a simple yet functional TODO list using a few shell functions. We'll store tasks in a text file, add unique identifiers to each item, and provide commands for adding, removing, and clearing tasks.

Let’s dive in! 🚀

Prerequisites ⚙️

You'll need a terminal using bash or zsh. The following functions can be added to your ~/.zshrc or ~/.bashrc file to make them available as commands in your terminal.

Step 1: Set Up Your Storage 🎲

First, let’s create an environment variable that defines where your tasks will be stored. Add this line to your configuration file:

export TODO="${HOME}/todo.txt"

This will store your task list in a file called todo.txt located in your home directory.

Step 2: Define Your Functions ✨

Now let's add some shell functions to manage our TODO list:

tla() { [ $# -eq 0 ] && cat $TODO || (echo "$(echo $* | md5sum | cut -c 1-4) 👉🏼 $*" >> $TODO && cat $TODO) ;}
tlr() { sed -i '' "/^$*/d" $TODO && cat $TODO ;}
tl() { cat $TODO ;}
tlc() { cat /dev/null > $TODO ;}

Here’s what each function does:

tla (Todo List Add): Adds tasks to the list. It generates a 4-character md5 hash to serve as a unique identifier for each task. If no argument is passed, it displays the current task list.
tlr (Todo List Remove): Removes tasks from the list by matching their md5 identifier.
tl (Todo List): Simply displays the current list.
tlc (Todo List Clear): Clears the entire task list, removing all entries at once.

At the end of each operation, the current state of your TODO list will be displayed.

Step 3: See It in Action ☕️

Here’s a quick demonstration of how these commands work:

➜  ~ tl       
➜  ~ tla test 0
# 0e57 👉🏼 test 0
➜  ~ tla test 1
# 0e57 👉🏼 test 0
# 2490 👉🏼 test 1
➜  ~ tla test 2
# 0e57 👉🏼 test 0
# 2490 👉🏼 test 1
# b0b3 👉🏼 test 2
➜  ~ tlr 2490
# 0e57 👉🏼 test 0
# b0b3 👉🏼 test 2
➜  ~ tl
# 0e57 👉🏼 test 0
# b0b3 👉🏼 test 2
➜  ~ tlc
➜  ~ tl

tla test 0: Adds "test 0" to the list with an md5 identifier.
tlr 2490: Removes the task with the identifier 2490 (in this case, "test 1").
tlc: Clears the list.

Conclusion ✍️

With just a few lines of shell script, you now have a functional TODO list right in your terminal. You can easily add, remove, or clear tasks with simple commands. This setup is lightweight and can be modified to fit your workflow.

Feel free to extend these functions or add your own twists. Happy hacking! 🚀

🚀 Edge Detection with Threads and MiniMagick in Ruby 🌄

Ernane Ferreira — Thu, 12 Sep 2024 01:53:17 +0000

Digital image processing is a fascinating field where computers are used to transform, enhance, and interpret images. It plays a crucial role in numerous applications, from medical imaging to computer vision and machine learning. One of the foundational techniques in this domain is edge detection ✨— a method used to identify significant transitions in pixel intensities, enabling us to detect objects and boundaries within images.

🔍 Why Edge Detection Matters

Edges are essentially where the most critical information of an image lies. They represent boundaries between different objects, colors, or textures, making them vital for tasks like segmentation and object recognition. Without edge detection, computers would struggle to differentiate between regions in an image.

🔨 How Edge Detection Works

Edge detection is primarily achieved through mathematical operations called convolutions. By applying convolution filters, we can detect changes in pixel intensities in both the horizontal ( $x$ ) and vertical ( $y$ ) directions. The most commonly used filters for edge detection are the Prewitt, Sobel, and Canny operators. In this project, we focus on using the Prewitt operator to perform this task.

Consider the following convolution matrices for detecting edges in both directions:

Gx = |-1  0  1|    Gy = |-1 -1 -1|
     |-1  0  1|        |  0  0  0|
     |-1  0  1|        |  1  1  1|

$G_x$ detects horizontal changes.
$G_y$ detects vertical changes.

By applying these matrices across the image, we extract valuable edge information for each pixel. The final edge map is generated by combining both directional components.

📋 Step-by-Step Process

Let's walk through the basic algorithm to detect edges in a grayscale image of size $\times N$ :

Initialize Matrices:
- Create three matrices: $G_x$ , $G_y$ , and $G$ , each of size $\times N$ . These will store the horizontal, vertical, and final edge information, respectively.
Convolution Operation:
- For each pixel, the gradient in the $x$ -direction ( $G_x$ ) and $y$ -direction ( $G_y$ ) is calculated using the convolution matrices.
Combine Results:
- Finally, the gradient magnitudes are combined to form the final edge-detected image, $G$ .

For i from 1 to M-2
  For j from 1 to N-2
    Gx(i, j) = [ I(i+1, j-1) + I(i+1, j) + I(i+1, j+1) ] - [ I(i-1, j-1) + I(i-1, j) + I(i-1, j+1) ]
    If Gx(i, j) < 0, Gx(i, j) = 0
    If Gx(i, j) > 255, Gx(i, j) = 255
  end-for
end-for

For i from 0 to M-1
  For j from 0 to N-1
    G(i, j) = Gx(i, j) + Gy(i, j)
    If G(i, j) > 255, G(i, j) = 255
  end-for
end-for

🧵 Multi-Threaded Implementation in Ruby

A key feature of this project is its use of multi-threading to parallelize the edge detection process 🧑‍💻. Instead of processing the entire image in a single thread, the work is divided into two threads:

One thread calculates the horizontal edges using $G_x$ .
Another thread handles the vertical edges with $G_y$ .

This approach significantly speeds up the computation, especially for large images.

Main thread: Reads the input image, initializes matrices, and spawns two threads.
Thread 1: Computes the edge detection in the $x$ -direction.
Thread 2: Computes the edge detection in the $y$ -direction.
Final step: The results from both threads are combined to produce the final edge map, $G$ .

🖼️ Results

Here are examples of processed images using this method. The left column shows the original images, and the right column presents the edge-detected outputs:

Original	Processed

🎯 Conclusion

By leveraging the power of Ruby threads, this project demonstrates how to efficiently apply edge detection to images in both the horizontal ( $x$ ) and vertical ( $y$ ) directions. The results show how edge detection enhances the structural details of images, making them more suitable for tasks like object recognition and segmentation. This approach not only speeds up the processing but also makes it scalable for larger datasets.

For more details and to explore the code, visit the GitHub repository. 🎉

[pt-BR] Guia Prático: Explorando o Poder da Gem ActiveRecord no Ruby - Sem Framework 🚀

Ernane Ferreira — Sat, 30 Mar 2024 02:40:44 +0000

[pt-BR] Guia Prático: Explorando o Poder da Gem ActiveRecord no Ruby - Sem Framework 🚀

Recentemente, tive contato com alguns novos entusiastas do Ruby que provavelmente em breve estarão explorando o Rails, dado o caminho que estão seguindo. Acredito que, uma vez que tenhamos uma compreensão básica de Ruby e a linguagem devidamente instalada, é vantajoso explorarmos o Active Record, uma poderosa gem que simplifica significativamente as operações no banco de dados. Dedico este conteúdo a vocês.

Introdução 🎉

A gem Ruby ActiveRecord é uma ferramenta poderosa que oferece abstrações simplificadas para interagir com bancos de dados, permitindo uma troca fácil do back-end do banco de dados, por exemplo, migrando de SQLite3 para MySQL sem a necessidade de alterar o código. Esta gem possui suporte integrado para abstrações de banco de dados para SQLite3, MySQL e PostgreSQL, e uma das suas principais vantagens é a necessidade mínima de configuração. Embora o ActiveRecord seja amplamente utilizado com o framework Ruby-on-Rails, ele também pode ser empregado com o Sinatra ou até mesmo de forma independente, sem qualquer estrutura web. Aqui iremos nos concentrar em demonstrar o uso do ActiveRecord de forma autônoma, fora de qualquer estrutura específica. 🌟

Preparando o Projeto 🛠️

Para desenvolver este tutorial de forma organizada e facilitar a compreensão e consulta posterior do conteúdo, adotarei uma certa estrutura de pastas e arquivos.

Criando uma Pasta para o Projeto 📂

mkdir ruby-and-activerecord

Inicializando o Bundle 📦

Para gerenciar as gems que serão utilizadas, recomenda-se o uso do Bundler. Neste tutorial utilizaremos o Gemfile para escopar as dependências do projeto. Para começar, execute o seguinte comando:

bundle init

Isso criará um novo Gemfile.

Instalando a Gem ActiveRecord 💎

Para instalar a gem ActiveRecord, você pode utilizar a ferramenta gem ou o gerenciador de pacotes do seu sistema, caso esteja disponível. Por exemplo:

# Instalando com gem
gem install activerecord

# No Ubuntu
apt install ruby-activerecord

Entretanto, neste tutorial, utilizaremos o Gemfile para organizar as dependências do projeto. Para isso, execute o seguinte comando:

bundle add activerecord

Você também pode adicionar diretamente ao seu Gemfile. Ele ficará semelhante ao conteúdo abaixo:

# frozen_string_literal: true

source "https://rubygems.org"

gem "activerecord", "~> 7.1"

Depois basta executar o bundle install.

Consultando a Documentação 📚

Antes, durante ou após a leitura deste tutorial (ou qualquer outro), é altamente recomendável que você consulte e verifique as informações diretamente na documentação oficial. Você pode usar o comando ri ou acessar a documentação online.

Por exemplo:

ri ActiveRecord
ri ActiveRecord::Base

Estabelecendo Conexão com o Banco de Dados 🎲

Antes de utilizar qualquer modelo, é essencial estabelecer uma conexão com o banco de dados. Como mencionado anteriormente, há uma grande praticidade em conectar uma aplicação ao ActiveRecord com diferentes tipos de banco de dados, como SQLite3, MySQL ou PostgreSQL, por exemplo. Abaixo, apresento exemplos para três adaptadores diferentes:

require 'active_record'

# SQLite3
ActiveRecord::Base.establish_connection(
  adapter: 'sqlite3',
  database: 'test.db'
)

# MySQL
ActiveRecord::Base.establish_connection(
  adapter: 'mysql2',
  host: 'localhost',
  username: 'seu_nome_de_usuario_do_banco_de_dados',
  password: 'sua_senha_do_banco_de_dados',
  database: 'seu_nome_do_banco_de_dados'
)

# PostgreSQL
ActiveRecord::Base.establish_connection(
  adapter: 'postgresql',
  host: 'localhost',
  username: 'seu_nome_de_usuario_do_banco_de_dados',
  password: 'sua_senha_do_banco_de_dados',
  database: 'seu_nome_do_banco_de_dados'
)

Para este tutorial, estaremos utilizando o SQLite, mas você pode optar por qualquer adaptador que desejar.

Instalando a Gem SQLite3 🪶

Para utilizar o adaptador SQLite3, é necessário instalar a gem correspondente. Assim como fizemos anteriormente com o ActiveRecord, faremos o mesmo processo para instalar essa gem. Nosso Gemfile ficará assim:

# frozen_string_literal: true

source "https://rubygems.org"

gem "activerecord", "~> 7.1"
gem "sqlite3", "~> 1.7"

Estabelecendo Conexão com o Banco de Dados SQLite 🪶

Para uma melhor organização, criaremos uma pasta de configurações e dentro dela um arquivo initializer.rb. Este arquivo será responsável por realizar a conexão com o banco de dados. Para simplificar o processo de configuração, também optaremos por criar um arquivo .yaml para armazenar as configurações do banco de dados fora do código.

# configurations/initializer.rb
require 'yaml'
require 'active_record'

db_config = YAML::load(File.open(Dir.pwd + '/configurations/database.yaml'))

ActiveRecord::Base.establish_connection(db_config)

E em nosso arquivo database.yaml teremos as configurações da seguinte forma:

# configurations/database.yaml
adapter: 'sqlite3'
database: './database/database.sqlite3'

ℹ️ Estamos armazenando o banco de dados no caminho ./database/database.db. Se necessário, altere esse caminho ou crie a pasta 'database' na raiz do projeto.

Com isso, a conexão está estabelecida. Para testá-la, basta executar o initializer.rb da seguinte forma:

ruby ./configurations/initializer.rb

Se não houver erros, estamos no caminho certo!

Criando um Modelo 🧑🏼‍💻

Para criar um modelo, basta criar a classe desejada herdando de ActiveRecord::Base. Os nomes das tabelas são assumidos com base no nome da classe do modelo que está sendo criado. Por exemplo, um modelo chamado User espera ter uma tabela chamada users. Um modelo chamado ProfileUser espera uma tabela chamada profile_users. Ele converte tudo para minúsculas e adiciona um sublinhado entre as palavras em maiúsculas.

Para uma melhor organização, criaremos uma pasta adicional na raiz do projeto, onde guardaremos todas as nossas models. Para começarmos, vamos criar uma model de User.

# ./models/user.rb
class User < ActiveRecord::Base
end

Tecnicamente, isso é tudo que você precisa fazer. Por padrão, ele mapeará os campos existentes do banco de dados para atributos no modelo. Você não precisa definir cada campo no código. No entanto, se desejar, você pode sobrescrever propriedades como o nome da tabela e a chave primária — por sua conta e risco 😬.

# ./models/user.rb
class User < ActiveRecord::Base
  self.table_name = 'user'
  self.primary_key = 'user_id'
end

Juntando as Peças 🛠️

Vamos criar um arquivo principal para reunir e usar nossos componentes enquanto experimentamos. Portanto, crie um main.rb na raiz do projeto e adicione o seguinte conteúdo:

# main.rb
require 'active_record'

require './configurations/initializer.rb'
require './models/user'

User.create(
  name: 'Ernane', 
  age: 16
)

Observe que estamos carregando o ActiveRecord, executando o initializer.rb para estabelecer a conexão com o banco de dados e importando nossa nova model de usuário. As próximas linhas são usadas para criar um usuário. Entraremos em detalhes sobre essas instruções em breve.

Para executar, realizamos a mesma ação que fizemos com o initializer:

ruby main.rb

Você pode notar que recebeu um erro porque nossa tabela users não existe no banco de dados ainda. Isso ocorre porque, como mencionado, o ActiveRecord realiza o mapeamento dos atributos do banco de dados em métodos da classe modelo correspondente. Se a tabela não existir, ocorrerá o erro que você deve estar vendo agora.

Para criar a tabela, você pode executar a criação manualmente em SQL. Por exemplo:

CREATE TABLE IF NOT EXISTS users (
  name TEXT,
  age INT,
  email TEXT,
  admin BOOLEAN,
  tshirt_size TEXT
);

Ou, se quiser adiantar um pouco no conteúdo, você pode criar uma migração.

Para uma melhor organização, mais uma vez, criaremos uma nova pasta chamada migrations dentro da nossa pasta de banco de dados. Lá, adicionaremos uma migração, que nada mais é do que um arquivo Ruby. Por exemplo, para o nosso modelo de usuário:

# ./database/migrations/create_user_table.rb

require './configurations/initializer.rb'

class CreateUserTable < ActiveRecord::Migration[6.0]
  def change
    create_table :users do |t|
      t.string :name
      t.integer :age
      t.string :email
      t.boolean :admin
      t.string :tshirt_size
      t.timestamps
    end
  end
end

CreateUserTable.migrate(:up)

Para executar essa migração, basta usar o Ruby no seu terminal como de costume.

ruby ./database/migrations/create_user_table.rb

Essa não é a melhor forma de lidar com migrações em um projeto. Você pode criar uma tarefa Rake para executar suas migrações, facilitando o processo. No entanto, não vou me ater a esse tópico agora, pois não é o objetivo dessa publicação.

Uso do ActiveRecord 🤩

Agora que tudo está pronto, podemos executar novamente nosso arquivo principal. Como agora temos a tabela criada, o erro anterior desaparecerá e poderemos realizar nossas primeiras manipulações com o ActiveRecord.

Listando Colunas da Tabela 📋

Depois de criar um modelo, você pode acessar as colunas como objetos vinculados ao modelo. Aqui está um exemplo que irá imprimir as colunas de uma tabela:

# ./examples/listing_columns.rb

User.columns.each do |column|
  puts "#{column.name} => #{column.type}"
end

Criando Novos Registros 🆕

Existem várias maneiras de criar um novo registro:

Criar um novo objeto e chamar explicitamente o método .save();
Usar um bloco para preencher o objeto e chamar o método .save();
Chamar .create() que criará e salvará em uma única etapa;

# ./examples/creating_new_records.rb

# Criar um novo objeto de usuário e então salvá-lo para armazenar no banco de dados
user = User.new(name: 'ErnaneDois', age: 16, email: 'teste0@teste.com', admin: false, tshirt_size: 'M')
user.save

# Usar um bloco para preencher o objeto e então salvar
User.new do |u|
  u.name = 'ErnaneUm'
  u.age = 18
  u.email = 'teste1@teste.com'
  u.admin = false
  u.tshirt_size = 'M'
end.save

# Criar e salvar em uma única etapa com ".create()"
User.create(name: 'ErnaneTres', age: 18, email: 'teste2@teste.com', admin: false, tshirt_size: 'M')

Encontrando Registros 🔍

Existem muitos métodos que você pode usar para consultar registros. Alguns deles incluem:

first();
last()
second(), third(), fourth(), fifth();
all();
where();
find_by();
find_by_sql();
find_by_*().

# ./examples/finding_records.rb

# Obter o primeiro usuário
primeiro_usuario = User.first
puts primeiro_usuario.name

# Obter o último usuário
ultimo_usuario = User.last
puts ultimo_usuario.name

# Também disponível: User.second, User.third, User.fourth, User.fifth

# Encontrar todos os usuários que correspondem à consulta e depois pegar o primeiro da lista
adultos = User.where('age > ?', 18)
puts "Adultos: #{adultos.length}"

# Obter todos os usuários
puts "Total de usuários: #{User.all.length}"

# Encontrar o primeiro usuário que corresponde à consulta
usuario = User.find_by(name: 'nomeNovo')
puts usuario.name

# Obter todos os usuários e classificar
usuarios_classificados = User.all.order(age: :desc)
usuarios_classificados.each do |usuario|
  puts "#{usuario.name}: #{usuario.age}"
end

# Você pode combinar vários campos dinamicamente em consultas find_by_*
usuario = User.find_by_name_and_age('nomeNovo', 16)
puts "#{usuario.name} tem #{usuario.age} anos"

# Consultar usando SQL personalizado
usuarios = User.find_by_sql('select * from users')
usuarios.each do |usuario|
  puts "#{usuario.name} tem #{usuario.age} anos"
end

Acesse o Guia do Ruby para obter mais informações.

Atualizando Registros 🔄

Para atualizar um registro, você também tem algumas opções. Uma delas é obter o registro, modificá-lo e, em seguida, chamá-lo explicitamente. Outra opção é chamar o método update() para fazer a alteração e salvar em uma única ação.

# ./examples/updating_records.rb

# Atualizar modificando um objeto de usuário e chamando explicitamente ".save"
usuario = User.first
usuario.name = 'novoNome'
usuario.save

# Atualizar e salvar em uma única etapa
User.first.update(name: 'nomeNovo')

Excluindo Registros ␡

Para excluir um registro, você pode acessar um registro individual ou chamar métodos para excluir todos os registros. Aqui estão alguns exemplos:

# ./examples/deleting_records.rb

# Maneira funcional, mas ineficiente, de excluir todos os registros:
User.all.each { |usuario| usuario.delete } # ou ainda => User.all.each(&:delete)

# Opção mais eficiente:
User.delete_all

Funções de Retorno de Chamada 👀

Existem vários métodos que você pode adicionar em modelo que serão acionados automaticamente quando determinadas ações forem executadas, como criar, atualizar ou excluir um registro, além de consultar um registro.

Saiba mais sobre retornos de chamada em Ruby on Rails Guides.

Esses métodos de retorno de chamada podem ser classificados em diferentes categorias:

📍 Ação de Exclusão:

before_destroy;
after_destroy.

📍 Ações de Criação:

before_create;
after_create.

📍 Ações de Criação e Atualização:

before_validation;
after_validation;
before_update;
after_update;
before_save;
after_save.

📍 Ações de Consulta:

after_initialize;
after_find.

📍 Ações de Criação, Atualização e Exclusão:

after_commit;
after_rollback.

Aqui está um exemplo de como configurar um retorno de chamada usando blocos:

# ./models/user.rb

class User < ActiveRecord::Base
  before_create do |u|
    puts "Prestes a criar o usuário: #{u.name}"
  end

  after_create do |u|
    puts "Novo objeto de usuário criado: #{u.name}"
  end
end

Outra maneira é especificar as funções de retorno de chamada a serem executadas usando symbols, operando em self:

# ./models/user.rb

class User < ActiveRecord::Base
  before_create :before_create_callback
  after_create :after_create_callback

  def before_create_callback
    puts "Prestes a criar o usuário: #{self.name}"
  end

  def after_create_callback
    puts "Novo objeto de usuário criado: #{self.name}"
  end
end

User.create(name: 'Ernane', age: 16) # Aciona os callbacks definidos anteriormente

Os retornos de chamada "around" (around_create, por exemplo) são um pouco mais complexos. Eles permitem que você execute código antes e depois de uma ação, podendo ser úteis para benchmarking de desempenho, por exemplo.

# ./models/user.rb

class User < ActiveRecord::Base
  around_create :around_create_callback

  def around_create_callback
    puts 'Um usuário está prestes a ser criado'
    yield # Aguarde até que o salvamento tenha ocorrido
    puts 'Um usuário foi criado.'
  end
end

User.create(name: 'Ernane', age: 16) # Aciona o callback definido anteriormente

Validação de Campos ✅

Ao adicionar validações a um modelo, você garante que qualquer objeto salvo atenda a determinados padrões. Existem várias validações integradas disponíveis. Aqui estão alguns exemplos de validações que você pode aplicar:

Garantir que um campo esteja vazio ou não vazio;
Garantir que um campo contenha um valor exclusivo;
Garantir o comprimento de um campo;
Garantir que um campo seja um valor numérico;
Garantir que um campo corresponda a uma expressão regular;
Implementar funções de validação personalizadas (o céu é o limite, ou quase).

Após aplicar as validações, você pode chamar os métodos .valid? e .invalid? no modelo para realizar as validações e gerar mensagens de erro, que podem ser acessadas no modelo. A chamada também executará as validações e gerará mensagens de erro. Ela retornará falso se a operação não for bem-sucedido. Você pode aprender mais sobre validações no Guia de Validações do ActiveRecord.

# ./models/user.rb

class User < ActiveRecord::Base

  # ...

  # Garantir que os campos de nome e idade estejam presentes
  validates_presence_of :name, :age

  # Garantir que um campo seja único
  validates_uniqueness_of :email

  # Usar uma expressão regular para limitar os valores do campo
  validates_format_of :name, with: /\A[a-zA-Z]+\z/, message: "Apenas letras são permitidas"

  # Garantir que um campo esteja vazio
  validates_absence_of :admin

  # Garantir que um valor tenha um comprimento específico
  validates_length_of :credit_card, is: 16

  # Garantir que o valor seja de um tipo específico
  validates_numericality_of :age, only_integer: true

  # Garantir um comprimento mínimo e máximo
  validates_length_of :name, minimum: 2, maximum: 64

  # Outra forma de especificar o comprimento
  validates_length_of :name, in: 2..64

  # Garantir que o valor corresponda a um conjunto específico
  validates_inclusion_of :tshirt_size, in: %w(PP P M G GG XG), message: "Tamanho de camiseta inválido: %{value}"

  # ...
end

# ./examples/validating_records.rb

usuario = User.new
usuario.email = 'test'
usuario.admin = 1
usuario.name = "Ernane123"
usuario.age = 50.5
usuario.tshirt_size = 'XM'

# Alternativamente, use `.valid?` ou `.invalid?` para gerar erros
unless usuario.save
  usuario.errors.messages.each do |field, messages|
    puts "#{field}: #{messages}"
  end
end

Este exemplo garantirá que os dados inseridos no objeto de usuário atendam aos critérios de validação definidos no modelo. Se houver algum erro de validação, ele será exibido na saída.

Transações em Bancos de Dados 🎲

O uso de transações em bancos de dados permite executar várias operações de forma segura, garantindo que todas sejam realizadas ou nenhuma delas seja concluída. Por exemplo, ao realizar operações complexas que envolvem múltiplas atualizações ou inserções, é crucial garantir a integridade do banco de dados, evitando estados inconsistentes.

Você pode criar e executar transações em blocos de código utilizando o método transaction fornecido pelo ActiveRecord. Veja um exemplo:

# ./examples/testing_transactions.rb

# Exemplo 1: 
# - Deve tentar mudar o nome e funcionar. 
# - Deve tentar mudar a idade e deve falhar pois o valor tem que ser inteiro (validação presente no modelo). 
# - Como falhou, as alterações já realizadas, mesmo que em sucesso, serão revertidas.

begin
  ActiveRecord::Base.transaction do
    usuario = User.first
    puts "Antes 1 =>", usuario.attributes
    usuario.name = 'novonome' # deve funcionar
    usuario.save!

    usuario.age = 50.6 # deve falhar
    usuario.save!
  end
rescue ActiveRecord::RecordInvalid => e
  puts "\nErro ao salvar: #{e.message}\n"
end

# ❌ Nada muda
usuario = User.first
puts "\nDepois 1 (nada muda) =>", usuario.attributes

# Exemplo 2: 
# - Deve tentar mudar o nome e idade e funcionar. 
# - Como não falhou, as alterações persistem.

ActiveRecord::Base.transaction do
  usuario = User.first
  puts "\nAntes 2 =>", usuario.attributes
  usuario.name = 'novonome' # deve funcionar
  usuario.save!

  usuario.age = 50  # deve funcionar
  usuario.save!
end

# ✅ As alterações persistem
# Agora nome e idade foram alterados
usuario = User.first
puts "\nDepois 2 =>", usuario.attributes
puts "Funciona perfeitamente."

Dentro do bloco de transação, você pode capturar exceções para tratamento específico ou para permitir que a transação continue. Se necessário, você pode relançar exceções para sair da transação.

Além disso, você não está limitado a operar apenas no modelo associado ao bloco de transação. Você pode chamar o método transaction em qualquer modelo ou instância de modelo para iniciar uma transação específica para aquele objeto.

O uso de transações é essencial para garantir a integridade e consistência dos dados em aplicações que envolvem operações críticas no banco de dados.

Relacionamentos ↔️

Associar modelos uns aos outros é um aspecto fundamental do ActiveRecord. Estes incluem relacionamentos como um para um, um para muitos e muitos para muitos.

Os relacionamentos disponíveis entre os modelos são:

pertence a (belongs_to);
tem um (has_one);
tem muitos (has_many);
tem muitos através de (has_many :through);
tem um através de (has_one :through);
tem e pertence a muitos (has_and_belongs_to_many).

Há uma espécie de 'mágica' ✨ que acontece quando se trata da nomeação de tabelas. Você pode substituir os nomes das tabelas e os nomes das colunas de chave estrangeira, mas é recomendado seguir as convenções para evitar configurações extras. Por exemplo, se um Perfil pertence a um Usuário, ele assume que existem tabelas de usuários e perfis, e a tabela de perfis terá uma coluna user_id.

Tabelas de ligação para relacionamentos muitos para muitos usam o nome de ambos os modelos em ordem alfabética. Por exemplo, se um Usuário tem um relacionamento muitos para muitos com um Departamento, então a tabela de ligação é esperada para ser nomeada departments_users e conter colunas user_id e department_id que fazem referência às tabelas denominadas departments e users.

Neste exemplo, preste atenção especial à singularidade ou pluralidade das palavras usadas nos nomes dos modelos, nomes dos relacionamentos e nomes das tabelas do banco de dados. Ao usar um relacionamento has_and_belongs_to_many, a tabela de ligação usa plurais de ambos os nomes em ordem alfabética.

Nessa etapa será necessário criar novas tabelas para que o exemplo funcione pois precisamos de mais tabelas para relacionar. Dessa forma, você pode se aventurar criando-as manualmente ou executar a migration presente aqui.

# ./models/user.rb
class User < ActiveRecord::Base
  has_one :profile
  has_many :posts
  has_and_belongs_to_many :departments
end

# ./models/post.rb
class Post < ActiveRecord::Base
  belongs_to :user
end

# ./models/profile.rb
class Profile < ActiveRecord::Base
  belongs_to :user
end

# ./models/department.rb
class Department < ActiveRecord::Base
  has_and_belongs_to_many :users
end

Dessa forma, podemos realizar as seguintes execuções:

# main.rb
usuario = User.create(name: 'Ernane')

# Algumas maneiras de criar o perfil para o usuário:
Profile.create(bio: 'ErnaneJ', user: usuario)
usuario.profile = Profile.create(bio: 'Hello World! :)')
usuario.create_profile(bio: 'Hello World! :)')

# Algumas maneiras de adicionar um post ao usuário (relacionamento um para muitos)
usuario.posts.create(content: 'Post de exemplo')
Post.create(content: 'Outro post', user: usuario)
usuario.posts.append(Post.create(content: 'Um terceiro post'))

# Criar os departamentos e relacionamentos (relacionamento muitos para muitos)
usuario.departments.create(name: 'TI')
Department.create(name: 'Vendas', users: [usuario])
usuario.departments.append(Department.create(name: 'RH'))

# Obtendo os objetos relacionados
usuario = User.find_by_name('Ernane')
puts usuario.inspect
puts usuario.profile.inspect
puts usuario.post_ids.inspect
puts usuario.posts.inspect
puts usuario.department_ids.inspect
puts usuario.departments.inspect

Você pode ler mais sobre associações acessando o Guides.

Migrações 🗄️

Para evitar a necessidade de escrever instruções SQL para criar, modificar e destruir esquemas de banco de dados, o ActiveRecord fornece um mecanismo para realizar migrações. Isso permite que você escreva código Ruby para especificar como deve ser a estrutura do banco de dados sem escrever SQL bruto.

Existem alguns benefícios nisso. Por exemplo, como comentado anteriormente, você pode usar a mesma migração para criar o esquema de banco de dados para SQLite, MySQL e PostgreSQL, mesmo que as instruções SQL reais possam variar de banco de dados para banco de dados. Ele também permite que você execute atualizações, desmonte e reconstrua facilmente um banco de dados apenas executando os scripts de migração Ruby, que por sua vez podem ser configurados em um Rakefile por conveniência.

Métodos Disponíveis 📋

Ao definir classes de migração, estes são alguns dos métodos disponíveis que você pode usar para executar operações de banco de dados. Você pode ler mais sobre os métodos disponíveis aqui.

create_table();
change_table();
rename_table();
drop_table();
create_join_table();
drop_join_table();
add_column();
change_column();
change_column_default();
change_column_null() (permitir/proibir nulo);
rename_column();
remove_column();
remove_columns();
add_timestamps() (created_at e updated_at);
remove_timestamps();
add_foreign_key();
remove_foreign_key();
add_index();
rename_index();
remove_index();
add_reference();
remove_reference().

Diferença Entre CHANGE() e UP()/DOWN() ⁉️

No início, pode ser um pouco confuso entender a necessidade desses dois métodos e você também pode estar se perguntando. Basicamente, se você definir migrações usando o método change, ele determinará automaticamente o que precisa ser feito para que as migrações up e down executem ou desfaçam as ações especificadas.

Se quiser especificar uma ação que funcione apenas em uma direção ou ter mais controle, você poderá definir explicitamente os métodos .up e .down. Eu usaria o padrão, change, a menos que você tenha alguma necessidade especial.

Criar e Eliminar Tabelas 🧑🏼‍💻

Este exemplo mostra como fazer uma migração simples que criará uma tabela chamada users com alguns campos: name, age, created_at e updated_at.

Chame o método migrate da classe de migração para atualizar o banco de dados. Você deve fornecer uma direção (:up ou :down) para especificar se deseja executar as alterações ou desfazê-las. Ele determinará automaticamente quais instruções precisam ser executadas para realizar cada ação.

class CreateUserTable < ActiveRecord::Migration[5.2]
  def change
    create_table :users do |table|
      table.string :name
      table.integer :age
      table.timestamps
    end
  end
end

# Criar a tabela
CreateUserTable.migrate(:up)

# Eliminar a tabela
CreateUserTable.migrate(:down)

Usando no IRB 🖥️

Ao usar o Ruby on Rails, você pode acessar o console do Rails com o comando rails console para entrar em um ambiente interativo que permite consultar e manipular seus modelos ActiveRecord. No entanto, se você estiver fora do ambiente Rails, precisará requerer os módulos Ruby onde seus modelos estão definidos.

Você pode usar o argumento -r para exigir os módulos desejados na inicialização do IRB. Isso economiza tempo, pois você não precisa digitar os comandos require manualmente dentro do interpretador.

irb -r ./models

Dessa forma, você pode iniciar o IRB com seus módulos já importados e prontos para uso.

Alternativamente, como dito, você pode importar manualmente os módulos dentro do IRB digitando os comandos require. No entanto, criar um script com os comandos de require economiza tempo e esforço. Uma vez dentro do IRB, você pode usar seus modelos como de costume:

$ irb
irb(main):001> require "./configurations/initializer.rb"
# => true
irb(main):002> require "./models/user.rb"
# => true
irb(main):003> User
# => User (call 'User.connection' to establish a connection)
irb(main):004> User.last
# => #<User:0x000000010bdb0630 ...>

Isso permite que você execute consultas e manipulações em seus modelos ActiveRecord diretamente do console interativo.

Conclusão 🎉

Após absorver este tutorial, você agora possui um entendimento sólido dos fundamentos do ActiveRecord. Agora, você deve se sentir confiante para instalar o ActiveRecord, explorar sua documentação e começar a utilizá-lo em seus projetos Ruby.

Aqui está um resumo do que foi aprendido:

Instalação e configuração inicial do ActiveRecord;
Definição de modelos e relacionamentos entre eles;
Execução de consultas para recuperar dados do banco de dados;
Criação e manipulação de registros no banco de dados;
Utilização de retornos de chamada para executar ações automáticas em modelos;
Realização de transações para garantir que várias operações de banco de dados sejam executadas com sucesso ou revertidas em caso de erro;
Criação e execução de migrações para gerenciar o esquema do banco de dados de forma programática;
Utilização do ActiveRecord em uma sessão interativa no IRB ou Pry.

Com esses conhecimentos, você está pronto para aproveitar ao máximo o ActiveRecord em seus projetos Ruby, facilitando o trabalho com bancos de dados e simplificando o desenvolvimento de aplicativos web. Lembre-se de continuar explorando a documentação oficial e praticar com exemplos do mundo real para aprimorar suas habilidades. 🚀

O repositório com os exemplos mencionados neste post está disponível e totalmente aberto a contribuições. Além disso, esta publicação também. Sinta-se à vontade!

Espero que tenha gostado dessa postagem e que ela tenha te ajudado, de alguma forma, a encontrar ou que você procurava! 💙

How to develop a svelte component and publish it as a package in NPM

Ernane Ferreira — Sun, 21 May 2023 02:24:14 +0000

Publish your favorite svelte component as a package on npm and make it available for use anytime.

When we like a certain component that we develop, we end up using and reusing it countless times, in different ways, that is; replicating your files and logic in many different places in the project, or in several other projects, or simply redeploying the same component over and over again. This will work, of course. However, it is not the best way to act in this situation.

Imagine that you will have to carry out maintenance, or simply change, say, the color of this component. Imagine that there are 10, 100, 200... Well, you will have to make this change in each component present in your project, correct? What if it is already applied to other projects? well, the change should be made too. The problem I think we already understood. But how to solve it?

When it comes to a project that uses the same technology, in the case that we will see in this post Svelte for example, you can create a component and publish it as a package in NPM and reuse it whenever you need it. That's what we'll see here! for cases where the projects do not share the same technology, this is a matter for another time. But if you like spoilers you can read about WebComponents.

What will we develop?

I recently made a simple svelte component - hence the idea of the post - to perform evaluations. It is simply a nest of stars and in it the user will be able to show his satisfaction with such content that the component will return the selected information in its configuration prop. He will be the one we will develop!

For this, you need to have an account on NPM, have NodeJs and NPM installed on your machine and be patient to venture out!

Initializing the project

The first step, like any project, is to create a directory for it. let's go!

$ mkdir svelte-star-rating
$ cd svelte-star-rating

Now, we can actually initialize our project.

$ npm init -y

This command will create a package.json file and will automatically fill in some information about the package we are developing like name, author, description, etc... the -y flag will perform a short auto-fill. If you want to do it manually run without it. But don't worry, you can always change package.json when needed.

Installing required dependencies

The next step is to install the necessary development dependencies of our package. That way, notice that package.json will add the dev dependencies section. In addition, I will take the opportunity to make some changes, such as name, author, keywords, etc. Feel free to fill in as you see fit.

Finally, the package.json should look like this:

{
  "name": "@ernane/svelte-star-rating",
  "version": "1.0.0",
  "description": "Simple component to assign scores based on stars.",
  "homepage": "https://github.com/ErnaneJ/svelte-star-rating",
  "bugs": {
    "url": "https://github.com/ErnaneJ/svelte-star-rating/issues"
  },
  "repository": {
    "type": "git",
    "url": "git+https://github.com/ErnaneJ/svelte-star-rating.git"
  },
  "keywords": [
    "svelte",
    "star",
    "ratting",
    "component",
    "sapper"
  ],
  "author": "ernane <ernane.junior25@gmail.com>",
  "license": "MIT",
  "devDependencies": {
    "rollup": "^2.39.0",
    "rollup-plugin-node-resolve": "^5.2.0",
    "rollup-plugin-svelte": "^7.1.0",
    "svelte": "^3.32.3"
  }
}

Component creation

As usual, I create my logic files usually in a subdirectory named src, I'll follow that pattern here. In this way, we will create an index.js file, it will be the starting point of our component.

Basically we will import the main component of our package and export it as default in index. It will be something like this:

// src/index.js
import SvelteStarRating from './SvelteStarRating.svelte';
export default SvelteStarRating;

As a consequence we will now have to create the file, which will be our svelte component itself, SvelteStarRating.svelte. To test it, let's just put a test message at the moment!

<!-- src/SvelteStarRating.svelte -->
<p>Hello World! It's my first package svelte component! ✨ SvelteStarRating ✨</p>

In this file we will have all the logic and implementation of our package. In it we will add styles, necessary imports, among other things.. Let's go ahead, we'll be back in it!

Formalizing structure

Now that we have the main structure of our component, we need to formalize it in our package.json. For this, we will need to make some more changes to it.

// ...
"main": "dist/index.js",
"module": "dist/index.mjs",
"svelte": "src/index.js",
"scripts": {
    "build": "rollup -c",
    "dev": "rollup -c -w"
},    
// ...

Since this part is a bit tricky, let's see what it's actually doing:

In main we define what will be the output after the execution of the compilation script,
In module we define the same, but as output an mjs extension file so that Node can differentiate it among the modules created with CommonJS and ES6.
In svelte, we are defining the path of our main file, the index.js that we created earlier.
And, finally, scripts will be the commands used for execution and compilation in development.

Note that the dist subdirectory, which we specified in the first two commands, does not exist as it will be automagically generated ✨.

After these small changes our package.json will look like this:

{
  "name": "@ernane/svelte-star-rating",
 "version": "1.0.0",
  "description": "Simple component to assign scores based on stars.",
  "main": "dist/index.js",
  "module": "dist/index.mjs",
  "svelte": "src/index.js",
  "scripts": {
    "build": "rollup -c",
    "dev": "rollup -c -w"
  },
  "homepage": "https://github.com/ErnaneJ/svelte-star-rating",
  "bugs": {
    "url": "https://github.com/ErnaneJ/svelte-star-rating/issues"
  },
  "repository": {
    "type": "git",
    "url": "git+https://github.com/ErnaneJ/svelte-star-rating.git"
  },
  "keywords": [
    "svelte",
    "star",
    "ratting",
    "component",
    "sapper"
  ],
  "author": "ernane <ernane.junior25@gmail.com>",
  "license": "MIT",
  "devDependencies": {
    "rollup": "^2.39.0",
    "rollup-plugin-node-resolve": "^5.2.0",
    "rollup-plugin-svelte": "^7.1.0",
    "svelte": "^3.32.3"
  }
}

Creating the rollup.config.js file

You are probably already familiar with this file because it is Svelte. But basically we perform the basic build configuration of our simple project.

import svelte from "rollup-plugin-svelte";
import resolve from "rollup-plugin-node-resolve";
const pkg = require("./package.json");
export default {
    input: "src/AtButton.svelte",
    output: [
        { file: pkg.module, format: "es" },
        { file: pkg.main, format: "umd", name: "Name" },
    ],
    plugins: [svelte(), resolve()],
};

Wow! Package successfully configured for use. 🥳

Testing component locally

Before we publish our new component on NPM, it's always good to test it to see how it really is and if its result is satisfactory. For this, we can use it on our machine even before we send it for publication. For this, let's create, in parallel, a simple project in Svelte. For this case, I'll use svelte-playground itself.

$ npx degit sveltejs/template svelte-playground

Then we access the cloned project and install two initial dependencies.

$ cd svelte-playground
$ npm install

Now, in order to use our component as an npm package and apply it to this project, we can run the following command in the directory of our svelte-star-rating package.

$ npm link

With it we will get a response similar to this:

# npm WARN svelte-star-rating@1.0.0 No repository field.

# audited 17 packages in 0.711s

# 3 packages are looking for funding
#   run npm fund for details

# found 0 vulnerabilities

After that, now in the svelte-playground test project we can run the same command, but now, going to the directory of our new package on our machine.

$ npm link /path/svelte-star-rating

That way we can use our component as a package locally, and best of all, in realtime!

Using component locally

Access the test project we created, svelte-playground, and run the project under development using the command present in your package.json.

$ npm run dev

EThen access the browser at the suggested port and see the application running. After that, we can now apply our component to this project and thus visualize its changes at runtime.

for that, we go to the src/app.svelte file, to make some changes.

<!-- src/app.svelte -->
<script>
  ...
  import StarRating from "@ernane/svelte-star-rating";
  ...
</script>

...
<StarRating/>
...

And then we'll have our component running locally. Fantastic, isn't it!?

Now we just have to develop our new component the way we want and check if the changes made match what we want. Here is the current development status of my svelte-star-rating.

Publishing package in NPM

Great, we already have our component working we would like. And now? well, now we publish it! Publishing is as simple as a push, check it out...

First, you must be logged into your NPM account, if you are not or don't know, just follow the steps described here.

After being logged in, and sure you want to publish the first version of your package, just run the following command:

$ npm publish --access public

Ready! you can access your profile on the NPM page and you will see a new package added! 🎉 Simple no?!

Testing new NPM package

You've undoubtedly done this here hundreds of times, or maybe less 😅.. Access your package information that will tell you how to install it. But following the standards you can do it with the simple npm install passing the name, defined in the package.json, of your project!

i.e,

$ npm i @ernane/svelte-star-rating

Usage will be the same as before, import and use. Well, that you already know!

If you have any questions, here is the repository that I used to store the package mentioned here in the post and the link to it already published on npm!

I hope you enjoyed this post and that it helped you, in some way, to find what you were looking for! 💙

Configuring Linux terminal to show current branch in versioned directories

Ernane Ferreira — Sun, 21 May 2023 01:59:01 +0000

Make your life easier as a developer and know the current branch in your workspace without complications. And the best? Without installing anything additional!

One of the gifts of a good developer is knowing exactly where he's pushing his changes. Currently, the best way to do this, especially using code versioning with Git, is to validate the current working directory branch. We have a few ways to do this:

Use git's own command to show the current branch:

$ git status

# On branch master
# Your branch is up to date with 'origin/master'.

# nothing to commit, working tree clea

Or yet:

$ git branch

# * master

We can install some other third-party terminal (such as Oh My ZSH), but that's a topic for another post! 😎
Another option is to simply manipulate your native terminal to show your current branch whenever you have a git-versioned directory. This alternative is what we will see in this post!

Changing settings to display the current branch

Normally, the terminal settings do not show the branch of the current directory if it is versioned by git, and by default only the user, host (machine name) and path (current path) are shown. However, it has some settings that can be manipulated from a variable in its file named PS1. To do so, simply open the .bashrc or .bash_profile file in your preferred text editor and add the following command at the end:

export PS1='\u@\h[\033[01;34m] \w[\033[0;32m]$(__git_ps1 " (%s)")[\033[01;34m]$[\033[00m] '

To apply the settings, it is necessary to reload the file. We can do this by restarting the system, logging out or simply reloading the configuration file:

source ~/.bashrc # or source ~/.bash_profile

Ready! 🎉 We already have our current branch showing in directories that are versioned by git.

Additional settings

Why not go further? Below I will leave some possible additional color settings, for example, that can be performed to make the present information as relevant as possible to your use case.

Values:

\u: User currently logged on the machine;
\h: Name of the machine (host), previously registered;
\H: Full machine name, previously registered;
\w: Full current working directory;
\W: Minified current working directory, base name only (last segment);
$(__git_ps1 "%s"): Current branch if it's in a git-versioned repository, otherwise nothing will be displayed.

Colors

Blue: [\033[0;34m];
Red: [\033[0;31m];
Fluorescent Red: [\033[1;31m];
Green: [\033[0;32m];
Fluorescent Green: [\033[1;32m];
Strong White: [\033[1;37m];
Gray: [\033[0;37m];
Default: [\033[0m].

Ready! This is the range of simple and powerful configurations available for use that will make it even easier for you to self-localize in the development process and, in addition, allow customization in the way you want and find valid. Mine looks like this at the time I write this post:

👾 ~/path/path(master)$

Yes, with emoji! 😬

What has been shown here is just a little of what is possible to be done. Therefore, as usual, I will leave some links that I used as a reference to write and that you can use to go further on the subject.

Good reading!

I hope you enjoyed this post and that it helped you find what you were looking for! 💙

The difference between traditional functions and arrow functions in javascript

Ernane Ferreira — Sun, 21 May 2023 01:43:02 +0000

Make no mistake, it's not just the compactness and elegant syntax that differ the ways of declaring functions in Javascript.

Arrow functions is a relatively new feature implementing in ES6 (ECMAScript 6) which in our eyes is just a more concise and elegant syntax to declare function expressions in Javascript. Although traditional functions and arrow functions work in a similar way, we must beware of certain differences that may not be noticeable.

Syntax

The difference in syntax between the two models is notorious, since in the arrow function it becomes possible to considerably reduce the number of lines present in the function declaration, especially if it is already a simple function. See examples:

Imagine a function that takes a user's name and prints it to the console. In the traditional way, we could declare it like this:

function sayMyNane(name){
  console.log(`My name is ${name}!`);
}

sayMyNane('Ernane'); // => My name is Ernane.

Already with the arrow functions present from ES6, we could do it as follows:

const sayMyName = (name) => {
  console.log(My name is ${name});
}

sayMyNane('Ernane'); // => My name is Ernane.

Remembering that in the case of arrow functions, the braces are only necessary if an expression is present, the same rule applies for parentheses, since they are only necessary if there is more than one argument to be passed. In this way, we could reduce it even further and write the above example as follows:

const sayMyName = name => console.log(My name is ${name}; 

sayMyNane('Ernane'); // => My name is Ernane.

Simple, isn't it? ✨ in this way, we can see how an arrow function can facilitate the declaration of a certain function because of its syntax and still return the same result as a common declaration.

Use of the 'this' keyword

Unlike the traditional declaration, arrow functions do not have their own this element, as the value of this inside an arrow function remains the same throughout the lifecycle of the function and is always bound to the value of this in the closest traditional parent function.

Did that get a little weird? 🤔 let me try to uncomplicate with an example:

Returning to the example used in the previous topic, imagine that we have a person object that has its name defined as one of its attributes and has a function that prints the name of that particular person to the console. Depending on the type of function used, it will not be able to correctly access the parent object that has the requested name attribute and, therefore, its return will be undefined.

let person = {
  name: "Ernane Ferreira",
  sayMyName: () => console.log(My name is ${this.name}.)
};

person.sayMyName(); // => My name is .

In the case of the function being declared in the traditional model, this will work as expected and we will correctly obtain the sought attribute. 🤗

let person = {
  name: "Ernane Ferreira",
  sayMyName: function() {
    console.log(My name is ${this.name}.);
  }
};

person.sayMyName(); // => My name is Ernane Ferreira.

Access to arguments

The arguments object is a local variable available inside all functions and it is what makes the reference possible arguments of a function within the same using the arguments object. However, arrow functions have no link to the arguments object:

const showArguments = () => console.log(arguments);

showArguments(1, 2, 3) // => ReferenceError: arguments is not defined.

In the case of a regular function, we can easily access a list of the arguments passed as a parameter when calling the function:

function showArguments(){ 
  console.log(arguments); 
}

showArguments(1, 2, 3) // => Arguments(3) [1, 2, 3]

Using the new operator

The new operator allows instantiation of a user-defined object type or one of the user-defined types. of internal objects that have a constructor function. Traditional functions are constructible and can be called using the new operator. On the other hand, arrow functions are callable and not constructible, that is, these functions can never be used as constructor functions and can never be invoked with the new operator.

Therefore, for this type of execution in traditional functions, we get the following execution result:

function sayMyName(){
  console.log(My name is ${name}); 
}

new sayMyName('Ernane'); // => Ernane

As for the arrow functions:

const sayMyName = () => console.log(My name is ${name});

new sayMyName('Ernane'); // => Uncaught TypeError: sayMyName is not a constructor

Parameters with duplicate naming

The arrow functions do not allow the name of duplicate parameters, but the traditional functions allow depending on the application or non-application of strict mode (Strict Mode) in the code implementation. For example, the javascript below is fully valid:

function addTwoNumbers(x, x){
  console.log(x+x);
}

addTwoNumbers(1,1); // => 2

However, the same code with strict mode applied is no longer valid:

'use strict';

function addTwoNumbers(x, x){
  console.log(x+x);
} 

// => Uncaught SyntaxError: Duplicate parameter name not allowed in this context

When using arrow functions, this occurs regardless of whether strict mode is applied. In both cases, the execution is invalid:

const addTwoNumbers = (x, x) => console.log(x+x); 

// => SyntaxError: Uncaught SyntaxError: Duplicate parameter name not allowed in this context.

That way, it's always good to pay close attention to the use of arrow functions instead of traditional functions. Although their syntax is very pleasant, they have some points that we must be careful not to miss.

In any case, further study on the subject is advisable. As always, I will leave below some recommendation links for the deepening of the theme.

I hope you enjoyed this post and that it helped you find what you were looking for! 💙

The 3 best tools I use to validate the meta tags present on my websites

Ernane Ferreira — Sat, 20 May 2023 15:27:43 +0000

It is very important to validate and verify how your article or new web page will be displayed when shared.

When a page on the web is shared — be it on Facebook, Twitter, Linkedin, Instagram, whatsapp, etc. — usually there is some kind of preview of it in the application it is being shared (a title, text snippet, description of what it is about, image or whatever is available). When you are the author of this content, it is extremely important to have a lot of control over the information being displayed, as other people share links to your content.

Here we will see the main (in my not so humble opinion) tools available for validating and creating meta tags for your website. By the way, the tools that will be mentioned are the ones I use whenever I post new content and I'm not entirely sure how some platforms will display them. 🧐

Hey Meta

One of the most important things when adding tags to your website header is to focus mainly on the most essential ones. For social sharing, the most important are title and description. Many services that allow you to share links will use these tags to create cards to preview your content. Even if they have specific tags, like Facebook and Twitter, whenever they don't find their tags, services will look for the generic description and title to know what to display in the share.

One tool that does a great job with these tags is Hey Meta. In it, you can put any url to be checked and it will show which meta tags it found in its scan or, if possible, try to guess which one should be present. This tool also provides an easy and practical way to add the essential tags on your website from a 'template' that they generate for you on the platform based on your content.

Facebook debugger

The company Meta, formerly known as Facebook, developed the Open Graph protocol and Facebook uses it to display its cards view on sharing links. In this way, the Open Graph became a social sharing standard available on the web and this is stated on its home page:

While there are many different technologies and schemes that can be combined, there is no single technology that provides enough information to richly represent any given webpage on the social graph. The Open Graph protocol builds on these existing technologies and gives developers something to implement.

As mentioned earlier, Facebook and other networks that use their own meta tags will fall back to base tags if they don't find their own or Open Graph tags (OG tags). However, as also mentioned, OG has become a standard for social sharing, and as such, it becomes important to implement at least the primary OG tags on any page you make available on the internet. The main ones are: og:type, og: title, og:description, og:image and og:url.

Since Facebook is the strongest in this field, it has also taken it upon itself to provide developers with a great tool to validate OG tags from any URL. This application provides a way to validate and preview how your pages will appear when shared on Facebook.

Twitter card validator

Like Facbeook, Twitter also has its own separate protocol. Tags for building the Twitter card on its content are only used by the social network, as most other platforms assume OG tags or native tags as the main focus for obtaining data from the associated url.

The biggest advantage and the main focus of using Twitter cards is having more control over how the card will represent your page on the platform and, for that, the social network has a huge list of options to be included. Due to it being platform specific, it is not a problem to stick to native meta tags and OG tags as Twitter will continue to use the available OG and/or native tags. Here you can check which OG tags present on your page are found and returned by twitter.

Anyway, Twitter tags are great to use if you want more control over what will appear when you share your page, as the platform has developed a twitter URL validator to help you verify how your content will appear to users when shared.

These were the three main tools I use and I find it extremely interesting to verify the information present in my meta tags whenever I publish new content. Of course, there are other very good ones, mainly more complete viewers, but I choose them because Hey Meta helps me to generate the tags in a reliable way and I always use the other two to validate their operation and make adjustments if necessary.

Use these tools to gain greater control over your content's views when shared. If you know of any other good tools that could complement it, I would be very happy if you share it with me below!

I hope this post helped you find what you were looking for! 💙

[pt-br] Como alavancar sua produtividade com o Visual Studio Code

Ernane Ferreira — Thu, 21 Apr 2022 18:22:53 +0000

Não há dúvidas de que o Visual Studio Code (VS Code), editor de código de código aberto desenvolvido pela Microsoft, é um dos editores mais queridos da última década devido ser uma ótima ferramenta para o dia a dia não se tratando apenas de código, mas da edição de qualquer tipo de texto.

Visual Studio ou Visual Studio Code? 🤔

O Visual Studio é uma IDE desenvolvida pela Microsoft, dedicada ao .NET Framework e a linguagens robustas como C, C++, C# e F#. Por ser uma solução completa, é uma ferramenta bem mais pesada do que o Visual Studio Code, que trataremos aqui, e que por sua vez trata de funcionalidades mais simples como a fácil edição de código com suporte a várias linguagens de programação, terminal integrado e controle de versão. Sendo, dessa forma, uma ferramenta mais leve. Mas não se engane, muito poderosa! 💪

Um mundo aberto de funcionalidades

O VS Code é capaz de fazer muitas coisas que nos ajudam a trabalhar melhor. A princípio ele é, e pode realmente parecer, uma ferramenta muito simples, mas ele possui uma loja de extensões imensa, e que continua crescendo constantemente.

Ou seja, com essa enorme coleção de extensões, podemos adicionar diversas funcionalidades e personalizações, ao VS Code de forma bem simples e prática. Dessa maneira, ele pode facilmente ser comparado a grandes IDEs pagas. Caso se interesse, facilmente qualquer usuário pode criar uma extensão e publicar na loja. Desse modo, sempre há novas ferramentas que podem ser interessantes para alguém.

Atalhos para aumentar sua produtividade

Como qualquer outra ferramenta, é de crucial importância que seus usuários aprendam a manuseá-la com destreza. Quanto mais você se aperfeiçoar nisso, mais fácil será trabalhar com ela em seu cotidiano. Este poderoso editor, assim como a maioria dos outros, possui atalhos que nos tornam mais ágeis na execução de certas atividades, principalmente as mais repetitivas.

Os atalhos são muitos, mas aqui vamos ver os principais que não podem faltar no seu dia a dia. 🚀

CTRL+K CTRL+0 ou CTRL+K CTRL+J: Dobrar ou desdobrar todas as funções ou métodos
CTRL+G: Ir para a linha
CTRL+P: Ir para o arquivo
F8: Ir para o próximo erro ou aviso
F12: Ir para a definição da função ou método
ALT+F12: Mostrar a definição da função ou método
CTRL+ALT+UP ou CTRL+ALT+DOWN: Adicione um cursor acima ou abaixo da linha atual
SHIFT+ALT+I: inserir um cursor no final de cada linha selecionada
CTRL+F2: Selecionar todas as ocorrências da seleção
CTRL+SHIFT+.: Ir para navegação via breadcrumbs
CTRL+ALT+LEFT ou CTRL+ALT+RIGHT: Mover o editor em grupos
SHIFT+ALT+0: Alternar o layout dos grupos em vertical e horizontal
ALT+Z: Alternar entre quebra de linha
CTRL+KM: Change a linguagem do arquivo
CTRL+B: Mostrar/esconder a barra lateral
SHIFT+ALT+UP ou SHIFT+ALT+DOWN: Copiar a linha pra cima ou pra baixo
CTRL+SHIFT+K: Apagar linha selecione
F2: Renomear simbolo ou variável
CTRL+KC: Comparar arquivo atual com a área de download+
CTRL+SHIFT+5: Terminal divisor
CTRL+K CTRL+S: Mostrar atalhos
CTRL+TAB: Alternar entre aba
CTRL+L: Selecionar toda linha
CTRL+SHIFT+L: Selecionar todas as ocorrências da seleção atual
CTRL+F2: Selecionar todas as ocorrências da palavra
CTRL+SHIFT+SPACE: Mostrar definição dos parâmetros
CTRL+K CTRL+X: Apagar espaços em branco
CTRL+SHIFT+H: Substituir em todos os arquivos
SHIFT+ALT+F: Formatar todo o documento
CTRL+K CTRL+F: Formatar seleção
CTRL+KV: Abrir preview ao lado (ex. Markdown)
CTRL+,: Abrir configurações do usuário
CTRL+KZ: Entrar no modo Zen

Sem dúvida alguma, essa é apenas a ponta do iceberg, pois existem muuuitos outros atalhos disponíveis para usar e melhorar o seu fluxo de trabalho como desenvolvedor. Caso se interesse, deixo aqui abaixo desse post alguns links de onde procurar mais informações!

Espero que tenha gostado dessa postagem e que ela tenha te ajudado, de alguma forma, a encontrar o que você procurava! 💙

Veja mais em meu blog!

[pt-br] Guia rápido e prático dos principais comandos git

Ernane Ferreira — Mon, 11 Apr 2022 00:02:36 +0000

Git é um sistema de controle de versão gratuito e de código aberto, originalmente criado por Linus Torvalds no ano de 2005. Ao contrário de sistemas de controle de versão centralizados mais antigos, como o SVN e CVS, o Git é distribuído, pois todo desenvolvedor tem o histórico completo de seu repositório de código localmente.

O Git também oferece excelente suporte para ramificação, mesclagem e reescrita do histórico do repositório, o que levou a muitos fluxos de trabalho e ferramentas inovadoras e poderosas. As solicitações pull é uma ferramenta popular que permite que as equipes colaborem em ramificações do Git e revisem com eficiência o código uns dos outros. Atualmente, o Git é o sistema de controle de versão mais utilizado no mundo e é considerado o padrão moderno para desenvolvimento de software.

Certo! mas por onde eu começo? 🤔

É simples: instale o Git na sua máquina! fácil, não é? atualmente o Git está disponível para as mais diversas plataformas e você pode encontrar como realizar esse download/instalação no seu próprio site.

🔗 Git para todas as plataformas

Configure o Git em sua máquina

Configure informações de usuário para todos os repositórios. 👨‍💻

Primeiramente, podemos configurar o nome que você quer ligado as suas transações de commit:

$ git config --global user.name "seu nome"

De maneira análoga, o email:

$ git config --global user.email "endereco-de-email"

Com isso, você já está apto a usar o git e ter suas informações vinculadas a seus commits.

Criando Repositórios

Inicie um novo repositório ou obtenha algum já existente.

Inicia um novo repositório local com um nome específico:

$ git init "nome-do-projeto"

Realiza o download de um projeto existente, bem como todo o seu histórico de versão:

$ git clone "url"

Realizando e revisando alterações

Revise edições, verifique o status de arquivos e crie transação de commit 🧐

Lista todos os arquivos novos, modificados e/ou deletados para serem commitados:

$ git status

Mostra diferenças nos arquivos que ainda não foram adicionadas:

$ git diff

Adiciona o seu estado atual para ser commitado e realiza um snapshot 📸 do arquivo:

$ git add "arquivo"

Mostra a diferença entre arquivos selecionados e a suas últimas versões já 'commitadas':

$ git diff --staged

Desmarca o arquivo, mas preserva seu conteúdo atual:

$ git reset "arquivo"

Salva o último snapshot realizado no arquivo permanentemente no histórico de versão:

$ git commit -m "mensagem descritiva do commit"

Mudanças agrupadas

Nomeie uma série de commits e, em seguida, combine as alterações adequadamente em uma ramificação

Lista todas as ramificações (branches) locais no repositório atual:

$ git branch

Cria uma nova ramificação:

$ git branch "nome-da-ramificação"

Muda para uma ramificação específica e atualiza o diretório de trabalho atual:

$ git checkout "nome-da-ramificação"

Combina o histórico de uma ramificação específica com a ramificação atual:

$ git merge "nome-de-uma-ramificação"

Exclui uma ramificação específica:

$ git branch -d "nome-da-ramificação"

Alterações de nomenclatura

Mude e remova os arquivos versionados

Remove o arquivo do diretório atual de trabalho e seleciona o mesmo para ser removido:

$ git rm "arquivo"

Remove o arquivo do controle de versão, mas preserva seu estado localmente:

$ git rm --cached "arquivo"

Muda o nome do arquivo e o seleciona para o commit:

$ git mv "arquivo-com-nome-atual" "arquivo-com-nome-renomeado"

Evite o rastreamento não desejados

Crie exceções para arquivos que você deseja que não sejam rastreados e adicionados ao histórico de versão do seu projeto. Para isso, se torna necessária a criação de um arquivo de texto comum na raiz do projeto de nome específico: .gitignore 🕵️

Este arquivo serve para suprimir o versionamento acidental de arquivos e diretórios correspondentes aos padrões especificados, como por exemplo:

build/
.env

Essas especificações não permitem que arquivos presentes no diretório build, ou arquivos que possuem extensão .env presente em todo o projeto, sejam rastreados ou adicionados acidentalmente para o histórico de versão.

Para listar os arquivos ignorados no projeto a partir dos padrões presentes no gitignore, use o comando abaixo:

$ git ls-files --other --ignored --exclude-standard

Salve fragmentos de código

Arquive, restaure e/ou exclua estágios e alterações incompletas presentes no projeto.

Armazena temporariamente as modificações de todos os arquivos já rastreados:

$ git stash

Aplica as alterações presentes no último stash:

$ git stash apply

Restaura os arquivos recentes em stash:

$ git stash pop

Lista todos os conjuntos de alterações presentes em stash:

$ git stash list

Descarta os conjuntos de alterações mais recentes em stash:

$ git stash drop

Revise seu histórico de versão

Navegue, valide e inspecione a evolução dos arquivos presentes no projeto.

Lista todo o histórico de versões para o branch atual:

$ git log

Lista o histórico de versões para um arquivo, incluindo mudanças em seu nome:

$ git log --follow "arquivo"

Mostra a diferença de conteúdo entre duas ramificações:

$ git diff "primeira-ramificação"..."segunda-ramificação"

Retorna mudanças de metadata e conteúdo para o commit especificado:

$ git show "commit"

Reabra seus commits

Desfaça enganos cometidos e crie um histórico substituto

Volta o histórico de versão ao estado do commit passado, mas mantendo as alterações no espaço de trabalho:

$ git reset "commit"

Retorna ao estado do commit passado, mas desfazendo todas as alterações e commits realizados após ele:

$ git reset --hard "commit"

Sincronize e salve as suas alterações Baixa todo o histórico de um marcador de repositório:

$ git fetch "marcador"

Combina o marcador da ramificação passada na ramificação local:

$ git merge "marcador"/"branch"

Envia todos os commits da ramificação local para a sua versão remota:

$ git push "alias" "branch"

Baixa o histórico presente no repositório remoto e incorpora as mudanças no repositório local:

$ git pull

Ufaa! 😅

Sem dúvidas você está com mais do que o necessário para versionar o seu código de maneira correta e segura. O bom de se utilizar do git é que, como foi citado anteriormente, ele é globalmente utilizado, o que possibilita aplicarmos esse conhecimento adquirido em qualquer plataforma que disfrute de seus serviços, como o Github, GitLab, etc.

Pode ter certeza que existem muitos outros comandos presentes no git que poderão te ajudar no dia a dia, mas essa listagem de comandos acima consegue te dar um ferramental muito forte para começar. Contudo, como de costume, deixo abaixo algumas referências que você poderá utilizar para desbravar esse mundo do versionamento de código.

Espero que tenha gostado dessa postagem e que ela tenha te ajudado de alguma forma a encontrar o que você procurava! 💙

Veja mais em meu blog!

[pt-br] Netlify e Google Domains: como configurá-los corretamente.

Ernane Ferreira — Mon, 07 Mar 2022 01:34:53 +0000

Recentemente, para implementação do meu site pessoal, adquiri o meu próprio domínio. Sempre quis ter um próprio e optei por comprar via domínios do Google. O processo de compra é relativamente simples, só são necessários os dados do cartão de crédito e endereço. Após isso, já estava com o meu domínio registrado, mas as configurações não são tão simples quanto o registro... 🧐

Decidi hospedar o meu site no Netlify, mas as configurações para outra empresa não devem ser tão diferentes. Abaixo mostrarei os passos para realizar as configurações do novo domínio adquirido com o site já hospedado.

Para ficar mais simples de compreender, as etapas foram divididas em duas: a primeira para a captura dos servidores de nomes no netlify e a outra para a aplicação deles no painel do google domains. Boa leitura! 📒

Configuração no Netlify

No console do netlify, acesse seu site e vá para a sessão de Configurações de domínio;
Em seguida, clique em Adicionar domínio personalizado, um provável botão verde 😝;
Após isso, provavelmente o seu domínio terá um banner inicializando com a opção 2 sendo Configurar seu domínio personalizado. Quando aparecer, clique nele;
Agora você será solicitado a fornecer o domínio que comprou (no meu caso, foi ernane.dev). Se você for o proprietário do domínio, o site solicitará que você valide que realmente é o dono, mas basta clicar em verificar. Um bom ponto a se levar em conta é que o próprio Netlify pode fornecer um domínio à você;
Depois de todos esses passos, você será redirecionado para as configurações do seu domínio e verá um aviso solicitando que você configure seu DNS: Clique em Opções ➡ Configurar DNS Netlify;
Adicione o domínio no campo solicitado - Provavelmente o Netlify solicitará que você verifique novamente seu domínio;
Adicione os registros DNS - Os registros DNS para seus sites Netlify serão configurados automaticamente. Você poderá pular essa parte, a menos que tenha um e-mail configurado com seu domínio;
Ative o DNS Netlify - O Nelify lhe dará nomes de seus provedores de nome. Mantenha-os abertos ou salve-os e dirija-se ao seu provedor de nome de domínio.

Prontinho! Com o Netlify já está tudo okay. 😄

Domínios do Google

Aqui será um pouco mais simples! 😁

No painel de configurações do seu domínio no Google Domains, vá para a seção Domain Name System - DNS.
Na seção NameServers, selecione a opção Usar nameservers personalizados. Para dominios do google, antes de adicionar os meus próprios, tornou-se necessário desabilitar o DNSSEC (Domain Name System Security Extensions), um recurso do (DNS) que autentica respostas à pesquisas de nome de domínio;
Em seguida, adicione os servidores de nomes que foram fornecidos pelo Netlify nos passos anteriores aos campos disponíveis.

E fim! seguindo todos os passos, seu domínio já estará configurado. Você verá que os domínios do google poderão recomendar uma espera de aproximadamente 48 horas para que as alterações sejam realizadas, mas comigo foi relativamente rápido. Após cerca de 15 a 30 minutos... Tcharann! 🎉 lá estava o meu novo site com o domínio configurado corretamente.

Espero que tenha gostado dessa postagem e te ajudado, de alguma forma, a encontrar o que você procurava! 💙

DEV Community: Ernane Ferreira

Text Improvement Automation with AppleScript & Gemini API 🔧

The Concept

🛠️ How to Set Up Your Own Text Improvement Automation

1. Create the Automation with Automator

2. Install Dependencies

3. Set the jq Path

4. Save and Run the Automation

🔍 Example of the Popup

💡 Customization Tips

🚀 Final Thoughts

Build a Simple TODO List with Shell Script 🐚

Prerequisites ⚙️

Step 1: Set Up Your Storage 🎲

Step 2: Define Your Functions ✨

Step 3: See It in Action ☕️

Conclusion ✍️

🚀 Edge Detection with Threads and MiniMagick in Ruby 🌄

🔍 Why Edge Detection Matters

🔨 How Edge Detection Works

📋 Step-by-Step Process

🧵 Multi-Threaded Implementation in Ruby

🖼️ Results

🎯 Conclusion

[pt-BR] Guia Prático: Explorando o Poder da Gem ActiveRecord no Ruby - Sem Framework 🚀

[pt-BR] Guia Prático: Explorando o Poder da Gem ActiveRecord no Ruby - Sem Framework 🚀

Introdução 🎉

Preparando o Projeto 🛠️

Criando uma Pasta para o Projeto 📂

Inicializando o Bundle 📦

Instalando a Gem ActiveRecord 💎

Consultando a Documentação 📚

Estabelecendo Conexão com o Banco de Dados 🎲

Instalando a Gem SQLite3 🪶

Estabelecendo Conexão com o Banco de Dados SQLite 🪶

Criando um Modelo 🧑🏼‍💻

Juntando as Peças 🛠️

Uso do ActiveRecord 🤩

Listando Colunas da Tabela 📋

Criando Novos Registros 🆕

Encontrando Registros 🔍

Atualizando Registros 🔄

Excluindo Registros ␡

Funções de Retorno de Chamada 👀

📍 Ação de Exclusão:

📍 Ações de Criação:

📍 Ações de Criação e Atualização:

📍 Ações de Consulta:

📍 Ações de Criação, Atualização e Exclusão:

Validação de Campos ✅

Transações em Bancos de Dados 🎲

Relacionamentos ↔️

Migrações 🗄️

Métodos Disponíveis 📋

Diferença Entre CHANGE() e UP()/DOWN() ⁉️

Criar e Eliminar Tabelas 🧑🏼‍💻

Usando no IRB 🖥️

Conclusão 🎉

How to develop a svelte component and publish it as a package in NPM

What will we develop?

Initializing the project

Installing required dependencies

Component creation

Formalizing structure

Creating the rollup.config.js file

Testing component locally

Using component locally

Publishing package in NPM

Testing new NPM package

Configuring Linux terminal to show current branch in versioned directories

Changing settings to display the current branch

Additional settings

Values:

Colors

Links:

The difference between traditional functions and arrow functions in javascript

Syntax

Use of the 'this' keyword

Access to arguments

Using the new operator

3. Set the `jq` Path