This plugin allows for themes to be used with your symfony project. A theme is a very simple idea and consists of:

• a layout
• a collection of stylesheets
• a collection of javascripts

By defining several themes, you can:

• Have different themes on an action-by-action, module-by-module, or even route-by-route basis.

• Easily change the entire look of your site for promotional or seasonal reasons

• Switch between themes on the fly using the web debug toolbar

Using the plugin couldn't be easier and consists of two steps

• Create a theme or themes
• Set each theme globally or exactly where you need it

With git:

git submodule add git://github.com/weaverryan/sfThemePlugin.git plugins/sfThemePlugin
git submodule init
git submodule update

With subversion

svn propedit svn:externals plugins

// In the editor, add the following entry and then save
sfThemePlugin https://svn.github.com/weaverryan/sfThemePlugin.git

svn up

In your config/ProjectConfiguration.class.php file, make sure you have the plugin enabled.

$this->enablePlugins('sfThemePlugin');

Finally, run the publish:assets task which will create a symbolic link from the plugin into your web directory:

./symfony plugin:publish-assets

As mentioned, a theme consists of a layout, stylesheets, and javascript. To create a theme, simply define each of these in app.yml:

all:
  theme:
    themes:
      new_design:
        layout:       new_design
        stylesheets:  [main, print: { media: print }]
        javascripts:  []

The layout can exist in the templates directory of your application or in the templates directory of any plugin. This means that your entire theme can live inside a plugin and be repackaged for other projects.

A few other, optional, configuration variables exist for a theme. See the config/app.yml packaged with the plugin for full examples.

Once you've created a theme or themes, you'll want to instruct your application to use those themes. By default, the plugin won't start using themes until you tell it to. So, you can apply theming selectively without affecting the rest of your application.

Themes can be attached in many different ways:

Very commonly, you'll want to use one theme for your entire application. This basically replaces the use of view.yml to define the layout, stylesheets, and javascripts for your application. Defining a default theme is easy:

all:
  theme:
    controller_options:
      default_theme:   new_design

By doing this, the new_design theme will be used globally in your application.

The global default theme can easily be overridden in any action. For example, suppose that you still need to use the old_design theme for a particular action:

public function executeIndex(sfWebRequest $request)
{
  // ...
  
  $this->loadTheme('old_design');
}

This method is the "strongest" method of setting a theme and will override all other methods.

Alternatively, themes can be set on a module-by-module basis. Once again, this will override the global default theme. For example, suppose the module old_module should use the theme old_design:

all:
  theme:
    controller_options:
      modules:
        old_module:    old_design

You can even set a theme for a paricular route. This means that you could have the same content served by two different urls, each rendering their own theme! For example, suppose that you create a route called homepage_old, and you want it to use the old_design theme:

all:
  theme:
    controller_options:
      routes:
        homepage_old:    old_design

By default (this can be turned off), you can switch to any available theme by appending ?sf_theme=theme_name to the end of any url.

This will set a user attribute so that you can browse your entire site with this theme. To clar the user attribute, simply append ?sf_theme=clear to the end of your url.

If you need to be more specific in your theming, you can easily do this by connecting to the theme.set_theme_from_request event. For example, suppose you want to use a different theme for users with the fr culture. In your application configuration file (apps/app_name/config/app_nameConfiguration.class.php):

public function configure()
{
  $this->dispatcher->connect(
    'theme.set_theme_from_request',
    array($this, 'listenSetThemeFromRequest')
  );
}

public function listenSetThemeFromRequest(sfEvent $event)
{
  $context = $event['context'];
  
  if ($context->getUser()->getCulture() == 'fr')
  {
    $event->setReturnValue('fr_theme');
    
    return true;
  }
  
  return false;
}

This plugin comes with a web debug panel that allows you to see your themes and switch between them:

The app.yml file packaged with the plugin shows several other configuration options for the plugin. These are documented in the app.yml file itself and won't normally need to be modified.

In your functional tests, you can easily test so a particular module has the correct theme. First, notify your sfTestFunctional instance of the theme tester:

$browser = new sfTestFunctional(new sfBrowser());
$browser->setTester('theme', 'sfTesterTheme');

To use it, simply do the following:

$browser->get('/some/url')

->with('theme')->begin()
  ->isCurrentTheme('wordpress_default')
->end();

This plugin was taken from sympal CMF and was developed by both Jon Wage and Ryan Weaver.

If you have questions, comments or anything else, email me at ryan [at] thatsquality.com