/**
     * Sort an array of objects.
     *
     * You can pass in one or more properties on which to sort.  If a
     * string is supplied as the sole property, or if you specify a
     * property without a sort order then the sorting will be ascending.
     *
     * If the key of an array is an array, then it will sorted down to that
     * level of node.
     *
     * Example usages:
     *
     * osort($items, 'size');
     * osort($items, array('size', array('time' => SORT_DESC, 'user' => SORT_ASC));
     * osort($items, array('size', array('user', 'forname'))
     *
     * @param array $array
     * @param string|array $properties
     */
    public static function osort(&$array, $properties)
    {
        if (is_string($properties)) {
            $properties = array($properties => SORT_ASC);
        }
        uasort($array, function($a, $b) use ($properties) {
            foreach($properties as $k => $v) {
                if (is_int($k)) {
                    $k = $v;
                    $v = SORT_ASC;
                }
                $collapse = function($node, $props) {
                    if (is_array($props)) {
                        foreach ($props as $prop) {
                            $node = (!isset($node->$prop)) ? null : $node->$prop;
                        }
                        return $node;
                    } else {
                        return (!isset($node->$props)) ? null : $node->$props;
                    }
                };
                $aProp = $collapse($a, $k);
                $bProp = $collapse($b, $k);
                if ($aProp != $bProp) {
                    return ($v == SORT_ASC)
                        ? strnatcasecmp($aProp, $bProp)
                        : strnatcasecmp($bProp, $aProp);
                }
            }
            return 0;
        });
    }

Now a few cools things about the function:

1. It uses anonymous/lambda functions (or closures, whatever your prefer to call them), and that’s just plain fun
2. You can sort on more than one property and because the sorting is recursive, it’ll sort the second property within the confines of the first, the third within the confines of the second, and so on. Think sorting in SQL
3. You can sort in ascending or descending order for any of the properties
4. It retains key associations so you could use this on an associative array of objects
5. If the parameter you want to sort on is an array itself then you can use any value (by specifying it’s key) in that array as the sorting value

<?php echo $this->escape($this->var); ?>
<?= $this->escape($this->var); ?>

You could simply do:

<?=~ $this->var; ?>

That’s a lot simpler, isn’t it?

To do this, we need to do two things; 1) extend the stream class and 2) make sure we register it before Zend Framework registers Zend_View_Stream.

<?php

class My_Stream extends Zend_View_Stream
{
    /**
     * Opens the script file and converts markup.
     */
    public function stream_open($path, $mode, $options, &$opened_path)
    {
        // get the view script source
        $path        = str_replace('zend.view://', '', $path);
        $this->_data = file_get_contents($path);

        /**
         * If reading the file failed, update our local stat store
         * to reflect the real stat of the file, then return on failure
         */
        if ($this->_data === false) {
            $this->_stat = stat($path);
            return false;
        }

        /**
         * Convert <?= ?> to long-form <?php echo ?> and <? ?> to <?php ?>
         *
         */
        $this->_data = preg_replace(
            '/\<\?\=~ (.*?);? \?>/',
            '<?php echo $this->escape($1); ?>',
            $this->_data
        );
        $this->_data = preg_replace(
            '/\<\?\=/',
            '<?php echo ',
            $this->_data
        );
        $this->_data = preg_replace(
            '/<\?(?!xml|php)/s',
            '<?php ',
            $this->_data
        );

        /**
         * file_get_contents() won't update PHP's stat cache, so we grab a stat
         * of the file to prevent additional reads should the script be
         * requested again, which will make include() happy.
         */
        $this->_stat = stat($path);

        return true;
    }
}

The observant of you will notice that the above is almost exactly the same as Zend_View_Stream::stream_open(), but with this bit of code added to it:

        $this->_data = preg_replace(
            '/\<\?\=~ (.*?);? \?>/',
            '<?php echo $this->escape($1); ?>',
            $this->_data
        );

So if you don’t like using ~ to do the escape this is where you’d change it.

Now all you have to do is register your stream before Zend Framework does. You could do this in your bootstrap file, your application class, or whereever it makes sense for your applicaiton. Basically, you’d just be dropping in a line like this:

