Table of Contents
What is Ruby on Rails?
Ruby on Rails (“RoR”) is an open-source web framework that is written in the Ruby programming language. It allows developers to quickly build powerful and robust web applications.
Rails is a web application development framework written in the Ruby programming language. It is designed to make programming web applications easier by making assumptions about what every developer needs to get started. It allows you to write less code while accomplishing more than many other languages and frameworks. Experienced Rails developers also report that it makes web application development more fun.
Rails is designed to take the weight of endless configurations off the developer’s shoulders by including everything you need to get started when creating a web application. It allows you to write less code while at the same time accomplish more.
Ruby vs Ruby on Rails
Ruby is an interpreted scripting language for quick and easy object-oriented programming.
Ruby on Rails is a Ruby framework for implementing web applications. RoR depends on Ruby.
MVC Architecture. The Model-View-Controller pattern is used to separate application’s concerns.
- Models — Ruby classes that handle the business logic by talking with the database to validate data
- Views — Templates (typically formed of a mix of HTML and Ruby code) that render the data from your models and handle logic for presentation that end users see and interact with
- Controller — The middleman between the model and the view controlling the flow of the application. They handle the requests, initiates changes to the model, redirects, etc.
Convention over Configuration. Rails has a set of assumptions or defaults used for best practice for building web applications. This decreases the number of decisions developers have to make and allows for the implicit behaviors to set up the configurations for them.
DRY (Don’t Repeat Yourself). This guides the framework to reduce the amount of code you have to write, especially redundant code. This helps make your application more maintainable, extendable, and less buggy.
Speed of Development. RoR minimizes the website development time by 25–50% as compared to other popular web frameworks.
Libraries. There’s a gem for just about anything you can think of. They are all publicly available at RubyGems.
Cost-effective. RoR is an open source solution, so unlike other commercial development frameworks there are no licensing costs involved.
Active RoR Community. RoR has an army of developers that are very open and friendly to beginners and offers useful plugins and libraries. The RoR community seems to truly care and want people to understand the benefits of Ruby on Rails.
In this tutorial we will create a Rails CRUD application and briefly demonstrate how Rails communicates with a SQLite database.
CRUD operations are commonly used in web development and it stands for:
- First, we’ll have to create a new Rails application (-T to create without the test framework):
rails new dog-app -T
2. Change your directory to access the application:
3. Generate the model for the application (model should be singular):
rails g model dog name motto
This creates 2 files:
The dog table in our database will have 2 fields: name and motto.
4. Generate the controller for the application (controller should be plural):
rails g controller dogs index show new edit
Other than the “dogs_controller.rb” that gets created, a “dogs” folder along with four files we requested gets added within the views folder:
5. The config/routes.rb file also gets automatically updated:
Since we are going to use all CRUD operations, let’s use the shortcut Rails has provided us. Update the config/routes.rb as such:
6. Now we’re ready to migrate our data. Double check our migration file to make sure it looks appropriate:
rake db:migrate . This will create the table in our SQLite database based on what is in our db/migrate/[date_time]_create_dogs.rb file.
7. Let’s add some dogs so we can run tests. Update the db/migrate/seeds.rb file with the following:
rake db:seed to add the dogs to the database.
8. In order to check if the dogs have been added to your database, run:
rails console or
Dog.all and you should see that the 4 dogs have been added.
rails routes or go to localhost:3000/rails/info/routes to see all routes your application is configured to:
Now we’re ready to start working on our CRUD functions. Let’s start with “Read”. We’re going to be working in multiple files so to avoid confusion, I’ll bold and italicize the file you should make updates in.
Goal: List all dogs
Controller — app/controllers/dogs_controller.rb, index method
Index — views/dogs/index.html.erb
Your page should look like this after running
rails s or
Goal: Show details of specific dog
Controller — app/controllers/dogs_controller.rb, show method
Show — views/dogs/show.html.erb
Goal: Create a new dog
Controller — app/controllers/dogs_controller.rb, new and create methods
New — views/dogs/new.html.erb
Goal: Update details for specific dog
Controller — app/controllers/dogs_controller.rb, edit and update methods
Edit — views/dogs/edit.html.erb
Goal: Remove a dog from the database
Controller — app/controllers/dogs_controller.rb, destroy method
Show — views/dogs/show.html.erb
Add to your current code:
Here is the current Controller code:
You’ll notice that this doesn’t completely follow DRY because we have the same line of code to find the dog written 4 times.
14. Let’s refactor the Controller file:
That looks better!
15. Let’s add some more links to our index.erb file to connect all the other pages in one area.
Understanding exactly what Rails is doing helps you know where to debug. Here is what happens when you click a button on your form:
- The browser sends a request to the server
- Rails gets the request and follows what method was listed (get, delete, post, etc.) and tries to match it with the appropriate route
- Once it finds the correct route, it maps to the appropriate method in your controller and calls on that.
- From there, it finds the associated view page (index, edit, show, and new) with that method to display the results to the user.
Don’t be afraid to use byebug!
Thanks for reading. Happy coding!