The Ruby Module Builder Pattern

Ruby
The Module Builder Pattern
Chris Salzberg
^

View Slide

About Me
●
Writer, programmer, translator
●
@shioyama on github, twitter, SO
●
I program in Ruby
●
I live in Tokyo
●
I am the author of Mobility
●
I blog at dejimata.com

View Slide

View Slide

We’re Hiring!

View Slide

Introduction
Introduction

View Slide

View Slide

MODULE

View Slide

MODULE
What the heck is a
anyway?

View Slide

“A self-contained component of a system,
often interchangeable, which has a well-
defined interface to the other components.”

View Slide

View Slide

Modular design is an attempt to combine the advantages
of standardization with those of customization.
- Wikipedia
Modular Design

View Slide

Elements of Module Design

View Slide

●
Abstraction
Extract common pattern into functional unit

View Slide

●
Abstraction
●
Specification
Define contractual interface for unit

View Slide

●
Abstraction
●
Specification
Define contractual interface for unit
●
Encapsulation
Hide implementation behind public interface

View Slide

Scaling Rule
The broader the scope of your abstraction
the more expressive your specification must be
the tighter your encapsulation must be

View Slide

Modularity in Ruby
●
Module (modularity through inclusion)
– collection of methods and constants
– callback method (included)
●
Class (modularity through inheritance)
– initializer, methods, constants
– callback method (inherited)

View Slide

Gems are also Modules!
●
Self-contained component
– collection of Classes, Modules, Objects and code
●
Well-defined interface to other components
– gem/ruby dependencies (gemspec), class/object interfaces
●
As flexible as its components allow it to be
gem install degica

View Slide

A Modular Gem: Mobility
●
Pluggable “Translation Framework”
●
Abstracts storage strategies into “backends”
●
Supports a flexible collection of plugins
Plugins
Backend

View Slide

The Ruby Module
module MyModule
def foo
“foo”
end
def self.included(base)
puts “included in #{base.name}”
end
end
module MyModule
def foo
“foo”
end
def self.included(base)
puts “included in #{base.name}”
end
end
class A
include MyModule
def foo
super + “bar”
end
end
# prints “included in A”
a = A.new
a.foo
#=> “foobar”
class A
include MyModule
def foo
super + “bar”
end
end
# prints “included in A”
a = A.new
a.foo
#=> “foobar”

View Slide

Flexible? Nope.
module MyModule(config)
def foo
config
end
end
def foo
config
end
end

View Slide

Flexible? Nope.
#=> SyntaxError: unexpected '\n'...
def foo
config
end
end
#=> SyntaxError: unexpected '\n'...
def foo
config
end
end
Class A
include MyModule(config)
end
#=> NoMethodError: undefined method `MyModule' for A:Class
Class A
include MyModule(config)
end
#=> NoMethodError: undefined method `MyModule' for A:Class

View Slide

Encapsulated? Nope.
module MyModule
def foo
“foo” + bar
end
private
def bar
“bar”
end
end
module MyModule
def foo
“foo” + bar
end
private
def bar
“bar”
end
end

View Slide

Encapsulated? Nope.
module MyModule
def foo
“foo” + bar
end
private
def bar
“bar”
end
end
module MyModule
def foo
“foo” + bar
end
private
def bar
“bar”
end
end
class A
include MyModule
def bar
“baz”
end
end
a = A.new
a.foo
#=> “foobaz”
class A
include MyModule
def bar
“baz”
end
end
a = A.new
a.foo
#=> “foobaz”

View Slide

View Slide

Solution?

View Slide

Metaprogramming!!!

View Slide

Building with Modules
Building with Modules

View Slide

module Addable
def +(point)
self.class.new(point.x + x, point.y + y)
end
end
module Addable
def +(point)
self.class.new(point.x + x, point.y + y)
end
end
A Simple Module
Point = Struct.new(:x, :y)
Point.include Addable
p1 = Point.new(1, 2)
p1 + p2
#=> #
Point = Struct.new(:x, :y)
Point.include Addable
p1 + p2
#=> #

View Slide

