DEV Community: Samala Sumanth

Grape GEM in Ruby on Rails: Handling User Model and API Endpoint

Samala Sumanth — Sun, 18 Jun 2023 20:34:48 +0000

Introduction:
In the world of Ruby on Rails, developers are often faced with the challenge of building robust and scalable APIs. One powerful tool that comes to the rescue is the Grape gem.
Grape provides a simple and efficient way to create APIs in Ruby, and in this blog, we will explore how to leverage Grape for handling the User Model in a Ruby on Rails application. Specifically, we will focus on creating an API endpoint for managing users at api/v1/users.

What is Grape?
Grape is a micro-framework for creating APIs in Ruby. It is designed to be lightweight, modular, and highly customisable. Grape integrates seamlessly with Ruby on Rails applications, making it an excellent choice for building APIs. With Grape, you can define endpoints, handle requests and responses, and even generate documentation effortlessly.

Setting up Grape in Ruby on Rails:
To begin, make sure you have a Ruby on Rails application set up. You can create a new Rails application by running the following command:

rails new my_app

Next, add the Grape gem to your application's Gemfile:

gem 'grape'

After adding the Grape gem, run bundle install to install the gem and its dependencies.

Creating the User Model:
In this example, we will assume that you already have a User model in your Rails application. If you don't, you can generate one using the following command:

rails generate model User name:string email:string

After generating the User model, run the migration using rails db:migrate to create the corresponding table in the database.

Implementing the User API Endpoint:
Now it's time to create the API endpoint for managing users. In your Rails application's app/api directory, create a new file named v1/users.rb. This file will contain the Grape endpoint definition for the users API.

module V1
  class Users < Grape::API
    version 'v1', using: :path
    format :json

    resource :users do
      desc 'Return a list of users'
      get do
        User.all
      end

      desc 'Return a specific user'
      params do
        requires :id, type: Integer, desc: 'User ID'
      end
      route_param :id do
        get do
          User.find(params[:id])
        end
      end

      desc 'Create a new user'
      params do
        requires :name, type: String, desc: 'User name'
        requires :email, type: String, desc: 'User email'
      end
      post do
        User.create(name: params[:name], email: params[:email])
      end

      desc 'Update an existing user'
      params do
        requires :id, type: Integer, desc: 'User ID'
        optional :name, type: String, desc: 'User name'
        optional :email, type: String, desc: 'User email'
      end
      put ':id' do
        user = User.find(params[:id])
        user.update(name: params[:name], email: params[:email])
        user
      end

      desc 'Delete a user'
      params do
        requires :id, type: Integer, desc: 'User ID'
      end
      delete ':id' do
        user = User.find(params[:id])
        user.destroy
      end
    end
  end
end

This code defines the /api/v1/users endpoint with various HTTP methods:

GET /api/v1/users - Returns a list of all users.
GET /api/v1/users/:id - Returns a specific user based on the provided :id.
POST /api/v1/users - Creates a new user with the given parameters.
PUT /api/v1/users/:id - Updates an existing user with the provided :id.
DELETE /api/v1/users/:id - Deletes a user with the given :id.

Mounting the User API Endpoint:
To make the User API endpoint accessible, you need to mount it in your Rails application. Open the config/routes.rb file and add the following line:

mount V1::Users => '/api/v1/users'

This line instructs the Rails application to map the /api/v1/users URL path to the V1::Users Grape API endpoint.

Conclusion:
With the Grape gem, building powerful API endpoints in Ruby on Rails becomes a breeze. In this blog post, we explored how to handle the User model and create an API endpoint at api/v1/users. By following the steps outlined above, you can easily implement CRUD operations for managing users via the API. Grape's simplicity and flexibility make it an excellent choice for building robust APIs in Ruby on Rails.

ChatGPT Alternative Built With Superpowers - ChatSonic ROR Gem

Samala Sumanth — Sat, 15 Apr 2023 18:14:26 +0000

In today's fast-paced digital world, language generation has become a powerful tool for automating tasks, enhancing user experiences, and driving innovation in various industries.

In this blog, we will dive into the world of "chatsonic" and explore how this https://rubygems.org/gems/chatsonic Rails Gem can enable you to leverage the power of LLM ChatGPT in your Ruby on Rails applications. We will discuss the features, functionalities as well as provide examples and code snippets to demonstrate how it can be integrated into your Ruby on rails applications.