stream_register_wrapper('zend.view', 'My_Stream');

Hopefully that gives you some ideas on extending the stream wrapper even more!

Usually I’m a total wallflower at conferences, gravitating to only the people I know. This time round I’m trying to change that and speak to people, ask speakers questions, and all that.

Right now, though, I’m enjoying dinner.

The agony of choice, eh?

If you’ve never seen a QrCode before, it looks something like this:

Now how cool would it be to be able to generate that automatically for each page on your site and allow people to be able bookmark that site on their phone? Well, I think it’d be pretty cool! So I came up with a very simple ZF view helper to do it for me.

This is the view helper code:

<?php

/**
 * Output a QR code block.
 *
 * Currently, only via Google Chart API is supported, but it has
 * room to add other sources of qrcode generation.
 *
 * @category   Amnuts
 * @package    Amnuts_View
 * @subpackage Amnuts_View_Helper
 */
class Amnuts_View_Helper_QrCode extends Zend_View_Helper_Abstract
{
    protected $template = '
        <div class="qrcode">
            <p>Bookmark this page on your mobile</p>
            <img src="%s" alt="QR Code image" />
            <p class="hint"><a href="http://en.wikipedia.org/wiki/QR_Code">What is this?</a></p>
        </div>
        ';

    /**
     * Constructor.
     *
     * @return Amnuts_View_Helper_QrCode
     */
    public function qrCode($template = null)
    {
        if (null !== $template) {
            $this->template = $template;
        }
        return $this;
    }

    /**
     * Generate the QR code image via Google's Chart API.
     *
     * @param  array  $params
     * @return string
     */
    public function google($params = array())
    {
        $default = array(
            'text'       => $_SERVER['SCRIPT_URI'],
            'size'       => '100x100',
            'correction' => 'M',
            'margin'     => 0
        );
        $params = array_merge($default, $params);

        $params['text']   = urlencode($params['text']);
        $params['margin'] = (int)$params['margin'];
        if (!in_array($params['correction'], array('L', 'M', 'Q', 'H'))) {
            $params['correction'] = 'M';
        }
        if (!preg_match('/^\d+x\d+$/', $params['size'])) {
            $params['size'] = '100x100';
        }

        $url = "http://chart.apis.google.com/chart?cht=qr&chl={$params['text']}"
             . "&chld={$params['correction']}|{$params['margin']}"
             . "&chs={$params['size']}";
        return sprintf($this->template, $url);
    }
}

As it’s a view helper, it’s very simple to use within your view. Just do something like:

<?php echo $this->qrCode()->google(); ?>

If you want to change the default template for one instance, you can do that such as:

<?php echo $this->qrCode('<li><img src="%s" /></li>')->google(); ?>

And, of course, you can change the parameters that the QrCode uses, too. By default, if you don’t supply the ‘text’ parameter then it will use the script uri. But you could change that with something like:

<?php echo $this->qrCode()->google(array('text' => 'Visit my site at: http://blog.amnuts.com/')); ?>

There are other options as view helper code shows. But this should get you started on easily using QrCodes on your own site.

I have to say that to documentation seems quite lacking on the ZF site (for all the the Feed components, really, not just the Writer). Because of that, what follows may be idiotic and there really is an easy way. If so, I hope that you will post up a comment and let me know because I’d love to learn!

On with what I did…

My set up is actually to take an email sent to a particular address and add the contents to an RSS feed as-and-when the email arrives. So when the first email comes in the RSS feed file needs to be created. Using the Zend_Feed_Writer_Feed component, this is a really easy job. Once saved the XML looks well structured and everything is as expected. But then what happens when the next email comes in? Obviously I wouldn’t want to create a new feed file because it’d remove any previous entries. Also, I want to tweak the pubDate so that it reflects when this new email came in. I also wanted to use the Zend_Feed_Writer_Entry component so that the structure of the new item matches the previous ones.

The first thing to do was to load the RSS file and tweak the pubDate.

$now = new DateTime();
$now->setTimestamp(time());
$feed = new Zend_Feed_Rss(null, file_get_contents($feedFile));
$feed->pubDate = $now->format(DATE_RSS);

