# Basics of Require

**URL:** <https://www.ruby-forum.com/t/basics-of-require/162906>\
**Category:** Ruby\
**Created:** [March 15, 2009, 3:12pm UTC](https://www.ruby-forum.com/t/basics-of-require/162906 "2009-03-15T15:12:58Z")\
**Posts on this page:** 6\
**Page:** 1

<div class="post-metadata">

**Author:** ![mschwab](https://www.ruby-forum.com/letter_avatar_proxy/v4/letter/m/59ef9b/32.png) [@mschwab](https://www.ruby-forum.com/u/mschwab)\
**Post date:** [March 15, 2009, 3:12pm UTC](https://www.ruby-forum.com/t/basics-of-require/162906/1 "2009-03-15T15:12:58Z")

</div>

I don’t have access to an instance of Ruby at the moment and I am not  
clear what is being said in The Ruby P.ming Language (Flanagan &  
Matsumoto). It says require code is executed immediately. It also says  
you can’t insert the require code in the middle of something as if you  
are copy-and-pasting, so can you explain some basics of what actually  
happens?

If I have a file myprog.rb and libfile1.rb, and I run myprog:

# myprog1.rb======== statement\_1 require libfile1

# libfile1.rb======= statement\_2

… I believe Ruby will run statement 1 and then run statement 2

Now if I change this to:

# myprog2.rb======== statement\_1 require libfile2

# libfile2.rb================= Module Libfilemod statement\_2 end

…I assume Ruby only runs statement 1 and stops

Now if I change myprog:

# myprog3========= statement\_1 def calllibfile require libfile1 end

…well, can you do that? If you can, presumably Ruby reads libfile1 but  
doesn’t execute it?

Also does require get executed in the order of text encountered in the  
file or does the Ruby runtime pick out the keyword require up front and  
expand it before the native code?

# myprog1.rb======== statement\_1 require libfile1

# libfile1.rb======= statement\_2

Does this do 1 then 2 or 2 first?

What are the differences between wrapping require code in ‘Module’,  
‘Def’ and ‘Class’?

The final question is in typical web environments like webrick, apache  
or eruby, does the require code get loaded and ‘compiled’ everytime any  
program refers to it or is there some mechanism to cache common code in  
‘compiled’ form?

---

<div class="post-metadata">

**Author:** ![mschwab](https://www.ruby-forum.com/letter_avatar_proxy/v4/letter/m/59ef9b/32.png) [@mschwab](https://www.ruby-forum.com/u/mschwab)\
**Post date:** [March 15, 2009, 5:10pm UTC](https://www.ruby-forum.com/t/basics-of-require/162906/2 "2009-03-15T17:10:45Z")

</div>

On Sun, 15 Mar 2009 09:10:39 -0500, Mike S. wrote:

> I don’t have access to an instance of Ruby at the moment and I am not  
> clear what is being said in The Ruby P.ming Language (Flanagan &  
> Matsumoto). It says require code is executed immediately. It also says  
> you can’t insert the require code in the middle of something as if you  
> are copy-and-pasting, so can you explain some basics of what actually  
> happens?

> What are the differences between wrapping require code in ‘Module’,  
> ‘Def’ and ‘Class’?

def method  
require ‘foo’  
end

only loads ‘foo’ when you call the method. The contents of ‘foo’ are  
visible globally. (Unlike a #include in C)

module Foo  
require ‘foo’  
end

class Foo  
require ‘foo’  
end

These are exactly the same. They both load ‘foo’, and the contents of  
‘foo’ are NOT wrapped in the module or class Foo.

> The final question is in typical web environments like webrick, apache  
> or eruby, does the require code get loaded and ‘compiled’ everytime any  
> program refers to it or is there some mechanism to cache common code in  
> ‘compiled’ form?

That depends on the environment. Webrick, which is a web server written  
in Ruby, keeps the same ruby interpreter running the whole time your  
server is running, so if you ‘require’ once, then the code stays loaded  
the whole time the server is running. With apache, it would depend on  
how  
you’ve set up apache to run the ruby interpreter. Eruby is a library  
that  
runs within a ruby interpreter, so it’s not really relevant to this  
question.

---

<div class="post-metadata">

**Author:** ![mschwab](https://www.ruby-forum.com/letter_avatar_proxy/v4/letter/m/59ef9b/32.png) [@mschwab](https://www.ruby-forum.com/u/mschwab)\
**Post date:** [March 15, 2009, 3:50pm UTC](https://www.ruby-forum.com/t/basics-of-require/162906/3 "2009-03-15T15:50:52Z")

</div>

Mike S. wrote:

> I don’t have access to an instance of Ruby at the moment

You might ought to explain that one. It even runs on wrist watches these  
days!

> # and I am not require libfile1
> 
> # libfile1.rb======= statement\_2
> 
> … I believe Ruby will run statement 1 and then run statement 2

Ya.

> # statement\_2 end
> 
> …I assume Ruby only runs statement 1 and stops

it runs statement\_2 while compiling module Libfilemod.

> doesn’t execute it?  
> When you call calllibfile, the libfile1 gets evaluated and inserted into  
> the  
> current environment (unless if someone else already required it).

However, the contents of libfile1 do not get inserted into the current  
scope  
(inside calllibfile). They insert into the top-level context. This is so  
you can  
delay requiring them, but get their symbols with the correct scope.

> Also does require get executed in the order of text encountered in the  
> file or does the Ruby runtime pick out the keyword require up front and  
> expand it before the native code?

The Ruby parser always runs top-to-bottom in each context

> Does this do 1 then 2 or 2 first?  
> You already asked that!

And get used to:

require ‘libfile1’

require is nothing more than a method that takes a string. It’s not a  
magic  
keyword with its own parsing rules (like its equivalents are in certain  
other  
languages.)

> What are the differences between wrapping require code in ‘Module’,  
> ‘Def’ and ‘Class’?

Nope - your tutorials cover that. Read on!

> The final question is in typical web environments like webrick, apache  
> or eruby, does the require code get loaded and ‘compiled’ everytime any  
> program refers to it or is there some mechanism to cache common code in  
> ‘compiled’ form?

The second require simply does not happen (if the string argument is the  
same!).  
So all the same symbols remain in the same Ruby environment.

---

<div class="post-metadata">

**Author:** ![mschwab](https://www.ruby-forum.com/letter_avatar_proxy/v4/letter/m/59ef9b/32.png) [@mschwab](https://www.ruby-forum.com/u/mschwab)\
**Post date:** [March 15, 2009, 5:39pm UTC](https://www.ruby-forum.com/t/basics-of-require/162906/4 "2009-03-15T17:39:40Z")

</div>

There’s a very nice, underused method of module which can help with  
loading  
code on demand. Despite being quite fluent in Ruby, I only found out  
about  
it a few weeks ago, thanks to Chad F…

It’s Module#autoload. It takes two arguments. The first is the NAME of  
a  
constant as either a String or a Symbol, the second is a string with the  
same meaning of the argument to require. What it does is to associate  
the  
first argument with the second, and if and when an undefined constant  
matching the first argument is encountered in the scope of the module,  
to  
effectively require the file named by the path argument. It can be used  
at  
the top level to autoload definitions of contstants in the global scope.  
For example

# at top level

autoload :Foo, ‘lib/foo’ # this will load lib/foo.rb the first time  
anyone  
references ::Foo

require ‘something.rb’

# in file lib/foo.rb

class Foo  
autoload :Bar, ‘lib/foo/bar’ # loads lib/foo/bar.rb when ::Foo::Bar  
is  
referenced when undefined  
end

# in file ‘lib/foo/bar.rb’

module Foo::Bar

# code

end

# in file ‘something.rb’

class MyClass \< Foo  
#…  
end

When the ‘class Myclass \< Foo’ is executed, Foo will be undefined, this  
will  
trigger the load of ‘lib/foo.rb’ which is expected to define the  
constant  
Foo which it does. Similarly lib/foo/bar.rb would be loaded if an when  
some  
code defined ::Foo::Bar as an undefined constant.

This is somewhat similar to the automatic class loading built into Rails  
(actually the ActiveSupport component of rails) using constant\_missing,  
but  
it’s actually built into Ruby, and has been for quite a while. In fact  
ActiveSupport and the rest of rails is evolving to implement automatic  
class  
loading using autoload, which is how I learned about it. Chad was doing  
a  
walkthrough of ActiveRecord at RubyRx and showed the new code.

–  
Rick DeNatale

Blog: [http://talklikeaduck.denhaven2.com/](http://talklikeaduck.denhaven2.com/)  
Twitter: [http://twitter.com/RickDeNatale](http://twitter.com/RickDeNatale)  
WWR: [http://www.workingwithrails.com/person/9021-rick-denatale](http://www.workingwithrails.com/person/9021-rick-denatale)  
LinkedIn: [http://www.linkedin.com/in/rickdenatale](http://www.linkedin.com/in/rickdenatale)

---

<div class="post-metadata">

**Author:** ![mschwab](https://www.ruby-forum.com/letter_avatar_proxy/v4/letter/m/59ef9b/32.png) [@mschwab](https://www.ruby-forum.com/u/mschwab)\
**Post date:** [March 15, 2009, 6:22pm UTC](https://www.ruby-forum.com/t/basics-of-require/162906/5 "2009-03-15T18:22:36Z")

</div>

Ken B. wrote:

> def method  
> require ‘foo’  
> end
> 
> only loads ‘foo’ when you call the method. The contents of ‘foo’ are  
> visible globally. (Unlike a #include in C)
> 
> module Foo  
> require ‘foo’  
> end
> 
> class Foo  
> require ‘foo’  
> end
> 
> These are exactly the same. They both load ‘foo’, and the contents of  
> ‘foo’ are NOT wrapped in the module or class Foo.

I can’t see the logic there. You’re saying if the require is inside a  
method, Ruby will not doing anything until your program calls that  
method. However if the require is inside a class, Ruby will go and fetch  
the code before you ever refer to that class?

---

<div class="post-metadata">

**Author:** ![mschwab](https://www.ruby-forum.com/letter_avatar_proxy/v4/letter/m/59ef9b/32.png) [@mschwab](https://www.ruby-forum.com/u/mschwab)\
**Post date:** [March 15, 2009, 7:01pm UTC](https://www.ruby-forum.com/t/basics-of-require/162906/6 "2009-03-15T19:01:03Z")

</div>

Mike S. [removed\_email\_address@domain.invalid](mailto:removed_email_address@domain.invalid) wrote:

> > require ‘foo’  
> > method, Ruby will not doing anything until your program calls that  
> > method. However if the require is inside a class, Ruby will go and fetch  
> > the code before you ever refer to that class?

The thing to grok here that is a class or module definition is itself  
executable code. That, after all, is how the class gets defined! When  
you say:

class MyClass  
end

you really are executing code in order to bring the class into existence  
(the constant name is created, etc).

When you think about it this way, you realize, aha! That’s how stuff  
like attr works. A big hunk of the coolness of Ruby depends upon this  
very fact.

class MyClass  
attr :howdy # executes right now!  
end

Similarly if you say

class MyClass  
puts “howdy”  
end

… then “howdy” is output as soon as this code is encountered. It is  
executable code.

But a method definition just defines a method. So when you say:

class MyClass  
def howdy  
puts “howdy”  
end  
end

then “howdy” is not output, because all you did was define a method -  
you haven’t called it yet. The “def” is executed right now (i.e. the  
method is indeed brought into existence) but its _contents_ are not  
executed (though of course the interpreter is applied to them, to make  
sense of them). m.