Namespacing with modules in Ruby - Interactive Code Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to define a module named MathTools.

Ruby

module [1]
  def self.square(x)
    x * x
  end
end

Drag options to blanks, or click blank then click option'

ATools

BMathTools

CToolsMath

DMathTool

Attempts:

3 left

💡 Hint

Common Mistakes

Using lowercase or incorrect module names.

Forgetting to capitalize module names.

The module name should be MathTools to match the intended namespace.

2fill in blank

medium

Complete the code to call the square method inside the MathTools module.

Ruby

result = MathTools.[1](5)
puts result

Drag options to blanks, or click blank then click option'

Asquare

Bsquare_root

Csquared

Dpower

Attempts:

3 left

💡 Hint

Common Mistakes

Using method names that do not exist in the module.

Calling methods without the module prefix.

The method defined in the module is named square, so we call MathTools.square(5).

3fill in blank

hard

Fix the error in the code by completing the module namespace correctly.

Ruby

module Geometry
  module [1]
    def self.area(radius)
      3.14 * radius * radius
    end
  end
end

Drag options to blanks, or click blank then click option'

AShape

Bshapes

CShapes

Dshape

Attempts:

3 left

💡 Hint

Common Mistakes

Using lowercase module names.

Using singular form when plural is more appropriate.

Module names should be capitalized and plural if representing a collection, so Shapes is correct.

4fill in blank

hard

Fill both blanks to define a nested module and call its method correctly.

Ruby

module [1]
  module Calculator
    def self.add(a, b)
      a + b
    end
  end
end

result = [2]::Calculator.add(3, 4)
puts result

Drag options to blanks, or click blank then click option'

AMathTools

CToolsMath

Attempts:

3 left

💡 Hint

Common Mistakes

Using different module names in definition and call.

Using dot notation instead of scope resolution operator.

The outer module is MathTools, and to call the nested method, use MathTools::Calculator.add.

5fill in blank

hard

Fill all three blanks to create a nested module with a method and call it properly.

Ruby

module [1]
  module [2]
    def self.greet(name)
      "Hello, #{name}!"
    end
  end
end

message = [3]::Greeter.greet("Alice")
puts message

Drag options to blanks, or click blank then click option'

AMyApp

BGreeter

DYourApp

Attempts:

3 left

💡 Hint

Common Mistakes

Mismatching module names between definition and call.

Using lowercase module names.

The outer module is MyApp, the nested module is Greeter, and the call uses MyApp::Greeter.greet.

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