Then I created the entry:

$entry = new Zend_Feed_Writer_Entry();
$entry->setId($entryId);
$entry->setTitle($emailSubject);
$entry->addAuthor(array(
    'name'  => $emailFromName,
    'email' => $emailFormAddress
));
$entry->setDateCreated($emailDate->getTimestamp());
$entry->setContent($emailBody);

At this point it would be really nice to have some kind of Zend_Feed_Rss::addEntry(Zend_Feed_Writer_Entry|string of entry xml), or ::appendEntry()/::prependEntry(), but I was not able to see anything of the sort. So what I did was to create a DOMDocument with the feed file contents, render the entry and append it to the channel node.

$rss = new DOMDocument();
$rss->loadXML($feed->saveXML());
$rss->formatOutput = true;
$rss->substituteEntities = false;

$renderer = new Zend_Feed_Writer_Renderer_Entry_Rss($entry);
$renderer->setRootElement($rss->documentElement);
$renderer->render();
$element = $renderer->getElement();

$channel  = $rss->getElementsByTagName('channel')->item(0);
$imported = $rss->importNode($element, true);
$channel->appendChild($imported);

file_put_contents($feedFile, $rss->saveXML());

Now, that’s not a lot of code, but does it seem even remotely logical to do that when there’s already a fairly inclusive API for the feeds – perhaps just not inclusive enough?

Like I mentioned at the start, though; if you know a better way then please let me know – I’m always happy to learn!

Hopefully have a bit of a review posted up here some time soon!

So what are my options? I could train everyone who posts blogs on the system to use a url shortening service or I could manually tweak all the links myself. As solutions they are not very practical at all; I don’t have the time to change any/all links myself, and I certainly don’t have enough patience to train everyone! So an automatic way of doing things is needed, and the filtering in Zend Framework comes to the rescue!

Zend Framework has a lot of filters that you can use right out of the box. They do all sorts such as string tags, newlines, camel case strings, and so on. The framework also provides an interface so you can easily create your own filters. For example, converting a string to title case. With that in mind you could see how easy it’d be to create a filter to scan for urls and shorten them. And that’s exactly what this filter does! It will scan the supplied text for any http or https urls, and then, if they are past a certain size, it will attempt to connect to a url shortening service and then replace the long urls with the short.

/**
 * Shorten urls found in text.
 *
 * This filter will scan the supplied text for any http or https urls, and
 * then, if they are past a certain size, it will attempt to connect to a
 * url shortening service and then replace the long urls with the short.
 *
 * Two services endpoints are in the class - tinyurl and is.gd - but there's
 * nothing to stop you supplying a different end point, so long as the format
 * of the end point has one string directive (%s) and the service simply
 * returns a short url.
 *
 * @copyright Copyright (c) 2009, Andrew Collington

 * @license New BSD License
 */
class Amnuts_Filter_ShortenUrls implements Zend_Filter_Interface
{
    const REGEX = "~(?:https?://(?:(?:(?:(?:(?:[a-zA-Z\d](?:(?:[a-zA-Z\d]|-)*[a-zA-Z\d])?)\.)*(?:[a-zA-Z](?:(?:[a-zA-Z\d]|-)*[a-zA-Z\d])?))|(?:(?:\d+)(?:\.(?:\d+)){3}))(?::(?:\d+))?)(?:/(?:(?:(?:(?:[a-zA-Z\d$\-_.+!*'(),]|(?:%[a-fA-F\d]{2}))|[;:@&=])*)(?:/(?:(?:(?:[a-zA-Z\d$\-_.+!*'(),]|(?:%[a-fA-F\d]{2}))|[;:@&=])*))*)(?:\?(?:(?:(?:[a-zA-Z\d$\-_.+!*'(),]|(?:%[a-fA-F\d]{2}))|[;:@&=])*))?)?)~";
    const SERVICE_ISGD    = 'http://is.gd/api.php?longurl=%s';
    const SERVICE_TINYURL = 'http://tinyurl.com/api-create.php?url=%s';

