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.

01022010

Cool.

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!

http://www.zend.com/webinar/Framework/webinar-leveraging-zend_form-decorators-20091216.flv

It’s a great introduction to decorators, how to implement them and how to do slightly more complex things with them. Well worth a watch!

For those too lazy to read that post, it can be summarised something like this:

Have a number of divs on your page that have different size blocks of text in them? Want to make all the divs have the same height, but can’t accurately determine what that height should be in advance? No problem! Use javascript to tweak the heights when the page has loaded and the browser knows the size of the divs. Use this plugin to do it automatically based on a class you supply the elements you want to change the size of. Better yet, make them all match either the smallest height or the largest height!

Simple, yes?

Well, that was with Prototype… But a while ago now I created a version for jQuery. So here it is.

/**
 * Same Height, jQuery plug-in.
 *
 * This plug-in allows you to automatically have all of the elements marked
 * with a particular class to be the same height, either by smallest or
 * largest.
 *
 * By default, 'samemaxheight' and 'sameminheight' will be used.
 *
 * Examples of use:
 *
 *     $(document).ready(function() {
 *         $('body').sameheight();
 *     });
 *
 *     $(document).ready(function() {
 *         $('#mainContent').sameheight({
 *             max: 'mymaxclass',
 *             min: 'myminclass'
 *         });
 *     });
 *
 *     $.fn.sameheight.defaults.max = 'mymaxclass';
 *     $.fn.sameheight.defaults.min = 'myminclass';
 *     $('body').sameheight();
 *
 * @copyright Copyright (c) 2009 Andrew Collington 
 */
(function($) {
    $.fn.sameheight = function(userOptions) {
        var options = $.extend({}, $.fn.sameheight.defaults, userOptions);

        var maxH = 0;
        $('.' + options.max, $(this)).each(function(){
            var h = $(this).height();
            maxH = (h > maxH) ? h : maxH;
        });
        $('.' + options.max, $(this)).each(function(){
            $(this).css({
                'height'   : maxH + 'px',
                'overflow' : 'hidden'
            });
        });

        var minH = 0;
        $('.' + options.min, $(this)).each(function(){
            var h = nodes[i].height();
            minH = ((h < minH) || !minH) ? h : minH;
        });
        $('.' + options.min, $(this)).each(function(){
            $(this).css({
                'height'   : minH + 'px',
                'overflow' : 'hidden'
            });
        });
    };

    $.fn.sameheight.defaults = {
        max: 'samemaxheight',
        min: 'sameminheight'
    };
})(jQuery);

]]> http://blog.amnuts.com/2009/12/24/same-height-for-elements-2/feed/ 0 http://blog.amnuts.com/2009/12/21/pointless-error-message/ http://blog.amnuts.com/2009/12/21/pointless-error-message/#comments Mon, 21 Dec 2009 15:11:42 +0000 Andy http://blog.amnuts.com/?p=143 Just ran a bit of SQL on Oracle and this was the oh-so helpful error message I got back:

Warning: ociexecute() [function.ociexecute]: OCIStmtExecute: ORA-00932: inconsistent datatypes: expected BINARY got BINARY

So you’re expecting a binary value and what you got was a binary value, but that’s inconsistent with the binary value you were expecting to be binary?!

On with the book review…

The book, as the title makes it plainly obvious, is about developing your team in relation to working with PHP.  It’s aimed at, well, pretty much anyone who has an interest in developing or working in a team, be it managers who need to set up and manage teams or developers working within a team who want to improve their work flow and procedures, or anyone in between.  It does this by giving an overview on several subjects, but doesn’t go as far as to tell you that you must do x, y or z.  This is understandable, though, as every team is different and the book acknowledges this.

Chapter 1 discusses the need for teams and the use of established software engineering patterns that can help as well as touching on some tools such as issue tracking, source control, etc.  This chapter is good if you’re not sure with a lot of terminology as the overview covers a few key topics such as continuous integration and regression, and also touches on software development principles.  It doesn’t go in to depth about any one thing, as they’re covered in further chapters.

