Preview
Video Player
00:00
00:00
Being Included
5:42One thing that’s really neat about the include method when using a module is that it gives us a way to hook in to that behavior and do something when a module is included in a class. We can use this to further extend the functionality in our modules. For example, when a module is included in a class, we could use that to run methods, write methods, or include other modules.
One thing that's really neat about
the include method when using a module
0:00
is that it gives us a way to
hook into that behavior and
0:04
do something when a module is included.
0:08
We can use this to further extend
the functionality in our modules, for
0:11
example, when a module is included in
a class we can use that to run methods,
0:16
write methods, or
even include other modules.
0:22
Let's see how included
works now using workspaces.
0:26
Okay, so here I am in a workspace and I've
created a new file called included.rb.
0:32
And the content of included.rb,
0:38
are just from the fetcher.rb
that we just had, and
0:41
all it includes is the fetcher module,
the dog class,
0:46
and an initialization of a new dog
instance right here called Fido.
0:51
And he is going to fetch a ball and a toy.
0:57
Let's just go ahead and
run it and see what happens.
1:01
Okay, so let's go ahead and
write the included method.
1:05
Now we write the included method by
calling included and the word ends.
1:11
So it's just another method and once we
give it the specific name called included.
1:20
It automatically runs for us.
1:26
However, this is going to be a little bit
different then every method we've seen so
1:28
far because It is a class method.
1:31
So just like in the math module
where every item that we ran
1:36
was a class method, with square root,
cosine, and all that.
1:42
Same thing happens with
the included method.
1:47
This runs on the class.
1:52
And it runs automatically when
a module is included in a class.
1:54
So let me save the file and
lets see what happens when we run it.
1:59
It's gonna give us an error and
we'll see how to fix it.
2:01
So it says wrong number of arguments one
through zero there's an argument error.
2:05
That means this method
requires an argument.
2:10
Now the argument that goes
into the included method
2:16
is the class in which
the module is included into.
2:19
So in this case, when we include
the Fetcher module in the dog class,
2:25
the dog class gets sent in as
the argument to the included method.
2:30
Which means we have to account for that.
2:35
Now normally,
we could name it something like class.
2:38
But that's a reserved word in Ruby.
2:41
So, conventionally, we can call it
klass or base or something like that.
2:44
But let's just stick with klass right now,
even though it's misspelled.
2:48
And for right now we'll just print
something to the screen saying,
2:55
klass has been included.
2:58
So I'm gonna save that and clear the
screen on the bottom and run this again.
3:00
And we'll see dog has been included.
3:07
Okay, so this comes down here, and
3:11
as soon as this method is included,
this code gets run.
3:14
Now because this method is run in
the context of a class method,
3:19
we can call other class methods,
inside of this method.
3:24
So that sound a little strange
but you know how we write
3:29
arrt_accessor when we want to have some
sort of attribute, like right here,
3:33
attr_accessor :fetch_count.
3:36
That's actually a class method.
3:41
And since it is, we can move it out of
there, and into the fetcher module.
3:44
Now, we have access to this
variable called fetch_count.
3:53
So let's go ahead and
print it out when we fetch an item.
3:59
And what we'll do first
is say fetch_count,
4:08
we're gonna set that
conditionally equal to 0.
4:12
And then increment it by one.
4:17
So what's gonna happen is as soon as
this fetch method is called after
4:19
being mixed into whatever class,
if fetch_count has not been accessed yet
4:24
we set it to zero and then increment
it by one and then run this.
4:30
And say okay we're gonna
display the count,
4:35
and we'll bring the item right back.
4:37
So now I'm gonna clear my screen,
and we are going to run this again.
4:39
And we can see we have one and
two which is the fetch count.
4:42
That's not very descriptive, so let's
go ahead and write the name right here.
4:47
Name, Fetch count.
4:52
Okay, so now Fido will display his name
each time we call this fetch method.
4:56
So all right, we have Fido,
he's got a fetch count of one.
5:04
And then the second time it's
run it got a fetch count of two.
5:07
And this is going to be specific to each
instance, so we could create another one,
5:13
say dog2.fetch ball, dog2.fetch toy.
5:17
And if we were to save this the attr_accessor
is created individually for
5:24
each dog object.
5:29
So now we see Fido has a fetch count of
two and Spot has a fetch count of two.
5:32
And again, if we had another class,
5:36
we could just mix in this
fetcher module to that as well.
5:38