On a high level ChatSonic Gem is a wrapper around the writesonic OpenAPI that can be easily integrated into your rails application by installing this Gem.

Main Repository: https://github.com/SamalaSumanth0262/chatsonic

STEP 1: Installing Gem

In your rails root directory, run this command gem install chatsonic

STEP 2: Get the API Key

Now head to https://docs.writesonic.com/reference/finding-your-api-key, Create an account for first time users. please find the image below for reference

STEP 3: Initialising and Configuring the Gem

Add gem 'chatsonic', '~> 1.0', '>= 1.0.2' to GemFile or Simply run gem install chatsonic

Now It's time to configure the gem with the help of API-KEY obtained from Step 1.

Create a file chatsonic.rb in initialisers folder which is right place to configure gem. Insert the below small chunk of code.

ChatSonic.configure do |config|
  config.access_token = "****" #required, Always fetch from ENV file, ENV["API-KEY"]
  config.uri_base: "https://api.writesonic.com/", # Optional, Used to override the default
  config.request_timeout: 240 # Optional, Used to override the default ( Just in case if the prompt take more 120 seconds)
end

Or You can directly initialise by creating a instance of the gem like below

client = ChatSonic::Client.new # if you have already initialised
# OR
client = ChatSonic::Client.new(access_token: "Your API Key")

STEP 4: Getting the Prompt

Now from anywhere in your rails application by using below chunk of the code you can get the PROMPT

response = client.prompt(parameters: {
    enable_google_results: true,
    enable_memory: true,
    input_text: 'Hi'
  })

enable_google_results: Gives your responses based on the data backed by google.

enable_memory: Stores all the previous conversations

input_text: Your prompt.

This will give prompt response "Hello! How may i assist you today ?"

Hurray !!! Thats it. Now you have integrated this Gem into your Rails Application.

Main Use Cases of this:

Act like ChatGPT with steroids
Conversational AI
Translational
Content Writer
More use cases can be found here

Proposed Future Developments:

Make this gem powerful and be compatible with all the features listed in this page: https://docs.writesonic.com/reference/introduction

Thanks for reading !!! Feel free to comment any kind of suggestions for this blog. I am all ears. Cheers !!!!

Thank you for inspiring !! Cheers. CEO Of writesonic @samanyougarg

Command Driven Design Pattern - ROR

Samala Sumanth — Thu, 30 Mar 2023 22:14:57 +0000

In this blog we'll dive into one lesser-known design pattern but highly efficient for large scaled applications which helps the code repository to keep organised and can be easily scaled up.

Design Pattern Name: Command Driven Pattern

Usually the request from client goes to the controller which speaks to the model ( database ) and send back the view or JSON.

But in this design pattern request from controller goes to a command, and a command can be having number of actions items to perform and send the response back.

In layman terms take an example of constructing a shopping mall. the action items are:

Buy the plot.
Setting up the base.
Raising the walls.
Elevators
Painting

so all these five steps can we performed a separate file called as COMMAND.

Lets consider this scenario:

Example: On User Sign up, consider these following actions are to be performed.

User must be authenticated.
User must be sent a logged-in alert email.
User should be awarded some points.
User should receive push notification.
Audit for all the above actions.

Let's create a folder in app/ called core and file called Command.rb

class Core::Command
  include ActiveModel::Validations

  attr_accessor :token

  def initialize(attributes = {})
    attributes.each do |name, value|
      if methods.include? "#{name}=".to_sym
        method("#{name}=".to_sym).call(value)
      end
    end
  end

  # this method can be ovveridden in other classes
  def run
  end
end

Now in Lets create CreateUserCommand.rb in core folder

class Core::CreateUserCommand < Core::Command
  attr_reader :user_params

  def initialize(params)
    super(params)
    @user_params = params
  end

  def run
    ActiveRecord::Base.transaction do
      authenticate_user
      mailer("Account Created")
      award_points
      send_push_notification
      mailer("User Logged In")
    end
    # can be written in JSON builder a seprate file
    return { name: "Samala Sumanth", git: "https://github.com/SamalaSumanth0262"}
  end

  def authenticate_user
    # can be separate command for user authentication
    puts "User Authenticated"
  end

  def mailer(message)
    # can be separate command for mailer
    puts message
  end

  def award_points
    # can be written in separate command for awarding points
    puts "User has been awarded 10 points"
  end

  def send_push_notification
    # User Notification Command
    puts "User has been sent push notification"
  end
