How to Use Module as Namespace in Ruby: Simple Guide

In Ruby, you use a module as a namespace by defining classes or methods inside it to group related code and avoid name clashes. Access these nested classes or methods using the scope resolution operator ::, like ModuleName::ClassName.

Syntax

A module acts as a container for classes, methods, or constants. Use the module keyword followed by the module name, then define your classes or methods inside. Access nested items with ::.

• module ModuleName: starts the namespace
• class ClassName: defines a class inside the module
• ModuleName::ClassName: accesses the class outside the module

ruby

module MyNamespace
  class MyClass
    def greet
      "Hello from MyClass"
    end
  end
end

obj = MyNamespace::MyClass.new
puts obj.greet

Output

Hello from MyClass

Example

This example shows how to define two classes with the same name inside different modules to avoid conflicts. Each class has its own greet method.

ruby

module Animals
  class Dog
    def greet
      "Woof!"
    end
  end
end

module Robots
  class Dog
    def greet
      "Beep boop!"
    end
  end
end

animal_dog = Animals::Dog.new
robot_dog = Robots::Dog.new

puts animal_dog.greet
puts robot_dog.greet

Output

Woof!
Beep boop!

Common Pitfalls

One common mistake is forgetting to use the scope resolution operator :: when accessing classes inside modules, which causes Ruby to look for the class in the global scope and raise an error. Another is nesting modules incorrectly or redefining modules unintentionally.

Wrong way:

obj = MyClass.new  # Error: uninitialized constant MyClass

Right way:

obj = MyNamespace::MyClass.new

Quick Reference

Concept	Usage
Define module	module ModuleName ... end
Define class inside module	class ClassName ... end inside module
Access class	ModuleName::ClassName
Avoid name clash	Use different modules as namespaces
Call method	ModuleName::ClassName.new.method_name

Key Takeaways

Use module to group related classes and methods as a namespace.

Access nested classes or methods with :: to avoid name conflicts.

Always prefix class names with the module name when using namespaces.

Modules help organize code and prevent clashes in larger projects.

Forget to use :: causes Ruby to look in the wrong place and raise errors.