class Point < Struct.new(:x, :y)
include Addable
def +(point)
puts “Enter Adder...”
super.tap { “Exit Adder...” }
end
end
p1 + p2
Enter Adder...
Exit Adder...
#=> #
class Point < Struct.new(:x, :y)
include Addable
def +(point)
puts “Enter Adder...”
super.tap { “Exit Adder...” }
end
end
p1 + p2
Enter Adder...
Exit Adder...
#=> #
Module Composition

View Slide

Problem: Abstraction
●
Module only defines addition for fixed pair of
accessors x and y
●
Can we abstract our module so that defines
addition on any set of accessors?
●
Can we do it in a way that supports method
composition?

View Slide

module AdderDefiner
def define_adder(*keys)
define_method :+ do |other|
self.class.new(
*(keys.map { |key| send(key) + other.send(key) })
)
end
end
end
module AdderDefiner
self.class.new(
)
end
end
end
Bootstrap Methods
●
Define a bootstrap method which builds
instance methods dynamically from arguments

View Slide

class LineItem < Struct.new(:amount, :tax)
extend AdderDefiner
define_adder(:amount, :tax)
end
extend AdderDefiner
end
Bootstrapping a Method

View Slide

extend AdderDefiner
end
extend AdderDefiner
end
def +(other)
self.class.new(amount + other.amount,
tax + other.tax)
end

View Slide

extend AdderDefiner
end
extend AdderDefiner
end
l1 = LineItem.new(9.99, 1.50)
l1 + l2
#=> #
l1 + l2
#=> #

View Slide

extend AdderDefiner
def +(other)
puts "Enter Adder..."
super.tap { puts "Exit Adder..." }
end
end
extend AdderDefiner
def +(other)
end
end
Bootstrapping + Composition

View Slide

extend AdderDefiner
def +(other)
end
end
extend AdderDefiner
def +(other)
end
end
l1 + l2
#=> ???
l1 + l2
#=> ???

View Slide