end

And Finally your controller should look like this

class UsersController < ApplicationController
  # bypass csrf protection for all the requests made
  protect_from_forgery with: :null_session
  before_action :set_user, only: %i[ show edit update destroy ]
  # /users/
  def create
   render json: ::Core::CreateUserCommand.new(user_params).run
  end

  private
    # Only allow a list of trusted parameters through.
    def user_params
      params.fetch(:user, {})
    end
end

Thats It. with this approach we have moved most of the logic into command instead of having them in fatty models.

Please feel free to comment and suggest any kind of improvement.

This blog is also inspired by: https://blog.slava.dev/command-driven-architecture-for-ruby-on-rails-35949a0b0558

You can contact me from my portfolio: https://sumanthsamala.netlify.app

Database Seeding and Relationships using LARAVEL

Samala Sumanth — Wed, 26 Oct 2022 14:18:36 +0000

Hi Fellas, In this blog, we'll walk through

How to create a table ( Migration ) and Model
Creating relationships between models ( Ex Library has_many Books ).
Seeding the database using the faker() library.

Pre-requisite:

PHP any version ( LTS is recommended )
Mysql ( for Database )
laravel

Let's get started !!!! whoooooeeeeeeee!!!! 🚀🚀

STEP 1️⃣:

Let's create a new laravel project using the laravel new demo here demo is my project name

STEP 2️⃣:

Change your current directory to the project created using the above command, in my case, it is cd demo. Ignore this line for professionals 😜
Make sure you fill in the details in the .env file
Create a database called demo by create database demo;

DB_HOST=127.0.0.1
DB_PORT=3306
DB_DATABASE=demo ( create a database in MySQL called demo )
DB_USERNAME=your_mysql_usernamae
DB_PASSWORD=your_mysql_password

let's create two models 1. Ĺibrary 2. Books by php artisan make:model Library -m, php artisan make:model Book -m
-m creates the migration file where we can include the details about columns of the tables library and books
By executing the above commands laravel will create two files in the model and database directory.

database/migrations/2022_10_25_185618_create_books_table.php
database/migrations/2022_10_25_185530_create_libraries_table.php
app/Models/Book.php
app/Models/Library.php

STEP 3️⃣:

Before running the migration command let's tell the laravel what are the columns that will be present in the model's created above
Let's get our hands dirty by writing some code now. Add the below code in the public function up() method in the library and book the migration file

// code to be added to the library migration file 
 Schema::create('libraries', function (Blueprint $table) {
            $table->id();
            $table->timestamps();
            $table->string('name');
            $table->string('librarian_name');
            $table->datetime('opening_time');
            $table->datetime('closing_time');
        });
// code to be added to the book migration file

 Schema::create('books', function (Blueprint $table) {
            $table->id();
            $table->integer('library_id');
            $table->timestamps();
            $table->string('name');
            $table->string('author_name');
        });

STEP 4️⃣:

let's create or migrate the columns into the database by running php artisan migrate. You should see a log like this

STEP 5️⃣:

Let us define the has_many relationship in the models ( Ex: Library has many books )

class Library extends Model
{
    use HasFactory;

    public function books()
    {
        return $this->hasMany(Book::class);
    }
}

STEP 6️⃣:

Let's create and load the database with some dummy data by using seeder files.
Create a factory file using php artisan make:factory BookFactory --model=Book
Create a seeder file by php artisan make:seeder BookSeeder
Add the following code to BookFactory.php file

<?php

namespace Database\Factories;

use Illuminate\Database\Eloquent\Factories\Factory;

/**
 * @extends \Illuminate\Database\Eloquent\Factories\Factory<\App\Models\Book>
 */
class BookFactory extends Factory
{
    /**
     * Define the model's default state.
     *
     * @return array<string, mixed>
     */
    public function definition()
    {
        return [
            'library_id' => $this->faker->randomDigit(),
            'name' => $this->faker->text(),
            'author_name' => $this->faker->text(),
        ];
    }
}

