Namespacing with modules in Ruby - Mini Project: Build & Apply

Namespacing with modules

📖 Scenario: Imagine you are organizing a small library system. You want to keep book-related and author-related code separate but still inside the same program. This helps avoid confusion when different parts have similar names.

🎯 Goal: You will create two modules named Books and Authors. Each module will have a class with the same name Info but with different details. Then you will print information from both classes to see how modules keep them separate.

📋 What You'll Learn

Create a module called Books with a class Info inside it

Create a module called Authors with a class Info inside it

Each Info class should have a method details that returns a string

Use the full namespaced class names to create objects and call details

Print the results from both Books::Info and Authors::Info

💡 Why This Matters

🌍 Real World

Namespacing with modules is useful when building large programs or libraries where different parts might have classes or methods with the same names.

💼 Career

Understanding modules and namespacing is important for writing clean, maintainable Ruby code and working on team projects or open-source libraries.

1

Create the Books module with Info class

Create a module called Books. Inside it, define a class called Info. Add a method details that returns the string "Book: Ruby Programming".

Ruby

# Your code here

Hint

Use module Books to start the module. Inside it, define class Info and a method details that returns the exact string.

2

Create the Authors module with Info class

Add a new module called Authors. Inside it, define a class called Info. Add a method details that returns the string "Author: Jane Doe".

Ruby

module Books
  class Info
    def details
      "Book: Ruby Programming"
    end
  end
end

# Your code here

Hint

Similar to step 1, create module Authors with class Info and a details method returning the exact string.

3

Create objects using namespaced classes

Create a variable book_info and assign it an object of Books::Info.new. Create another variable author_info and assign it an object of Authors::Info.new.

Ruby

module Books
  class Info
    def details
      "Book: Ruby Programming"
    end
  end
end

module Authors
  class Info
    def details
      "Author: Jane Doe"
    end
  end
end

# Your code here

Hint

Use the full namespaced class names with :: to create new objects and assign them to the variables.

4

Print details from both objects

Use puts to print the result of calling details on book_info and then on author_info.

Ruby

module Books
  class Info
    def details
      "Book: Ruby Programming"
    end
  end
end

module Authors
  class Info
    def details
      "Author: Jane Doe"
    end
  end
end

book_info = Books::Info.new
author_info = Authors::Info.new

# Your code here

Hint

Use puts book_info.details and puts author_info.details to print the strings returned by the methods.

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