Pagetypeitis

Antipatterns and Solutions 
for SilverStripe's page types

The good

Page types are great building blocks
Support OOP AND MVC architectures
Great for beginners

The Bad

Hard to SCALE FOR complex PROJECTS
Tend to influence other areas

Impacts

Leaks into UI
Too many types, unclear purpose

Leaks into architecture
Template variations drive page types

Harder to mix'n'match interface components

Antipattern: The God Page Object


* actual Page.php 

Antipattern: Page God Objects

Shared functionality on lowest common class
Often includes template helpers
Not much better than globals

Antipattern: Deep Inheritance

Over-specialization
Often necessitated by monolithic module design

Antipattern: Deep Inheritance

class ArticleHolder extends BlogHolder {
	private static $has_one = array('Author' => 'Member');
}
class TaggedArticleHolder extends ArticleHolder {
	private static $many_many = array('Tags' => 'Tag');
}

Antipattern: Monolithic Structure

Extend class just to add one feature
Prevents composition from different classes
Particularly bad for modules

Antipattern: Monolithic Structure

// in a module
class BlogEntry extends Page {
	public function getTagCloud() {
		// lots of useful code here
	}
}

// in your project code
class ArticlePage extends BlogEntry {
	public function getTagCloudSorted() {
		return $this->getTagCloud()->sort('Name');
	}
}

Solutions

Solution: Template Includes

Reuse across page types
Document context expectations

Composition over Inheritance

Single purpose objects
Encourages horizontal code reuse
Improves testability (no controller mocking)

Composition Over Inheritance

class Tag extends DataObject {
	private static $db = array('Label' => 'Varchar');
}

class Page extends SiteTree {
	private static $many_many = array(
		'Tags' => 'Tag'
	);
}

class Page_Controller extends ContentController {
	public function TagCloud() {
		return new TagCloud(Page::get()->relation('Tags'));
	}
}

Composition Over Inheritance

class TagCloud extends ViewableData {
    
    protected $tags;
	
	public function __construct($tags) {
		$this->tags = $tags;
	}

	public function TagsByCount() {
		$results = new ArrayList();
		$namesToCount = $this->tags->dataQuery()->query()
			->setGroupBy('Name')
			->setSelect('Name', 'COUNT(*)')
			->setOrderBy('COUNT(*) DESC')
			->execute()
			->map();
		
		foreach($namesToCount as $name => $count) {
			$results->push(new ArrayData(array(
				'Name' => $name,
				'Frequency' => $freq
			)));
		}

		return $results;
	}

}

Solution: Extensions

Reuse across classes
Add model schemas, properties and methods
Limitation: No method or property overrides
Relies on extension points (canEdit, updateCMSFields, ...)
PHP 5.4 has "traits" with similar features

Solution: Extensions

class Taggable extends DataExtension {
	private static $many_many = array('Tags' => 'Tags');
}

// In mysite/_config.yml
BlogEntry:
  extensions:
    - Taggable

Solution: Polymorphic Base Classes

Interface and behaviour variations
Based on model data, context or config 
Keeps inheritance "flat"

Solution: Polymorphic Base Classes

class ArticlePage extends Page {
	
	private static $db = array(
    		'Type' => 'Enum("News Entry,Blog Entry")'	);
	
	public function getCMSFields() {
		$fields = parent::getCMSFields();
		if($this->Type == 'Blog Entry') {
			$fields->addFieldToTab(
                'Root.Main', 
                new TagField()
            );
		}
		return $fields;
	}
}

Solution: View Helpers

General purpose commands without controller context
Package as reuseable, independent functionality
Auto-detected through PHP interface usage
But: Not really OOP, use sparingly

Solution: View Helpers

class InflectionViewHelper implements TemplateGlobalProvider {
	
	public function Pluralize($str) {
		return Inflector::pluralize($str);
	}
	
	public static function get_template_global_variables() {
		return array('Pluralize')
	}
}

Title

Made with Slides.com