Beginners Guide to a Rails Project From Scratch 
Published: 2020-03-04 17:15:16

**Intro**

Let's face it, creating a project from scratch can be a daunting task. Creating various numerous folders and files can be extremely time consuming. Luckily for us, Ruby on Rails has the ability to create the entire shell of a project from scratch in just a few lines of code. By the end of this sections you will have a complete rails project with full MVC (Model, View, Controller) abilities and full CRUD (Create,Read,Update,Delete).

Domain Model
For this project we will be working with one artist model. 

**Creating our project, creating the initial files and folders**
The name of our project will be artist_generator. To create the project enter the following code 



```
rails new artist_generator
```

Next we will use resource to create a model, controller, migration, and route pages for our artist.

```
rails g resource Artist name
```

You should get the following output:
```
      invoke  active_record
      create    db/migrate/20200302192435_create_artists.rb
      create    app/models/artist.rb
      invoke    test_unit
      create      test/models/artist_test.rb
      create      test/fixtures/artists.yml
      invoke  controller
      create    app/controllers/artists_controller.rb
      invoke    erb
      create      app/views/artists
      invoke    test_unit
      create      test/controllers/artists_controller_test.rb
      invoke    helper
      create      app/helpers/artists_helper.rb
      invoke      test_unit
      invoke    assets
      invoke      scss
      create        app/assets/stylesheets/artists.scss
      invoke  resource_route
       route    resources :artists
```
Just with that one line of code we created an artist controller, artist model, empty artist view folder, and a create_artists table with a column of name.




NOTE: If you made a mistake with the naming of what you just created you can undo all of it with

```
rails d resource Artist name
```


Now we are ready to migrate!

**Migrations**

code the following to migrate your table

```
rails db:migrate
```

You should get the following schema created

```
ActiveRecord::Schema.define(version: 2020_03_02_211121) do

  create_table "artists", force: :cascade do |t|
    t.string "name"
    t.datetime "created_at", precision: 6, null: false
    t.datetime "updated_at", precision: 6, null: false
  end


```
Now that our migrations are complete lets see if our server works. To get a hello/rails screen we need to have our views, controller, and routes complete. Luckily for us our rails generate code we entered earlier should have taken care of that. Lets test it out. Type the following:

```
rails s 
```
You should see this in your command line:

```
=> Booting Puma
=> Rails 6.0.2.1 application starting in development 
=> Run `rails server --help` for more startup options
Puma starting in single mode...
* Version 4.3.3 (ruby 2.6.1-p33), codename: Mysterious Traveller
* Min threads: 5, max threads: 5
* Environment: development
* Listening on tcp://127.0.0.1:3000
* Listening on tcp://[::1]:3000
```

Great lets go to http://localhost:3000/ on our web browser and you will see the following:

