Dependency Injection for Wordpress

Dependency Injection for
WordPress Plugin Development

Mike Toppa
WordCamp Nashville
April 21, 2012
#wcn12

www.toppa.com @mtoppa

Mike Toppa
● Director of Development, WebDevStudios
● 17 years of experience in web development,
project management, and team management
● Universities: Georgetown, Stanford, Penn
● Dot coms: E*Trade, Ask Jeeves
● Start-ups: Finexa, Kai's Candy Co
● WordPress development for non-profits


Code is Poetry


We want code to be...
● Easy to understand
● Easy to change
● Reusable (DRY)
● Bug free


So why is it usually like this?

“O.P.C” http://abstrusegoose.com/432

It happens because we are always in a hurry,
and requirements are always changing.


But coding fast and dirty
only makes us slower in the long run.


“We like to think we spend our time power typing,
but we actually spend most of our time
staring into the abyss.”

- Douglas Crockford
principal discoverer of JSON,
Creator of JSLint


The ratio of time spent reading code versus
writing is well over 10 to 1.

Therefore, making code easy to read
makes it easier to write.

- Bob Martin
Paraphrased from his book Clean Code


Clean code saves time, saves $$


Clean code techniques
● Using meaningful names
● Don't repeat yourself (DRY)
● Object oriented principles and patterns
● Unit testing, test driven development (TDD)
● The “boy scout rule”
● Vertical slicing
● ...and many more

The SOLID Principles
● Single Responsibility (SRP)
● Open-Closed (OCP)
● Liskov Substitution (LSP)
● Interface Segregation (ISP)
● Dependency Inversion (DIP)


Shashin

My plugin for displaying albums, photos, and
videos from Picasa, Twitpic, and YouTube
(and others coming soon)


I used the new version as a test case for applying
clean code principles to WordPress plugins


Dependency Injection for Wordpress

My Shashin plugin consists of 44 classes, each of
which has a meaningful name, follows the SRP,
and “does one thing”

PicasaPhotoDisplayer
SettingsMenu
YouTubeSynchronizer
Uninstall
etc.


Shashin example

class Admin_ShashinInstall {
// ...

public function run() {
$this->createAlbumTable();
$this->verifyAlbumTable();
$this->createPhotoTable();
$this->verifyPhotoTable();
$this->updateSettings();
return true;
}

// ...
}


Class Autoloading
● The problem:
● PHP lacks an equivalent statement to “import” or
“use” for classes
● Having to hardcode a bunch of file paths is extra
work, and makes code harder to change
● The solution:
● PHP 5.1.2 and spl_autoload_register()
● PHP Standards Working Group: PSR-0


PSR-0: Official Description
● Each "_" character in the CLASS NAME is
converted to a DIRECTORY_SEPARATOR
● The fully-qualified namespace and class is suffixed
with ".php" when loading from the file system
● Alphabetic characters... may be of any
combination of lower case and upper case
● ...And other rules about namespaces
● Source: https://github.com/php-fig/fig-
standards/blob/master/accepted/PSR-0.md

PSR-0 Example

Admin_ShashinInstall

is translated to

Admin/ShashinInstall.php


Toppa Plugin Libraries Autoloader
// this is at the top of the main file for my Shashin plugin

require_once dirname(__FILE__) . '/../toppa-plugin-libraries-for-
wordpress/ToppaAutoLoaderWp.php';

$shashinAutoLoader = new ToppaAutoLoaderWp('/shashin');

// that's it! I can now call “new” on any class under the shashin folder
// and its class file will be automatically loaded


Shashin's capabilities are shaped by how its
objects are wired together, through
implementation of the
Dependency Inversion Principle


Naïve model of a button and lamp
Lamp
Button
+ turnOn()
+ poll()
+ turnOff()

class Button {
private $lamp;

public function __construct(Lamp $lamp) {
$this->lamp = $lamp;
}

public function poll() {
if (/* some condition */) {
$this->lamp->turnOn();
}
}
}
Example from “Agile Software Development”

Dependency inversion applied

<<interface>>
Button SwitchableDevice

+ poll() + turnOn()
+ turnOff()

Lamp

This is the Abstract Server pattern

class Lamp implements SwitchableDevice {
public function turnOn() {
// code
}

public function turnOff() {
// code
}
}

