DEV Community: Ronak Bhatt

Rails 6 - Active Storage changes

Ronak Bhatt — Sat, 07 Aug 2021 18:41:05 +0000

Active Storage was introduced in Rails 5.2. In Rails 6, there are enhancements done to Active Storage.

Let’s explore them.

mini_magick replaced by image_processing gem

In Rails 5.2, Active Storage was using mini_magick to handle image resizing (variants).

In Rails 6, a new gem called image_processing is used by default to handle image variants. (commit)

The image_processing gem has below advantages:

New methods #resize_to_fit, #resize_to_fill, etc also sharpens the thumbnail after resizing.
It fixes the image orientation automatically. This can be referred here.
It provides another backend libvips that has significantly better performance than ImageMagick. With ImageMagick, resizing and sharpening a 1600x900 image to 800x800 is 1.87x slower, and to 300x300 is 1.18x slower. On libvips it doesn’t go above 1.20x slower, on average it’s only about 1.10x slower.

Fix for has_many_attached field in update query

Let’s say we have a User class and it has field images. Users can upload multiple images to their profiles. So we add has_many_attached method to User class as shown below

class User < ApplicationRecord
  has_many_attached :images
end

update query replaces the existing collection instead of appending to the collection.

user.images.attach(filename: "profile_pic.jpg")

user.images.count
=> 1

blog = ActiveStorage::Blob.create_after_upload!(filename: "updated_pic.jpg")
user.update(images: [blog])

user.images.count
=> 1
user.images.first.filename
=> "updated_pic.jpg"

Note:

We can append files by using the attach function.
More changes related to Active Storage can be found here.

Great Ruby Gems Most People Haven’t Heard About

Ronak Bhatt — Fri, 01 Jan 2021 06:39:34 +0000

What are the best Ruby gems that you can use in your Rails projects?

That’s what you’ll discover in this article!

I’m going to give you 7 gems, but not the same old gems that you’ve seen a million times, I’m going to be sharing with you some gems that are very helpful, but little-known.

But before we do that…

A warning.

I’ve seen developers that pull in a gem for just about everything.

If it remotely sounds like it could be helpful.

Without taking a moment to think if that gem solves the problem they have if it’s the best option, well-maintained & documented, etc.

That’s a mistake.

1. Find Dead Routes To Keep Your Code Clean

As your Rails application grows, you’ll accumulate more & more routes.

You’ll change code & some of these routes become stale.

No longer needed…

But they’ll stay there, in your config/routes.rb, making it harder to manage.

How do you find which routes to delete?

There is a gem called traceroute.

It loads your routes & compares them to the controller actions you’ve defined.

But right now it has two limitations:

It doesn’t work with Rails 6
It doesn’t detect implicit controller actions

You can find it here.

2. Make Your Migrations Safer So You Can Avoid Problems Rails migrations can cause a lot of problems if done wrong.

For example:

Removing a column can cause problems because Rails has a cache of columns, and running a migration doesn’t reset this cache.

Another example:

If you add an index & you’re running PostgreSQL the whole table gets locked until the operation is complete.

Not good for your users.

Your application won’t be able to respond to requests that need to work with a locked table.

The good news?

You don’t have to remember all of these things.

With the help of the strong_migrations gem, you’ll know when you have one of these unsafe migrations before it makes it into production.

You can find it here.

3. Find Your Slow Tests & Make Them Faster

Slow tests are no fun.

But there are tools to help you find why your tests are slow so you can fix them!

One of these tools is the combination of test-prof + ruby-prof.

Here’s how to use it:

TEST_RUBY_PROF=1 rake

Outputs:

%self       total       self         wait        child       calls   name
 43.21      2.001     2.001     0.000     0.000        1     Kernel#sleep
   2.97      0.184     0.138     0.000     0.046     1640   Array#permutation
   1.39      0.064     0.064     0.000     0.000      144   PG::Connection#async_exec

Here I can clearly see my call to sleep, but this could easily be an API call, reading a big file, a slow SQL query, etc.

Another thing you can do is to use the event profiler.

Btw, Rails 6 added parallel testing, you’ve to enable this in test/test_helpers.rb if you’re upgrading your current project.

4. Find Out Which Code Is Used In Production & Which Isn’t

Let’s finish with another tool to help you improve your code.

It’s called coverband.

If you run this gem in production (low overhead), you’ll get a coverage report of what code is being run.

You can even track unused views!

This can help you make decisions when deleting code & cleaning your project.

Don’t let unused code build up!

You can find it here.

Thanks for reading!
I hope that helps someone. Thanks :).

I’d love to hear thoughts or comments around this. Feel free to email me at ronakabhattrz@gmail.com or hit me up on Twitter, @ronakabhattrz .

What is the Difference between Ruby Blocks, Procs and Lambdas

Ronak Bhatt — Fri, 13 Nov 2020 09:20:36 +0000

Having a problem understanding the difference between ruby blocks, procs and lamdas. What are the blocks? What is the difference between procs and lambdas? Let's break this down.

BLOCKS:

