Framework on Framework - FOFRapid application development for the Joomla! CMS

So, what’s that “FOF” thing?

Yeah, I know what you’re thinking“Oh, dear Lord, not ANOTHER framework!”

FOF uses the Joomla! PlatformIt does not completely replace it

Plays along with the other boysCompatible with Joomla! 2.5, 3.0 and 3.1.

D.R.Y. - Don’t Repeat YourselfI hate copying/pasting the same code over and over and over and over and over and over and over...

Less is moreConvention over configuration – less time, effort, code and bugs

Flexible, without imposing it’s way of thinkingThere are no black boxes. There are methods, plugin events...

Backwards compatibilityThere are no quantum, undocumented changes overnight

Some historyHow we got here

July 2009 – Base MVC classesMy own classes, extending from JModel & co, minimising copied & pasted code

September 2011 – Turning into a proper frameworkBasically, I wanted a RAD framework which doesn’t change every day

October 2011 – Implemented HMVCwhile I was stuck on a plane, on the ground, for four hours

May 2012 – First public releaseduring the J and Beyond 2012 conference

June 2012 – Bootstrap & jQueryIn the optional Akeeba Strapper package

February 2013 – version 2.0 did NOT go into Joomla! 3.1which is basically something good

March 2013 onwards – Taking off with XML view templatesmaking it a really Rapid Application Development framework

FOF’s Anatomy

Some general thoughts

Web services. Integrated JSON support and transparent authentication, opening the door for data provisioning to apps (web, desktop, mobile,...)

Almost RESTful, not entirely

HMVC components right here, right now, without having to relearn Joomla! component development, i.e. the exact opposite of the proposed Joomla! Framework, whenever that ’s ready.

Structure

Dispatcher

Controller

Model View

ToolbarHelpers

“triad”

Table

The Dispatcher is the entry point (a.k.a. “router”). It will setup, run and render the MVC triad.

The Controller is a thin interface to push data to the model state and instantiate views

The Model is the workhorse. Business logic goes here.The Table class is a hybrid data adapter, controller and

model (following J!'s convention)

The View fetches model state data and renders them in a meaningful way

The Toolbar handles the rendering of titles, buttons and so on

Non-OOP stuff. Basically, a nice way to say “cruft”

Convention over Configuration

Convention over configuration in the Dispatcher The Dispatcher is your component’s router. It routes the

request to the appropriate Controller based on conventions:

A POST request gets routed to the save task

A GET request to a plural view name gets routed to the browse task

A front-end GET request with an ID gets routed to the read task

A back-end GET request with an ID gets routed to the edit task

Convention over configuration in Models

Tables are named as #__component_view, e.g. #__todo_items

Auto increment field is named component_view_id, e.g. todo_item_id

Magic fields: enabled, created_by, created_on, modified_by, modified_on, locked_by, locked_on, hits

You can override defaults without copying & pasting code, ever. Copy & paste is the devil!

Convention over configuration in Controllers

Default tasks (not RESTful!): browse, read, edit, add, delete, save, apply, ...

Customize with onBeforeMethod and onAfterMethod methods, e.g. onBeforeSave. Don't copy & paste code.

All MVC objects can be passed a $config array to customize them. It "flows" from dispatcher to component to model and view.

FOF guesses the task if it's missing based on plural/singular view name and existence of ID in the query

Convention over configuration in Views

Views inherit from FOFView and its specialized children, e.g. FOFViewHtml

Customize using the onTask methods, e.g. onBrowse

The toolbar is handled outside the view, in a FOFToolbar descendant class. Override it with a toolbar.php file in the component's root.

Magic toolbar methods, e.g. onItemsBrowse allow you to customize the toolbar without copying & pasting code.

Epic features

HMVC – Hierarchical MVC

Include the results of component views anywhere (other views, other component, modules, ...)

FOFDispatcher::getTmpInstance(‘com_foobar’, ‘items’, array( ‘layout’ => ‘fancy’))->dispatch();

Reuse view templates

Load a view template from another view, component, ...

echo $this->loadAnyTemplate('site:com_foobar/item/form');

Media files overrides

Load media files like this:FOFTemplateUtils::addCSS('media://com_foobar/css/frontend.css');

Media overrides are inside the template folder, e.g.templates/tpl_example/media/com_foobar/css/frontend.css

Web services & automatic JSON and CSV views

Just add format=json or format=csv

JSON: You have an instant JSON-based remote API for your components

CSV: You can quickly export whatever you see in the backend to Excel, Numbers, LibreOffice, Google Docs, etc.

Transparent authentication support using URL parameters or HTTP Basic Authentication

XML-based views

It’s JForm on double dose of steroids

Browse, read and edit views from XML templates

You don’t need to write any PHP or HTML, but you can mix traditional PHP-based and XML-based templates, even in the same view

Overridable with Joomla! template overrides

You can write components with virtually no PHP code at all

Resources

http://github.com/akeeba/fof