class Button {
private $switchableDevice;

public function __construct(SwitchableDevice $switchableDevice) {
$this->switchableDevice = $switchableDevice;
}

public function poll() {
if (/* some condition */) {
$this->switchableDevice->turnOn();
}
}
}

A web of collaborating objects
● The SRP and DIP together drive a
“composition” approach to OO design
● From Growing Object Oriented Software,
Guided by Tests:
"An object oriented system is a web of
collaborating objects... The behavior of the
system is an emergent property of the
composition of the objects - the choice of
objects and how they are connected... Thinking
of a system in terms of its dynamic
communication structure is a significant mental
shift from the static classification that most of us
learn when being introduced to objects."

Composition
(“Has a...”)

vs.

Inheritance
(“Is a...”)


The SRP is about objects that do one thing

The DIP is about how to wire them together
to create working, flexible software


Never, ever do this

class Button {
private $lamp;

public function __construct() {
$this->lamp = new Lamp();
}

//...
}


Instead, you want to
inject the object dependency

Dependency injection!


Dependency injection is one of many
design patterns
for implementing the
Dependency inversion principle


It comes in two flavors


Constructor injection

public function __construct(SwitchableDevice $switchableDevice) {
}


Setter injection

public function setSwitchableDevice(SwitchableDevice $switchableDevice) {
}


Which to use?

It depends


Dependency chains

If class A depends on class B,
and class B depends on class C,
class A should be blissfully unaware of class C


To do this without going insane,
you need an injection container


Example from Shashin
class Lib_ShashinContainer {
// …
public function getPhotoRefData() {
if (!isset($this->photoRefData)) {
$this->photoRefData = new Lib_ShashinPhotoRefData();
}

return $this->photoRefData;
}

public function getClonablePhoto() {
if (!isset($this->clonablePhoto)) {
$this->getPhotoRefData();
$this->clonablePhoto = new Lib_ShashinPhoto($this->photoRefData);
}

return $this->clonablePhoto;
}

Example continued

public function getClonablePhotoCollection() {
if (!isset($this->photoCollection)) {
$this->getClonablePhoto();
$this->getSettings();
$this->clonablePhotoCollection = new Lib_ShashinPhotoCollection();
$this->clonablePhotoCollection->setClonableDataObject($this->clonablePhoto);
$this->clonablePhotoCollection->setSettings($this->settings);
}

return $this->clonablePhotoCollection;
}


Beyond the textbook examples


What to do when you need
a new object inside a loop

One solution is cloning


Shashin Example

class Admin_ShashinSynchronizerPicasa extends Admin_ShashinSynchronizer {
// …

public function syncAlbumPhotos(array $decodedAlbumData) {
// …

foreach ($decodedAlbumData['feed']['entry'] as $entry) {
$photoData = $this->extractFieldsFromDecodedData($entry, $photoRefData,
'picasa');
// ...
$photo = clone $this->clonablePhoto;
$photo->set($photoData);
$photo->flush();
}


What if you need a new object inside a loop,
but can't know the subtype you'll need
ahead of time?

Let the injection container figure it out


Shashin Example

class Public_ShashinLayoutManager {
// ...
public function setTableBody() {
// …

for ($i = 0; $i < count($this->collection); $i++) {
// ...

$dataObjectDisplayer = $this->container->getDataObjectDisplayer(
$this->shortcode,
$this->collection[$i]
);

$this->tableBody .= $dataObjectDisplayer->run();

// ...
}

Dependency injection: key benefits
● Makes your object dependencies adaptable to
emerging needs
● With an injection container, simplifies managing
dependency chains
● Supports “preferring polymorphism to
conditionals”, making it easy to add new class
subtypes


Will this proliferation of objects
eat up all my memory?

No


Use dependency injection to instantiate
only the objects you need,
when you need them


Make immutable objects into
properties of the container,
so you only need to instantiate them once


PHP 5 has improved memory
management

“In PHP 5, the infrastructure of the object model was
rewritten to work with object handles. Unless you
explicitly clone an object by using the clone keyword you
will never create behind the scene duplicates of your
objects. In PHP 5, there is neither a need to pass objects
by reference nor assigning them by reference.”

From http://devzone.zend.com/article/1714


But don't overdo it:
avoid needless complexity

Dependency Injection for Wordpress

More Related Content

What's hot (17)

Viewers also liked (20)

Similar to Dependency Injection for Wordpress (20)

More from mtoppa (19)

Recently uploaded (20)

Dependency Injection for Wordpress

Editor's Notes