Namespacing with modules in Ruby - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

Output of nested module constant access

What is the output of this Ruby code?

Ruby

module Outer
  module Inner
    VALUE = 42
  end
end

puts Outer::Inner::VALUE

A 42

B nil

C NameError

D Outer::Inner::VALUE

💡 Hint

Think about how constants are accessed inside nested modules.

The constant VALUE is defined inside Inner module which is nested inside Outer. Accessing it with Outer::Inner::VALUE returns 42.

❓ Predict Output

intermediate

Method call with same name in different modules

What will this Ruby code print?

Ruby

module A
  def self.greet
    'Hello from A'
  end
end

module B
  def self.greet
    'Hello from B'
  end
end

puts A.greet
puts B.greet

A

Hello from A
Hello from A

B

Hello from B
Hello from A

C

Hello from A
Hello from B

D NoMethodError

💡 Hint

Each module has its own greet method.

Each module defines its own greet method. Calling A.greet prints 'Hello from A' and B.greet prints 'Hello from B'.

🔧 Debug

advanced

Why does this code raise an error?

This code raises an error. What is the cause?

Ruby

module Outer
  module Inner
    def self.message
      'Hi'
    end
  end
end

puts Inner.message

A TypeError - because Inner is not a module

B NoMethodError: undefined method 'message' - because message is not defined

C SyntaxError - because module nesting is incorrect

D NameError: uninitialized constant Inner - because Inner is not accessible without Outer namespace

💡 Hint

Check how you access nested modules outside their parent.

Inner is defined inside Outer, so you must access it as Outer::Inner. Using Inner alone causes a NameError.

📝 Syntax

advanced

Identify the syntax error in module nesting

Which option contains the correct syntax to define a nested module in Ruby?

A module Outer module Inner end end

B module Outer; module Inner; end; end

C module Outer { module Inner } end

D module Outer: module Inner: end end

💡 Hint

Remember Ruby uses 'module' and 'end' keywords with semicolons allowed.

Option B uses correct Ruby syntax with semicolons to separate statements. Others use invalid syntax like braces or colons.

🚀 Application

expert

How many constants are accessible from Outer module?

Given this code, how many constants can be accessed directly using Outer::CONST_NAME?

Ruby

module Outer
  CONST1 = 1
  module Inner
    CONST2 = 2
  end
  CONST3 = 3
end

A 2

B 3

C 1

D 0

💡 Hint

Only constants defined directly inside Outer are accessible as Outer::CONST_NAME.

CONST1 and CONST3 are defined directly inside Outer and accessible as Outer::CONST1 and Outer::CONST3. CONST2 is inside Inner and must be accessed as Outer::Inner::CONST2.

Practice

1. What is the main purpose of using modules for namespacing in Ruby?

easy

A. To group related code and avoid name conflicts

B. To create new classes automatically

C. To speed up program execution

D. To replace methods with variables

Solution

1. Step 1: Understand what namespacing means

   Namespacing helps organize code and avoid conflicts when different parts use the same names.

2. Step 2: Identify the role of modules in Ruby

   Modules group related methods and constants, preventing clashes by creating separate spaces.

3. Final Answer:

   To group related code and avoid name conflicts -> Option A

4. Quick Check:

   Modules = Group code + avoid conflicts [OK]

Hint: Modules group code to prevent name clashes [OK]

Common Mistakes:

• Thinking modules create classes automatically
• Believing modules speed up code execution
• Confusing methods with variables inside modules

2. Which of the following is the correct syntax to define a nested module MathTools::Algebra in Ruby?

easy

A. module MathTools; module Algebra; end; end

B. module MathTools.Algebra; end

C. module MathTools:Algebra; end

D. module MathTools, Algebra; end

Solution

1. Step 1: Recall Ruby syntax for nested modules

   Nested modules are defined by opening one module inside another using separate module keywords and end statements.

2. Step 2: Check each option

   module MathTools; module Algebra; end; end correctly uses two module blocks nested inside each other. Other options use invalid syntax such as dots, colons, or commas.

3. Final Answer:

   module MathTools; module Algebra; end; end -> Option A

4. Quick Check:

   Nested modules use separate module blocks [OK]

Hint: Use separate module blocks for nesting [OK]

Common Mistakes:

• Using dot or comma instead of nested blocks
• Trying to define nested modules with :: inside module keyword
• Missing the end keyword for each module

3. What will be the output of the following Ruby code?

module Outer
  module Inner
    def self.greet
      "Hello from Inner"
    end
  end
end

puts Outer::Inner.greet

medium

A. Outer::Inner

B. Hello from Inner

C. NoMethodError

D. SyntaxError

Solution

1. Step 1: Understand module nesting and method call

   The method greet is defined as a class method on the nested module Inner.

2. Step 2: Access the method using the namespace operator

   Calling Outer::Inner.greet correctly accesses the method and returns the string.

3. Final Answer:

   Hello from Inner -> Option B

4. Quick Check:

   Nested module method call = "Hello from Inner" [OK]

Hint: Use :: to call nested module methods [OK]

Common Mistakes:

• Trying to call method without self prefix
• Confusing module names with method names
• Expecting errors due to misunderstanding nesting

4. Identify the error in the following Ruby code:

module A
  module B
    def greet
      "Hi"
    end
  end
end

puts A::B.greet

medium

A. Syntax error in module definition

B. Module B is not nested correctly

C. Cannot call puts on module

D. Method greet is not defined as a class method

Solution

1. Step 1: Check method definition inside module

   The method greet is an instance method but is called on the module itself.

2. Step 2: Understand method call on module

   Calling A::B.greet expects a class method, but greet is an instance method, causing a NoMethodError.

3. Final Answer:

   Method greet is not defined as a class method -> Option D

4. Quick Check:

   Instance method called on module = error [OK]

Hint: Define methods with self. for module calls [OK]

Common Mistakes:

• Calling instance methods directly on modules
• Assuming nested modules cause syntax errors
• Thinking puts cannot be used with module methods

5. Given the following code, how can you call the calculate method from outside the modules?

module Finance
  module Tax
    def self.calculate(amount)
      amount * 0.15
    end
  end
end

hard

A. Finance.Tax::calculate(100)

B. Finance.Tax.calculate(100)

C. Finance::Tax.calculate(100)

D. Finance::Tax#calculate(100)

Solution

1. Step 1: Identify method type and module nesting

   The method calculate is a class method inside nested modules Finance and Tax.

2. Step 2: Use correct Ruby syntax to call nested module method

   Use the :: operator to access nested modules and call the class method with dot notation.

3. Final Answer:

   Finance::Tax.calculate(100) -> Option C

4. Quick Check:

   Nested module method call uses :: and . [OK]

Hint: Use :: for modules, dot for methods [OK]

Common Mistakes:

• Using dot instead of :: for modules
• Using # instead of . for method calls
• Mixing dot and :: incorrectly