Chapter 2 covers MVC (Model View Controller) design principles and how you might form you team to deal with different aspects of the MVC pattern.  To be honest, if you’ve dealt with MVC at all in your job then this chapter holds no surprises, as you will know how the pattern works and how you would give responsibilities to different team groups/members.  However, if you’ve not had any experience at all then it offers a nice little introduction to the pattern.  (Remember, though, that this is not about how you would code the MVC pattern or use it in your project – it’s about making the principles of the pattern known to you and how it may fit in to team working.)

Chapter 3 is about dealing with complexity.  That is to say, if you have a complex project or application then this chapter gives you an idea on how to manage that and implement things that will make your job easier.  Essentially, what this chapter comes down to is why it’s a good idea to use a framework.  Again, it’s nothing new if you’ve already used frameworks (generally by then you know all the reasons why it tends to be a good thing for complex projects), but if you’re contemplating using one, or sit in a more managerial role and want to know why your developers are using one, then it’s worth the read.  At the end of the chapter the author also gives links to a number of different frameworks – some of which I hadn’t heard of before – along with their license type and a brief description.  What I especially liked about this chapter is that the author came over quite framework agnostic.  He wasn’t saying that one framework is better than another or which you should use – he supplies a list of frameworks and arms you with knowledge of what to look for in a framework (commercial license, documentation, support, code quality, security, etc.) and sets you on your way.  It is, of course, up to you to choose a framework that best suits your project and then integrate that in to your team workings.  This is a Good Thing!

Chapter 4 is about the process to get from the concept of an application to the end product and the steps in between.  There are a number of flow charts throughout this chapter that help you understand the process, and for someone like me who generally goes from being told someone wants an application,  to getting a brief functional requirements set and then making the thing, I can see that I have room for improvement!

Chapter 5 is about Agile development, and probably the chapter I was looking forward to the most.  Agile development was something I’d heard about, had an ever-so vague idea of what it was, but wasn’t too sure.  this chapter tells you what the principles are behind Agile development, how is works when dealing with the customer and a wide general overview.  The chapter then goes on to cover Extreme Programming (XP) a bit, and how Agile and XP can work in the team, pair programming, sustainable working styles for the developers, stand-up meetings, and so on.  It was good to find out a lot of how I work falls under Agile/XP, even though I didn’t know it at the time!  I learned a lot from this chapter and know a number of things I want to try to implement in to my working practice.

Chapter 6 is about collaboration among the team.  Basically it covers how source control is helpful, bug control and reporting, and ways developers can communicate (mailing lists, for example).  Useful stuff if you don’t know about it already, but pretty much any developer I know already uses source control in one form or another, as well as bug reporting, mailing lists, IRC, and everything else.

Chapter 7, the final chapter, is about continuous integration – what happens when your project needs to change, how does the project evolve, how to ensure team success and more.  Even though this is a distinct chapter in itself, I did get the feeling that it was more like a summary chapter of everything that you had just read.  But this was probably just because the author was referencing a number of his earlier chapters because they relatedto what he was taling about at the time.

Conclusion

This book is only 160 or so pages in size and it tries to cram a lot of information in to it.  There are times I wish the author could have gone in to more detail, but could also very much appreciate that the author didn’t have enough room to do so.  I actually quite liked that it was a really high-level overview for the most part, because it gave me a lot of ideas of things I want to investigate further and can now go and find resources that covers those bits in much more details.

Because I know quite a number of principles this book covered, such as the MVC chapters, source control, etc., I didn’t take quite so much away from it as another person may – and I’m sure other developers would feel the same – but I did still learn a lot from it, such as the agile development, and a number of keys principles that mayhelp me manage my time better as well as have a more integrated team.

