Composition in Ruby

As Rubyists prepare for the most anticipated release of Ruby 3.0, its worth looking to unchanged principles.

Composition

One exiting feature of the ruby language is the presence of Modules.

module LimitOrder def price @price end end class Order attr :what, :amount (...) end class StockOrder < Order include LimitOrder (...) end 

StockOrder inheritances anything from Order and has access to properties and methods of LimitOrder.

• include works on instances of an object. Thus, any object generated by Stockorder.new can access the price method.

• extend on the other hand includes properties and methods to classes and modules.

Instantiate Objects without publicly calling new

Let's design a module OrderPrototype. Its main purpose is to provide a method order, which finally calls Order.new.

module OrderPrototype def defaults { } end def order **fields (...) ## process fields and fillup arguments Order.new **arguments end end 

The composition process starts by defining a module Limit:

module Limit extend OrderPrototype class << self def defaults super.merge { order_type: :limit, tif: :good_till_cancelled } end end end 

class << self assigns the following methods to the class-level. defaults are processed by OrderProtoype.order.

Limit.order size: 1, (...) instantiates a specialized Order-Object without inheritance. Other useful order prototypes are Market.order, StopLimit.order a.s.o.

The Limit-object acts as a singleton
masquerading as constructor for conventional ruby objects.

The approach is implemented in: https://github.com/ib-ruby/ib-extensions/blob/master/lib/ib/order-prototypes.rb
and further documented here