DEV Community: Ajithkumar P S

Do you know how the delivery of assets works in your Rails 7 app?

Ajithkumar P S — Mon, 24 Jun 2024 04:48:48 +0000

Have you ever struggled to understand how your Rails application delivers assets? If yes then this blog post is for you. come let's get into it.

So what are assets in the context of a web app?

Assets in your application are supplementary files that the browser requests after the initial chunk of HTML is loaded. These assets include CSS stylesheets, JavaScript files, images, videos, and more.

What is the Asset Pipeline?

The asset pipeline provides a framework to handle the delivery of JavaScript and CSS assets.

When you create a new rails app using below command:

rails new my-demo-app

By default, you will get sprockets-rails for CSS and importmap-rails for JavaScript processing. You can find these gems in your Gemfile.

Features of Asset Pipeline

Adding fingerprints to the assets, so that the file is cached by the web browser and CDN.

For example, If your app has a stylesheet named navbar.css. It will insert a SHA256 fingerprint to that file like below.

navbar-908e25f4bf641868d8683022a5b62f54.css

You can invalidate the cache by altering this fingerprint, which happens automatically whenever you change the file contents.

JavaScript processing using import maps.
Concatenate all CSS files into one main .css file, which is then minified or compressed.
It allows coding assets via a higher-level language for CSS.

Import maps:

Import maps let you import JavaScript modules using logical names that map to versioned/digested files – directly from the browser.

Enough of theory, let's dive into a simple example to see how it works all together

Create one new rails app using the below commands, If not created already.

rails new my-demo-app
cd my-demo-app
rails s

Now in our new application, we are going to add bootstrap library.

Importmaps provide a way to pin JavaScript modules and load them in your application directly from a CDN or locally.

Adding bootstrap and popperjs using jspm cdn link.

config/importmap.rb:

# Pin npm packages by running ./bin/importmap

pin "application"
pin "@hotwired/turbo-rails", to: "turbo.min.js"
pin "@hotwired/stimulus", to: "stimulus.min.js"
pin "@hotwired/stimulus-loading", to: "stimulus-loading.js"
pin_all_from "app/javascript/controllers", under: "controllers"
pin "bootstrap", to: "https://ga.jspm.io/npm:bootstrap@5.3.3/dist/js/bootstrap.esm.js"
pin "@popperjs/core", to: "https://ga.jspm.io/npm:@popperjs/core@2.11.8/lib/index.js"

We can add any npm packages using the below command as well, for eg.

bin/importmap pin react react-dom

vendor/javascript folder is the place where downloaded JS packages would be stored.

Then, import the package into your application.js as usual

app/javascript/application.js:

// Configure your import map in config/importmap.rb. Read more: https://github.com/rails/importmap-rails
import "@hotwired/turbo-rails"
import "controllers"
import "bootstrap"
import "@popperjs/core"

To add bootstrap css into our app, copy all the code from bootstrap cdn then create one new file bootstrap.css under vendor/css folder and paste in it. Now we need to add this to our asset load path.

config/initializers/assets.rb:

# Be sure to restart your server when you modify this file.

# Version of your assets, change this if you want to expire all your assets.
Rails.application.config.assets.version = "1.0"

# Add additional assets to the asset load path.
Rails.application.config.assets.paths << Rails.root.join("vendor", "css")

# Precompile additional assets.
# application.js, application.css, and all non-JS/CSS in the app/assets
# folder are already added.
# Rails.application.config.assets.precompile += %w( admin.js admin.css )

Then rename application.css to application.scss and import bootstrap there like below.

app/assets/stylesheets/application.scss:

/*
 * This is a manifest file that'll be compiled into application.css, which will include all the files
 * listed below.
 *
 * Any CSS (and SCSS, if configured) file within this directory, lib/assets/stylesheets, or any plugin's
 * vendor/assets/stylesheets directory can be referenced here using a relative path.
 *
 * You're free to add application-wide styles to this file and they'll appear at the bottom of the
 * compiled file so the styles you add here take precedence over styles defined in any other CSS
 * files in this directory. Styles in this file should be added after the last require_* statement.
 * It is generally better to create a new file per style scope.
 *
 *= require_tree .
 *= require_self
 */
@import "bootstrap";

application.scss serves as the starting point where you import all the other stylesheets that make up our application's styles.

Sprockets on its own is not able to transpile the Sass into CSS. So we need a sass engine to transpile our sass to regular css. Add this gem in your Gemfile.

gem 'dartsass-sprockets'

then run bundle install command.

Now uncomment root path line your routes.

config/routes.rb:

