AdamTBradley.com

Populating template variables in Play Framework applications

Mon, 03 Jan 2011 08:15 -0500

I’ve just finished my first, supersimple project using Play Framework and Google App Engine, and I’ve been looking over my work to figure out what I’ve learned might come in handy in my next project or to other programmers.

The template for the new site, a simple code-snippet blog, is similar to the one for this blog, complete with the “fat footer” including feeds from multiple sources. Since the code to populate the variables that provide this data to the template has to run before every page load for almost every controller, it makes sense to put it into a single location that can be run automatically. The @With and @Before annotations provide this functionality.

First, we define a controller that contains the setup code. The @Before annotation tells Play! to run the function it’s applied to before any action in this controller. (There are also @After and @Finally “interceptions”.)


public class Template_Setup extends Controller {
    @Before
    public static void Footer_Setup() {
        ...
        renderArgs.put("somedata", somedata);
    }
}

Second, we use the @With annotation on each controller that needs our setup. This effectively allows the class to extend more than one parent class (If you’ve ever used Play’s built-in Secure module, you’re already familiar with @With).


@With(Template_Setup.class)
public class SomeController extends Controller {
...

With that done, any time an action in our SomeController controller is called, the Template_Setup.Footer_Setup() function will be run first, ensuring that our templates receive the data needed to generate the page.

Yahoo Query Language: The HTML Table

Fri, 12 Nov 2010 07:46 -0500

I recently applied for a new job at the Brown University Library–successfully, as it turned out. As part of the application/interview, I lost a week’s worth of sleep completing a presentation assignment regarding the Library’s Named Collections website. My response to this assignment was a website that combined the content from this site with other sources of information on campus, including the Library’s blog and Brown’s overall web presence.

One of the main tools I used in building this was Yahoo Query Language, in particular the “html” table. YQL, accodring to Yahoo, “is an expressive SQL-like language that lets you query, filter, and join data across Web services.” The simplest way to use it is to go to the YQL Console, enter a query, and copy the provided REST query link into the code where you’ll be using this data.

YQL’s html table allows you to query a specific web page, and optionally apply an XPath query, and returns the result as well-formed XML or JSON. For example, the query select * from html where url="http://library.brown.edu/collatoz/" will return a version of our page (by default, we get only the <body> element and its descendants) ready for just about any processor we want to use.

But pulling the entire body from the page gives us a lot of boilerplate information (header and footer info, sitewide navigation, etc.) that we’re not interested in here. So let’s add an XPath query to give us just collection titles and links: select * from html where url="http://library.brown.edu/collatoz/"; and xpath="//li[@class='bodytext']/a[@class='main']". We can expand this query, though, to give us more of what we want from the page. This XPath query will give us the collection links, in addition to the list of “subject groups” (from the list on the right side of the original page) and the in-page navigation links–which gives us a list of all letters that start the name of at least one collection: //li[@class='bodytext']/a[@class='main']|//a[starts-with(@href, 'cluster.php')]|//span[@class='bodytextSmallBold']/a–this link will give you the XML version of this query’s results, ready to be parsed using SimpleXML, XSLT, or whatever (You can also get the results in JSON format.

For my project, I used XSLT to translate output from YQL and several other sources, including the RSS feed of the Library’s news blog, into XHTML with RDFa markup. I’m looking forward to finding other uses for Yahoo’s technology.

The New AdamTBradley.com

Mon, 08 Nov 2010 07:56 -0500

Welcome to the new version of adamtbradley.com. This is the first new project I started using Symphony CMS, but not the first I finished (that would be the new website for the Swearer Center for Public Service at Brown University).

I plan to use this blog as kind of a review site for new technologies/software products I’ve encountered in the course of my work and spare-time experimentation. In the forseeable future, that will probably include things like Symphony, Django and Python, PHP frameworks, the Play Framework, web services, and Google App Engine. (Historically, I’ve enjoyed creating new blogs much more than actually writing in them. I’ll be writing in this one and I Really Mean It This Time.)

Symphony is a major shift from Textpattern, the system I used for my last several websites and now my second-favorite CMS. Many of the major differences between Textpattern and Symphony are tracable to Symphony’s use of XSLT as a template language: Since Symphony can natively process any XML, it can act as a simple REST web service client. This means that Symphony can do many things on its own that require a plug-in in Textpattern–the five feeds pulled into my footer, for example, are all handled without a single extension; in Textpattern I would have needed five plugins to populate these (bit_rss for the RSS feed from LibraryThing, my own atb_twitter for the Twitter feed, and a few plugins that may or may not already exist to load, cache, and parse the XML from GitHub, Flickr, and Delicious).

The other major feature Symphony has that Textpattern lacks is its support for custom content types, or “Sections” in Symphony parlance. Textpattern’s equivalents of Symphony’s sections would be articles, links, images, files, and comments; in Symphony, these are user-created collections of fields. For example, my Comment section has six fields: Text Inputs for Author, Email and Website (the Email field is a special type created by an extension–it generates an MD5 hash so I can pull Gravatars, a date field, a Textarea for the actual comment body, and a “Select Box Link” (effectively a specialized foreign key field) providing a link to the comment’s article.

Overall, I’m impressed enough with Symphony that it’s likely to become my default choice for setting up new websites in a LAMP environment–it’s adaptable, and once you’re used to it, easy enough to use. The documentation isn’t as complete as I’d like, and much of what I’ve learned about writing extensions for it has been gleaned from reading the source code, both of Symphony’s core, and of other people’s extensions, but the forums are still a very helpful resource (This is essentially where Textpattern was four or five years ago, when I started using it).

Connecting Twitter (or StatusNet) to iChat (or Adium) with Python

Sun, 27 Jun 2010 11:59 -0500

This is just a simple Python script I wrote to update my IM status with the IM programs on my Mac. (On my Windows and Linux machines, there’s a Pidgin plugin that takes care of this for me.)

The best way to run this is from cron something like this in your crontab to poll Twitter and update Adium/iChat every 15 minutes:

0,15,30,45 * * * * python /Scripts/twit.py

And here is the thoroughly-commented script itself:

# Put your Twitter screen name here.
twit = 'daydreamlab'

from appscript import *
from xml.dom.minidom import parse
from urllib2 import urlopen

#Grab the XML feed from the Twitter API.
tweetXML = urlopen('http://twitter.com/statuses/user_timeline/'+twit+'.xml?count=1')

# If you use identi.ca, use this instead:
#tweetXML = urlopen('http://identi.ca/api/statuses/user_timeline/'+twit+'.xml?count=1')

#Grab the text of the newest entry.
newestTweet = parse(tweetXML).getElementsByTagName('text').item(0).firstChild.data

#Tell iChat to update its status message. (Comment this line out if you don't use iChat.)
app('iChat').status_message.set(newestTweet)

#Tell Adium to update its status message for each account. 
#(Uncomment these lines if you use Adium.)
#for account in app('Adium').account.get():
#        account.status_message.set(newestTweet)

XSLT: Formatting nested groups of items

Fri, 17 Apr 2009 09:01 -0500

I’m in the process of builidng my first site using the Symphony CMS.

Symphony uses XSLT as its template language. In theory, this should make it more flexible than core Textpattern, with its limited number of built-in tags (Although the huge number of plugins available for Textpattern definitely means Txp is still capable of holding its own). That is, if I actually knew XSLT well enough to write a single template without turning to The Google dozens of times for answers to newbie questions.

For the site in question, I need to display a list of categories as a set of song lyrics, divided into verses of four lines each. In this first version, I’d decided I wanted the song divided into columns of four verses each. I’ve changed my mind on this design decision, but rather than let the ~~headache~~ experience go to waste, I’ve decided the code might interest other, still-newer-than-me newbies. It demonstrates how to build nested lists in XSLT, which is much less intuitive than in a procedural language like PHP (or Textpattern Tags with a plugin like zem_nth).

Your first impulse, if you’re used to PHP, is to do something like this to group blocks of items together:


<p>
<xsl:template match="data/posts">
        <xsl:if test="position() mod 4 = 1"></p><p></xsl:if>
        <xsl:apply-templates />
</xsl:template>
</p>

That so doesn’t work.

The problem is, it’s not valid XML—the parser will see an xsl:if tag matched with a closing p tag and scold you (Symphony won’t even let you save a template with this markup in it—it fails the first test the CMS subjects it to).

To handle nested groups, you have to do something like this (I’m using the Blueprint CSS framework, thus the divs with class "span-8"):


<xsl:template match="/data/categorylist">
        <!-- For every sixteenth item in the list: -->
        <xsl:for-each select="entry[position() mod 16 = 1]">

 
         <!--Process this item and the next 16, putting them inside a div -->
                <div class="lyrics span-8">
                <xsl:for-each select=".|following-sibling::entry[position() &lt; 16]">
                        <!-- With every fourth item in this block of 16: -->
                        <xsl:if test="position() mod 4 = 1">
                        <!-- Wrap the current item and the next four in a p -->
                        <p>
                                <xsl:apply-templates select=".|following-sibling::entry[position() &lt; 4]"/>
                        </p>
                        </xsl:if>
                </xsl:for-each>
                </div>

 
 </xsl:for-each>
</xsl:template>

As the comments explain, you have to grab every nth item, then apply your templates to that item plus the following n-1, or, in XPath, .|following-sibling::entry[position() < 16] (’.’ means the current item in the list being processed; ‘|’ means “and”).

Date format conversion in XSLT

Sun, 18 Apr 2010 14:06 -0500

This is a utility I wrote for a new site I’m developing with Symphony
It’s useful for translating dates from RSS feeds into ISO date values usable by the EXSLT date functions.

Note that this relies on the EXSLT str:tokenize() function.


<?xml version="1.0" encoding="UTF-8"?>
<xsl:stylesheet version="1.0"
        xmlns:xsl="http://www.w3.org/1999/XSL/Transform"
        xmlns:str="http://exslt.org/strings">


<xsl:template name="rfc-to-iso">
<xsl:param name="input-date" />


<!-- Read parts of the date into variables, reading backwards from the end,
     so we don't have to worry about the optional weekday -->
<xsl:variable name="year" select="str:tokenize($input-date, ' ')[last()]" />
<xsl:variable name="tz" select="str:tokenize($input-date, ' ')[last()-1]" />
<xsl:variable name="time" select="str:tokenize($input-date, ' ')[last()-2]" />
<xsl:variable name="day" select="str:tokenize($input-date, ' ')[last()-3]" />
<xsl:variable name="month" select="str:tokenize($input-date, ' ')[last()-4]" />


<xsl:value-of select="$year" />-<xsl:choose>
<!-- Translate month into a two-digit number -->
<xsl:when test="$month = 'Jan'">01</xsl:when>
<xsl:when test="$month = 'Feb'">02</xsl:when>
<xsl:when test="$month = 'Mar'">03</xsl:when>
<xsl:when test="$month = 'Apr'">04</xsl:when>
<xsl:when test="$month = 'May'">05</xsl:when>
<xsl:when test="$month = 'Jun'">06</xsl:when>
<xsl:when test="$month = 'Jul'">07</xsl:when>
<xsl:when test="$month = 'Aug'">08</xsl:when>
<xsl:when test="$month = 'Sep'">09</xsl:when>
<xsl:when test="$month = 'Oct'">10</xsl:when>
<xsl:when test="$month = 'Nov'">11</xsl:when>
<xsl:when test="$month = 'Dec'">12</xsl:when>
</xsl:choose>-<xsl:value-of select="$day" />T<xsl:value-of select="$time" /><xsl:if test="$tz = '+0000'">Z</xsl:if><xsl:if test="$tz != '+0000'"><xsl:value-of select="$tz" /></xsl:if>


</xsl:template>


</xsl:stylesheet>

Parsing the Twitter API's XML with XSLT

Sat, 01 May 2010 00:00 -0500

This is just a simple Twitter XML to XHTML parser I wrote for a site I’m developing with Symphony CMS.
Note that it relies on the date format converter I posted earlier.

There’s likely a much more efficient way to do what I’m doing here, but as I’m relatively new to XSLT, I haven’t found it yet.

<?xml version=&quot;1.0&quot; encoding=&quot;UTF-8&quot;?>
<xsl:stylesheet version=&quot;1.0&quot;
    xmlns:xsl=&quot;http://www.w3.org/1999/XSL/Transform&quot;
    xmlns:str=&quot;http://exslt.org/strings&quot; 
    xmlns:date=&quot;http://exslt.org/dates-and-times&quot;
    extension-element-prefixes=&quot;str&quot;>

<xsl:import href=&quot;../utilities/rfc-to-iso-dates.xsl&quot; />

<xsl:template match=&quot;//statuses/status&quot;>
    <li class=&quot;tweet&quot;>
    <!--make date display prettier-->
    <xsl:variable name=&quot;now&quot; select=&quot;date:date-time()&quot; />

    <xsl:variable name=&quot;tweetdate&quot;>
        <xsl:call-template name=&quot;rfc-to-iso&quot;>
        <xsl:with-param name=&quot;input-date&quot; select=&quot;created_at&quot; />
        </xsl:call-template>
    </xsl:variable>

    <xsl:variable name=&quot;datediff&quot; select=&quot;date:difference($tweetdate, $now)&quot; />
    <xsl:variable name=&quot;secsdiff&quot; select=&quot;date:seconds($datediff)&quot; />

    <span class=&quot;date&quot;>
        <xsl:choose>
            <xsl:when test=&quot;$secsdiff < 60&quot;>
            <xsl:value-of select=&quot;$secsdiff&quot;/> seconds ago</xsl:when>

            <xsl:when test=&quot;$secsdiff < 3600&quot;>
            <xsl:value-of select=&quot;round($secsdiff div 60)&quot; /> minutes ago</xsl:when>

            <xsl:when test=&quot;$secsdiff < 86400&quot;>
            about <xsl:value-of select=&quot;round($secsdiff div 3600)&quot; /> hours ago</xsl:when>

            <xsl:otherwise>
            <xsl:value-of select=&quot;concat(date:day-in-month($tweetdate), '. ', date:month-name($tweetdate))&quot; /></xsl:otherwise>
        </xsl:choose>:
    </span>

    <xsl:text> </xsl:text>

    <!-- Is this a reply? Add an &quot;(in reply to whoever)&quot; link. -->
    <xsl:if test=&quot;in_reply_to_status_id != ''&quot;>
        <a class=&quot;responselink&quot; href=&quot;http://twitter.com/{in_reply_to_screen_name}/status/{in_reply_to_status_id}&quot;>(in reply to <xsl:value-of select=&quot;in_reply_to_screen_name&quot; />)</a>
        <xsl:text> </xsl:text>
    </xsl:if>

    <!-- Parse the text word-by-word -->
    <xsl:for-each select=&quot;str:tokenize(normalize-space(text), ' ')&quot;>

        <xsl:choose>

        <!-- @reference. Make this a link to the referenced user's Twitter page. -->
        <xsl:when test=&quot;starts-with(., '@')&quot;>
            <a>
                <xsl:attribute name=&quot;href&quot;>
                <xsl:value-of select=&quot;concat('http://twitter.com/', substring(.,2))&quot; />
                </xsl:attribute>
                <xsl:value-of select=&quot;.&quot; />
            </a> 
        </xsl:when>

        <!-- Hashtag. Link to a Twitter search for this tag. -->
        <xsl:when test=&quot;starts-with(., '#')&quot;>
            <a>
                <xsl:attribute name=&quot;href&quot;><xsl:value-of select=&quot;concat('http://search.twitter.com/search?result_type=recent&q=%23', substring(., 2))&quot; />
                </xsl:attribute>
                <xsl:value-of select=&quot;.&quot; />
            </a> 
        </xsl:when>

        <!-- Web URL. Turn it into a link. -->
        <xsl:when test=&quot;starts-with(., 'http:')&quot;>
            <a href=&quot;{.}&quot;><xsl:value-of select=&quot;.&quot; /></a> 
        </xsl:when>

        <!-- Just a word. -->
        <xsl:otherwise>
            <xsl:value-of select=&quot;.&quot; /> 
        </xsl:otherwise>

        </xsl:choose>

        <xsl:text> </xsl:text>

    </xsl:for-each>

    </li>

</xsl:template>

</xsl:stylesheet>

Mixing GET variables and segment-based addressing in CodeIgniter

Thu, 19 Feb 2009 00:00 -0500

“Since CodeIgniter does not utilize GET strings, there is no reason to allow” GET variables, the CodeIgniter User Guide informs us.

Unfortunately, occasionally there is a reason to use those variables—in my case, an in-house authentication program interfered with POST requests made by Javascripts—and it’s not entirely obvious how to make them available in your CodeIgniter app. The Guide seems to suggest enabling query strings, but while that gives you access to the $_GET array, it also cripples your existing URLs—using “query strings” essentially means choosing controllers and methods to execute using GET variables exclusively, what I usually see called “messy URLs.”

The solution is (relatively) simple, but not immediately obvious. I found the solution in this forum post (hopefully it’ll be more visible here). Add these settings to your applications config.php:

$config['uri_protocol'] = &quot;PATH_INFO&quot;; 
$config['enable_query_strings'] = TRUE;
$config['permitted_uri_chars'] = 'a-z 0-9~%.:_-?=+&;';

This should give you an app that uses URI segments to map requests to controllers, but can also pull an occasional argument out of the $_GET superglobal, using the more-or-less generic, universal .htaccess settings I “borrowed” from Textpattern:

<IfModule mod_rewrite.c>
    RewriteEngine On
    RewriteCond %{REQUEST_FILENAME} !-f
    RewriteCond %{REQUEST_FILENAME} !-d
    RewriteRule ^(.*)$ index.php/$1 [L]
</IfModule>