In this project, we'll use our knowledge of Ruby hashes and symbols to construct a program that displays, adds, updates, and removes movie ratings!

A Night at the Movies

Perfect! Let's move on to the next branch of our `case` statement, which handles updating an existing movie in the hash. (This should be very similar to the work we did in the "add" branch!) We'll do this in three steps:

Update

Awesome! Now let's handle displaying the contents of our `movies` hash. This will be a little different from what we did for the "add" and "update" branches.

Display

Keeping track of all the parts of our digital lives is a pain. Now that you know how to write Ruby, however, you can make things easy for yourself! Let's start by creating a program that will keep track of our movie ratings.

It'll do one of four things: add a new movie to a hash, update the rating for an existing movie, display the movies and ratings that are already in the hash, or delete a movie from the hash. If it doesn't receive one of those four commands, the program will output some kind of error message.

This project will give you a lot of room for creativity, but we know sometimes it can be a little disorienting to not have strict instructions. If you ever feel lost, don't hesitate to check out the example code in this exercise to help you along!

What You'll Be Building

Great! Let's build out each part of the `case`, one step at a time. We'll start with the "add" branch.

Prompting: Redux!

All right! We're nearly done with the "add" part of our `case`. The final thing we'll want to do is perform a check to see whether the movie to be added is already in the hash.

To do this, we'll add an `if`/`else` statement.

Error! Error!

Almost there! Let's handle the "delete" part of our `case` statement, which will remove whatever key the user specifies from the hash. (This will be very similar to what we did for "add" and "update.")

Ruby makes it easy to remove a movie/rating pair from our hash: we just write `movies.delete(title.to_sym)`!

Delete

First things first: let's create a hash to hold our movies and their ratings. Next, let's prompt the user for input so we can eventually store movie/ratings pairs in our hash.

```rb
favorite_foods = {
  vegetable: 'broccoli'
}
puts "Do you like coding in Ruby?"
answer = gets.chomp
```

1. A hash is a way of storing data with a specifiable key, as opposed to an array where the data is only accessible using numbers (or indices). It is created using a pair of curly braces `{ }`.
2. `puts` displays a message in the console. In this example, we ask if you like coding in Ruby.
3. In order to get the user input, we have to call `.chomp` on `gets`.

Setting Up

Good work! Now we'll want to create the main body of our program: the `case` statement, which will decide what actions to take based on what the user types in.

`if` and `else` are powerful, but we can get bogged down in `if`s and `elsif`s if we have a lot of conditions to check. Thankfully, Ruby provides us with a concise alternative: the `case` statement. The syntax looks like this:

```rb
case language
  when "JS"
    puts "Websites!"
  when "Python"
    puts "Science!"
  when "Ruby"
    puts "Web apps!"
  else
    puts "I don't know!"
end
```

The `else` is what the `case` statement will do if it doesn't match any of its `when` statements to the `case` (in this case, the value of `language`).

The Case Statement

Perfect! Our program is really coming along.

You might have wondered how we're going to get our movies and ratings from the user—which come in as strings—into the hash where we want our movies to be symbols and our ratings to be integers. Built-in Ruby magic to the rescue!

Ruby's `.to_sym` method can convert a string to a symbol, and `.to_i` will convert a string to an integer.

Not My Type

Fantastic! You built a little app with only a few dozen lines of code. Impressive, isn't it?

The four verbs your program knows—add, display, update, and delete—are universal. This acronym is better known as <a href="http://en.wikipedia.org/wiki/Create,_read,_update_and_delete">CRUD </a>  for **c**reate, **r**ead, **u**pdate, and **d**elete (respectively). These are the actions you take when you update an entry in a database, ask a website for information, or write a blog post. Being familiar with this setup is good, because you'll see it in everything from <a href="http://en.wikipedia.org/wiki/Application_programming_interface">API </a>calls to web frameworks like Ruby on Rails.