Add the following code to BookSeeder.php to create 10 records in the Books table


namespace Database\Seeders;

use Illuminate\Database\Seeder;
use \App\Models\Book;

class BookSeeder extends Seeder
{
    /**
     * Run the database seeds.
     *
     * @return void
     */
    public function run()
    {
        Book::factory(10)->create();
    }
}

Finally Run the seeding command php artisan db:seed --class=BookSeeder

Similarly, we can write both Seeder and Factory files for the library model too.

We can verify the data by running the select query from our database select * from books

Entire code is present in GitHub repo: https://github.com/SamalaSumanth0262/LARAVEL-Relationships-Seeding, Feel free to raise PR or contribute. we can add a hacktober-fest label too if required so that it counts towards the contribution

For those who don't know hacktober fest, No worries I was one of them 😜 https://hacktoberfest.com/

Please feel free to comment or any suggestions are welcome. Cheers !!!!!!!

You can get in touch with me on
Website🧑🏻‍💻: https://sumanthsamala.netlify.app/
Linkedin🗒: https://www.linkedin.com/in/samala-sumanth-82431161/
GitHub: https://github.com/SamalaSumanth0262
twitter: https://twitter.com/sumanth0262

REST API's for CRUD Operation Using Spring Boot

Samala Sumanth — Wed, 03 Aug 2022 23:06:00 +0000

In this article, Under 10 Steps we shall look at how to create a simple RESTful api with spring boot by taking an example of USER.

Required Pre-requisites 🗣:

Java installed on the machine 👨‍💻.
Postman to test the API's.
Willing to learn 😉

Its time to jump into the code 🚀

STEP 1: Create a base project from https://start.spring.io/. Give a project name and description. Add the 3 required dependencies: Spring Web, Spring Data JPA and MySQL driver.! Finally click on generate which will download a zip file. Extract and open in your preferred IDE like IntelliJ, eclipse or NetBeans.

In my case the application name is crud

STEP 2: Lets create some boilerplate by creating three folders in crud/src/main/java/com/example/crud/CrudApplication.java which are 1. controller 2. model 3. repository 4. service. Typically your folder structure should look like below.

STEP 3: Create a Database and a users table with user_id ( primary Key ), first_name and email in your mysql
execut the following code which does the job for you in mysql terminal

CREATE TABLE `user_schema`.`users` (
  `user_id` INT NOT NULL AUTO_INCREMENT,
  `first_name` VARCHAR(45) NULL,
  `email` VARCHAR(45) NULL,
  UNIQUE INDEX `user_id_UNIQUE` (`user_id` ASC),
  PRIMARY KEY (`user_id`));

and add the following code in crud/src/main/resources/application.properties

spring.datasource.url = jdbc:mysql://127.0.0.1:3306/user_schema
#username and password of mysql 
spring.datasource.username=root
spring.datasource.password=root
spring.jpa.properties.hibernate.dialect = org.hibernate.dialect.MySQL5InnoDBDialect

STEP 4: Let's do the magic by writing some code in these Folders. Create a file named User.java in model folder and add the following code.

package com.example.crud.model;

import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.Table;

@Entity
@Table(name = "users")
public class User {

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    @Column(name="user_id")
    private Long id;

    @Column(name="first_name")
    private String firstName;

    @Column(name="email")
    private String email;

    public Long getId() {
        return id;
    }

    public void setId(Long id) {
        this.id = id;
    }

    public String getFirstName() {
        return firstName;
    }

    public void setFirstName(String firstName) {
        this.firstName = firstName;
    }

    public String getEmail() {
        return email;
    }

    public void setEmail(String email) {
        this.email = email;
    }
}

STEP 5: Now create another file in repository package named UserRepository.java where it's class is extended from JPARepository to enable query execution abilities like create(), update(), get() and delete() methods. finally add the following code

package com.example.crud.repository;


import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.stereotype.Repository;

import com.example.crud.model.User;

// @Repository tells the spring boot that it wrapped with User Table with sql execution queries.
@Repository
public interface UserRepository extends JpaRepository<User, Long> {
}