Rails.application.routes.draw do
  # Define your application routes per the DSL in https://guides.rubyonrails.org/routing.html

  # Reveal health status on /up that returns 200 if the app boots with no exceptions, otherwise 500.
  # Can be used by load balancers and uptime monitors to verify that the app is live.
  get "up" => "rails/health#show", as: :rails_health_check

  # Defines the root path route ("/")
  root "posts#index"
end

Under app/controllers folder, create one new file and paste the below code.

posts_controller.rb:

class PostsController < ApplicationController
    def index
    end
end

Create one new view file at app/views/posts and paste the following html code in it:

index.html.erb:

    <nav class="navbar navbar-expand-lg navbar-light bg-light">
        <div class="container-fluid">
            <a class="navbar-brand" href="#">My Blog</a>
            <button class="navbar-toggler" type="button" data-bs-toggle="collapse" data-bs-target="#navbarNav" aria-controls="navbarNav" aria-expanded="false" aria-label="Toggle navigation">
                <span class="navbar-toggler-icon"></span>
            </button>
            <div class="collapse navbar-collapse" id="navbarNav">
                <ul class="navbar-nav ms-auto">
                    <li class="nav-item">
                        <a class="nav-link active" aria-current="page" href="#">Home</a>
                    </li>
                    <li class="nav-item">
                        <a class="nav-link" href="#">About</a>
                    </li>
                    <li class="nav-item">
                        <a class="nav-link" href="#">Contact</a>
                    </li>
                </ul>
            </div>
        </div>
    </nav>

    <div class="container mt-5">
        <div class="row">
            <div class="col-md-8">
                <div class="blog-post mb-4">
                    <h2 class="blog-post-title">Blog Post Title 1</h2>
                    <p class="blog-post-meta">June 23, 2024 by <a href="#">Author</a></p>
                    <p>This is a paragraph from the first blog post. It contains some interesting content that readers might enjoy.</p>
                    <hr>
                </div>
            </div>
            <div class="col-md-4">
                <div class="p-4 mb-3 bg-light rounded">
                    <h4 class="fst-italic">About</h4>
                    <p class="mb-0">This is a simple blog page example using Bootstrap 5.3. Customize it as you like!</p>
                </div>
            </div>
        </div>
    </div>

    <footer class="blog-footer text-center py-3 bg-light">
        <p>Blog template built with <a href="https://getbootstrap.com/">Bootstrap</a>.</p>
    </footer>

Create one new css file under app/assets/stylesheets. This is our custom stylesheet and paste the following css code.

posts.css:

body {
    font-family: Arial, sans-serif;
}

.navbar-brand {
    font-weight: bold;
}

.blog-post-title {
    color: #007bff;
    margin-bottom: 0.5rem;
}

.blog-post-meta {
    color: #6c757d;
    margin-bottom: 1rem;
}

.blog-footer {
    margin-top: 2rem;
    border-top: 1px solid #e5e5e5;
}

.container {
    max-width: 960px;
}

h4.fst-italic {
    font-style: italic;
}

.p-4 {
    padding: 1.5rem !important;
}

.p-4 .list-unstyled {
    padding-left: 0;
    list-style: none;
}

Finally, start our rails server using rails s to see things in action.

Now view your page source using Ctrl+U, all your application stylesheets concatenated into one big css file application.css and fingerprint is added as well.

Also our npm packages added successfully, see in the <script type="importmap" data-turbo-track="reload"></script> tags. The big advantage of this approach is it will eliminate the need for Webpack, yarn, node or any other part of the JavaScript toolchain.

To learn more in detail about asset pipeline

Thanks for reading this post, will come back with another way of handling javascript in the rails app.

How to estimate a task?

Ajithkumar P S — Sun, 25 Feb 2024 15:18:12 +0000

Currently, I'm working as a web developer. I'm not good at estimating a task (or) project's sprint tasks. Each sprint may have a list of tasks. How to properly estimate these tasks. Looking for help. Thanks in advance!

Active job in Rails: Things You Need to Know 💎

Ajithkumar P S — Sat, 06 Jan 2024 08:23:45 +0000

What is Active Job?

Active Job was first made available in Rails from 4.2. When you create a new rails app Active Job will be the default framework for creating, enqueuing and executing background jobs. These jobs can be everything from sending emails, putting images into S3 bucket like so on.

The Goal of Active Job:

By default all rails apps will have a job setup in place. We can then have other background job frameworks and other gems build on top of that, without having to worry about their API differences between them such as Sidekiq and Resque.

Note 📗
An in-process thread pool is a way of running jobs concurrently within a single process, using multiple threads. Rails by default comes with an asynchronous queuing implementation that runs jobs with an in-process thread pool. This is well-suited for dev/test environments, since it doesn’t need an external infrastructure, but it’s not recommended for production, since it drops pending jobs on restart.

Creating a Job 🚀:

