Heads up! To view this whole video, sign in with your Courses account or enroll in your free 7-day trial. Sign In Enroll

Ruby Modules

Preview

Start a free Courses trial
to watch this video

Sign up for Treehouse

Being Included

5:42 with Jason Seifer

One 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.

Code Samples

First, we modify our Fetcher module to have an included class method. This method defines an attribute on the class it is included in called fetch_count.

module Fetcher
  def self.included(klass)
    attr_accessor :fetch_count
  end

The fetch method is then modified to say how many times the fetch count has occurred. The ||= operator is called the conditional assignment operator. It conditionally sets the value of @fetch_count to 0 if we haven't accessed it yet.

  def fetch(item)
    @fetch_count ||= 0
    @fetch_count += 1
    puts "[#{@name}, Fetch count: #{@fetch_count}] I'll bring that #{item} right back!"
  end
end


class Dog
  include Fetcher
  def initialize(name)
    @name = name
  end
end

dog = Dog.new("Fido")
dog.fetch("ball")
dog.fetch("toy")

Now, when we create a new Dog instance and run the fetch method, we get the following output:

[Spot, Fetch count: 1] I'll bring that ball right back!       
[Spot, Fetch count: 2] I'll bring that toy right back!

This fetch_count variable is specific to each Dog instance: 

dog2 = Dog.new("Spot")
dog2.fetch("ball")
dog2.fetch("toy")

So running that produces the following output:

[Fido, Fetch count: 1] I'll bring that ball right back!       
[Fido, Fetch count: 2] I'll bring that toy right back!
[Spot, Fetch count: 1] I'll bring that ball right back!       
[Spot, Fetch count: 2] I'll bring that toy right back!

Related Discussions

Have questions about this video? Start a discussion with the community and Treehouse staff.

Sign up

    Related Discussions

    Have questions about this video? Start a discussion with the community and Treehouse staff.

    Sign up

    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

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

    Sign up

      You need to sign up for Treehouse in order to set up Workspace

      Sign up