Dci in PHP

Herman Peeren
SweetlakePHP
August 2015
DCIData - Context - Interaction

Trygve Reenskaug James Coplien (Cope)

playing roles
not all behaviour at the same time

This picture and on coming pages example from Victor Savkin:
http://www.sitepoint.com/dci-the-evolution-of-the-object-oriented-paradigm/

what the system is
< >
what the system does
• anemic model, “data”
• adding behaviour in a “context”
• behaviour grouped in roles
• context = use case, scenarios
• model matches mental model
• readability of object oriented code
• object oriented < > class oriented

• http://fulloo.info/Documents/
• http://en.wikipedia.org/wiki/Data,_context_and_interaction
• https://groups.google.com/forum/#!forum/object-composition

“Wrapper” implementation
• Instantiate the Roles and constructor-inject a RolePlayer-
object in them.
• Leads to “object schizophrenia”: what is the $this in a
Role-method referring to? It should be the same object as
the $this in the RolePlayer.
https://en.wikipedia.org/wiki/Schizophrenia_%28object-oriented_programming%29
• Big NO-NO and showstopper in DCI.

Some implementations of DCI in PHP
that are none or less “wrapper”:
• CoreDCI: can be used in PHP 5.3 (no traits). A method-injection PHP-implementa-
tion from 2010 using naming conventions like r Rolename Actions-classes.
Used in http://code.google.com/p/waxphp/.
See http://code.google.com/p/php-coredci/wiki/UsingCoreDCI
• Fatty: originally for Laravel. Uses closure object binding (in PHP 5.4).
See http://kirkbushell.me/data-context-interaction-for-php/.
Code on https://github.com/kirkbushell/fatty.
• the “reverse wrapper” (object wraps the role rather than the role wrap-
ping the object), which also results in methods of a role being injected in a data ob-
ject (with examples in PHP 5.3 and using traits).
See https://github.com/mbrowne/dci-php.
Discussion: https://groups.google.com/d/msg/object-composition/YDKfrGuLXDo/
pRirNWtks4oJ

CoreDCI: can be used in PHP 5.3 (no traits). A method-injection PHP-implemen-
tation that gets the rolename for the objects from the context’s execute() signature. You
need to implement an interface with the Rolename in the roleplaying object. That doesn’t
make it very flexible if you want to add behaviour. Also: what is $this in Role methods?
class Account
extends DCIObject
implements rMoneySource, rMoneySink {
protected $balance;
function __construct($initial_balance) {
parent::__construct();
$this->balance = $initial_balance;
}
function Withdraw($amount) {
if ($amount <= $this->balance) {
$this->balance -= $amount;
return $amount;
}
else
throw new DCIException(“Insufficient Funds”,”Tried to withdraw $amount<br />{$this->balance} available.”);
}
function Deposit($amount) {
$this->balance += $amount;
}
class TransferCtx extends Context {
function Execute(rMoneySource $source, rMoneySink $sink, $amount) {
parent::Execute();
$source->TransferFunds($sink,$amount);
}
}
function GetBalance() { return $this->balance; }
}

Fatty: originally for Laravel. Uses closure object binding (in PHP 5.4). Example only
shows how to use instead of inheritance.
see:
• http://php.net/manual/en/closure.bind.php#110845 for example adding method
• https://gist.github.com/mbrowne/5047982 for a similar implementation
Closure object binding:
public function addMethod($methodName, $methodCallable)
{
if (!is_callable($methodCallable)) {
throw new InvalidArgumentException(‘Second param must be callable’);
}
$this->methods[$methodName] = Closure::bind($methodCallable, $this, get_class());
}
public function __call($methodName, array $args)
{
if (isset($this->methods[$methodName])) {
return call_user_func_array($this->methods[$methodName], $args);
}
throw RunTimeException(‘There is no method with the given name to call’);
}

the “reverse wrapper” (object wraps the role rather than the role wrapping
the object), which also results in methods of a role being injected in a data object.
In each RolePlayer:
function addRole($roleName, Context $context) {
$this->_setCurrentContext($context);
$roleClassName = $this->currentContextClassName.’Roles’.$roleName;

if (!class_exists($roleClassName, false)) {
throw new InvalidArgumentException(“The role ‘$roleClassName’ is not defined
(it should be defined in the same *file* as the context to which it belongs).”);}

$role = new $roleClassName($this, $context);

$this->bindRoleMethods($role);
return $this;
}
function __call($methodName, $args) {
if (isset($this->roleMethods[$this->currentContextClassName][$methodName])) {
$role = $this->roleMethods[$this->currentContextClassName][$methodName];
}
if (!isset($role) || !method_exists($role, $methodName)) {
// error handling...
}
//Call $role->$methodName() with the given arguments
return call_user_func_array(array($role, $methodName), $args);
}

Mixins from Nooku Framework
• Nooku Framework started as a new framework for Joomla. It had mixins before we
had traits in PHP.
• Mixins are methods mixed into an object (not into a class, like traits):
$object->mixin($mixin);
• DCI roles can be implemented as mixins. I made a mixout() method to get rid of the
methods when leaving the context.
• it is “under the hood” a kind of reverse wrapper: every object has a mixin()-method
and when a method is called is is looked up in the list and then called on the mixin
where it is defined.
public function __call($method, $arguments)
{
if (isset($this->_mixed_methods[$method]))
{ //etc.
$result = call_user_func_array(array($mixin, $method), $arguments);
}
...

Nooku’s __call() also looks at closures and other mixed-in methods.
Here the part where the mixin is an object:
elseif(is_object($this->_mixed_methods[$method]))
{
$mixin = $this->_mixed_methods[$method];
//Switch the mixin’s attached mixer
$mixin->setMixer($this);
// Call_user_func_array is ~3 times slower than direct method calls. I say: not worth that ugly switch
switch (count($arguments))
{
case 0 :
$result = $mixin->$method();
break;
case 1 :
$result = $mixin->$method($arguments[0]);
break;
case 2 :
$result = $mixin->$method($arguments[0], $arguments[1]);
break;
case 3 :
$result = $mixin->$method($arguments[0], $arguments[1], $arguments[2]);
break;
default:
// Resort to using call_user_func_array for many segments
$result = call_user_func_array(array($mixin, $method), $arguments);
}

Work in progress... some thoughts:
“Data” don’t exist
• in Functional Programming
• and Event Sourcing
Data, state is
• a left fold
• a snapshot
• a result of a stream of events

• then what about
DATA? - Context - Interaction
• if we implement that with Event Sourcing
• we have events as a result of interacting roles
• a “context” instead of an “aggregate”
• roles played by a reconstituted stream of events

• can we learn from DCI for better
Domain Driven Design?
• behaviour related to use case / scenarios
• adding behaviour at runtime (roles)
• better names (context, role)
• algorithm more a whole, readability
• a model is not a tree...

Take away:
• separating behaviour from data
Behaviour
is better composable
than objects

Herman Peeren
August 2015
herman@yepr.nl

Dci in PHP

More Related Content

What's hot (20)

Similar to Dci in PHP (20)

More from Herman Peeren (20)

Recently uploaded (20)

Dci in PHP