Day 29 : #100DaysofCode - Very Simple Rails App CRUD Practice
Tags: 100daysofcode
Published: 2020-06-30 02:42:35

Today I focused on a rails simple CRUD code-along. I watched a youtube video and went step-by-step on how to create an application that can display an item name and item quantity and allow a user to conduct CRUD functionality on it. 

So what was the first step? The database of course! 

<h1> Database/Generators </h1>

Within the database, I wanted to create an Items table with a name column that should be a string and a quantity column that should be an integer. Something like this: 

<b>
Table name: Items
-- name : string
-- quantity : integer
</b>

Rails is amazing because I no longer have to manually set up a table, rails allows users to use generators to get things done. 

For example, if all I wanted to do was create the db table/ migration there is a migration generator. With the following: 

``rails g migration ``

However, no one wants JUST the migration because you will still need to make your models, controller, and views. 

So instead I decided to use the models generator. The models generator will create a migration and model for us. So, I ran the following: 

``rails g model item name:string quantity:integer``

The above will automatically generate an item model and migration.

When you go to ``app/models/item.rb`` you will see this:

```
class Item < ApplicationRecord
end
```

It also generated your migration within your database. You will see that a table was automatically generated within ``db/migrate/create_items.rb`` and will look similar to this: 

```
class CreateItems < ActiveRecord::Migration[6.0]
  def change
    create_table :items do |t|
      t.string :name
      t.integer :quantity
      t.timestamps
    end
  end
end
```

You will also see that it generated test_unit files that will come in handy in the future for creating test. 

After generating your model and migration, it is best to migrate your database and mess around with it to make sure it works. Go ahead and run the following, 

``rails db:migrate`` or ``rake db:migrate``

then jump into console and play around:

``rails console``

Within your console, try creating an Item. 

```
 i = Item.create(name: "glasses", quantity: 5)
```

If you run ``i`` or ``i.all`` you should see the item that you just created. 

GREAT! Now what? Now, we create our controller. 

And guess what! Rails has a controller generator. 

``rails g controller items`` 

<i>Note that the controller name that you choose should be pluralized.</i> The controller generator will create a controller, views folder, test unit files, assets files, and helper files.

If you want to specify what methods should be included in your controller and the view files that you want to be generated included in your file, run the following: 

``rails g controller items index show``

After running that, if you look at your views you will see pre-written methods within ``app/controllers/items_controller.rb``, like so: 

```
class ItemsController < ApplicationController

  def index
   
  end

  def show
 
  end

end
```

So how do you see all of the items within your database? And where would that restful route be? When you think about it, you do not want to go to ``localhost3000/index`` to view all of your items. It makes more sense to go to ``localhost3000/items``

So how do we do that?
 
You need to take the pre-defined method in your items controller called index and just like Sinatra, grab all the items from your database and present them in your view. 

Add the following to your index method, within your ``app/controllers/items_controller.rb``. 

```
class ItemsController < ApplicationController

  def index
     @items = Item.all
     render :index #the render is optional
  end

  def show
 
  end

end
```

Note, that I put that adding render is optional because rails implicitly knows to look for a directory with the same controller name and a file with the same action name that will automatically render your view. So, technically, you no longer have to render, you can leave it blank because rails is magic (just kidding-- there no such thing as magic, said no one). 

However, since I am new to rails, I chose to specify what view my index method will render. 

``render :index``

Since we used the controller method generator to generate our views, we do not need to create a index view, but if it is not there/you chose not to use the generator, simply create a file named ``index.html.erb`` in your ``app/views/item`` folder by running: ``touch app/views/items/index.html.erb``

Within your index view, add the following code so that you can display all of your items on the index view:  

```
<ul>
  <% @items.each do |item| %>
 <li> <%= item %> </li>
  <% end %>
</ul>
```

Last, the major difference between rails and sinatra is you have to specify your routes. To add a route you need to go to the routes folder, ``config/routes.rb``

Create a route by adding the following: 

```
get '/items', to: 'items#index', as: items
```

The code above, pretty much handles the  ``get '/items'`` request of ``/items``, 
then it sends the ``get '/items'`` request to the index method in the items controller. Then it specifies the path ``as:items`` so that it is easily referenced in the future when using the rails ``link_to`` method.

Now when you run ``rails server`` and head over to localhost/3000/items in your browser you should see the ``glasses -  5`` that you originally created in your rails console.