Enough talking, Let’s start doing. An example of an active job. In this example, I'm assuming you have a User model and UserMailer with a send_welcome_email method that sends the email. Let's say you want to create a background job that sends an ✉️ email after new user creation. First, you need to generate a new job:

rails generate job send_welcome_email

In app/jobs/send_email_job.rb file, define your job.

class SendWelcomeEmailJob < ApplicationJob
  queue_as :default

  def perform(user)
    UserMailer.welcome_email(user).deliver_later
  end
end

When you use deliver_later, the email is not send at the moment, but rather is pushed in a job's queue.

Enqueuing a Job ➡️:

class User < ApplicationRecord
    after_create :send_welcome_email

    def send_welcome_email
        SendWelcomeEmailJob.perform_later(self)
    end
end

If you use perform_later method, It will enqueue a job to be performed as soon as the queuing system is free.

Queuing Backends 🔙:

For enqueuing and executing jobs in production you need to set up a queuing backend, that is to say, you need to decide on a 3rd-party queuing library that Rails should use. Rails itself only provides an in-process queuing system, which only keeps the jobs in RAM. If the process crashes or the machine is reset, then all outstanding jobs are lost with the default async backend. This may be fine for smaller apps or non-critical jobs, but most production apps will need to pick a persistent backend(Sidekiq, Resque, Delayed Job, and others). For more info visit official guide: https://guides.rubyonrails.org/active_job_basics.html

Thanks for reading, Happy coding!!!

Toolbox for Ruby

Ajithkumar P S — Sun, 31 Dec 2023 05:30:26 +0000

If you don't know which library to use in your ruby projects. It is a useful site to look for 🧐 https://www.ruby-toolbox.com/.

Exploring Enumerable Module in Ruby 💎

Ajithkumar P S — Tue, 26 Dec 2023 15:25:52 +0000

Hi everyone, I’m excited to share my blog post with you all today! In this post, we’ll be exploring the Enumerable module in Ruby and its various methods.

The Enumerable module is a powerful tool that can be used to iterate over collections, filter elements, and perform other operations. We’ll be focusing on the (EEE), which is a bit confusing at first, but it’s actually quite easy and powerful.

1. Enumeration:

It is a process of looping through the list of items one by one technically speaking it is termed as traversing or iterating. We will probably use a for loop to achieve the result, Wait there is a magic method already available that is #each. Where it came from, you guessed it right, Yeah that it belongs to the Enumerable module.

2. Enumerable:

In Ruby, we will name an object as enumerable when it represents a set of items and a method to iterate through each of its elements. It includes various methods such as #map , #select and #uniq. Let’s get your hands a little bit dirty, Open your IRB or rails console try this out, and check how it works. Ex: [1,2,3].map { |n| n * 2 }

Note: Some methods, like #count and #take, are designed to work specifically with arrays, rather than using those provided by the Enumerable module.

3. Enumerator:

As a concept of simply instantiating by either creating an Enumerator. new or by invoking an instance method of an Enumerable object.

The Enumerable module works by using a method called #each, which should be available in any class that wants to use it. When you use #each with a block on an array, it performs the actions specified in the block for each item in the array. If you believe things are getting harder don’t worry you will understand better by running the below code on your machine.

If you call the #each method on an array without giving a block of code to execute for each of its elements, you will get an Enumerator object. In simple words, calling #each method without a block returns an Enumerator instance that lets you work with the array’s items in a versatile way, like iterating through them or applying other operations.

Enumerators allow you to loop through objects manually and chain multiple enumeration methods together. Simply, they give you control over how you traverse a collection of items, and you can perform various actions on those items in a sequence.

The #with_index method is a great example of how you can improve an enumerator’s functionality. In this case, you start by calling #each method on an array to get an enumerator. Then, by using #with_index, you can attach indices to the elements in the array, making it possible to print both the index and the element for each item in the collection.

Here are those common Enumerable methods explained in a simpler terms:

#each: To iterate each item in a collection one by one.
#map: Modify each element in the collection using a block of code and it returns the new updated collection.
#select: If you want to fetch items from the collection based on a condition.
#reduce: It’s useful when you want to combine all the elements in the collection into a single value by repeatedly applying an operation from the block.
#any?: It is used to check at least one element in the collection that matches the given condition.

Conclusion:

That’s a wrap. Thanks for reading! Hope I’ve encouraged you to understand and play around with one of the key concepts of the Enumerable module and its usage. As I said earlier, now you’re able to connect the (EEE), then you and I are just AWESOME.

These methods provide powerful ways to work with collections of data in Ruby.

To learn more about Enumerable here is the official doc: https://ruby-doc.org/3.2.2/Enumerable.html

Need rubyists help in RSpec Framework

Ajithkumar P S — Tue, 19 Dec 2023 15:22:42 +0000

