What was

The most exciting thing for CwS in 2008 must've been that Pascal and I got to spend about half the year working together, as real life desk neighbours at Photobox, when I managed to hire him for 2 projects in spring and autumn.

We got around to churn out some lovely best practice code (almost all Zend Framework based) and wrote about it. Gaining some traction with CwS, we started looking into other distribution channels, Twitter being the first, and our articles were gladly picked up by PHPDeveloper as well as the Zend DevZone. I always meant to write about the increase of traffic and the benefit of hustling your site a little bit (we received some very helpful comments in the process, so it's not all just numbers and pretty graphs), but didn't get around to it. I guess you'll have to trust me on this one.

What definitely wasn't was a series about tips I wanted to publish for people newer to the world of web development, mostly because Roger Johansson had the same idea round-about the same time, and he does it so much better.

For your collective and individual enjoyment, I've grouped our 15 most popular posts in (not necessarily from) 2009:

1. A CSS Framework
2. Fixing the Back Button and Enabling Bookmarking for AJAX Apps
3. Modular CSS
4. Unit testing controllers with Zend Framework
5. CSS Background image on html image element?
6. Deploying PHP applications with Vlad and SVN
7. Dynamic tables with XSLT
8. Clean URLs for a better search engine ranking
9. Find your node: Advanced XPATH commands
10. A caching pattern for models
11. XML validation in PHP
12. 4 ssh config tips for faster remote working
13. CSS is Worthless
14. My take on jQuery charts
15. Unit testing web service based models in Zend Framework

What will be (maybe)

Of course we're looking forward to another year of CwS that will discuss all aspects of web technology that we deal with, client and server side. Right now there are many exciting news on the horizon (if not already knocking on our door daily), I'm thinking Zend Framework 2.0, PHP 5.3, push concepts such as Comet (especially in the PHP world), and of course the exciting new world of HTML 5 with all its possibilities and pitfalls. The last word in deployment and build processes is surely not spoken without having a look at integrating dpkg or rpm mechanisms, and in more concrete news, I'm doing a PHP certification this year, so hopefully you'll hear some of my experience learned there, too.

Of course we're still open for contributors to write a post here and there, so feel free to contact us if you've got an idea or maybe simply a nice code example you'd like to share.

This leaves me with wishing you all a happy new year, thanks again for being such a smart audience. Here's to you and a great 2010,

from all of us at Content with Style

$cfgShowBlob = true

or

$cfg['ShowBlob']

had any effect, and the solution was terribly elusive. "view blob", "show blob", "display blob", all that Google suggested were people asking the same question, at various ages of the internet.

Even more annoying, the most common answer was "Why would you want to do that?", and too many times I was reading that they shouldn't be read anyway, because it could be large amounts of, well, binary data, bla bla bla.

In my case this makes very much sense, though, because I was looking at serialized data objects. Don't ask me why it's not a TEXT field (another smartypants suggestion in a forum), that's just the setup I was dealing with.

After much digging and the wish for a search engine that will suggest better search terms to me, I finally decided to bother the source instead, and found "display_blob". Hurray! It comes in this form:

$_SESSION['userconf']['display_blob'];

All you need to do is set this session variable (possibly by sticking it into the config? I didn't try it out), or alternatively: Open the content frame and put

&display_blob=true

into the querystring, and it will keep it in the session for you, when you use the frameset as normal afterwards.

While writing this, I also saw this page, can anyone translate?

What is Xapian?

Xapian is a Search Engine Library, similar to Lucene and Sphinx. It's compiled from C++ code and therefore pretty low level. There are PHP, Perl and Python bindings available for it, which are straight forward to use. Packages are available for Ubuntu and Red Hat, it compiles on OSX and you can run it on Windows via CygWin.

Demo Scripts

Rather than explaining why and how, I decided to create some demo scripts instead. The XapianWrapper PHP class I've created is quite large, so feel free to download the example zip file as well.

db.sql

CREATE DATABASE `demo`;

CREATE TABLE `demo`.`demo` (
`id` INT( 10 ) UNSIGNED NOT NULL AUTO_INCREMENT PRIMARY KEY ,
`unique_key` VARCHAR( 255 ) NOT NULL ,
`name` VARCHAR( 255 ) NULL DEFAULT NULL ,
`summary` TEXT NULL DEFAULT NULL ,
`date` DATETIME NULL DEFAULT NULL ,
UNIQUE (`unique_key`));

INSERT INTO `demo`.`demo` 
(`id`, `unique_key`, `name`, `summary`, `date`)
VALUES (NULL, 'foo', 'foo', 'foo bar test', '2008-11-05 00:00:00'), 
(NULL , 'bar', 'bar', 'test foo bar', '2009-11-05 00:00:00');        

XapianWrapper.php

<?php
// includes
require_once 'xapian.php';

// main class
class XapianWrapper {
  const XAPIAN_FIELD_URL = 0;
  const XAPIAN_FIELD_NAME = 1;
  const XAPIAN_FIELD_DATE = 2;
  const XAPIAN_FIELD_UID = 3;
  const XAPIAN_FIELD_SUMMARY = 4;
  const XAPIAN_PREFIX_UID = "UID:";
  
  const SETTINGS_XAPIAN_DB = './xapian_db';

  const SETTINGS_MYSQL_HOST = 'localhost';
  const SETTINGS_MYSQL_USER = 'root';
  const SETTINGS_MYSQL_PASS = 'root';
  const SETTINGS_MYSQL_DB = 'demo';
  const SETTINGS_MYSQL_TABLE = 'demo';

  const DEFAULT_COUNT = 10;

  private $mysql_link;
  private $category_cache;
  
  private $xapian_read_db;
  private $xapian_write_db;
  private $xapian_stemmer;
  private $xapian_indexer;
  private $xapian_enquire;

  private function xapian_init_readonly() {
    try{
      $this->xapian_read_db = new XapianDatabase(self::SETTINGS_XAPIAN_DB);
      $this->xapian_stemmer = new XapianStem("english");
      $this->xapian_enquire = new XapianEnquire($this->xapian_read_db);
    } catch(Exception $e) {
      throw new Exception('Could initialize Xapian: ' . $e->getMessage());
    } 
  }
  
  private function xapian_init_writable() {
    try{
      $this->xapian_write_db = new XapianWritableDatabase(self::SETTINGS_XAPIAN_DB, Xapian::DB_CREATE_OR_OPEN);  
      $this->xapian_indexer = new XapianTermGenerator();
      $this->xapian_stemmer = new XapianStem("english");
      $this->xapian_indexer->set_stemmer($this->xapian_stemmer);
    } catch(Exception $e) {
      throw new Exception('Could initialize Xapian: ' . $e->getMessage());
    } 
  }
  
  private function mysql_init() {
    $this->mysql_link = mysql_connect(self::SETTINGS_MYSQL_HOST, self::SETTINGS_MYSQL_USER, self::SETTINGS_MYSQL_PASS);
    if (!$this->mysql_link) {
      throw new Exception('Could not connect: ' . mysql_error());
    }

    $db_selected = mysql_select_db(self::SETTINGS_MYSQL_DB, $this->mysql_link);
    if (!$db_selected) {
      throw new Exception('Can\'t use db : ' . mysql_error());
    }
  }
  
  /**
   * Index method
   *
   */
  public function index($params) {
    $this->xapian_init_writable();
    $this->mysql_init();
    
    $start = microtime(true);

    $response = new stdClass();
    $response->indexed = array();

    $offset = (isset($params['offset'])) ? intval($params['offset']) : 0;
    $count = (isset($params['count'])) ? intval($params['count']) : self::DEFAULT_COUNT;
    $sql = 'SELECT * FROM '.self::SETTINGS_MYSQL_TABLE.' LIMIT ' . $offset . ', ' . $count . ';';

    $result = mysql_query($sql);

    if (!$result) {
      throw new Exception('Invalid query: ' . mysql_error());
    }
    
    $this->xapian_write_db->begin_transaction();

    while ($row = mysql_fetch_array($result, MYSQL_ASSOC)) {
       $response->indexed[] = $this->index_row($row);      
    }

    $this->xapian_write_db->commit_transaction();
    mysql_free_result($result);
    mysql_close($this->mysql_link);

    return $response;
  }
    

  private function index_row($row) {
    $doc = new XapianDocument();

    $this->xapian_indexer->set_document($doc);
    $this->xapian_indexer->index_text($row['name'],50);
    $this->xapian_indexer->index_text($row['summary'], 1);

    $GUID = self::XAPIAN_PREFIX_UID . $row['unique_key'];
    $doc->add_term($GUID);

    $doc->add_value(self::XAPIAN_FIELD_URL, $row['url']);
    $doc->add_value(self::XAPIAN_FIELD_DATE, date('Ymd', strtotime($row['date'])));
    $doc->add_value(self::XAPIAN_FIELD_UID, $row['unique_key']);
    $doc->add_value(self::XAPIAN_FIELD_NAME, $row['name']);
    $doc->add_value(self::XAPIAN_FIELD_SUMMARY, $row['summary']);
    
    $this->xapian_write_db->replace_document(strval($GUID), $doc);

    $row_response = array();
    $row_response['name'] = $row['name'];
    $row_response['guid'] = $row['unique_key'];
    $row_response['url'] = $row['url'];
    return $row_response; 
  }
  
  /**
   * Delete method
   *
   */
  public function delete($params) {
    $this->xapian_init_writable();

    $this->xapian_write_db->begin_transaction();

    $response = array();

    foreach($params['items'] as $param_guid) {      
      $GUID = self::XAPIAN_PREFIX_UID . $param_guid;
      $this->xapian_write_db->delete_document(strval($GUID));
      $response[] = $param_guid;
    }
    
    $this->xapian_write_db->commit_transaction();
    return $response;
  }

  /**
   * Search method
   *
   */
  public function search($params) {
    $this->xapian_init_readonly();

    $start = microtime(true);

    // queries array to later construct full query
    $arr_queries = array();

    // from date
    if(!empty($params['date_from'])) {
      $arr_queries[] = new XapianQuery(XapianQuery::OP_VALUE_GE, 6, date('Ymd', strtotime($params['date_from'])));
    }

    // to date
    if(!empty($params['date_to'])) {
      $arr_queries[] = new XapianQuery(XapianQuery::OP_VALUE_LE, 6, date('Ymd', strtotime($params['date_to'])));
    }

    // unique key
    if(!empty($params['unique_key'])) {
      $arr_queries[] = new XapianQuery(self::XAPIAN_PREFIX_UID . $params['unique_key']);
    }

    // normal search query parsed
    if(!empty($params['search'])) {
      $qp = new XapianQueryParser();
      $qp->set_stemmer($this->xapian_stemmer);
      $qp->set_database($this->xapian_read_db);
      $qp->set_stemming_strategy(XapianQueryParser::STEM_SOME);
      $arr_queries[] = $qp->parse_query($params['search']);
    }

    // Find the results for the query.
        // construct final query
    $query = array_pop($arr_queries);

    foreach($arr_queries as $sq) {
      $query = new XapianQuery(XapianQuery::OP_AND, $query, $sq);
    }    
    $this->xapian_enquire->set_query($query);
  
    // set the count to the specified params
    $offset = (isset($params['offset'])) ? intval($params['offset']) : 0;
    $count = (isset($params['count'])) ? intval($params['count']) : self::DEFAULT_COUNT;
    $matches = $this->xapian_enquire->get_mset($offset, $count);

    $response = new stdClass();
    $response->result_count = $matches->get_matches_estimated();
    $results = array();

    $i = $matches->begin();
    while (!$i->equals($matches->end())) {
      $m = array();

      $n = $i->get_rank() + 1;
      $doc = $i->get_document();

      $m['position'] = $n;
      $m['url'] = $doc->get_value(self::XAPIAN_FIELD_URL);
      $m['name'] = $doc->get_value(self::XAPIAN_FIELD_NAME);
      $m['summary'] = $doc->get_value(self::XAPIAN_FIELD_SUMMARY);
      $m['date'] = $doc->get_value(self::XAPIAN_FIELD_DATE);
      $m['unique_key'] = $doc->get_value(self::XAPIAN_FIELD_UID);
      $m['percent'] = $i->get_percent();

      $results[count($results)] = $m;
      $i->next();
    }

    $response->results = $results;
    $end = microtime(true);
    
    // runtime info
    $response->execute = new stdClass();
    $response->execute->call = 'search';
    $response->execute->offset = $offset;
    $response->execute->count = $count;
    $response->execute->start = $start;
    $response->execute->end = $end;
    $response->execute->time = $end - $start;

    // debug stuff
    $response->execute->debug = $query->get_description();

    return $response;
  }
}

index.php

<?php

require_once 'XapianWrapper.php';

$x = new XapianWrapper();
$res = $x->index(array());
print_r($res);               

search.php

<?php

require_once 'XapianWrapper.php';

$x = new XapianWrapper();
$params = array('search' => 'foo');
$res = $x->search($params);
print_r($res);           

delete.php

<?php

require_once 'XapianWrapper.php';
$x = new XapianWrapper();
$params = array(
	'items' => array('foo'),
);
$res = $x->delete($params);
print_r($res);

Using the example

Once you've unzipped the expamples, you should now be able to create the DB from the db.sql file, and run the php examples via command line.

bash$ php index.php 
stdClass Object
(
    [indexed] => Array
        (
            [0] => Array
                (
                    [name] => foo
                    [guid] => foo
                    [url] => 
                )

            [1] => Array
                (
                    [name] => bar
                    [guid] => bar
                    [url] => 
                )

        )

)
bash$ php search.php 
stdClass Object
(
    [result_count] => 2
    [results] => Array
        (
            [0] => Array
                (
                    [position] => 1
                    [url] => 
                    [name] => foo
                    [summary] => foo bar test
                    [date] => 20081105
                    [unique_key] => foo
                    [percent] => 100
                )

            [1] => Array
                (
                    [position] => 2
                    [url] => 
                    [name] => bar
                    [summary] => test foo bar
                    [date] => 20091105
                    [unique_key] => bar
                    [percent] => 50
                )

        )

    [execute] => stdClass Object
        (
            [call] => search
            [offset] => 0
            [count] => 10
            [start] => 1256674866.79
            [end] => 1256674866.79
            [time] => 0.000944852828979
            [debug] => Xapian::Query(Zfoo:(pos=1))
        )

)
bash$ php delete.php 
Array
(
    [0] => foo
)
bash$ php search.php 
stdClass Object
(
    [result_count] => 1
    [results] => Array
        (
            [0] => Array
                (
                    [position] => 1
                    [url] => 
                    [name] => bar
                    [summary] => test foo bar
                    [date] => 20091105
                    [unique_key] => bar
                    [percent] => 100
                )

        )

    [execute] => stdClass Object
        (
            [call] => search
            [offset] => 0
            [count] => 10
            [start] => 1256674876.02
            [end] => 1256674876.02
            [time] => 0.000872850418091
            [debug] => Xapian::Query(Zfoo:(pos=1))
        )

)

Right, I leave it up to you to amend the examples to suit your individual needs. As always any feedback or improvements are welcome. Happy indexing and searching everyone.

PHP cli script 'internationalize.php'

<?php
// check for CLI
if (php_sapi_name() != "cli") {
  print "This script is written to run under the command line ('cli') version of\n";
  print "the PHP interpreter, but you're using the '".php_sapi_name()."' version\n";
  exit(1);
}

// check for valid syntax
if(empty($argv[1])) {
  die('syntax: php internationalize.php <file> <optional token prefix>');
}


function get_key($str, $prefix) {
  $key = str_replace(' ', '_', strtolower($str));
  $key = preg_replace('/[\\:\\.\\,\\!\\?]{0,}/', '', $key);
  $prefix = $GLOBALS['prefix'];
  return $prefix.$key;
}

function key_replace($matches) {
  if(trim($matches[2]) != "") {
    $key = get_key($matches[2]);
    return '<'.$matches[1].'><?php echo $this->translate->_("'.$key.'"); ?></'.$matches[3].'>';
  } else {
    return $matches[0];
  }
}


// get a prefix for the tokens
$prefix = (!empty($argv[2])) ? $argv[2] . '_' : '';

// identify and load file
$file = realpath($argv[1]);
$contents = file_get_contents($file);

// create backup file
copy($file, $file.'.bak');

// reg exp to find all text in between tags
$pattern = '/<([\\w \\=\\%\\"\\(\\)\\\'\\:]+)>([\\w\\s\\:\\.\\,\\!\\?_-]+)<\\/([\\w]+)>/';

// replace with translation calls
$translated = preg_replace_callback($pattern, 'key_replace', $contents);
file_put_contents($file, $translated);


// start generate ini file
$rows = array();
$matches = array();
preg_match_all($pattern, $contents, $matches);

for($i=0; $i<count($matches[1]); $i++) {
  if(trim($matches[2][$i]) != "") {
    $key = get_key($matches[2][$i]);
    $rows[] = $key.'="'.addslashes($matches[2][$i]).'"';
  }
}

$ini_string = implode("\n", $rows);
file_put_contents($file.'.translation.ini', $ini_string);

Example view file 'test.phtml'

<p>Fooo</p>

<blockquote style="test">Ich teste gerade</blockquote>

<ul>
  <li>Test list</li>
  <li>Test list  2</li>
</ul>                                                                        

Translate it!

Now we're set. We just need to call:

php internationalize.php test.phtml

We end up with a this in test.phtml:

<p><?php echo $this->translate->_("fooo"); ?></p>

<blockquote style="test"><?php echo $this->translate->_("ich_teste_gerade"); ?></blockquote>

<ul>
  <li><?php echo $this->translate->_("test_list"); ?></li>
  <li><?php echo $this->translate->_("test_list__2"); ?></li>
</ul>

and this in test.phtml.translation.ini:

fooo="Fooo"
ich_teste_gerade="Ich teste gerade"
test_list="Test list"
test_list__2="Test list  2"

In progress

This is not meant as THE solution. It's merely a quick script I put together in a couple of minutes. There are a couple of things that it can't do, like translating attributes and all that.

I'm no reg exp guru, and if you can improve please feel free to comment. Otherwise, have fun.

svn st | grep .php | grep M | cut -c 8- | xargs -n1 php -l

I use xargs quite a lot lately, but some good clues came from David Singletons post "Using xargs like you mean it".

Exception information:

Message: SQLSTATE[HY000]: General error: 2014 Cannot execute queries while other unbuffered queries are active. Consider using PDOStatement::fetchAll(). Alternatively, if your code is only ever going to run against mysql, you may enable query buffering by setting the PDO::MYSQL_ATTR_USE_BUFFERED_QUERY attribute.
Stack trace:

#0 /project/ZendFramework-1.7.1/Zend/Db/Statement.php(109): Zend_Db_Statement_Pdo->_prepare('UPDATE `foo...')
#1 /project/ZendFramework-1.7.1/Zend/Db/Adapter/Pdo/Abstract.php(170): Zend_Db_Statement->__construct(Object(Zend_Db_Adapter_Pdo_Mysql), 'UPDATE `foo...')
#2 /project/ZendFramework-1.7.1/Zend/Db/Adapter/Abstract.php(429): Zend_Db_Adapter_Pdo_Abstract->prepare('UPDATE `foo...')
#3 /project/ZendFramework-1.7.1/Zend/Db/Adapter/Pdo/Abstract.php(220): Zend_Db_Adapter_Abstract->query('UPDATE `foo...', Array)
#4 /project/ZendFramework-1.7.1/Zend/Db/Adapter/Abstract.php(551): Zend_Db_Adapter_Pdo_Abstract->query('UPDATE `foo...', Array)

...

Turns out the server runs MySQL pre 5.17:

$ yum list installed | grep mysql
mysql.i386                              5.0.45-7.el5                   installed
mysql-server.i386                       5.0.45-7.el5                   installed
php-mysql.i386                          5.1.6-23.2.el5_3               installed

In order to fix this we need to turn on query buffering:

$pdoParams = array(
    PDO::MYSQL_ATTR_USE_BUFFERED_QUERY => true
);

$params = array(
    'host'           => '127.0.0.1',
    'username'       => 'webuser',
    'password'       => 'xxxxxxxx',
    'dbname'         => 'test',
    'driver_options' => $pdoParams
);

$db = Zend_Db::factory('Pdo_Mysql', $params);

Thanks to Joe Devon from MySQL Talk for pointing out the relevant part of the Zend Framework documentation that points out why it happens and how to fix it.

In my instance it was a very nasty episode of lower back pain, which made me go through a month of not being able to tie my shoes. Of course it could have been worse. I did have a break planned anyway (ironically it was to get fit and do the Dunwich Dynamo) so I didn't have to bail out of a current contracting situation, and I was lucky that my osteopath didn't confirm my fears and sent me to hospital to have any surgery done. However, I didn't feel OK with taking on any contracting job for two and a half months, and I did spend quite some money on sessions to get my spine clicked into position. Also, following the routine I was recommended means I have to do back and core strength exercises every day.

This is why I want to give you contractors out there a couple of words on your way:

Stay healthy

I know it sounds lame, but you might want to consider doing the exercises before the pain comes. This might keep you fit and healthy to cope with 8 to 10 hours sitting each day, plus it might also help to balance out the stress that sometimes comes with contracting work, deadlines and delivery dates.

Look at your working environment

If you can help it, make sure you get a good chair, the computer set up and all the rest. I am sure you know the drill.

Insurance

In my case it didn't really matter that much, but what if I had kids, a mortgage and an ongoing contract? Clearly I should be insured against loss of income? There's a pretty neat guide on Contractors UK about what to look for when you purchase insurance. I recommend reading it and contemplating the necessary steps.

Finally, if you're suffering from back pain like I do, have a look at youtube. The videos of yoga exercises have given me some good clues of what to incorporate into my exercise routine.

Also, If you have any tips to share, be it about injury prevention, workplace set up or experiences with insurance claims, please do!

SimpleXML provides no way to remove [...] XML nodes.

You might think otherwise and hack it with unset(), as it was done in one of the web applications I inherited at work, but today I found out that this works under some conditions, but not with every setup. I'd love to tell you what exactly the differences are that make it break, but I didn't spend the time tracking it down.

I can tell you what unset() did the the specific setup (PHP 5.1.2 on Windows Vista): Nothing. It happily executed it without error or warning, but also without changing anything.

Luckily S. Gehrig had a good and in my eyes not-hacky idea in a thread on stackoverflow.com: He suggests to use the DOM, specifically dom_import_simplexml(), to then simply use removeChild().

In my case I had a predictable XML structure to parse, and only needed to kick out the first of a set of nodes, so my solution (using the same xml setup as example) is as follows:

$data='<data>
    <seg id="A1"/>
    <seg id="A5"/>
    <seg id="A12"/>
    <seg id="A29"/>
    <seg id="A30"/>
</data>';
$doc=new SimpleXMLElement($data);
$dom=dom_import_simplexml($doc->seg[0]);
$dom->parentNode->removeChild($dom);
echo $doc->asXml();
/*outputs: 
 * <?xml version="1.0"?>
 * <data><seg id="A5"/><seg id="A12"/><seg id="A29"/><seg id="A30"/></data>
 */

For more complex XML structures (and probably closer to most real-life scenarios), I agree with S. in suggesting xpath as a way to detect your unwanted node.

Assumptions

I am using the auto include mechanism for this one, utilizing the PEAR naming convention, and all my files will sit underneath a Shared folder within the library folder.

A custom form Element

This is sitting under Shared/Form/Element/Image.php

<?php
class Shared_Form_Element_Image extends Zend_Form_Element 
{
  public $helper = "imageUpload";
  public $options;
  
  public function __construct($image_name, $attributes, $data_item) {
    $this->options = $data_item;
    parent::__construct($image_name, $attributes);
  }
}

As you can see, the form Element itself doesn't contain much code, but it does overwrite the property 'helper'. Which bings us to the next file:

A custom view helper

In our example, this sits under Shared/Views/Helpers/ImageUpload.php

<?php
class Shared_View_Helper_ImageUpload extends Zend_View_Helper_FormFile {

  public function imageUpload($name, $value, $attribs, $options) {
    $str = parent::formFile($name, $attribs = null);

    if(!empty($options[$name])) {
      $str .= $this->getImagePreview($name, $options[$name]);
    } else {
      $str .= $this->getEmptyPreview();
    }
    
    return $str;
  }

  private function getImagePreview($name, $path) {
    $img = ($this->view->doctype()->isXhtml())
       ? '&lt;img src="/'.$path.'" alt="'.$name.'" />'
       : '&lt;img src="/'.$path.'" alt="'.$name.'">';
    
    return '&lt;p class="preview">'.$img.'&lt;/p>';
  }
  
  private function getEmptyPreview() {
    return '&lt;p class="preview">No image uploaded.&lt;/p>';
  }
}

Pretty straight forward, I am just subclassing the FormFile helper that Zend brings us. However, you might want to create a different helper all together, if you need to use much more customized markup than I do.

Invocation

The form itself will no contain the image path as element, therefore we need to inject it into the form data inside the Controller, then invoke the Form with that data:

$data['image'] = $image_path;
$form = new My_From($data);

Inside our Form, all we need to do now is to add a new element using our custom ImageUpload element:

$preview = new Shared_Form_Element_Image('image', null, $options);
$preview->addValidator('Count', false, 1);
$preview->addValidator('Extension', false, 'jpg,png,gif');
$preview->setLabel('My Image');
$fields[] = $preview;

1. cd into your PEAR installation directory
2. Make backup of phpunit file in bin folder
3. Edit the original file, replace #!/usr/bin/php with #!/Applications/MAMP/bin/php5/bin/php
4. 3. Also remove this:

   
   if (strpos('/usr/bin/php', '@php_bin') === 0) {
       set_include_path(dirname(__FILE__) . PATH_SEPARATOR . get_include_path());
   }
   

5. And finally, something that Mark didn't mention, add PEAR include path into /Applications/MAMP/conf/php5/php.ini

• exporting the project locally,
• zipping it up,
• moving it to the server,
• unpacking and symlinking it, to finally
• run a small script that would set the correct production config, chmod log and cache folders etc.

In the following article, I'm going to describe how I went from there to deploying my Zend Framework-driven PHP apps with Vlad. To save yourself some time, feel free to skip the back story, the pre-requisite of installing ruby, gem and rake, or go straight to the deployment recipes.

I did the above method for a while, and realized quickly how much time is wasted by this process. Remembering my efforts of deploying PHP apps with Capistrano, I felt it was time to set up an automated deployment routine. While re-reading the article, thoughts returned of how unwieldy and badly documented Capistrano came across, and I started looking for something more lean, that wouldn't scare of my non-ruby colleagues who might have to do my job when I'm away.

Very quickly I was lead to Vlad the Deployer, replacing one deployment app where the person in charge of the name had one tipsy field day with, well, another.

Taking it for its first spin, I felt that while there's a lot of confidence behind Vlad, the word "simple" crops up lots of times, but again, the documentation is a bit of a thinking man's manual; As soon as you go beyond the initial example it skips a few steps here and there, which can leave someone who is unfamiliar with the concept struggling. Maybe it's a case of "it's advanced stuff, just live with it".

Luckily I have my Capistrano experience, so I got started fairly quickly using Vlad for my own purposes. What I liked immediately about Vlad was that it declares as one of the project goals to "use the right tool for the job (ssh, rsync, etc)."

My initial goal was to use Vlad

• to have a deployment one-liner,
• to roll back if needed, and
• to be able to share logs and other assets between releases

For the example below I created a demo Zend Framework application with Zend_Tool, but what I'm describing should work for any PHP app out of the box, actually for any app, if you add any potential server tasks yourself. This example is using Subversion, but there is other examples out there that'll tell you how to use it with Git and other SCM software.

Setup

To be able to deploy with Vlad you need to have the following 4 things set up:

1. unix/linux development platform with SVN

not much to add, Vlad works on Mac OS X and various linux flavours, but not under Windows. For this setup I'm assuming you're working with SVN.

2. server with SVN client

Your webserver should be able to work with SVN, and it should be able to reach your SVN repository.

3. install vlad dependencies

on OS X 10.5 you already have a rails installation coming with the developer tools; just do

% gem update rails

Alternatively and on earlier OS X, you can use MacPorts, to install Ruby with

% port install ruby

You might also be able to use fink, and on debian/ubuntu you can install via aptitude

% sudo apt-get install ruby
% sudo apt-get install rubygems

For other platforms and compiling from source see here:
http://www.ruby-lang.org/en/downloads

Next you need to install Rake. For all systems, to update gem and install Rake, do the following. You don't need to gem update if you started from scratch:

% gem update --system
% gem update

Gem may fail initially - if so this is due to a bug in the gem command and requires you to edit the gem script (found with the command which gem on the command line, it's probably in /usr/bin/gem) by adding to the require statements (under require 'rubygems'):

require 'rubygems/gem_runner'

And finally, to install Rake itself:

% gem install rake

There are 3 more dependencies,

• Hoe
• Rubyforge
• open4

but they're installed automatically with the next step.

4. install vlad as a gem

To install vlad as a gem, all you need to do is

% sudo gem install vlad

while allowing for dependencies to be installed, which is set by default. Congratulations, you're ready to configure Vlad.

Pre-Configure

As Vlad is working closely with your system tools, you should set up your SSH for it first. You need to make sure the remote user is set up correctly, and you'll want some way of not having to enter your password a million times. Luckily I wrote about this recently. For the server I'd like to deploy to I added this. You might not need the ControlMaster/ControlPath, the important line is to set the remote user:

Host myserver.pretendco.com
    ControlMaster auto
    ControlPath ~/.ssh/master-%r@%h:%p
    User remoteuser

Now let's have a look at the server itself. There is a possibility that the web directory isn't writable by your remote user and you need to have root permissions. As you should use the root user for all this, and sudo croaks on remote commands, it's best to set your future releases directory to be owned by your remote user.

on the remote machine

% sudo chown remoteuser:remotegroup /path/to/releases/directory
% chmod 775 /path/to/releases/directory

Configure and Deploy

Next you need to create 2 files for Vlad: A Rakefile in your root directory, and a deploy.rb config file in application/configs. Your project should look a little something like this (yes, this is slightly abbreviated):

 |-application
 |---configs
 |-----config.ini
 |-----deploy.rb  <-- just created
 |---controllers
 |---models
 |---views
 |-library
 |-public
 |-Rakefile     <-- just created

At its core, the Rakefile is very straight forward; I've lifted the initial loading step more or less from the Vlad documentation, with the exception of setting the path for deploy.rb manually. Should your application have a root folder /config, you're following default convention and won't need the instructions in the curly braces. Further down I'm resetting the :update_symlinks task to link to shared logs and media folders, as well as linking the Zend library into my library. By default Vlad would set 3 shared folders: /log, /system and /pids, which I am all omitting here.

require 'rake'
require 'rake/testtask'
require 'rake/rdoctask'

begin
  require 'vlad'
  Vlad.load {:config => 'application/configs/deploy.rb'} # set path for deploy.rb
rescue LoadError
  # do nothing
end

namespace :vlad do
  # Clear existing symlink task so that we can redefine.
  Rake.clear_tasks('vlad:update_symlinks')

  # we've only got log to share
  remote_task :update_symlinks, :roles => :app do
    run "rm -Rf #{latest_release}/log && ln -s #{shared_path}/log #{latest_release}/log && chmod -f 666 #{latest_release}/log/*"
    run "rm -Rf #{latest_release}/public/media && ln -s #{shared_path}/cache #{latest_release}/public/media"
    run "rm -Rf #{latest_release}/library/Zend && ln -s #{shared_path}/Zend #{latest_release}/library/Zend"
  end
end

Next up is deploy.rb, the config file for the to-be-deployed app. The only 3 mandatory lines in all cases are :domain, :deploy_to, and :repository.

set :application, "Example application"
set :domain, "pretendco.com"
set :deploy_to, "/project/example_releases"
set :repository, 'http://svn.pretendco.com/example/trunk'
set :svn_cmd, 'svn --username svnuser --password svnpwd'

The default SVN command is svn, but in my case the SVN user is different to local and remote user, and for some reason the SVN password prompt from within the deployment step kept failing on me, so I added it right here. Not the safest thing in the world, but I'm using a limited read-only SVN user for these purposes, so that's good enough for me. Any suggestions of improvement are welcome.

For your convenience I have zipped up both files, or if you like, the whole demo project.

The first time you run vlad, you do

% rake vlad:setup vlad:update

You can skip the additional vlad:migrate vlad:start mentioned in the vlad documentation, as we're neither migrating DBs (this time), nor does Apache need to be restarted.

vlad:setup has now created a folder structure on your server that looks like this (abbreviated again):

 |-project
 |---example_releases
 |-----current           <-- link to your web application
 |-----releases
 |-------yyyymmddhhiiss  <-- your web application
 |---------application
 |---------library
 |-----------Zend        <-- link to Zend Framework
 |---------log           <-- link to shared logs
 |---------public
 |-----------media       <-- link to shared media
 |-----revisions.log
 |-----scm               <-- folder used to checkout release
 |-----shared
 |-------log
 |-------media
 |-------Zend

vlad:update has exported your application from the HEAD of your SVN repository, pushed it into a release folder, and pointed /current to this release. This means once you've verified this initial deployment step you can set your Apache webroot to point to /project/example_releases/current. You can also see that the folders /log, /public/media and /library/Zend have been symlinked, so you'll want to move all your dynamically created files into the shared folder now.

As a side note, I've had two major criticisms about this, out of which I have fixed one in this example: The first one was that initially I didn't include Zend Framework in my release, but rather added it to the global include_path on the server. "Your applications should be self-contained!", Pascal was shouting from his desk, including some expletives. The other thing he flagged up was that the version of my application config checked into SVN was set up for the live environment, so that I didn't have to change a thing when deploying. I have fixed this in the meantime as well, with a set of other convenient changes, but you'll have to be patient for me to write my next post about it and stick with this solution for now.

The good news are that you're ready to go now! To release a new version:

• check in your changes into SVN
• make sure that the repository URL in deploy.rb points to the same as yours
• run % rake vlad:update to deploy your app
• put your feet up, and enjoy the rest of your day.

If your release is broken, roll back with

% rake vlad:rollback

This will remove the last release and symlink to the previous version.

As a final word of warning: Using any means of deployment that rely on your code versioning software mean that you have to keep it clean. Only check in code you've tested locally, don't use the branch you deploy from as a backup mechanism. If you and any other people working with your code follow this advice, Vlad will save you lots of time, and turn the pain of updating a site into the joy of releasing something new.

Gavin Sinai put up a code snippet in the PHP.net reference, which shows how to set the error handler to get rid of it:

<?php
function HandleXmlError($errno, $errstr, $errfile, $errline)
{
   if ($errno==E_WARNING && (substr_count($errstr,"DOMDocument::loadXML()")>0))
   {
       throw new DOMException($errstr);
   }
   else
       return false;
}

function XmlLoader($strXml)
{
   set_error_handler('HandleXmlError');
   $dom = new DOMDocument();
   $dom->loadXml($strXml);   
   restore_error_handler();
   return $dom;
 }

?>

What is the problem?

Unit tests for database driven models are relatively straight forward. Usually we connect to a separate database, containing a known set of data. Since we know the data we can run assertions against it.

However, unit testing models that talk to web services presents us with a different set of problem. Usually our application runs requests against something that is not in our control. Unless the service provider gives us some kind of test mode, we're operating with dynamic live data which shouldn't be used for testing, since it's harder to test in the first place, but also could be harmful to be manipulated.

Let's have a look at two strategies to test out models.

Mock objects for Services

If we are using an object to represent the API calls to the service from within our model, i.e. Zend_Service_Delicious, we can swap this object for a mock object. A simple accessor allows us to overwrite private properties of the object:

class DeliciousModel {
  private $delicious;

  public function __construct() {
    $this->delicious = new Zend_Service_Delicious('username', 'password');
  }

  public function getPosts() {
    return $this->delicious->getAllPosts();
  }

  public function setProperty($name, $value) {
    if(UNITTEST_CONTEXT) {
      $this->$name = $value;
    }
  }
}

Now it's easy swap out private properties from within a unit test:

public function testDeliciousModel {
  $mockPosts = array('foo', 'bar');    

  $deliciousMock = $this->getMock('Zend_Service_Delicious', array('getAllPosts'));
  $deliciousMock->expects($this->once())
          ->method('getAllPosts')
          ->will($this->returnValue($mockPosts));
  
  $model = new DeliciousModel();
  $model->setProperty('delicious', $deliciousMock);

  $posts = $model->getPosts();
  $this->assertEquals($posts, $mockPosts);
}

Of course this would mean that we're not launching any requests to our services at all, but instead check that models are doing the right method calls to the service API object, and get the right data back.

Validate service requests

Generally speaking, models that are using web services will transform method calls into HTTP requests against web service end points. Those might come in a variety of flavours, but all together we can say that, if we can intercept the request, we can make sure the model serializes method calls correctly into known request data.

Test adapter for Zend_HTTP calls

If our model uses Zend_Http to launch the API calls, we might provide a hook in the model so that we can swap the HTTP adapter for the test adapter that ships with Zend Framework. We then have access to the entire request that the model launched, which we can use for assertions:

public function testJsonCall() {
  $adapter = new Zend_Http_Client_Adapter_Test();

  $response = "";
  $response .= "HTTP/1.1 200 OK" . "\r\n";
  $response .= "Content-type: application/json" . "\r\n";
  $response .= "\r\n";
  $response .= '{}';

  $adapter->setResponse($response);

  $model = new JsonModel();
  $model->setAdapter($this->adapter);

  $request_raw = $model->http_client->getLastRequest();
  // do your assertions here
}

Swap the endpoint

Instead of changing the adapter to intercept the call, we could swap the endpoint of the web service against a mock service. This endpoint then can respond with known data which we can use for our assertions.

Depending on what kind of web services we have to mock, we might use the servers provided by Zend, e.g. Zend_Rest_Server or Zend_Soap_Server.

A better understanding

Looking at the two strategies above, it still might seem to be a hassle to do, what is essentially a replication of the web service functionality with test data, whether that happens as mock object, on the request/response level, or as test endpoint.

But instead, this exercise is a very valuable documentation of ones understanding of the service functionality at a particular point in time. Given that service APIs are often in a constant state of change, things might break in the future, but the tests we've written can help us understand whether it's down to our own code or the web service instead. If things fail at the web service level, we can now refer to our tests to compare what we expect the service to do with what it actually does.

Related Links

• Unit Testing Code which Consumes SOAP Services
• Mocking with SoapUI
• Unit Testing with Stubs or Mocks

So, for myself as much as everyone out there, here is my collected useful knowledge that has helped me ease the pain of remote work.

1. Execute commands remotely as one-liners

This is what some deployment tools such as vlad use, but for a quick look at something, it cuts out valuable seconds you could look at web comics instead.

Let's try a simple example:

matthias:~ matthias$ ssh remoteuser@myserver.pretendco.com ls -l
remoteuser@myserver.pretendco.com's password: 
total 804
lrwxrwxrwx   1 remoteuser remoteuser      31 Nov 10  2007 access-logs -> /links/to/my/access-logs
drwxr-xr-x   2 remoteuser remoteuser    2048 Apr  6  2008 cgi-bin
-rw-r--r--   1 remoteuser remoteuser  808417 Jul 17  2007 error_log_dump
drwxr-x---   3 remoteuser mail     2048 Oct  1  2007 etc
drwxrwx---   7 remoteuser remoteuser    2048 Apr  4 02:33 mail
drwxr-x---   3 remoteuser remoteuser    2048 May 23  2008 public_ftp
drwxr-x---  30 remoteuser nobody   2048 Dec  4 06:33 public_html
drwxr-xr-x   7 remoteuser remoteuser    2048 Sep 24  2008 tmp
lrwxrwxrwx   1 remoteuser remoteuser      11 Apr  1  2006 www -> public_html
matthias:~ matthias$
		

You can even pipe through to a remote command. Here's an example taken from Look Here First, where the content of a local file is concatenated to a remote file.

matthias:~ matthias$ cat localfile.txt | ssh remoteuser@myserver.pretendco.com "cat - >> remotefile.txt"
		

2. Add your public key to your remote server

Next let's see how we can get around typing our password all the time. One way of doing this is to add your public key to your remote server.

# first, upload public key from client to server
client$ scp ~/.ssh/id_rsa.pub remoteuser@myserver.pretendco.com:~

# next, setup the public key on server
server$ mkdir ~/.ssh
server$ chmod 700 ~/.ssh
server$ cat ~/id_rsa.pub >> ~/.ssh/authorized_keys
server$ chmod 600 ~/.ssh/authorized_keys
server$ rm ~/id_rsa.pub
		

Of course, we can combine with the previous example and run it like this:

matthias:~ matthias$ cat ~/.ssh/id_dsa.pub | ssh remoteuser@myserver.pretendco.com "cat - >> ~/.ssh/authorized_keys2"
		

Windows users fear not, you can do this too, with PuTTY and PuTTYgen.

3. Let the ControlMaster handle your sessions

Sadly this might not always possible, maybe your key management on your server is different, or you don't have permissions to the file.

Luckily you can get around this by letting your first ssh connection act as ControlMaster. By adding the following to ~/.ssh/config, you only need to enter your password once, and all parallel sessions won't ask for a password

Host *
    ControlMaster auto
    ControlPath ~/.ssh/master-%r@%h:%p
		

4. Set your user and hostname for your host

Finally, more often than not your username won't be the same on your local machine and on whatever server you'd like to connect to, or your server might not use the default ssh port. Or maybe you're just tired of typing that superlong domain name, and look for a less challenging typing task. ~/.ssh/config to the rescue.

As final example:

Host myserver
    User remoteuser
    Port 22022
    HostName myserver.pretendco.com
		

Most likely you won't need the Port instruction in there, because your server runs ssh on the default port 22, so just drop the line.

All this allows us something as compact as:

matthias:~ matthias$ ssh myserver mycommand

Have fun, and let's hope this got you into your weekend early!

The Basic Idea

The initial thought behind this is that a model should be able to return calls either uncached or cached, without initializing some cache object every time. It should be easy to switch between the two calls, and the cache should be coming with the model object already.

The old way

Before introducing the cache pattern, I would create an object that then would use Zend_Cache_Frontend_Class, then initialize a new instance of my model in there, then redefine a method that acts as somewhat like a proxy, but uses the cache. And if that wasn't enough, I'd have to initialize them both, like in this example:

$model = MyModel();
$model_cached = MyModelCached();

$values_direct = $model->doStuff();
$values_cached = $model_cached->doStuff();

The new way

So Matthias asked me: Would it not be nicer if the cache was already available in the model, and you could do something like this:

$model = MyModel();
$values_direct = $model->doStuff();
$values_cached = $model->cache->doStuff();

A great idea. As you can see this proposed way saves a bit of code, it's intuitive and easy to change, if you ever need to switch between cached and non-cached calls.

The Code

First we need to create an object that initializes the cache. We'll initialize a cache with Zend_Cache and then utilize the __call function to check whether a call exists in the cached object or not. This enables us to only do valid calls.

class BaseModelCache {
  private $object;
  private $cache;
  
  public function __construct($object) {
    $backendName = 'File';
    $frontendName = 'Class';

    $frontendOptions = array(
      'lifetime' => 1800,
    );

    $backendOptions = array(
      'cache_dir' => '/my/cache/dir/',
    );

    $this->object = $object;
    $frontendOptions['cached_entity'] = $object;

    try {
      Zend_Loader::loadClass('Zend_Cache');
      $this->cache = Zend_Cache::factory($frontendName, $backendName, $frontendOptions, $backendOptions);     
    } catch(Exception $e) {
      throw($e);
    }
  }
  
  public function __call($method, $args) {
    $class = get_class($this->object);
    $class_methods = get_class_methods($class);

    if(in_array($method , $class_methods)) {
        $caller = Array($this->cache, $method);
        return call_user_func_array($caller, $args);
    }

    throw new Exception( " Method " . $method . " does not exist in this class " . get_class($class ) . "." );
  }
}

The second step is to create a base model class, that we'll use for all our models. It will initialize the cache object using the BaseModelCache and make it available as public property:

abstract class BaseModel {
  public $cache;

  public function __construct() {
    $this->cache = new BaseModelCache($this);
  }
}

Et Voilà! Now we can create models by extending the BaseModel. The cache will be available as described above.