We're set up to load page content from text files.

Next we need to display that content in the browser.

We want people to be able to type in a path and

see the contents of a text file that was loaded in from the pages directory.

Let's add directions to the welcome paid so that people know to try this,

we'll let it welcomed the RB in the views directory and

will add in an age female paragraph with our directions Visit

/PageName, To view a page.

Save that, and now if we run the app.

And reload the route path, we'll see those directions.

But if we try that now by clicking in the address bar and typing in Nick Pettit.

Remember that's the name of the sample text file we created.

We see Sinatra doesn't know that steady.

By the way notice that the space in the URL gets replaced with a %20.

Space characters aren't valid in a URL so the browser encodes them.

Sinatra still gets the space character in the browser requests though

we want to be able to type in slash Nick Pettit or slash robots or

any other page we've created the text file for and have it load, but

there's no way we can create separate Sinatra outs for all those.

Not only would our app code be really long,

we can't possibly anticipate every page that users might want to create.

So instead, we're going to create a single route that will match

any page users might attempt to visit.

And we'll do it using a URL parameter.

A URL parameter allows users to substitute any string they want for

part of the request path.

That string will then be accessible within your Sinatra route.

First let's set up a route with a URL parameter.

We want this to respond to HTTP get requests.

So we'll use the get method as we did before.

So we'll go here into wiki.rb then copy get method.

Then we need a path to match.

Paths always start with the slash.

So we'll set that up in a string.

The next segment of the path will be our URL parameter.

Parameters are marked with a colon followed by a parameter name.

We want this parameter to be the title of the page we want to view.

So, we'll call it title, :title.

And as always the route needs a block to call when it gets a matching request.

Let's set the route up so that we can look at the parameter we're getting

from the URL parameters gets stored along with other parameters in the params hash.

You can access params within any Sinatra route block.

The keys of the params hash are the names of the parameters you can use either

a symbol or a string whichever you prefer both will access the same parameter.

So to access the title parameter we give it the symbol, title as a key.

Our title URL parameter is now the return value of the block.

So that's what will be returned in the response to the browser.

Let's save our work, restart our app.

And then reload the preview for the /NickPettit URL.

We can see that it takes the string from the request path

along with the encoded space character.

Puts it into the title URL parameter and then prints that parameter out.

Now that we've got a page title, we can pass it to the page content method to load

text files from the pages directly.

So, instead of just returning the title parameter, we'll pass it to page content

as an argument, page_content (params(:title): will be our new argument.

And since that's the last expression on the block,

the page text will be the new return value.

Let's restart the app again.

And reload our preview page.

Instead of the Nick Pettit title parameter we'll see the content

of the text from the page's directory.

This page is a little bare bones though.

We're just dumping raw text in the response instead of HTML.

We're not displaying the page title anywhere.

So, up next, we'll show you how to use ZR beat to embed the title and

text into an HTML template.