![Rails Intro Page](https://dev-to-uploads.s3.amazonaws.com/i/aev6qtl86awdhwm5pqoa.png)

Now that we know our server works lets create our index controller/views:

**Creating our Index Controllers/Views**

Let's start creating our artist controllers at app/controllers/artists_controller. Here we will start with a blank index method.

```
class ArtistsController < ApplicationController
  def index
    
  end

end
```
Now lets go to localhost3000/artists and see our index page:

![Error message](https://dev-to-uploads.s3.amazonaws.com/i/vjrr5sznj27x6upkq3jx.png)

Rails is telling us we don't have a index.html.erb in the views page. So lets make one.

Go to app/views/artists and create an index.html.erb page by entering the following in the command line

```
touch app/views/artists/index.html.erb
```

Now go back to localhost3000/artists and you will notice a blank page. This is good news! We now have a index.html.erb page we just need to fill it out with forms.

Code the following on your index.html.erb page:

```
<h1>Index Page</h1>
<% @artists.each do |artist| %>
    <td> Artist link:</td>
    <td><%=link_to artist.name, artist_path(artist) %></td>
<%end%>
```

Let's head back to our controller page and fill out our index method.

```
  def index
    @artists = Artist.all
  end
```

Head back to your index page and you will see the following

![Index_Page](https://dev-to-uploads.s3.amazonaws.com/i/dqax5ap55jcsvb1s80rf.png)

Now that we know that our index page will load we need to code a create controller and views page to allow us to create and display an artist on our index page.

**Creating our Artist Create Controller/Views**

```
#artists_controller.rb

  def new
    @artist = Artist.new
  end

  def create
    @artist = Artist.new(artist_params)

    if @artist.save
      redirect_to @artist
    else
      render :new
    end
  end

private

  def artist_params
    params.require(:artist).permit(:name)
  end
```

There is a lot going on here so lets break it down. 

First under the private section we added a method for artist params. By adding it under private it provides an interface for protecting attributes from end-user assignment.

Next we created an create method that if the artists is successfully created and saved it will redirect you to the artist show page (which we will create later). If it is not saved it will render the new page again.


Next lets create our new.html.erb page.

First create the view page:
```
touch app/views/new.html.erb
```

Next code the following on the page:

```
<h1>Create an Artist</h1>

<%= form_for @artist  do |f| %>
  <%= f.label :name %>
  <%= f.text_field :name %>
  <br />

  <%= f.submit %>
<% end %>

```
This will show the following on localhost3000/artists/new:

![Create page](https://dev-to-uploads.s3.amazonaws.com/i/t6ccqpnbhv2fhgfdlupl.png)

Next lets code our show controllers/views

**Creating Artist Show Controller/Views**

Lets start by creating a show method:

```
  def show
    @artist = Artist.find(params[:id])
  end
```
Next lets fill out the show.html.erb page

```
touch app/views/artists/show.html.erb
```

```
#show.html.erb

<h1>Show Page</h1>
  
<h1><%= @artist.name %></h1>

<%= link_to 'Home', artists_path%>

```

Now once you create an artist it will take you to the show page of that artist. If you click on the home button on the show page it will take you back to the index page.

**Creating Edit/Update**

Lets head back to our controller and create an edit and update method


```
#app/controllers/artists_controller.rb
  def edit
    @artist = Artist.find(params[:id])
  end

  def update
    @artist = Artist.find(params[:id])

    @artist.update(artist_params)

    if @artist.save
      redirect_to @artist
    else
      render :edit
    end
  end

```
The edit method just requires us to find the current artists we are trying to edit. The update method we first find the artist and if the artist is found we update and redirect to the show page. Otherwise we render the edit page again (which we will make next)

Now that we have our controller completed we will create our edit.html page which is where we will edit and update our artist.

```
touch app/views/artist/edit.html.erb
```


```
#app/views/artist/edit.html.erb

<h1>Editing <%= @artist.name %></h1>

<%= form_for @artist  do |f| %>
  <%= f.label :name %>
  <%= f.text_field :name %>
  <br />

  <%= f.submit %>
<% end %>

```
Now if we change the name of our artist it will save the change and send us back to the show page.

But what if we want to go to the edit page from the show page? One line of code will fix that.

```
<h1>Show Page</h1>
  
<h1><%= @artist.name %></h1>

<%= link_to 'Home', artists_path%>
#new code
<%= link_to 'Edit', edit_artist_path(@artist)%>
```

Now we can create, edit, and update our artist. The last thing we need to do is be able to delete an artist.

**Deleting an Artist**
First add the following code to the bottom of your show page. This will add a delete button. 

```
<%= button_to "Delete", artist_path(@artist), method: :delete %>
```

Now we just need to make our destroy controller. Lets create a destroy method and add it to our artist controller:

```
  def destroy
    @artist = Artist.find(params[:id])
    @artist.destroy
    flash[:notice] = "Artist has been deleted."
    redirect_to artists_path
  end

```

The following method will find then destroy the current artist. It will then alert the user that the artist has been deleted.

You've done it, you have created a full CRUD app from scratch using Rails 

![Alt Text](https://dev-to-uploads.s3.amazonaws.com/i/ris080f3empx24icgf99.gif)