Airfrost

I would like to take a few moments to talk about the very awesome and very powerful backend to airfrost v2, an unfortunately very little-known CMS called Symphony.

First, an introduction

Symphony markets itself as a CMS, but like Rails is more of a framework built on top of Ruby than, let’s say, a web app (bear with me here), I see Symphony as more of a framework built on top of XML/XSLT than a CMS. Rails has its Models/Views/Controllers structure, and Symphony has its Section/Datasource/Page/Utility structure. With both Symphony and Rails, first starting out may be tough and confusing. But once you do get the hang of them, it’s like you’re sitting on a giant maniacal robot bent on taking over the world with as little repetitive work and as much control on your part as possible. (Which, I assure you, is a great feeling.)

The aim of this introduction is to stick you on top of that robot.

---

Because Symphony evolves around XSLT (eXtended Stylesheet Language Transformation), a web standard encouraged by the W3C for “transforming” XML documents into nicer looking things, you have pretty much unlimited power as to what you are able to do. Everything you see in airfrost v2—from the archives to the categories page—were coded by hand, and made possible with XSLT. With XSLT and Symphony, you not only able to add in the behavioral aspects of the site yourselves, you’re expected to do it (a “roll your own site” kinda thing).

A “theme” in Symphony is basically the entire site, with all the pages and styles intact. All that’s missing from the picture is database settings and entries (and all the other server-specific nitty-gritty). So unlike wordpress, if I send you the workspace folder (equivalent of a theme in Symphony), I am basically sending you airfrost, but sans articles. Neat, eh?

The basics of XSLT and Symphony

To understand how to make a site with Symphony, you have to first understand the basics of XSLT—which isn’t hard if you’re already familiar with scripting fundamentals (for-each loops and if statements and all that). XSLT “styles” information just as CSS styles HTML.

(Note to mac users: you can follow along with the examples below using a XSLT editing application such as TestXSLT.)

A frequently used example to explain XSLT is this: say you have a file called library.xml. In it, get this, is books in a library somewhere. You’ve also added to it (for your own reference) whether or not you’ve read the book. Imagine that it looks something like this:

<?xml version="1.0" encoding="UTF-8" ?>
<library>
    <book>
        <name>The Hitchhiker's Guide to the Galaxy</name>
        <read>true</read>
    </book>
    <book>
        <name>Sherlock Holmes</name>
        <read>false</read>
    </book>
</library>

A stroll in the park for those who are even just semi-familiar with HTML, right? Well, Symphony’s Datasources are used for making nice XML snippets just like that—the Datasource editor built into Symphony allows you to take the raw data from your Sections and turn them into XML snippets just like that one. You can then attach the XML from the Datasource to either an Utility (more about those soon) or a page. Sections in Symphony are basically mini-blogs that store entries—airfrost has three sections: the journal, the tumblelog, and the folio. You can then “transform” the XML data with XSLT, which would look something like this:

<?xml version="1.0" encoding="UTF-8" ?>
<xsl:stylesheet version='1.0' xmlns:xsl='http://www.w3.org/1999/XSL/Transform'>
    <xsl:output method="xml"
        doctype-public="-//W3C//DTD XHTML 1.0 Strict//EN"
        doctype-system="http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd"
        omit-xml-declaration="no"
        encoding="UTF-8"
        indent="yes" />

    <xsl:template match="/library">
        <h3>Library</h3>
        <p>The books in the library are:</p>
        <ul> <!— as you can see, XHTML elements can go straight in with the XSLT —>
            <xsl:for-each select="book"> <!— goes through all the <book>'s in the <library> —>
                <li><p>
                    <strong><xsl:value-of select="name" /></strong>, which 
                    <xsl:choose> <!— an if() statement —>
                        <xsl:when test="read = 'true'">
                            you've read.
                        </xsl:when>
                        <xsl:otherwise>
                            you haven't read yet.
                        </xsl:otherwise>
                    </xsl:choose>
                </p></li>
            </xsl:for-each>
        </ul>
    </xsl:template>
</xsl:stylesheet>

All that wonderful XML and XSLT up there would result in something like this:

Library

The books in the library are:

• The Hitchhiker’s Guide to the Galaxy, which you’ve read.
• Sherlock Holmes, which you haven’t read yet.

So now you know the purpose of XSLT. Nifty, huh? An actual Symphony site would have a lot of similar XSLT snippets for transforming XML snippets, which would probably be used on multiple pages on your site—for example, the “Journal Entry” utility here at airfrost is used both on the home page and on the entry pages—such as this one. For that reason, Symphony has another trick up its sleeve called Utilities.

Utilities in Symphony are snippets of XSLT that can be attached to a Datasource or a page. Or both. Or multiple. Or multiple and both. Makes sense, right? Pages in Symphony are exactly what it sounds like—a page (if you’re having trouble grasping the concept, take a look at airfrost v2’s sitemap—all the links on there represent a Page on airfrost).

So there you have it—now that you’ve gotten introduced to Symphony and its concepts, go ahead and grab a copy for yourself! I wasn’t able to explain the full nitty-gritty of Symphony (and looking back, I seemed to somehow miss out completely on Masters), but if you’re interested in pursuing further into Symphony, you can certainly do so by reading the wiki, going through some of the awesome screencasts, or by reading the much more in-depth but slightly more advanced article, A Symphony Walkabout. And if you happen to run into any troubles, there even is an awesome community who will gladly help you out. Words simply can’t describe Symphony’s incredible user interface and its sheer flexibility, so please, please, go grab a copy for yourself and test it out! Now go forth and code!