A block is a collection of code enclosed in a do/end statement or between braces { }. They are chunks of code that you can pick up and drop into another method as input or chunk of code that you associate with a method call. If you have used each before to loop through an Enumerable then you have used blocks.

Defining a block

def block_method
  puts "we are in the method"
end

block_method { puts "The block is called"}

PROCS

So what if you want to pass two blocks to your function. How can you save your block into a variable?
Ruby introduces procs so that we are able to pass blocks around. Proc objects are blocks of code that have been bound to a set of local variables.Once bound, the code may be called in different contexts and still access those variables.

Defining procs

You can call new on the Proc class to create a proc . You can use the kernel object proc. Proc method is simply an alias for Proc.new. This can be assigned into a variable.

factor = Proc.new {|n| print n*2 }

or 

factor = proc {|n| print n*2}

//using the proc value

[3,2,1].each(&factor)

>642

LAMBDAS

Can be defined using the method lambda or can be defined as stuby lambda

lamb = lambda {|n| puts 'I am a lambda' }
lamb = -> (n) { puts 'I am a stuby lambda' }

Difference between Procs and Lambdas

Procs don’t care about the correct number of arguments, while lambdas will raise an exception.

Return and break behaves differently in procs and lambdas
Next behaves same way in both procs and lambdas

References

rubyguides.com : Click Here!!!!

I hope that helps someone. Thanks :).

Thanks for reading. 🙂

I’d love to hear thoughts or comments around this. Feel free to email me at ronakabhattrz@gmail.com or hit me up on twitter, @ronakabhattrz .

Rails 6, Stimulus events

Ronak Bhatt — Tue, 27 Oct 2020 12:54:57 +0000

An action is a connection between:

a controller method
the controller’s element
a DOM event listener

gallery_controller.js

// controllers/gallery_controller.js
import { Controller } from "stimulus"

export default class extends Controller {
  next(event) {
    alert("Justclick !!! :")
  }
}

View File Setup

<div data-controller="gallery">
  <button data-action="click->gallery#next">…</button>
</div>

Descriptors

The data-action value click->gallery#next is called an action descriptor. In this descriptor:

click is the name of the DOM event to listen for
gallery is the controller identifier
next is the name of the method to invoke

The full set of these shorthand pairs is as follows:

I hope that helps someone. Thanks :).

Thanks for reading. 🙂

I’d love to hear thoughts or comments around this. Feel free to email me at ronakabhattrz@gmail.com or hit me up on twitter, @ronakabhattrz.

How to Use Scopes in Ruby on Rails

Ronak Bhatt — Thu, 15 Oct 2020 07:24:53 +0000

Scopes are custom queries that you define inside your Rails models with the scope method.

Every scope takes two arguments:

A name, which you use to call this scope in your code
A lambda, which implements the query

It looks like this:

class User < ApplicationRecord
  scope :active, -> { where("status: 0") }
end

As a result of calling a scope, you’ll get an ActiveRecord::Relation object.

Which means you can chain & combine scopes!

Example:

User.active

When To Use Scopes?

Let’s see an example.

def index
  @books = Book.where("LENGTH(title) > 20")
end

This is an index controller action that wants to display books with titles longer than 20 characters.

It’s fine.

But if you want to use this query in other places, you’re going to have duplicated code.

Duplicated code makes your project harder to maintain.

Let’s move this query into a scope.

Like this:

class Book
  scope :with_long_title, -> { where("LENGTH(title) > 20") }
end

Now our controller action looks like this:

def index
  @books = Book.with_long_title
end

Summary
Good job! As a result of reading this article, you’ve learned how to use Rails scopes in the most effective way.

Don’t forget to put this new knowledge into practice so you can remember how it works.

Thanks for reading. 🙂

I’d love to hear thoughts or comments around this. Feel free to email me at ronakabhattrz@gmail.com or hit me up on twitter, @ronakabhattrz.

Rails 6, Stimulus and Select2

Ronak Bhatt — Wed, 02 Sep 2020 09:01:24 +0000

This is just a quicky, to help out anyone using Rails 6, or any Stimulus-enabled Rails project and Select2, the amazing jQuery plugin for better select boxes.

add select2 & select2-bootstrap-theme package in web-pack

yarn add select2
yarn add select2-bootstrap-theme

Simple Select2 + Stimulus Controller

select2_controller.js

import { Controller } from "stimulus"
import $ from 'jquery';

require("select2/dist/css/select2")
require("select2-bootstrap-theme/dist/select2-bootstrap")

import Select2 from "select2"

export default class extends Controller {
  connect() {
    $('.content-search').select2();
  }
}

Replace f.select dropdown according to select2 specifications

<div class="form-group" data-controller='select2'>
  <%= f.select :user_id, User.all.map { |user| user.name }, {include_blank: false, required: true, include_hidden: false}, class: 'form-control content-search' %>
</div>

I hope that helps someone. Thanks :).

I’d love to hear thoughts or comments around this. Feel free to email me at ronakabhattrz@gmail.com or hit me up on Twitter, @ronakabhattrz.