[MUSIC] Hi.

I'm Jason, your Ruby teacher here at Treehouse.

In this workshop we're going to be going over the differences between extend and

include when working with modules in Ruby.

There are some finer points when working with each of these methods and

we're gonna go over them now.

So, let's go ahead and get started.

Okay, let's get into some of the differences between include and

extend when working with modules in Ruby.

Now, I'm going to create a very simple module here called the Shout module.

Now, this module is going to contain one method and it's going to say introduce.

And the introduce method is going

to return a string that says, Hello!

I'm here!

Now let's create a class that works with the Shout module.

So a person can Shout.

Now let's go ahead and see what happens when we run this.

I'm gonna have a little statement right here, we can say Person.new.introduce.

So if I click down into the console here in my workspace and

type ruby include_extend.rb we see that

this method was run that says introduce and it says, Hello!

I'm here!

Now if we tried to call this on the Person class,

we would get a no method error saying that the introduced method didn't exist.

Undefined method introduce for the person class.

And that makes sense because when we include a module,

we get all of the different methods in the instances of our class.

However, what if we had another class?

So we have a Person and let's also say we have a Dog class.

When we use the extend keyword with a module

the extend keyword will operate on the class, rather than on the instance.

So if we Dog.new.introduce.

I'm gonna take these out of here so that we can see.

We'll get the no method error in there.

However, when we say Dog.introduce, we do not get that error.

So here we go, undefined method introduced for dog and then the program stops.

So if we take that out and then just do Dog.introduce, it says, Hello!

I'm here!

So extend will operate at the class level and

include operates on the instance level.

Any instance of the class gets the methods inside of the module.

Now, practically speaking, we could include and extend something in a class.

So we could say extend the shout module on both Person and Dog.

And this could work for all sorts of different modules, and classes.

So if we run this again, both the class and

the instance would get these different module methods.

Now, this isn't very practical, so I've prepared a couple

modules here in the attribute_maker.rb file.

Now, let's go ahead and I'm just gonna scroll through this for just a moment and

introduce everything that's going on.

First, I'm gonna load this up into an irb session.

I'm gonna say, okay, load "./attribute_maker.rb",

and that prints a couple of things to the screen.

I'm gonna clear my screen here and what this does, just to give you an idea,

this allows you to create users with the attributes of first name and last name.

So we can say, create(first_name: "Jason", last_name: "Seifer").

That will return a user instance with those attributes set.

And we'll do another one, (first_name: "Nick", last_name: "Pettit").

So now we have two user instances.

And we can say, find_by(:first_name, "Nick").

And it would return an array with all the users that met those

different qualifications found.

So, how do we do this?

All we did was write this include method to include the AttributeMaker module.

But, we're getting these class methods when that's included.

And one of those class methods is called attributes, which we pass

an array of symbols to, and thenwe can set those when we create a user.

Now, how in the world does all of this work?

Well it works through the power of modules.

So I'm gonna exit that for just a moment, and

then walk through how this was all done.

We have this module, AttributeMaker.

That's the core module that we sent in.

Ignore this line for a second right here.

We also have this ClassMethods module.

Now the ClassMethods module contains our create and

find_by methods as well as this method called attributes.

Now we know that these work, and

we're gonna walk through them a little bit more in just a moment.

Then our instances also have a method called attributes,

a two-string method, and our module overrides the initialize method.

So, now, let's go back and see how all of this works.

This is a certain pattern.

When we include the attribute maker module, in our user class,

there's a method inside of modules that gets run, automatically called included.

The included method runs every time you type include and

and then the name of a module.

So as soon as the include method is fired in the AttributeMaker module it gets run.

It takes one argument which is the class which is including the module.

Now since class is a reserved word in Ruby,

we misspell it inside of this argument to get into the method.

And it could be something besides class if we really want it to.

Other common names are base and klass and things like that.

Klass is kinda one of the more common misspellings.

So as soon as this is included, we extend the class with our ClassMethods module,

which is defined deeper inside of the AttributeMaker module.

Here's our ClassMethods module.

And that will get us all of the behavior at the class level and the instance level.

So here's where it gets a little bit tricky.

We define a class method called attributes inside of this ClassMethods module.

