[MUSIC]

Our users can create pages, read pages, update pages, what's left?

Right, deleting pages.

For every resource you create,

there may come a time when you don't want it anymore.

You might not want prospective employers to see that page where you show off your

collection of giant robot toys.

So let's allow our users to delete pages.

Just as a browser is supposed to send get requests to get data from the server and

post requests to post new data on the server,

a browser sends delete requests to delete data.

Actually, as with Patch requests,

it's technically still a POST request coming from the browser, but

it has amount of parameters that indicate it should be treated as a delete

request and Rails converts to request type to delete internally.

Because it's a different request type,

that means we're going to need a different route.

Let's set one up in our routes.rb file here.

As with the post and patch routes,

there's no need to worry about priority order since there's no chance of

a delete request getting confused with GET requests no matter what its path is.

So we'll put the new route here at the bottom.

Since we're routing delete requests, we'll call the delete method.

As with all our other page routes, the path should start with /pages.

And as with the show edit and update routes,

we'll need a model ID to look up which record we're working with.

So we'll add an ID URL parameter /:id.

We'll route these delete requests to the page's controller's destroy method.

to: pages#destroy.

Of course,

the destroy action method doesn't exist on the page's controller yet.

Let's add it now.

Action methods on the controller have to be public.

So be sure the method definition goes above the private keyword or

Rails won't be able to call it.

So we'll define a destroy method.

We'll look up the page to destroy it using the id parameter from the URL,

just like we do for the show method, the create method, etc.

We'll assign it to an instance variable named page, and

we'll call the Page.find method and we need to pass it the ID of

the page object it should look up, which we're getting from the params[:id].

Model objects have a destroy method you can call to delete

that record from the database.

So, we simply call page.destroy.

Now we need a way to send the delete request.

We'll add a delete link to the show view for an individual page.

So we'll edit at views > pages > show.html.erb.

At the bottom, we'll embed some output right after the edit link.

Within that tag, we'll call link to and we'll set the link text to delete.

Then we'll pass it our page object.

The object's ID will be used in the path for the generated link.

Let's try this delete link out.

We'll load the show view for one of the pages we want to get rid of.

We can look at the generated HTML for the link in our browser's developer tools.

There it is, a link to pages followed by the ID of the page object.

Now let's close the developer tools and click the link.

It seems like nothing's happening.

Let's go to our terminal and check the Rails log to see what's going on.

We seen started GET /pages/6 over and over.

It looks like our link is being handled as a GET request, not a delete request.

And because a GET request with this path gets routed to the show action,

it's just taking us back to the same page again.

Our link is taking us to the same page we're already on.

We can fix this by changing the type of HTTP request that the link sends.

We'll just add a method keyword argument to link to with

the request type that we want to send as a value.

In this case, we want to send a delete request, so we'll use the symbol delete.

Note that the method argument name here doesn't refer to the method on

the controller.

That's named destroy, not delete.

This is the HTTP request method such as Get post or delete.

Let's save this, refresh our browser and try clicking the delete link again.

It looks like nothing's happening still, but if we look at the log in our terminal,

you'll see that Rails processed it as a DELETE request.

We can also see that it loaded the requested page and then deleted it.

We can confirm this if we go back to the index of all pages.

The page we were on is gone, as it should be.

Now we just need to update the page's controller to handle things a little more

gracefully when we click that link.

As with the create an update methods, we're going to send the browser a redirect

response so that it loads a different path.

In our delete method, right after we destroy the page objects,

we'll call redirect_to.

And we'll send it to the /pages path by calling the pages_path method.

Save that, and now when we visit a page and click the Delete link, we'll be

redirected back to the list of all pages and that page will be gone from the list.

You can now create, read, update and

delete instances of your page model, all from your browser.

You have a complete Rails resource.

Before we wrap up the course, though,

there's a couple more things we can do to make the code cleaner.

The first will let us clean up our routes.rb file quite a bit, and

we'll be showing you that next.