We've set our new wiki page form up to submit via an HTTP POST request, but

we're getting the error Sinatra doesn't know this ditty.

The problem is that we need to set up a Sinatra route to handle POST requests.

Down here Sinatra provides us with a sample route to get us started,

post to the /create path.

Let's go back in our main app code and add a post route there.

Just as you used Sinatra's GET method to set up routes to handle HTTP GET requests,

you use Sinatra's POST method to set up routes for HTTP POST requests.

The post method works in much the same way as the get method.

You call the method and

pass of a string with the request path should match /create in this case.

Then you pass it a block that should be called whenever a matching post

request is received.

For now we'll just have the block respond to the browser with a string.

Hello from the post "/create" route!

By the way, you may be remembering how our get new route

conflicted with the URL parameter in the get title route.

You may be wondering if it's okay to define our post

create route down here at the bottom of the file.

There's no need to worry.

None of the get routes will match our post request no matter what the path

is because the request type is different.

We might need to be concerned if there were another post route with

a URL parameter.

But since this is the only post route,

we can define it anywhere in the file we want.

Let's test this new route.

Remember because we made a change to our Ruby code,

we have to restart the server even if it's already running.

Now, I'll visit form to create a new page, fill it out.

And then submit it, which should send a POST request to the /create path.

And in response,

instead of an error, we see our string, Hello from the post "/create" route!

Our route is being mapped successfully.

Displaying placeholder messages is all fine and good, but

we need a route to take our form data and save a new Wiki page for us.

Remember our route to view an individual page which

got the page title from a URL parameter?

That parameter was made available within the route block through the params hash.

Form parameters from POST requests also get placed into the params hash.

We can look at the form parameters by calling the inspect

method on params which converts the hash to a string.

So I'll replace our placeholder text, and

get the parames hash and call the inspect method on it.

Now if we restart the server, and fill out the form.

And submit it, we'll see the title we entered under the title key.

And the content we entered under the content key.

Let's copy this string, and

paste it temporarily in a comment right above our route so we can refer to it.

So remember the save content method we set up previously?

It takes the title string and the content string.

And saves the content to a text file for us.

And now we finally have the title and the content ready to pass to it is input.

We'll call save_content within our route block.

For the title, we'll pass it the value from the title key of the params hash.

And for the content, we'll pass it the value from

the content key, params["content"].

Let's restart our server again.

We'll visit the new page form.

It's already filled out from our prior submission, and let's submit it again.

We'll see only a blank page in response.

But if we go back to our workspace, refresh our file list,

And look in the pages directory, we'll see a text file with the page

title we entered as its name and the contents we entered as its content.

If we go back to the preview again, fill out the form again, And submit it again,

we'll get another blank page but, we can go back to the workspace, refresh again.

And we'll see another new file based on our form contents.

We're successfully saving our form data.

There is one more detail to take care of.

We don't want the browser to just show a blank page after we submit the form.

So the final thing we'll do is tell the browser to make a GET

request to show the new page after it's saved.

To do that will add a call to the redirect method at the end of a route block.

The redirect method tells Sinatra to send a redirect response to the browser,

redirects cause the browser to send the GET requests for a particular URL or path.

Whatever string you pass to the redirect method, that's the URL or

path the browser will be redirected to.

The path for the new page will consist of a slash followed by the page title.

So we'll use the title parameter to construct the path for the redirect.

So we'll start the string with a slash and then interpolate the title parameter,

Into the string.

Our route should be complete now, so

we shouldn't need the reference comment anymore.

Let's delete that.

Let's restart the server again.

Now we can go back to the new page form.

Submit a new page.

And once the page is saved we'll be redirected to view it.

This works fine until we try to submit a new page that has a space in the title.

At that point the page will seem to lock up and

may eventually return a 502 bad gateway message.

We've seen that when Sinatra starts up it prints a bunch of debug

messages to the terminal.

If Sinatra encounters any errors while it's running,

the error messages get logged in the terminal too.

Let's go back to our workspace and look at the Sinatra log messages in the console.

We'll scroll up until we find the problem.

InvalidURIError.

URI basically means the same thing as URL.

We'll also see the URL that the create route tried to redirect us to.

The problem is that spaces aren't a valid character within a URL,

they need to be encoded.

If you type a space into your browser address bar or

click on a link with a space, it'll be okay.

Let's try this here, Alena Holligan, note the space in there.

Your browser encodes the space characters when it sends the request.

But when we're sending a redirect back to the browser,

we need to encode the URL ourselves.

We can do that with the URI module.

It's part of the Ruby standard library,

which means it's included with every Ruby distribution.

The URI escape method can escape that is, encode the redirect path for us.

First we're going to need to load the URI library at the top of the file,

right here and to require "sinatra" we'll type, require 'uri".

Note that it's named uri,

not URL, if you type URL here, the library will fail to load.

Then we'll take our redirect path and pass it exactly as it is URI.escape.

The return value of URI.escape

will be the same path string except that if it contains any bases or

other invalid characters, they'll be encoded so the path is valid.

Now let's restart our server.

And now I'll try submitting a page with a space in the title again.

We've already got the form filled out, let's click Submit.

And this time we're successfully redirected to the new page.

And there are no errors from Sinatra logged in the console.

Our users can create new pages now, nice work.

We set up one Sinatra route that lets users send GET requests for

a new HTML form.

Then we set up a second route that accepts POST requests with the form data and

saves it to a file.

We've shown you techniques to load existing page data and

to save new page data.

In the next stage,

we'll combine those abilities to let users edit existing pages.