Abstraction is simple and beautiful while writing abstract code is an art.
While writing web apps apart from writing business logic most of the time we end up writing CRUD operations (Create, Read, Update Delete). There are a bunch of methods available to generate boilerplate code i.e. scaffolding, custom generators, etc. which have their own dos and don'ts.
I personally have been exploiting abstraction to write CRUD operations. Consider an example of developing a school management system where we have controllers like Student, Course, Section, Teacher, Exam, and many others. A typical student controller CRUD would be
class StudentsController < ApplicationController
before_action :set_student, only: %i[ show edit update destroy ]
def index
@students = Student.all
end
def show
end
def new
@student = Student.new
end
def edit
end
def create
@student = Student.new(student_params)
respond_to do |format|
if @student.save
format.html { redirect_to @student, notice: "Student was successfully created." }
format.json { render :show, status: :created, location: @student }
else
format.html { render :new, status: :unprocessable_entity }
format.json { render json: @student.errors, status: :unprocessable_entity }
end
end
end
def update
respond_to do |format|
if @student.update(student_params)
format.html { redirect_to @student, notice: "Student was successfully updated." }
format.json { render :show, status: :ok, location: @student }
else
format.html { render :edit, status: :unprocessable_entity }
format.json { render json: @student.errors, status: :unprocessable_entity }
end
end
end
def destroy
@student.destroy
respond_to do |format|
format.html { redirect_to students_url, notice: "Student was successfully destroyed." }
format.json { head :no_content }
end
end
private
def set_student
@student = Student.find(params[:id])
end
def student_params
params.require(:student).permit(:first_name, :last_name, :roll_no, :date_of_birth)
end
end
Sections controller CRUD would look like
class SectionsController < ApplicationController
before_action :set_section, only: %i[ show edit update destroy ]
def index
@sections = Section.all
end
def show
end
def new
@section = Section.new
end
def edit
end
def create
@section = Section.new(section_params)
respond_to do |format|
if @section.save
format.html { redirect_to @section, notice: "Section was successfully created." }
format.json { render :show, status: :created, location: @section }
else
format.html { render :new, status: :unprocessable_entity }
format.json { render json: @section.errors, status: :unprocessable_entity }
end
end
end
def update
respond_to do |format|
if @section.update(section_params)
format.html { redirect_to @section, notice: "Section was successfully updated." }
format.json { render :show, status: :ok, location: @section }
else
format.html { render :edit, status: :unprocessable_entity }
format.json { render json: @section.errors, status: :unprocessable_entity }
end
end
end
def destroy
@section.destroy
respond_to do |format|
format.html { redirect_to sections_url, notice: "Section was successfully destroyed." }
format.json { head :no_content }
end
end
private
def set_section
@section = Section.find(params[:id])
end
def section_params
params.require(:section).permit(:name)
end
end
And Course CRUD would be
class CoursesController < ApplicationController
before_action :set_course, only: %i[ show edit update destroy ]
def index
@courses = Course.all
end
def show
end
def new
@course = Course.new
end
def edit
end
def create
@course = Course.new(course_params)
respond_to do |format|
if @course.save
format.html { redirect_to @course, notice: "Course was successfully created." }
format.json { render :show, status: :created, location: @course }
else
format.html { render :new, status: :unprocessable_entity }
format.json { render json: @course.errors, status: :unprocessable_entity }
end
end
end
def update
respond_to do |format|
if @course.update(course_params)
format.html { redirect_to @course, notice: "Course was successfully updated." }
format.json { render :show, status: :ok, location: @course }
else
format.html { render :edit, status: :unprocessable_entity }
format.json { render json: @course.errors, status: :unprocessable_entity }
end
end
end
def destroy
@course.destroy
respond_to do |format|
format.html { redirect_to courses_url, notice: "Course was successfully destroyed." }
format.json { head :no_content }
end
end
private
def set_course
@course = Course.find(params[:id])
end
def course_params
params.require(:course).permit(:title, :credit_hours, :code, :year)
end
end
If you notice most of the time we are doing same kind of operation i.e. in the case of the show we first set the resource which could be Student, Course, Section, etc. In general, we are dealing with a resource or resources everywhere in the controllers.
In the Ruby on Rails world, we often talk about resources, we model every real-world object into Rails model as we did with the school management system Student, Course, Teacher, Exam. If we look at our above code we just specified resource name in reach controller for example in StudentsController we used Student, @student, @students, set_student, or student_params and the same is the case with CoursesController we have used Course, @course, @courses, set_course, or course_params, etc. In short, we are repeating the resource name in each file. We can come up with a generic controller let say BaseController where we perform all operations on a resource rather than student, course, section, etc. Then, we just inherit StudentsController, CoursesController, TeachersController, ExamsController from a single source of truth BaseController.
Let's start with the show function and try to write BaseController.
class BaseController < ApplicationController
before_action :set_resource, only: %i[ show ]
def show
end
def set_resource
resource ||= resource_class.find(params[:id])
instance_variable_set("@#{resource_name}", resource)
end
def resource_class
@resource_class ||= resource_name.classify.constantize
end
def resource_name
@resource_name ||= controller_name.singularize
end
end
Writing create function is a bit more interesting
def create
@resource = resource_class.new(resource_params)
respond_to do |format|
if @resource.save
format.html { redirect_to @resource, notice: "#{resource_name} was successfully created." }
format.json { render :show, status: :created, location: @resource }
else
format.html { render :new, status: :unprocessable_entity }
format.json { render json: @resource.errors, status: :unprocessable_entity }
end
end
end
update and destroy functions are somewhat similar
def update
@resource = resource_class.find(params[:id])
respond_to do |format|
if @resource.update(resource_params)
format.html { redirect_to @resource, notice: "#{resource_name} was successfully updated." }
format.json { render :show, status: :ok, location: @resource }
else
format.html { render :edit, status: :unprocessable_entity }
format.json { render json: @resource.errors, status: :unprocessable_entity }
end
end
end
def destroy
@resource = resource_class.find(params[:id])
@resource.destroy
respond_to do |format|
format.html { redirect_to "#{controller_name}_url", notice: "#{resource_name} was successfully destroyed." }
format.json { head :no_content }
end
end
In all of the above rewrites, we just simply used resources as a generic variable attribute. destroying an object is the same no matter its Student, Course, Section, or Exam so resource.destroy works the same for each resource.
Our final refactoring will look like this
Since controllers are inherited from BaseController we can always override any method in the respective controller. For example, instead of directly creating a Student object we have a service written which takes student params and creates Student object after applying a bunch of business logic and pre-checks. For such scenarios, we can override create the function in StudentsController.
We can use the same pattern while writing our APIs and all other scenarios where we have a similar pattern repetition.
Thank You so much for the read.
Top comments (0)