However, this book wasn’t all roses and there were a number of things I really didn’t like.  The first thing is the authors style of writing.  I honestly didn’t gel with it very well and actually struggled to get past the first couple of chapters.  There was an overabundance of commas – sometimes breaking up the sentence in odd places – and it because a little repetitive and word for no reason.  My wife accuses me of using commas too much, which I probably do, but the amount in this book just caused me a headache!  The writing style I could get over (as mine’s not the best, but then, I’m not trying to sell you a book!), but the one thing that really pissed me off was that fact that the credits included a proof reader!!  WHAT?!  I lost count of the times ‘form’ was used when it should have been ‘from’, or the spelling mistakes, grammatical errors, or missing words entirely!  A couple of my favourites is when the author was discussing the use of functional programming vs. OOP, and then goes on to say, “Be it fictional programming you are using or object-oriented programming…”  Fictional programming!  And this highlights the commas quite nicely, “…we might be about to deal with estimates that are off the mark for some time, in the long run, both, the development team as well as clients and users will become frustrated…”  I don’t so much blame the author for these mistakes – I can’t imagine the pressure of writing a book and trying to get it spot on – but isn’t that why you employ proof readers and editors??

All in all I’d say that if you’ve been developing for a while and had any team experience then this book wont be of much use to you.  However, if you’ve never worked in a team environment, or don’t have much development experience, are a manager or something like that, then you may find this book quite beneficial to you for an overview of working in and establishing team working principles.

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

Did you know that you can use the short php open tags and echo tag in your view scripts, and you don’t even need to have this turned on in the php.ini file?

So you can have things like:

<? $this->viewHelper(); ?>

and:

<?= $this->variable; ?>

instead of:

<?php $this->viewHelper(); ?>
<?php echo $this->variable; ?>

Might not seem a lot, but when you have a lot of view scripts to write then you can save quite a few key strokes.

It’s able to do this, even if you have short_tags off (as it should be!) because Zend_View uses a stream to open and seek through the view script – Zend_View_Stream.

There are some things to bare in mind with this kind of functionality. Obviously, you only want it to apply to text boxes and textareas – anything else is a waste of time… Even password fields are pointless to have a hint in them because it’ll only be a series of stars anyway!

The next thing to bare in mind is that you don’t want to reset the value if the user has typed anything in. And sometimes you may even want to accept the user typing exactly what the hint is, you you can’t just assume that if the value == the hint then it’s OK to clear.

And with those things in mind, here’s the plug-in:

/**
 * Form text box hints.
 *
 * This plug-in will allow you to set a 'hint' on a text box or
 * textarea.  The hint will only display when there is no value
 * that the user has typed in, or that is default in the form.
 *
 * You can define the hint value, either as an option passed to
 * the plug-in or by altering the default values.  You can also
 * set the hint class name in the same way.
 *
 * Examples of use:
 *
 *     $('form *').textboxhint();
 *
 *     $('.date').textboxhint({
 *         hint: 'YYYY-MM-DD'
 *     });
 *
 *     $.fn.textboxhint.defaults.hint = 'Enter some text';
 *     $('textarea').textboxhint({ classname: 'blurred' });
 *
 * @copyright Copyright (c) 2009,
 *            Andrew Collington, andy@amnuts.com
 * @license New BSD License
 */
(function($) {
    $.fn.textboxhint = function(userOptions) {
        var options = $.extend({}, $.fn.textboxhint.defaults, userOptions);
        return $(this).filter(':text,textarea').each(function(){
            if ($(this).val() == '') {
                $(this).focus(function(){
                    if ($(this).attr('typedValue') == '') {
                        $(this).removeClass(options.classname).val('');
                    }
                }).blur(function(){
                    $(this).attr('typedValue', $(this).val());
                    if ($(this).val() == '') {
                        $(this).addClass(options.classname).val(options.hint);
                    }
                }).blur();
            }
        });
    };

    $.fn.textboxhint.defaults = {
        hint: 'Please enter a value',
        classname: 'hint'
    };
})(jQuery);

Some examples of use (as shown in the plug-in header comment, but I figure it can’t hurt to show it again!)

$('form *').textboxhint();

$('.date').textboxhint({
    hint: 'YYYY-MM-DD'
});

$.fn.textboxhint.defaults.hint = 'Enter some text';
$('textarea').textboxhint({ classname: 'blurred' });