And this is going to take an array of arguments.

Now what we're passing in symbols, and we could write some more checks to make sure

that everything we pass in is a symbol.

Now this splat operator makes sure that anything sent in is an array.

Now we call it args to be short for arguments.

So we take this and flatten it in case there are multiple levels in the array.

Then we iterate over each item and

get this attribute block level instance variable.

And then just for debugging purposes, we've printed it out to the screen.

Now we can do something really fun.

We define a method using the method called define_method.

What the define_method method does is,

as you can imagine based on the name, creates a method by that name.

Now we're doing that at the class level, so

you can kind of think of this as saying, as soon as this method is included it

would be the same as writing defined method inside of the user class.

The first argument that we would get is first_name, so

it would run define_method with the symbol of first_name,

then we pass a block to it and this block is run.

What it does is return the value inside of the attributes hash,

with the argument, which at this point is first_name.

Essentially it would be the same as writing def

first_name, attributes[:first_name].

But this is all done for us.

Now you might wonder where attributes is coming from.

That happens later on in this module.

We have this method definition called attributes which either initializes and

sets the attribute's instances variable to an empty hash, or returns it if it exists.

Now the attributes method is inside of the AttributeMaker module.

But, since this defined method is operating essentially

at the instance level, we have access to the attributes method.

The second part here defines another method where we're setting that attribute.

We can pass define_method either a string or a symbol.

Here we're passing it a string which will define the first_name_equals

method which will set that as the value inside our attributes hash.

Now, these methods are created automatically.

So, our user class has no idea, when it's created,

that it's going to have these methods for these different attributes.

Next, we have the create method.

Now, create initializes a new instance and this is still

in the ClassMethods module, so this is still operating at the class level.

Then what this does is initialize a new instance

with the arguments that are sent in as a hash.

It then appends that instance to an instances array and returns it.

The instances array is just another method inside of our ClassMethods

module that either initializes or returns an empty array.

Or, if the array exists, it returns the instances array and

this is at the class level.

So we would have access to user.instances.

Finally, our last method that we have at the class level is the find_by method.

And we pass in an attribute and a value.

We initialize an empty array that we call found.

We then iterate over the instances at the class level and,

if this instance has an attribute with that value,

we append that to the found array and then return that found array.

After that, we have that instances method which we went over earlier.

And then here are our actual instance methods that get included from

the AttributeMaker module.

We already went over the attributes method, and

we redefined the to_s method, which prints out the class and the attributes.

And finally we overrode the initialize method to pass in a hash for

the different attributes.

We then iterate through them and for each key in value we set that to

the internal attributes hash at the given key, with the given value.

So once we do all that,

we can do all sorts of fun things that we saw in our IRB console.

Let's go ahead and check that out one more time.

I'm gonna load this in.

And you can see as soon as I type load, it says attribute: first_name and

attribute: last_name.

If we scroll up, we can see that it got to this point in the code

because included was run and then this attributes method was run.

So now, let's go ahead and create a user,

first_name: "Jason", last_name: "Seifer".

And we'll create another one.

User.create(first_name: "Bob",

last_name: "Seifer").

Now at this point, we should have access to the user.instances method.

And we do. And f I were to create another one,

and then I rerun this instances method, we can see that that was appended as well.

So now when we clear this If I say User.find_by,

pass in the symbol, firs_name: "nick",

we get back an array with one user in it.

If I do find_by(:last_name,

we get back an array with two items in it, just like we expected.

And, if I wanted to say user as an instance,

User.find_by(:last_name, "Seifer"),

and I will call the first item in there and

see that I can go to user.attributes, and it returns a hash of the attributes.

I can say user.first_name and that just returns the user's first name,

user.last_name "Seifer",

and then I could do user.first_name = "Also Jason" and

if I checked out the user, we can see that the attributes hash was also updated.

Now what we see here with extending

ClassMethods when including a class is pretty common.

This is a very common Ruby idiom that you'll see

if you start reading a lot of code.

Go ahead and read over the different ClassMethods and

the module, and even try including it on your own.

Go ahead and play around with it.

And these are the basics of using include and extend.

By combining both of them you get a lot of power and

flexibility when writing your Ruby programs.