Accessing instance method of a different class with current object

From the book Practical Object-Oriented Design in Ruby, by Sandi Metz:

class Gear
 attr_reader :chainring, :cog, :rim, :tire
 def initialize(chainring, cog, rim, tire)
  @chainring = chainring
  @cog = cog
  @rim = rim
  @tire = tire
 end

  def ratio
   chainring / cog.to_f
  end    
 def gear_inches
  ratio * Wheel.new(rim, tire).diameter #line number 11
 end
 # ...
end

class Wheel
 attr_reader :rim, :tire
 def initialize(rim, tire)
  @rim = rim
  @tire = tire
 end

 def diameter
  rim + (tire * 2)
 end
 # ...
 end

 Gear.new(52, 11, 26, 1.5).gear_inches

> The immediate, obvious consequence of this reference is that if the name of the
Wheel class changes, Gear’s gear_inches method must also change.
On the face of it this dependency seems innocuous. After all, if a Gear needs to
talk to a Wheel, something, somewhere, must create a new instance of the Wheel
class. If Gear itself knows the name of the Wheel class, the code in Gear must be
altered if Wheel’s name changes.

>In truth, dealing with the name change is a relatively minor issue. You likely have
a tool that allows you to do a global find/replace within a project. If Wheel’s name
changes to Wheely, finding and fixing all of the references isn’t that hard. However,
the fact that line 11 above must change if the name of the Wheel class changes is the
least of the problems with this code. A deeper problem exists that is far less visible but
significantly more destructive.

>When Gear hard-codes a reference to Wheel deep inside its gear_inches
method, it is explicitly declaring that it is only willing to calculate gear inches for
instances of Wheel. Gear refuses to collaborate with any other kind of object, even if
that object has a diameter and uses gears.

>If your application expands to include objects such as disks or cylinders and you
need to know the gear inches of gears which use them, you cannot. Despite the fact
that disks and cylinders naturally have a diameter you can never calculate their gear
inches because Gear is stuck to Wheel.

I couldn't get wrap my head around the paragraph which is made bold. How can disk and cylinder objects access the method gear_inches, since gear_inches is an instance method of class Gear.(Sending gear_inches message to Disk and Cylinder)

Kindly clarify.

Think of it as a more hypothetical scenario, since what it describes is clearly not coded in the example you provided.

First, note that the Wheel instance isn't accessing any methods in the Gear class in this case. The other way around, Gear is accessing methods from a Wheel instance.

Second, think how a Gear would calculate a diameter for a potentially different type. Now using Wheel.new(...) wouldn't make any sense! What you could do, is pass the object that has a diameter method as a parameter, and call that method inside of gear_inches:

# One possible implementation
def gear_inches(object_with_diameter)
  ratio * object_with_diameter.diameter
end

Now the gear_inches depend on what type of object is being passed, and isn't tied to Wheel.

> How can disk and cylinder objects access the method gear_inches, since gear_inches is an instance method of class Gear.

The text doesn't say that disk or cylinder are supposed to call gear_inches. Quite the opposite: gear_inches needs a diameter to calculate its return value. Right now, it gets that diameter from a Wheel instance that it creates on its own.

However, hard-coding Wheel.new(...) into the method creates a coupling between Gear and Wheel. To loosen this coupling, you could for example pass the wheel instance to Gear's initializer. Which is exactly what Sandi shows in the next example:

> POODR, page 41:
>
> class Gear
> attr_reader :chainring, :cog, :wheel
> def initialize(chainring, cog, wheel)
> @chainring = chainring
> @cog = cog
> @wheel = wheel
> end
>
> def gear_inches
> ratio * wheel.diameter
> end
> # ...
> end
>
> # Gear expects a 'Duck' that knows 'diameter'
> Gear.new(52, 11, Wheel.new(26, 1.5)).gear_inches
>

"a 'Duck' that knows 'diameter'" means that wheel doesn't have to be an actual wheel (an instance of the Wheel class). Instead, it could be any object that responds to diameter, like for example a (hypothetical) disk or cylinder.