Code smells in PHP

Code smells in PHP

Dagfinn Reiersøl, ABC Startsiden 1

Who am I?

• Dagfinn Reiersøl
– dagfinn@reiersol.com
– Twitter: @dagfinnr
– Blog: agilephp.com
• Mostly PHP since 1999
• Wrote PHP in Action
• Code quality / agile development enthusiast


What is a code smell?

Train your nose to tell you...
– ...when to refactor
– ...what to refactor
– ...how to refactor


It's more like a diagnosis

• A disease has a treatment, a code smell has a refactoring
• (or several)
• Code smell distinctons are important
• For each smell, there is one or more refactorings
• http://industriallogic.com/papers/smellstorefactorings.pdf


What is refactoring?

• “Improving the design of existing code”
• Maintain behavior
• Change the structure
• Make it more readable, eliminate duplication
• Proceed by small steps
• Keep code working always


The “bible” of refactoring

• “Martin Fowler...is not Jesus
Christ, and his books are not
the Bible.”
• Except this one really is the
bible.
• Java examples, but mostly
PHP-relevant


Refactoring is a specific,
learnable skill
• Learn to apply specific, named refactorings.
• Refactorings have specific instructions
• Learn to go in baby steps
• Test between each step
• Undo if you get lost
• Weird intermediate results are OK


Refactoring in PHP

• Very little tool support
• This is both a bad thing and a good thing
• Extract Method is particularly crucial, but unsupported by tools


Why refactor?

• Make code easier to read (saves time)
• Make it easier to find bugs
• Learn design principles
• Discover new abstractions
• Clean, maintainable code


How much is enough?

• Make it as clean as you possibly can, if circumstances allow
• Boy Scout Rule
• When you change code, you're likely to change it again soon
• Better code needs less refactoring
• Better code is easier to refactor


Why duplication is so bad

• Harder to maintain
• Harder to debug
• Incomplete bug fixes
Original code Original code

First copy Debug First copy

Second copy Second copy


Automated test coverage is
essential
• Unit tests primarily
• Tests make it easy to fix when you break something
• Acceptance tests helpful sometimes
• Manual testing only in special, desperate circumstances
• Legacy code paradox


Another bible: Clean Code

• Lots of smells and
heuristics


Don't take examples personally

• I'm using somewhat real open-source examples
• No personal criticism implied
• Refactoring examples must be somewhere in the middle (not
awful, not perfect)
• Awful is too hard to refactor (=advanced material)
• Perfect doesn't exist
• Just pretend I wrote all of it ;-)