Recently I made a TDD for my project rails_todo_api it is a API only application with devise for user authentication and RSpec framework for testing. I'm new to testing and rspec. Here is my github repo: https://github.com/iak97/rails_todo_api.

I need a code review and feedback about it. What improvements and fixes I need to make to better the code. Thanks in advance!

Fallen in love with Ruby 💖

Ajithkumar P S — Sun, 17 Dec 2023 17:55:34 +0000

Hello all rubyists 👋, In this blog post I will share what made me to fall in love with Ruby programming language. I'm not the expert still just sharing my views here.

Initially I have started my career in web development as a PHP Developer. 🐘 -> 💎

As the docs says Ruby A Programmer's Best Friend. It offers more readability and elegant syntax that is easy to read and write not very cryptic see in action.

PHP Example code 🐘:

<?php
class Student {
    public $name;
    public $age;
    public $grade;

    function __construct($name, $age, $grade) {
        $this->name = $name;
        $this->age = $age;
        $this->grade = $grade;
    }

    function display() {
        echo "Name: " . $this->name . "\n";
        echo "Age: " . $this->age . "\n";
        echo "Grade: " . $this->grade . "\n";
    }
}

$student1 = new Student("John", 18, "A");
$student2 = new Student("Jane", 19, "B");

echo "Student 1:\n";
$student1->display();

echo "\nStudent 2:\n";
$student2->display();
?>

Ruby Example code 💎:

class Student
  attr_accessor :name, :age, :grade

  def initialize(name, age, grade)
    @name = name
    @age = age
    @grade = grade
  end

  def display
    puts "Name: #{@name}"
    puts "Age: #{@age}"
    puts "Grade: #{@grade}"
  end
end

student1 = Student.new("John", 18, "A")
student2 = Student.new("Jane", 19, "B")

puts "Student 1:"
student1.display

puts "\nStudent 2:"
student2.display

For me the ruby version looks cool and feels more readable than PHP and easy to understand with less lines of code as well. Not only readability there is often more than one way of doing things in Ruby. If you know some other interesting stuffs in Ruby let me know in comments section. Thanks for reading 🤝.

How to Setup RSpec on a Rails Project

Ajithkumar P S — Thu, 30 Nov 2023 06:28:11 +0000

At the time of writing this article using ruby 3.2.0 & Rails 7.1.2

Let's get started...

1. Create a new project

rails new rspec-test-app -d postgresql
cd rspec-test-app
rails db:create
rails s

2. Install gems

group :development, :test do
  gem 'rspec-rails', '~> 6.1.0'
  gem 'factory_bot_rails'
  gem 'faker'
end

3. Run below commands

bundle install
rails g rspec:install

4. Configure factory bot

Create spec/support/factory_bot.rb file then copy & paste below code

# spec/support/factory_bot.rb
require 'rails_helper'

RSpec.configure do |config|
    config.include FactoryBot::Syntax::Methods
end

Almost done. Now generate the user model

rails generate model User email:string password:string
rails db:migrate

It will generate following files for us:

invoke  active_record
create  db/migrate/20231130055533_create_users.rb
create  app/models/user.rb
invoke  rspec
create  spec/models/user_spec.rb
invoke  factory_bot
create  spec/factories/users.rb

Now run the below command and the watch the output
rspec

*

Pending: (Failures listed here are expected and do not affect your suite's status)

  1) User add some examples to (or delete) /home/spritle/p/rspec-test-app/spec/models/user_spec.rb
     # Not yet implemented
     # ./spec/models/user_spec.rb:4


Finished in 0.00287 seconds (files took 0.64832 seconds to load)
1 example, 0 failures, 1 pending

To know more:

rspec-rails
factory_bot_rails
faker

I hope this helps you to start your journey on rspec 🚀. Thanks for reading!

Active Support Rails

Ajithkumar P S — Sat, 25 Nov 2023 06:57:33 +0000

Hello all Rubyists, This is my first blog post on dev.to and I'm very excited to start off. Here we go, As per ruby on rails guide, Active Support is the Ruby on Rails component responsible for providing Ruby language extensions and utilities.

Active Support in Ruby on Rails enhances the capabilities of the Ruby language by adding more features and utilities, making it easier for developers to build web applications efficiently.

What does that really mean?

It means that you can do a lot of really cool stuffs with Active Support that you cannot do in regular Ruby code. For example, When I use 'person'.pluralize in an irb and see what happens below

We are getting NoMethodError in Ruby — that’s where ActiveSupport can come in. Active Support automatically provides methods, such as .pluralize, .singularize and many more methods to Rails applications. The same method in a rails console.

Now it works! It is just an intro to Active Support. There many more methods available. Please checkout the official docs to know more. active support guide Thanks for reading!