We're getting the page title from a URL parameter and

we're using it to load in page content from a text file.

Now we just need to convert our response to actual HTML and

we can do that using ERB.

Let's talk about the embedding part of embedded Ruby.

You store some static text, usually HTML code, in a file.

Then using specially ERB tags you embed Ruby code into the static

text that displays changing dynamic data.

Each time the template is rendered each piece of Ruby code is evaluated to

get a result.

Those results are inserted into the template in place of the ERB tags,

giving you text that changes each time the template is rendered.

Let's set up a temporary playground where we can try out ERB text.

I'm going to create a new get route with a path of /test.

It's important to place this before the get title route in

your code to avoid a conflict.

We'll talk about the reason for that later.

Within the route block, we'll call the ERB method and

have it render a template called test.

Then we'll create a new file in the views directory called test.erb.

The next time we visit the /test path, it will render the contents of this file.

There are two kinds of ERB, tags, regular embedding tags and output embedding tags.

Regular embedding tags start with <% and

end with %>, they contain some Ruby code in between those symbols.

The code gets evaluated but the results aren't placed directly into the output.

So let's say I had a regular tag like this, grade = 54.

When the tag gets evaluated the grade variable will be set but

nothing will appear in the output.

Regular embedding tags are most frequently used for two things, loops and

including or excluding parts of the template based on the condition.

If you include a conditional like an IF expression in a regular embedding tag,

any text inside the conditional will only be included in the output if

the condition is true.

So let's say that I had a statement up here,

a regular ERB tag setting the grade variable to 97.

And then I'll put insert another ERB tagged with a conditional in it.

if grade, if the grade variable, if the value in it is greater than 60,

I'll put separate ERB tag down here with the end keyword to end the if statement.

Now anything contained inside that conditional is only going to be printed

if the conditional is true.

So let's put a paragraph tag in here saying you passed.

If grade were lower than sixty, you passed would not be included in the output.

But since it's set to ninety seven, it will be.

Let's save this.

And now let's restart our server.

And try visiting the /test path.

It loads the test.arb tag,

evaluates the Ruby code setting the grade variable to 97.

Then it checks the conditional testing whether the grade variable is greater

than 60.

And it is, so it prints the paragraph tag, you passed.

If we change the variable's value to say 54,

save that, and reload the page, the condition

will no longer be true and the you passed HTML will be excluded from the output.

By the way you may have noticed that I didn't restart the app after making

changes to the ERB template.

That's because,

unlike the main Ruby code, ERB templates are reloaded each time they're rendered.

So if you save changes to the ERB template,

they'll show up as soon as you refresh your browser.

The other common use of regular embedding tags is in loops.

If you place a loop in a regular embedding tag,

any text inside the loop lobby will be output repeatedly.

So let's say that I wanted to output three paragraphs containing the word fish.

We'll create a regular embedding tag up here and

we'll loop three times by calling the times method on the integer object three.

Times method takes a block which loops that number of times.

And since it's a do end block we need the end keyword down here in a separate tag.

Now any text we put inside the loop here will be repeated that number of times.

So let's put an HTML paragraph tag, and we'll just put the word fish inside it.

Save this and reload our page.

And you see it loops three times,

each time outputting an HTML paragraph with the word fish.

In addition to regular embedding tags, ERB also has output

embedding tags which begin with <%= and end with %>.

The equal sign at the start is the only difference in how you type output tags

versus regular tags.

Like regular embedding tags the Ruby code inside an output tag gets evaluated when

the template is rendered.

But unlike regular tags, the return value of the Ruby code gets included in

the template in place of the tag.

So if we have an output embedding tag with the math operation 2 + 2,

when the template is rendered the code will be evaluated and the result, four,

will be included in the output.

Similarly, we can place a call to the time.now method in an output tag and

we'll get the current time in the output.

And because the values are updated every time we render the template,

we can refresh the page and see a new result every time.

We can mix regular embedding tags and output embedding tags too.

For example, we can nest an output embedding tag inside an each block and

the output tag will be evaluated repeatedly.

So let's say we wanted to print an HTML paragraph element for

each item in an array.

We can set up the array within a regular embedding tag.

And the each method, if you recall, loops through each element of the array,

passing it to the argument here in the block.

Again this is a multi-line block starting with do, so

we're going to need the end keyword in a separate tag down here.

And any text here within the loop will get repeated.

So we're going to output an HTML paragraph tag and we're going to embed within it

the output number, the current value of the number variable.

Let's save this and reload our page.

And we get the output 1 fish, 5 fish, 25 fish.

It loops through each value and our array, passes it into the number argument to

the block, and then within the loop body this output embedding tag gets evaluated.

The current value of number is the result, and that gets embedded into the output.

So that's how to embed Ruby code into an HTML template using ERB.

We're done trying out ERB code for now, so

let's go into the views directory and delete the test.erb file.

We'll also want to go into the main app code and delete the get /text route