Preview

Start a free Courses trial
to watch this video

Saving The Address Book

Name: Saving The Address Book
Uploaded: 2015-03-04T15:16:05Z
Duration: 494 s
Description: Saving

8:14 with Jason Seifer

Saving

Teacher's Notes
Video Transcript
Downloads

Documentation Links

Ruby IO Documentation
Ruby YAML Documentation
Ruby Psych Documentation - This is the class YAML interfaces with.

Code Samples

require "./contact"
require "yaml"

class AddressBook
  attr_reader :contacts

  def initialize
    @contacts = []
    open()
  end

  def open
    if File.exist?("contacts.yml")
      @contacts = YAML.load_file("contacts.yml")
    end
  end

  def save
    File.open("contacts.yml", "w") do |file|
      file.write(contacts.to_yaml)
    end
  end

  def run
    loop do
      puts "Address Book"
      puts "a: Add Contact"
      puts "p: Print Address Book"
      puts "s: Search"
      puts "e: Exit"
      print "Enter your choice: "
      input = gets.chomp.downcase
      case input
      when 'a'
        add_contact
      when 'p'
        print_contact_list
      when 's'
        print "Search term: "
        search = gets.chomp
        find_by_name(search)
        find_by_phone_number(search)
        find_by_address(search)
      when 'e'
        save()
        break  
      end
      puts "\n"
    end
  end

Okay, now comes the fun part. 0:00

We're going to add the ability to save our address book to a file. 0:02

Now, this is gonna work in a couple different parts. 0:08

So for right now, let's just go ahead and write two methods, open. 0:12

And save. 0:19

Open and save are gonna be called at different points in the address book. 0:21

Now, we've got this run method which basically controls our entire program. 0:27

We could add contacts, print the address book, search through the contacts or exit. 0:31

So before we exit, what we're gonna do is call the save method. 0:38

What that's gonna do is save our contact list even though we haven't written 0:45

it yet. 0:50

And then, on the inverse of that, once we initialize the address book, 0:54

let’s go ahead and call the open method, so 1:00

that anything that we have saved, will be loaded in to our contacts. 1:04

Now, all we have to do is write these methods. 1:12

We’re going to be using a class from the standard library of Ruby, called YAML. 1:16

What YAML will do is save all of our Ruby objects into a text-based format. 1:21

Now, we're not gonna delve too far into YAML right now, but 1:29

I'm going to show you a couple of different pieces of documentation so 1:33

that we can see how YAML works. 1:38

Basically, we get this YAML class and 1:40

it can dump and load Ruby objects and 1:45

it serializes them into text in a certain way. 1:49

And then, we're going to write that text out to a file. 1:55

Now, YAML as a class is just an interface to another class, 2:00

which is where the methods that we'll be using come from. 2:05

We're gonna be using the load file and 2:10

two YAML methods, and then for writing out our files, 2:14

we're gonna be using the IO and file class. 2:20

We're gonna be using the open method on file which is alias for new. 2:25

Now this is all kind of a lot to take in, so let's go ahead and write the code and 2:32

then I will explain it. 2:36

So we'll write our save method first, and here's how it works. 2:40

We're gonna open a certain file, which is just gonna be called contacts.yml. 2:44

Then, we have to tell Ruby that we're opening it with the mode w for writing. 2:48

Then we write to this file the contents of our contacts 3:00

array and that's gonna save our file. 3:05

So what happens here is we're using this open method. 3:12

File.open is a method that takes an argument, which is the name of 3:14

the file as the first argument, and then the mode you want to access this file. 3:20

In this case, we're choosing right mode. 3:27

The other options that we could use are documented here in the documentation. 3:30

Could be read-only, read-write, write-only, 3:34

read-write, write-only and read-write, and this is only for 3:39

a pending or it depends where you want to start in the file. 3:44

Now we're doing this as write-only which means we're going to write the contact 3:50

list out each time we call save. 3:53

So let's go back here and just make sure that this works. 3:58

So first we'll add a contact, Jason Seifer, and then let's go ahead and exit. 4:06

Uh-oh, undefined method to_yaml, and why is that? 4:13

Well, it's because we have not required ymml. 4:19

It's part of the standard library, 4:24

all we have to do is require that library up here at the top of the file. 4:27

Clear my screen here. 4:35

And we'll try that one more time. 4:39

Add a contact, and then let's go ahead and exit. 4:44

Okay, so that worked. 4:50

Now here in the work space, 4:52

over on the left side in the side bar, go ahead and hit refresh. 4:53

When we do that, notice that way have a file called contacts.yml. 5:00

This is our address book program having written out contact. 5:06

Now in yml format, this dash right here means it's an array. 5:11

And it shows that it's a Ruby object of the contact class, and 5:17

phone numbers and addresses are an array. 5:23

So that looks good, we know that our contacts are being written, so 5:27

now let's implement this open method. 5:31

And first, we'll see if the file exists. 5:36

So if the file exists, we're going to assume that 5:45

we have contacts in there, so we can just replace 5:50

the contacts array with the contents of the YAML file, 5:55

and we do this by calling load_file. 6:00

On the YAML class, and 6:08

what that will do is parse everything in this file back into Ruby objects, 6:10

and replace the current internal contacts array with those contents. 6:15

So let me go back down here to the console, and clear the screen. 6:24

Now when I load the address book, let's go ahead and print it out and see if there is 6:33

anything in there, and this time the contact list has been printed. 6:37

So here we go, let's go ahead and 6:41

add another contact to make sure it is working. 6:43

And let's add a phone number this time, 6:47

and let's add an address as well. 6:52

Okay, so all of this seems to be working. 7:11

And now if we exit and go back over here and 7:14

check out our contacts file, we can see that the YAML is all working correctly. 7:18

It's loading up our contact and 7:24

our phone numbers, and everything seems to be working. 7:26

Now if we wanted to, we could add more things to this like the ability 7:30

to remove contacts, but for right now, things are looking pretty good. 7:33

And it's important to practice this stuff on your own, so if you'd like to, 7:38

go ahead and add the ability to remove contacts. 7:43

That would be great extra credit. 7:45

In this course, you've built a simple but effective contact list management program. 7:48

You've learned to use your own classes and objects, use loops and blocks and more. 7:53

Most importantly we've learned how to break things down and 7:58

add features to your program and think like a Ruby programmer. 8:01

Great job, but don't stop there. 8:05

Try to think about other things that you can add to the address book program, and 8:07

then practice on your own by doing it. 8:11

You need to sign up for Treehouse in order to download course files.

Build an Address Book in Ruby

Saving The Address Book

Documentation Links

Code Samples