Duplicated Code
// even if we are interacting between a table defined in a
// class and a/ table via extension, ensure to persist the
// definition
if (($tableDefinition = $this->_table->getDefinition()) !== null
&& ($dependentTable->getDefinition() == null)) {
$dependentTable->setOptions(
array(Table::DEFINITION => $tableDefinition));
}
...
// even if we are interacting between a table defined in a
// class and a/ table via extension, ensure to persist the
// definition
Dagfinn Reiersøl, ABC Startsiden= $this->_table->getDefinition()) !== 15
if (($tableDefinition null

Long Method

• Long methods are evil
• Hard to read (time-consuming)
• Hard to test
• Tend to have duplicate logic
• Hard to override specific behaviors


How long?

• “The first rule of functions is that they should be small”
• “The second rule of functions is that they should be smaller than
that”. - Robert C. Martin, Clean Code
• My experience: the cleanest code has mostly 2-5 line methods
• But don't do it if it doesn't make sense
• Do One Thing
• One level of abstraction only


Refactoring a Long Method

• Split method into smaller methods
• Extract Method is the most important refactoring
// Execute cascading updates against dependent tables.
// Do this only if primary key value(s) were changed.
if (count($pkDiffData) > 0) {
$depTables = $this->_getTable()->getDependentTables();
if (!empty($depTables)) {
$pkNew = $this->_getPrimaryKey(true);
$pkOld = $this->_getPrimaryKey(false);
foreach ($depTables as $tableClass) {
$t = $this->_getTableFromString($tableClass);
$t->_cascadeUpdate($this->getTableClass(),
$pkOld, $pkNew);
}
}


Extract Method: mechanics

1.Copy the code into a new method
2.Find all temporary variables
3.Return all of them from the method
In PHP, unlike Java, we can return multiple variabless

4.Find the ones that are initialized in the method
5.Pass all of those into the method
6.The result is ugly, but a step forward


Extract Method: result

private function executeCascadingUpdates($pkDiffData) {
if (count($pkDiffData) > 0) {
$depTables = $this->_getTable()->getDependentTables();
if (!empty($depTables)) {
$pkNew = $this->_getPrimaryKey(true);
$pkOld = $this->_getPrimaryKey(false);
foreach ($depTables as $tableClass) {
$t = $this->_getTableFromString($tableClass);
$t->_cascadeUpdate(
$this->getTableClass(), $pkOld, $pkNew);
}
}
}
return array($pkDiffData,$tableClass,
$depTables,$pkNew,$pkOld,$t);
}


Validation Overcrowding
function setTable(Table $table){
$tableClass = get_class($table);
if (! $table instanceof $this->_tableClass) {
require_once 'My_Exception.php';
throw new My_exception("blah blah");
}
$this->_table = $table;
$this->_tableClass = $tableClass;
$info = $this->_table->info();
if ($info['cols'] != array_keys($this->_data)) {
}
if (!array_intersect((array)$this->_primary, info['primary'])
== (array) $this->_primary) {
}
$this->_connected = true;


Extracting Validation

• Don't waste time reading validation code
• Extract validation (logging, error handling) into separate
method(s)
function setTable(Table $table) {
$this-validateTable($table);
$this->_table = $table;
$this->_tableClass = get_class($table);
$this->_connected = true;
}


Large Class

• As methods get smaller, there will be more of them
• Hard to keep track of all the methods
• Class has multiple responsibilities
• A class should have only one reason to change
• Duplication is likely


Refactoring a Large Class

• Primarily Extract Class
• Look for patterns in method names
function __construct($url = null, $useBrackets = true)...
function initialize()...
function getURL()...
function addQueryString($name, $value, $preencoded = false)...
function removeQueryString($name)...
function addRawQueryString($querystring)...
function getQueryString()...
function _parseRawQuerystring($querystring)...
function resolvePath($path)...
function getStandardPort($scheme)...
function setProtocol($protocol, $port = null)...
function setOption($optionName, $value)...
function getOption($optionName)...


Refactoring a Large Class

• Look for
– Patterns in method names (see previous)
– Subset of data and methods that go together
– Subset of data that change together
• Mechanics in short
– Create a new class
– Copy variables and methods into it
– Change methods one by one to delegate to the new class
• You must have automated tests


Primitive Obsession

“People new to objects usually are reluctant to use small objects
for small tasks, such as money classes that combine number
and currency, ranges with an upper and lower, and special
strings such as telphone numbers and ZIP codes.”

- Martin Fowler, Refactoring


Primitive obsession: non-OO
dates
• Will this work?
strftime($arrivaltime);

• Plain PHP date handling is ambiguous, obscure and error-prone
• Use objects instead
$datetime = new DateTime('2008-08-03 14:52:10');
echo $datetime->format('jS, F Y') . "n";


Primitive obsession example

• The primary key is an array (when?) or a scalar (when?)
• Are these names or values?
if (is_array($primaryKey)) {
$newPrimaryKey = $primaryKey;
} else {
$tempPrimaryKey = (array) $this->_primary;
$newPrimaryKey = array(
current($tempPrimaryKey) => $primaryKey);
}
return $newPrimaryKey;


Primitive obsession example

• Huh?
/**
* Were any of the changed columns part of the primary key?
*/
$pkDiffData = array_intersect_key(
$diffData, array_flip((array)$this->_primary));
}

• It's clever, obscure, therefore error-prone
• I think I prefer this:
foreach ((array)$this->_primary as $pkName) {
if (array_key_exists($pkName,$diffData))
$pkDiffData[$pkName] = $diffData[$pkName];
}


Primary key class
class PrimaryKey {
public function __construct($primitive) {
$this->primitive = $primitive;
}
public function isCompoundKey() {
return is_array($this->primitive);
}
public function getSequenceColumn() {
return array_shift($this->asArray());
}
public function asArray() {
return (array) $this->primitive;
}
public function filter($data) {
return array_intersect_key(
$data, array_flip($this->asArray()));
}
}


Benefits of the PrimaryKey class

• More expressive client code
• Details can be found in one place
• Less duplication
• Easier to add features
• Much easier to test


More expressive code and tests
• What this comment is telling us...
/**
* [The class] assumes that if you have a compound primary key
* and one of the columns in the key uses a sequence,
* it's the _first_ column in the compound key.
*/
• ...can be expressed as a test.
/** @test */
function shouldAssumeFirstColumnIsSequenceColumn() {
$primaryKey = new PrimaryKey('phone','name');
$this->assertEquals(
'phone',
$primaryKey->getSequenceColumn()
);
}

Consider a small class when...

• ...two or more data values occur together repeatedly (ranges,
etc)
• ...you keep testing the type of a data value
• ...you keep converting a data value
• ...you keep testing for null


More Primitive Obsession

Error-prone:
$info = $table->info();
$this->_primary = (array) $info['primary'];

Verbose:
$info = $table->info();
$this->_primary = (array) $info[SomeClassName::PRIMARY];

Better:
$this->_primary = $table->getPrimaryKey();


Don't return null

Alternatives:
• Throw an exception
• Return an empty array
• Return a Null Object (Special Case)


Nested ifs and loops

• Hard to read
• Even harder to test
if (isset($this->session)) {
//...
if (isset($this->session['registered'])
&& isset($this->session['username'])
&& $this->session['registered'] == true
&& $this->session['username'] != '') {
//...
if ($this->advancedsecurity) {
$this->log(
'Advanced Security Mode Enabled.',AUTH_LOG_DEBUG);
//...


How to deal with nesting

• Start with the deepest level, extract methods
• How much code to extract?
– Whole expression (foreach (...) {...})
– Code inside expression
– Part of code inside expression
• Adding tests (if none exist)
– Write tests first, then extract?
– Or do careful extraction, then add tests?
• Replace Nested Conditional with Guard Clauses


Conditionals in general

• Often smelly
• Learn how to avoid or simplify them
• http://www.antiifcampaign.com
• Replace Conditional with Polymorphism
• Decompose Conditional
// handle single space character
if(($nb==1) AND preg_match("/[s]/u", $s))

if($this->isSingleSpaceCharacter($s))


Feature envy / Inappropriate
Intimacy
• Does the row object need to poke inside the table objects,
checking for null?
• No, it's an implementation detail of the Table class
• It's accessed as if it were public, breaking encapsulation
abstract class Row...

if (($tableDefinition = $this->_table->getDefinition())
!== null
&& ($dependentTable->getDefinition() == null))
{
$dependentTable->setOptions(
Dagfinn Reiersøl, ABC Startsiden
array(Table::DEFINITION 39

Move everything into the
“envied” class?
This simple?
$dependentTable->copyDefinitionFrom($this->_table);

Misleading method name. How about this?
$dependentTable->copyDefinitionIfNeededFrom($this->_table);

Ugh. Let's Separate Query from Modifier
if (!$dependentTable->hasDefinition()) //query

$dependentTable->copyDefinitionFrom($this->_table);


Redundant Comment

/**
* If the _cleanData array is empty,
* this is an INSERT of a new row.
* Otherwise it is an UPDATE.
*/
if (empty($this->_cleanData)) {
return $this->_doInsert();
} else {
return $this->_doUpdate();
}


(Partly) obsolete comment

The comment has (apparently) not been updated to include all
options

* Supported params for $config are:-
* - table...
* - data...
* @param...

public function __construct(array $config = array())...
{
if (isset($config['table'])...
if (isset($config['data']))...
if (isset($config['stored'])...

Functions should descend only one
level of abstraction

• _cleanData is at a lower level of abstraction than _doInsert()
and _doUpdate()
• This is hard, but important
if (empty($this->_cleanData)) {
} else {
}

if ($this->isNewObject()) {
} else {
}

Long Parameter List

• Hard-to-read method calls, especially with nulls and booleans
• Uncle Bob: More than three arguments “require special
justification”
• Easy to mix up arguments, causing bugs
• Hard to test all variations
$nextContent = $phpcsFile->findNext(
array(T_WHITESPACE, T_COMMENT),
($closeBrace + 1), null, true
);


One way to shrink the argument
list
• Remove unused arguments
public function quoteInto($text, $value,
$type = null, $count = null)


Replace optional / boolean
arguments with methods
Boolean argument
protected function _getPrimaryKey($useDirty = true)

Split into separate methods instead
protected function _getPrimaryKeyDirty()
protected function _getPrimaryKeyClean()

Or even objects
$this->dirtyData->getPrimaryKey();
$this->cleanData->getPrimaryKey();


Introduce Parameter Object

• Encapsulate two or more arguments in a class
• Try to make it more meaningful than “options”
public function log($id, $username, $command = 'unknown',
$action,$e)

public function log(LogEvent $event)...


Code smells in PHP

Recommandé

Recommandé

Contenu connexe

Tendances

Tendances (20)

En vedette

En vedette (15)

Similaire à Code smells in PHP

Similaire à Code smells in PHP (20)

Dernier

Dernier (20)

Code smells in PHP