So I created a small phing task which uploads a package to a channel server:

   <target name="deploy" description="Upload package to channel server">
    <input propertyname="version" defaultValue="" promptChar="?">Version</input>
    <input propertyname="username" defaultValue="" promptChar="?">Channel-Benutzer</input>
    <input propertyname="password" defaultValue="" promptChar="?">Channel-Passwort</input>
    <property name="channel">http://my-channel-server.com/pearfrontend.php</property>
    <property name="uploadFile">_build/PACKAGENAME-${version}.tgz</property>
    <exec command="curl -d "login=Submit&password=${password}&user=${username}" --cookie-jar /tmp/deployCookie -s ${channel} > /dev/null"></exec>
    <exec command="curl -F release=@${uploadFile} -F submitted=1 -F f=0 -F filename=${uploadFile} --cookie /tmp/deployCookie ${channel} > /tmp/deployCheck"></exec>
  </target>

I realize that this task lacks any error handling, so you might want to check your channel server afterwards. However so far this worked very well for me.

Pro tip: This is especially nice at the end of a Jenkins Build Pipeline.

Reinstalling xdebug did not help and I eventually found the solution in the Zend forums.

Here are the steps I used to get the current xDebug version (2.1.1) installed:

sudo -s
ftp http://pecl.php.net/get/xdebug-2.1.1.tgz
tar zxvf xdebug-2.1.1.tgz
cd xdebug-2.1.1
export CFLAGS="-arch i386 -arch x86_64 -g -Os -pipe -no-cpp-precomp"
export CCFLAGS="-arch i386 -arch x86_64 -g -Os -pipe"
export CXXFLAGS="-arch i386 -arch x86_64 -g -Os -pipe"
export LDFLAGS="-arch i386 -arch x86_64 -bind_at_load"
/usr/local/zend/bin/phpize
./configure --with-php-config=/usr/local/zend/bin/php-config
make
cp modules/xdebug.so /usr/local/zend/lib/php_extensions/xdebug.so

References in PHP are bad. Do not use them. They hurt and will just mess with things and do not expect to be able to outsmart the engine with references!

This is what I came up with:
Install Meld – a visual diff tool:

sudo apt-get install meld

To be able to launch Meld from the file browsers context menu install “Nautilus Actions” (Nautilus is the name of the Ubuntu file browser). Nautilus Actions is an extension to add custom entries to the context menu.
To install it type:

sudo apt-get install nautilus-actions

Launch it from System -> Settings -> Nautilus Actions
and add a new action with these settings:

1. Label: Compare
2. Icon: /usr/share/pixmaps/meld.png
3. Path: /usr/bin/meld
4. Parameters: %M
5. Conditions tab: Group “Appears if selection contains” select “Both”
6. check “Appears if selection has multiple files or folders”

Restart the file browser:

nautilus -q

Then you can select two files, right click, and select “Compare” and Meld will show you the differences between the selected files.

First an article title “The Number One Developer Productivity Tool” (via @weierohpinney) which refers to an article by Joel Spolsky.

And secondly David Heinemeier Hansson sums it up in my favorite-tweet-of-the-month:

How many people have you interrupted today by IM or phone or in-person where an email would have done just fine?

Ich habe den Leute-Podcast seit 4.9.2006 (damals zu Gast: Prof. Dieter Jauch, Direktor der Wilhelma) abonniert und seither auch fast keine Folge verpasst. Über die Zeit kamen viele Podcast auf meinen iPod – aber Leute ist der Einzige, der sich gehalten hat.

An die Herren Siller, Heim & Kollegen: weiter so…

To use it in a Zend Framework project I suggest the following steps:

1. Download und unpack Minify

2. Split up Minify according to the Zend Framework project structure

Assuming you are using the standard directory structure suggested for Zend Framework projects, copy the contents of “min/lib” from the Minify project to “library/minify/lib” in your project. The files “config.php”, “groupsConfig.php” and “index.php” go to a new directory under “public” called “minify”.

This steps ensures that only the necessary files are located in the public area of the project.

3. Configure Minify

Next we need to configure Minify. I suggest using the group feature to summarize all Javascript files into single URL – same goes for CSS.

Here is an example configuration:

return array(
'js' => array('//javascripts/prototype.js', '//javascripts/application.js'),
'css' => array('//stylesheets/application.css')
);

Of course you can have as many files in the groups as you like. If you need more – or different combination of files in groups throughout your website create groups accordingly.
You can test your groups by accessing the group url directly. E.g. the javascript url from the above example can be accessed through: http://server.name/minify/?g=js
This should display the grouped and minified javascript files.

4. Using the minified files

Now you can just use the above url to include the configured groups in your application, by using:

<script type="text/javascript" src="minify/?g=js"></script>

While this would work perfectly can could go even further. The above example will tell the browser to cache the contents for a given time (see config.php). This introduces a little conflict: If the timeout is small the cache will be refreshed more often than necessary. A higher value makes it difficult if you need to change something in your files, since not all browsers will get the changes when they appear.

Minifys solution to this is to add a second parameter which identifies any changes to the group. As long as this (numeric) identifier stays the same, there is no need to delivery the file again – caching is preferred. Once the identifier changes the files will be served to the browser again.

Sounds complicated  ? It’s not ! Minify brings some handy utilities making it easy.
Since we are using Zend Framework I would suggest to create a helper to encapsulate all this.

5. The minify helper

To let a helper do all the work with the caching identifier we change the SCRIPT-Tag to:

<script type="text/javascript" src="<?php echo $this->Minify('js') ?>"></script>

So it our soon-to-be-create Helpers job to construct the url to Minify group and take care about that caching stuff.

Here is the helper code:

class My_View_Helper_Minify {
  public function setView(Zend_View_Interface $view) {
    $this->view = $view;
  }
  public function Minify($group) {
    require_once 'minify/lib/Minify/Build.php';
    static $builds = array();
    static $gc = false;
    if (false === $gc) {
      $gc = (require '../public/minify/groupsConfig.php');
    }
    if (! isset($builds[$group])) {
      $builds[$group] = new Minify_Build($gc[$group]);
    }
    return $builds[$group]->uri($this->view->baseUrl.'/minify/?g='.$group);
 }
}

Note: Most if this code is taken from Minifys utils.php and packed into a ZF helper.

Summary
I implemented theses steps in 3 projects so far and the results are very good. I hope this helps to serve Javascript and CSS files more elegantly.

To fix this the phing scripts needs to be fixed.
Locate the script with:
which phing
edit the script to replace the line:
-logger phing.listener.AnsiColorLogger
to
-logger phing.listener.DefaultLogger

Little example ?

Open up Firebug for this page, select the Console tab and enter the following command into the Firebug command line:
$x(“/html/body/div[2]/div/h1″)
Result:
[h1]
Note: Hover the mouse over the h1 and you will see the corresponding element highlighted in the page.

Even better – to have a look at the inner HTML of the headline element enter:
$x(“/html/body/div[2]/div/h1″)[0].innerHTML