    /**
     * Options array containing:
     *
     *    - maxsize
     *      Maximum size the url can be before attempting to shorten it
     *    - service
     *      The url to the service API that returns a short url
     *    - timeout
     *      The maximum time allowed for a connection
     *
     * @var array
     */
    public $options = array(
        'maxsize' => 35,
        'service' => self::SERVICE_ISGD,
        'timeout' => 5
    );

    /**
     * Set options on construct
     *
     * @param array $options
     */
    public function __construct(array $options = array())
    {
        if (!empty($options)) {
            $this->options = array_merge($this->options, $options);
        }
    }

    /**
     * Filter the text.
     *
     * The filtering may take some time, depending on how many links are in
     * the text to be shortened, how responsive the service is, etc.
     *
     * @param string $text
     * @return string
     * @see Zend_Http_Client, Zend_Http_Response
     */
    public function filter($text)
    {
        $matches = $replacements = array();
        $matched = preg_match_all(self::REGEX, $text, $matches, PREG_PATTERN_ORDER);
        if ($matched) {
            $http = new Zend_Http_Client();
            foreach ($matches[0] as $url) {
                if (strlen($url) > $this->options['maxsize']) {
                    $http->setConfig(array(
                        'timeout' => $this->options['timeout']
                    ));
                    $http->setUri(
                        sprintf($this->options['service'], urlencode($url))
                    );
                    $response = $http->request(Zend_Http_Client::GET);
                    if ($response->isSuccessful()) {
                        $replacements[$url] = $response->getBody();
                    }
                    $http->resetParameters();
                }
            }
        }
        if (empty($replacements)) {
            return $text;
        }
        return str_replace(
            array_keys($replacements),
            array_values($replacements),
            $text
        );
    }
}

It’s very easy to use, too:

$shorten = new Amnuts_Filter_ShortenUrls();
$updated = $shorten->filter($text);

Here’s an example of using tinyURL as the service and only converting urls in the text that are longer than 50 characters:

$shorten = new Amnuts_Filter_ShortenUrls(array(
    'maxsize' => 50,
    'service' => Amnuts_Filter_ShortenUrls::SERVICE_TINYURL
));
$updated = $shorten->filter($text);

Obviously there’s a lot of room for improvement; javascript encoding, representation as an image, and so on… but then it wouldn’t be quick an easy – it’d be slightly longer and just a little more complex.

class Amnuts_View_Helper_EncodeEmail extends Zend_View_Helper_Abstract
{
    /**
     * Return the class on direct calls.
     *
     * @return Amnuts_View_Helper_EncodeEmail
     */
    public function encodeEmail()
    {
        return $this;
    }

    /**
     * Return an encoded email address to help against spam.
     *
     * @param string $address The email address to encode
     * @return string
     */
    public function address($address)
    {
        $xhtml = '';
        $address = (string)$address;
        $len = strlen($address);
        for ($x = 0; $x < $len; $x++) {
            if (preg_match('!\w!', $address[$x])) {
                $xhtml .= '%' . bin2hex($address[$x]);
            } else {
                $xhtml .= $address[$x];
            }
        }
        return $xhtml;
    }

    /**
     * Return an encoded mailto link to help against spam.
     *
     * If no link text is supplied then the email address will be used
     * (as is generally preferred).
     *
     * @param string $address The email address to encode
     * @param null|string $text Text to use for link
     * @param array $attrs Any extra attributes for link
     * @return string
     */
    public function link($address, $text = null, array $attrs = array())
    {
        $encodedtext    = '';
        $encodedaddress = $this->address($address);
        if (null === $text) {
            $text = (string)$address;
        } else {
            $text = (string)$text;
        }
        $len = strlen($text);
        for ($x = 0; $x < $len; $x++) {
            $encodedtext .= '&#x' . bin2hex($text[$x]).';';
        }
        $xhtml = '<a href="&#109;&#97;&#105;&#108;&#116;&#111;&#58;' . $encodedaddress . '"';
        if (!empty($attrs)) {
            foreach ($attrs as $k => $v) {
                $xhtml .= ' ' . $this->view->escape($k) . '="' . $this->view->escape($v) . '"';
            }
        }
        $xhtml .= '>' . $encodedtext . '';
        return $xhtml;
    }
}