STEP 6: Now Inside your service folder create a file named UserService.java. In this service layer we typically handle the business logic 🤖.

package com.example.crud.service;
import com.example.crud.model.User;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import com.example.crud.repository.UserRepository;
import java.util.List;

@Service
public class UserService {

    @Autowired
    UserRepository userRepository;

    public User createUser(User user){
        return userRepository.save(user);
    }

    public List<User> getUsers(){
        return userRepository.findAll();
    }

    public void deleteUser(Long userId){
        userRepository.deleteById(userId);
    }

    public User updateUser(Long userId, User userDetails){
        User user = userRepository.findById(userId).get();
        user.setFirstName(userDetails.getFirstName());
        user.setEmail(userDetails.getEmail());
        return userRepository.save(user);
    }
}

STEP 7: Now inside the controller folder, create a file named UserController.java. This is the first and foremost layer when a request hits the server. This is right place to do validate the params or authorising the API or adding some middleware validations. But right now we only focus on writing the basic structure of the controller.
Finally add the following code.

package com.example.crud.controller;

import java.util.List;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.RestController;

import com.example.crud.model.User;
import com.example.crud.service.UserService;

// spring will understand that the methods in this class will follow rest convention
@RestController
@RequestMapping("/api")
public class UserController {
    // spring will create a bean when we do a autowiring
    @Autowired
    UserService userService;

    // invoking the spring-boot that this is end point /users
    // to create USER
    @RequestMapping(value="/users", method=RequestMethod.POST)
    public User createUser(@RequestBody User usr) {
        return userService.createUser(usr);
    }

    // to get all the list of Users
    @RequestMapping(value="/users", method=RequestMethod.GET)
    public List<User> readUsers() {
        return userService.getUsers();
    }

    // to update the values of USER
    @RequestMapping(value="/users/{userId}", method=RequestMethod.PUT)
    public User readUsers(@PathVariable(value = "userId") Long id, @RequestBody User empDetails) {
        return userService.updateUser(id, empDetails);
    }

    // to delete the record from the DB
    @RequestMapping(value="/users/{userId}", method=RequestMethod.DELETE)
    public void deleteUsers(@PathVariable(value = "userId") Long id) {
        userService.deleteUser(id);
    }

}

Finally your repository directory should look like:

Hurray !!!!! Thats it !! 🤘🤘 Now you can start 🏎 the application on port number 8080 (of course the default port)

Step 8: Test 👻 your API using postman

Please find the postman collection link here: https://www.getpostman.com/collections/763c722809426a268aac

PS: You can find the github repository here https://github.com/SamalaSumanth0262/Spring-Boot-CRUD . Do follow me on https://github.com/SamalaSumanth0262 🙋‍♂️ or https://twitter.com/sumanth0262 🙋‍♂️

Hey Peeps, This is my first blog 🎯 on JAVA with spring boot. Please do leave any kind of improvements or suggestions. More than happy to hear🙇‍♂️.. Cheers !!! 🍻🍻

Raw SQL vs Rails Queries

Samala Sumanth — Mon, 07 Jun 2021 05:49:34 +0000

The key difference is that ActiveRecord lets you be more productive by using a higher-level abstraction which lets you write less code.

This abstraction comes at a cost and can lead to performance problems if you don't pay attention to the queries that ActiveRecord generates. N + 1 queries can be a major problem here.

My Observation is if you don't know how to perform an operation with ActiveRecord it is often better to write a bit of SQL with a test backing it and go back and refactor later.

Alright, Let's make our hands dirty.

Here is the schema of our DB which comes handy in wrinting SQL queries as well as rails queries.

Example 1: A simple inner join.

RAW SQL:

select * from customers inner join votes on votes.customer_id = customers.id where customers.active = 1

Active Record:

Customer.joins(:votes).where(active: true)

Example 2: Inner join with two tables
RAW SQL:

select * from customers inner join posts on posts.customer_id = customers.id inner join comments on comments.post_id = posts.id where customers.active = 1

Active Record:

Customer.joins(posts: :comments).where(customers: { active: true })

Explanation: The amount of code written has been drastically reduced in case of active record.

Example 3: Inner join with three tables.

RAW SQL:

select * from customers cst inner join posts pst on pst.customer_id = cst.id inner join comments cmt on cmt.post_id = pst.id inner join votes v on v.comment_id = cmt.id where cst.active = 1

Active Record:

Customer.joins(posts: [comments: :votes]).where(customers: {active: true})

PS: if you want to get the schema or the rails code you can find the repository here

Hope this read gives you little idea of where to use SQL and rails queries. Please feel free add your thoughts or suggestions :D

Docker Fundamentals

Samala Sumanth — Sun, 30 May 2021 12:48:58 +0000

since you landed here you definitely want to know what docker is?

We'll start off by telling the problem statement: let's say we want to use create-react-app where the OS is not compatible of node to install npm install -g create-react-app 😿 , you can achieve this by using Docker Image. Hurray!!!! Interesting. isn't it? 🤔

WHAT is docker? simply you can think off like a Sea Port harbour docker 🚢 where we have containers to be exported into other places across the world and container contains the goods and materials. Similarly, our docker also has containers but here we call those goods and materials as an Image, just a technical term. so all the images need a place to store we call it Docker Hub. just like a GitHub is the place to store code as simple as that.

Now, How does docker solve our problem, Though the OS doesn't support node what if the docker image provides you with all the dependencies to install create-react-app… WOW, that's a solid idea !!!!! 💡 so Image is independent of the OS. Moving forward I'll show how to create an image and push it to docker hub. Here is the architecture diagram of a docker

Without any delay, let's go ahead create our first image and store it in docker hub.
Install docker from here.

Create a folder called docker-sample. or fork the repo from here

mkdir docker-sample && cd docker-sample && mkdir public && cd public && vim index.html

and write some HTML code you can refer here

now vim Dockerfile .
let's start adding the code to the file. FROM node:alpine , this line will fork the base node repo where our application code gets run. By doing this step we've just got a copy of machine and does not contain any application code
Add COPY . /usr/src , we copy all the files from the current directory and paste in /usr/src where usr stands for a universal system resource.
Add WORKDIR /usr/src , we tell the container that usr/src in the source of my application code.
Add RUN npm install, this will install packages in package.json and also we have in-built npm installed in node:alpine.
Add CMD ['npm', 'run', 'start'] , RUN is a block command where the execution blocks but here we want to run a command asynchronously so we use CMD.
Add EXPOSE 80 , we are telling docker once the image runs in the container we expose port number 80. Finally, your Dockerfile should look like this.

Now then we have copied the code and we set the working directory and all set except we are left with building the image, we run this command now docker build . -t docker_id/name_of_the app in my case its docker build . -t 14bee0262/docker-sample where docker_id is the user_id of docker hub.
Before uploading to docker hub we need to really check in our local whether the container is running image or not? we can run the image by docker run --restart always -d -p 80:80 14bee0262/docker-sample you should see the below image in your localhost …taaadaaa!!!!
- restart => whenever there's is an exception docker restarts the image.

d is for telling the docker to restart the daemon.
p is the port number binded_container_port:exposed_port Now you can push this image by docker push user_id/name_of_image in my case its docker push 14bee0262/docker-sample and my image is here. you can check in your docker hub dashboard. Now where ever you are in the world whatever the OS configuration is you can just pull the image and run it and your server is UP Cheeeeerrrss!!!! 🍹 🍹 😄 😄. Anyways Documentation is available for much more information . PEACE !!!!!!!! PS: Any Suggestions, Any comments are heartfully welcome.

Make up for Rails console

Samala Sumanth — Sun, 09 Aug 2020 12:36:52 +0000

Peeps!!!! i felt that i should have done this earlier... Being a ROR dev i really feel uncomfortable to examine this default rails console. A linter or formatter for this problem might be a solution. Now comes the magic..scroll bottom !!!!

##### BOOOM #####

Just follow these 3 steps and make the magic happen!!!

Just add awesome_print gem in development group in Gemfile which is located in root path of your application.

group :development do
   gem 'awesome_print'
end

Add this code block in by doing vim ~/.pryrc

require "awesome_print"
AwesomePrint.pry!

and save it by :wq!

This file is called when our rails console starts. so no need of running source ~./pryrc

Here you go.. just play around rails console now . PEACE
For more details you can refer documentation https://github.com/awesome-print/awesome_print