NoMethodError
super: no superclass method `+' for
#

View Slide

extend AdderDefiner
def +(other)
end
end
extend AdderDefiner
def +(other)
end
end

View Slide

extend AdderDefiner
def +(other)
tax + other.tax)
end
def +(other)
end
end
extend AdderDefiner
def +(other)
tax + other.tax)
end
def +(other)
end
end

View Slide

Configurable & Composable

View Slide

Define methods directly on extending class

View Slide

Define methods directly on extending class
Define methods on module
included into extending class

View Slide

module AdderIncluder
adder = Module.new do
self.class.new(
)
end
end
include adder
end
end
self.class.new(
)
end
end
include adder
end
end
Module Boostrapper

View Slide

self.class.new(
)
end
end
include adder
end
end
self.class.new(
)
end
end
include adder
end
end
Module Boostrapper
AdderDefiner#define_adder

View Slide

self.class.new(
)
end
end
include adder
end
end
self.class.new(
)
end
end
include adder
end
end
Module Boostrapper
Anonymous module

View Slide

extend AdderIncluder
def +(other)
end
end
def +(other)
end
end
Module Composition

View Slide

self.class.new(
)
end
end
include adder
def +(other)
end
end
self.class.new(
)
end
end
include adder
def +(other)
end
end
Module Composition

View Slide

self.class.new(
)
end
end
include adder
def +(other)
end
end
self.class.new(
)
end
end
include adder
def +(other)
end
end
Module Composition
LineItem.ancestors
#=> [LineItem,
#,
...

View Slide

def +(other)
end
end
def +(other)
end
end
Now it Works
l1 + l2
Enter Adder...
Exit Adder...
#=> #
l1 + l2
Enter Adder...
Exit Adder...
#=> #

View Slide

In the Wild
●
Technique of building anonymous modules to
include in classes is widely used (e.g. Rails)

View Slide

Recap
Addable
Defines + method on fixed variables x and y.
AdderDefiner
Adds class method define_adder which defines + method
on configurable set of variables.
AdderIncluder
Also adds class method define_adder which defines +
method, but in a composable way using anonymous module.

View Slide

Is this Modular?
●
Boostrap method(s) extended as class methods
●
Instance methods defined on anonymous module
●
Configuration state stored on including class,
referenced by methods on anonymous module
define_foo
define_foo
extend
def foo(*args)
self.class.foo
end
def foo(*args)
self.class.foo
end
include
MyClass
@foo
Module.new

View Slide

The Module Builder
The Module Builder

View Slide

Classes, Modules & Objects

View Slide

class Module
Object Model Revisited
●
Module is a Class
is a

View Slide

class ModuleBuilder < Module
●
Module is a Class
●
A class can have subclasses

View Slide

def initialize(method_name)
●
Module is a Class
●
●
(Sub)classes can define methods

View Slide

def initialize(method_name)
define_method method_name do
●
Module is a Class
●
●
(Sub)classes can define methods
●
Modules can also define methods

View Slide

Elements of a Module Builder
class Attributes < Module
def initialize(*attribute_names)
@names = attribute_names
# ...
# ...
end
def included(klass)
@names.each do |name|
define_method name do
# ...
end
# ...
end
end
end
class Post
include Attributes.new(:title,
:content)
end
# ...
# ...
end
def included(klass)
# ...
end
# ...
end
end
end
class Post
include Attributes.new(:title,
:content)
end
Subclass Module
Define module methods in
initialize or included hook
Include instance of Module
subclass in other classes
Configure in initializer

View Slide

Configure in an Initializer
# ...
end
# ...
end
class Post
include Attributes.new(:title, :content)
end
# ...
end
# ...
end
class Post
include Attributes.new(:title, :content)
end

View Slide

Encapsulate in a Closure
# ...
def included(klass)
locale = ...
mobility_backend_for(name).read(locale)
end
end
end
end
# ...
def included(klass)
locale = ...
mobility_backend_for(name).read(locale)
end
end
end
end

View Slide

class AdderBuilder < Module
def initialize(*keys)
self.class.new(
)
end
end
end
self.class.new(
)
end
end
end
Addable as Module Builder

View Slide

self.class.new(
)
end
end
end
self.class.new(
)
end
end
end
Addable as Module Builder
AdderDefiner#define_adder

View Slide

Encapsulated Module Building
include AdderBuilder.new(:amount, :tax)
end
l1 + l2
#=> #
end
l1 + l2
#=> #
●
No bootstrap method added to class
●
No private methods mixed into class

View Slide

Composition Too
include (Module.new do
self.class.new(
)
end
end
def +(other)
end
end
include (Module.new do
self.class.new(
)
end
end
def +(other)
end
end

View Slide

Composition Too
def +(other)
end
end
def +(other)
end
end
LineItem.ancestors
[LineItem,
#,
... ]
It has a name!

View Slide

Applying the Pattern

View Slide

broader abstraction
more expressive
specification
tighter
encapsulation

View Slide

module Alchemist
class ModuleBuilder
def initialize category
@category = category
end
def build
build_module do |category_module|
define_inspect_method(category_module)
define_unit_methods(category_module)
end
end
private
attr_reader :category
def build_module(&block)
Module.new do
def self.define_unit_method(names)
names.each do |name|
define_method(name.to_sym) { Alchemist.measure self, name.to_sym }
end
end
end.tap &block
end
def define_inspect_method(category_module)
category_module.class_eval %(def self.inspect() "#" end)
end
def define_unit_methods(category_module)
category_module.class_eval category_methods
end
def library
Alchemist.library
end
def category_methods
unit_names.map do |name|
%(define_method("#{name}") { Alchemist.measure self, :#{name} }) + "\n" +
prefixed_methods(name)
end.join("\n")
end
def unit_names
library.unit_names(category)
end
def prefixes_for(name)
if library.si_units.include?(name.to_s)
library.unit_prefixes.keys
else
[]
end
end
def prefixed_methods(name)
prefixes_for(name).map do |prefix|
%(define_method("#{prefix}#{name}") { Alchemist.measure_prefixed self,
:#{prefix}, :#{name} })
end.join("\n")
end
end
end
module Alchemist
class ModuleBuilder
end
def build
end
end
private
Module.new do
end
end
end.tap &block
end
end
end
def library
Alchemist.library
end
end.join("\n")
end
def unit_names
end
else
[]
end
end
end.join("\n")
end
end
end
BEFORE

View Slide

module Alchemist
class ModuleBuilder
end
def build
end
end
private
Module.new do
end
end
end.tap &block
end
end
end
def library
Alchemist.library
end
end.join("\n")
end
def unit_names
end
else
[]
end
end
end.join("\n")
end
end
end
module Alchemist
class ModuleBuilder
end
def build
end
end
private
Module.new do
end
end
end.tap &block
end
end
end
def library
Alchemist.library
end
end.join("\n")
end
def unit_names
end
else
[]
end
end
end.join("\n")
end
end
end
module Alchemist
define_inspect_method(category)
define_unit_methods(category)
end
def define_unit_method(names)
end
end
private
def define_inspect_method(category)
define_method :inspect do
"#"
end
end
def define_unit_methods(category)
unit_names(category).map do |name|
Alchemist.measure self, name.to_sym
end
define_method "#{prefix}#{name}" do
Alchemist.measure_prefixed self, prefix.to_sym, name.to_sym
end
end
end
end
def library
Alchemist.library
end
def unit_names(category)
end
else
[]
end
end
end
end
module Alchemist
define_inspect_method(category)
define_unit_methods(category)
end
def define_unit_method(names)
end
end
private
def define_inspect_method(category)
define_method :inspect do
"#"
end
end
def define_unit_methods(category)
unit_names(category).map do |name|
Alchemist.measure self, name.to_sym
end
define_method "#{prefix}#{name}" do
Alchemist.measure_prefixed self, prefix.to_sym, name.to_sym
end
end
end
end
def library
Alchemist.library
end
def unit_names(category)
end
else
[]
end
end
end
end
BEFORE
AFTER

View Slide

Compact and Versatile
class GeoLocation
include Dry::Equalizer.new(:latitude, :longitude)
attr_reader :latitude, :longitude
def initialize(latitude, longitude)
@latitude, @longitude = latitude, longitude
end
end
class GeoLocation
include Dry::Equalizer.new(:latitude, :longitude)
attr_reader :latitude, :longitude
def initialize(latitude, longitude)
@latitude, @longitude = latitude, longitude
end
end
@keys = keys
define_methods
freeze
end
@keys = keys
define_methods
freeze
end
def define_methods
define_cmp_method
define_hash_method
define_inspect_method
end
def define_methods
define_cmp_method
define_hash_method
define_inspect_method
end

View Slide

Compact and Versatile
point_a = GeoLocation.new(1, 2)
point_b = GeoLocation.new(1, 2)
point_c = GeoLocation.new(2, 2)
point_a.inspect
#=> "#"
point_a == point_b # => true
point_a.hash == point_b.hash # => true
point_a.eql?(point_b) # => true
point_a.equal?(point_b) # => false
point_a == point_c # => false
point_a.hash == point_c.hash # => false
point_a.eql?(point_c) # => false
point_a.equal?(point_c) # => false
point_a = GeoLocation.new(1, 2)
point_b = GeoLocation.new(1, 2)
point_c = GeoLocation.new(2, 2)
point_a.inspect
#=> "#"
point_a == point_b # => true
point_a.hash == point_b.hash # => true
point_a.eql?(point_b) # => true
point_a.equal?(point_b) # => false
point_a == point_c # => false
point_a.hash == point_c.hash # => false
point_a.eql?(point_c) # => false
point_a.equal?(point_c) # => false

View Slide

Flexible and Extendable
Title Backend
#
#
read(:fr)
Storage
Strategy
...
class Post
extend Mobility
translates :title,
fallbacks: { fr: :en },
default: ‘No Translation’
end
I18n.locale = :fr
post = Post.new
post.title
#=> post.title_backend.read(:fr)
class Post
extend Mobility
translates :title,
fallbacks: { fr: :en },
default: ‘No Translation’
end
I18n.locale = :fr
post = Post.new
post.title
#=> post.title_backend.read(:fr)
●
Mobility uses Module Builders to:
– Customize translation accessors per-attribute
– Add attribute-specific customization to models

View Slide

But umm, is this... okay?

View Slide

Don’t be Afraid!
●
A Module Builder is:
– Just a subclass
– Just configuring an
instance
– Just defining methods
on a module

View Slide

But most of all, a Module Builder is just...

View Slide

But most of all, a Module Builder is just...
PLAIN OLD RUBY
RUBY

View Slide

Thanks!
Thanks!

View Slide

The Ruby Module Builder Pattern

The Ruby Module Builder Pattern

Chris Salzberg

More Decks by Chris Salzberg

Other Decks in Programming

Featured

Transcript