In Eclipse I have every project checked out in ~/workspace/ so every directory with the matching server root would need to be switched. This shell script handled all the svn switch –relocate statements for me. Replace oldservername and newservername.

for dir in `ls -1 */.svn/entries | xargs grep -H -l oldservername | grep -E -o "^[^\/]+"`; do
svn switch --relocate `svn info $dir | grep ^Repository\ Root | cut -f 3 -d ' '` `svn info $dir | grep ^Repository\ Root | cut -f 3 -d ' ' | sed 's/oldservername/newservername/'` $dir
done

It may be best to make a backup of your project directories, especially if you have local uncommitted changes. This script works on bash-like command lines, such as Mac OS X.

“When the Union Delegates called upon me to insist that none but men who had seven years’ apprenticeship should be employed in the works, I told them that I preferred employing a man who had acquired the requisite mechanical skill in two years rather than another who was so stupid as to require seven years’ teaching. The delegates regarded this statement as preposterous and heretical. In fact, it was high treason. But in the long run we carried our point.”

James Nasmyth: Engineer; an autobiography by James Nasmyth

What I’ve been working on the past couple of days months is a new PEAR channel frontend; the basis for the PEAR2 website. I wanted a simple PEAR channel frontend, that just looks at the local filesystem for all the channel info, and would display the basics: what packages are available, categories, releases etc. Basically, just a simple web view that would not need a database backend, or any complex installation.

It would be simple to create a standalone library that just parsed xml files and read out the data, but having each underlying piece a reusable component would be very beneficial.

• a simpler XML library for parsing files
• an HTTP request library
• a library to talk to PEAR channels
• a simple templating system with php as the template language
• html/css templates to present the content in

So when you consider the all the pieces that are required, this is quite an undertaking.

Implementation:

Ordinarily the pear installer, or pyrus, communicates to a PEAR channel through the xml files that describe the packages available. What we’ve done, is used the installer as the backbone for channel discovery and information retrieval, and we’ve told it to look at the local filesystem instead of at a remote channel. This is done using a “filesystem” adapter for the PEAR2_HTTP_Request package, which turns your local filesystem into a fake Internet. This is a fairly simple concept, that makes for a very simple PEAR channel frontend.

So, if you couple that model for data retrieval with a completely new PHP 5.3+ template system with roots in Savant, we’ve got a really nifty base for building pear channel websites.

So! The package is in the pear2 sandbox and is titled PEAR2_SimpleChannelFrontend as a companion to the PEAR2_SimpleChannelServer which makes channel creation (with categories!) a breeze.

I’ve added it to my local PEAR channel by simply dropping the .phar file in the web root as index.php, add a small .htaccess file and that’s all that is needed. Check it out at http://pear.saltybeagle.com/

As of tonight you can try it out for yourself by grabbing the PEAR2_SimpleChannelFrontend-0.1.0.phar off of the PEAR2 website and saving it along side your channel.xml and browsing to the phar file. I named it index.php for simplicity, and placed the following .htaccess file in place:

<IfModule mod_rewrite.c>
RewriteEngine On
RewriteBase /
RewriteCond %{REQUEST_FILENAME} !-f
RewriteCond %{REQUEST_FILENAME} !-d
RewriteRule . index.php [L]
</IfModule>

Also, my thanks to Amir for the coding help with SimpleChannelFrontend, and the pear2 site. Things are moving along quite nicely.

Savant is the foundation of the top PHP-based templating systems. In particular Solar View and Zend Framework’s View have roots in Savant and the great work of Paul M. Jones. Each of these are very successful templating systems, and they make for a proven foundation for templating and ease of use. So now that PEAR2 is gathering energy, and needs a strong templating system, Savant makes a good fit. But, with PEAR2, we have a lot of new features available with PHP 5.3, which means we can re-think some aspects of templating.

First, I want to talk about template/view annoyances, then about how Savant has solved these issues in PEAR2_Templates_Savant.

Annoyances:

1.) assigning data to the view

This is a problematic issue. Either you manually assign all of the data to the view, or choose individual pieces of data. Assigning individual pieces takes too much time and can lead to missing data in the view if new fields are added to a model and not assigned, or mismatched variable names. Data assignment is also difficult when the model uses magic methods or iterators for data retrieval.

2.) view selection

If you’re a sane person you probably have a pretty strong map between your models and views. Meaning, for the BaseballPlayer model, you’re probably going to be using a BaseballPlayer[.tpl.php|.phtml] file. This model to view mapping should be logical and happen automatically.

3.) isolation/sandboxing view data and template system

The data used within the view should be isolated from the templating system. The contextual data should not interfere with the templating system and vice-versa. Protected/private methods in the template system should not be callable within the template.

4.) view system setup

You should only have to set up your view system once per application, not per template.

5.) controller and flow logic in templates

It’s easier to maintain one template file for the site rather than separate sandwich templates pieces for the header and footer. The sandwich template method can lead to out of sync HTML tags, but it is difficult to use one template for the site without introducing controller logic into this view.

6.) data escaping

Sometimes this is necessary, sometimes it isn’t. Should the developer handle this or the designer? Does it matter? Flexibility should be allowed for either, and if we want data to be escaped it should happen automatically while still allowing access to un-escaped data if I know what I’m doing.

PEAR2_Templates_Savant – A New Hope

First, I want to talk about the concept of partial templates. If you’ve used the partial helper within Zend View or Solar View, you know how beneficial this can be. Partials are a simple way to break up large templates into smaller templates. This makes for a very object-oriented template usage, which matches many MVC applications, and also aids in data isolation and limiting variable scope. This is the default method of rendering in PEAR2_Templates_Savant.

Now the pitch.

How PEAR2_Templates_Savant fixes the annoyances above

1.) assigning data to the view

Because partials are the default method of rendering, there is no more assignment of data to the view. The data is made available to the template as the $context variable. This means instead of $view->name = $baseballplayer->name; or using $view->assign($baseballplayer);, you’ll simply use $view->render($baseballplayer, [tpl]);

This means that there is never any confusion about what data was assigned, or how to access the data from within the template. It also means that views have access to the public methods of the object rendered, which helps for objects which use getters and setters, or magic methods for data retrieval.

For those of you used to the old way, you can still pass a stdClass object with your own custom assignments.

2.) view selection

The render method accepts two parameters, contextual data and the template you wish to use. BOTH are optional arguments, but the magic happens when the template name is null.

Back to our ’sane’ developers who know that a BaseballPlayer object should always be rendered using the BaseballPlayer.tpl.php template. They have taken the time to build a good structure for the models in their applications, and by doing so, their life is made easier by eliminating what template to select. PEAR2_Templates_Savant uses a mapper which will map objects to templates (configurable of course). The default mapper simply maps class names to template files.

BaseballPlayer => BaseballPlayer.tpl.php
BaseballCoach => BaseballCoach.tpl.php
BaseballTeam_Phillies => BaseballTeam/Phillies.tpl.php
BaseballTeam\Phillies => BaseballTeam/Phillies.tpl.php

You can assign simple replacements to apply to the class name and the file extension is also customizable for the .phtml fans out there. Of course you can provide your own template mapper which implements the MapperInterface.

ClassToTemplateMapper.php

3.) isolation/sandboxing view data and template system

This is where PHP 5.3 shines. Closures allow us to create little sandboxes for data to play in. Feel free to pass in a __config value to the view, knowing that the data won’t interfere with the view object (who would do this?) – without using nasty global variables. Also, your template system can have private/protected methods which aren’t available inside the view which makes the class easy to extend if you need to customize. Side effect, we don’t use $this-> to get to the data, we use the $context to access data given to the view, and $savant to render further partial templates. Win for data and template separation!

4.) view system setup

Because partials are used as the default rendering, the view setup happens once and is used through the entire application.

5.) controller and flow logic in templates

When used in an application which maps objects to templates, this makes it very easy to pass off data to other templates without knowing the type of data. This means there’s no more controller-ish logic within a template such as:

<html>
…
<body>
<?php
if ($this->mydata instanceof BaseballPlayer) echo $this->partial('baseballplayer.tpl.php', array('name', $this->mydata->name));
elseif ($this->mydata instanceof BaseballTeam) echo $this->partial('baseballteam.tpl.php', array('name', $this->mydata->name));
?>
</body>
</html>

Now, you can create one outer page template, and hand off data to another template without having to know what type of data is:

<html>
…
<body>
<?php echo $savant->render($context->mydata); ?>
</body>
</html>

Objects are mapped to templates, arrays are looped over, strings, ints, doubles etc are returned after they’ve passed through any escape methods you’ve assigned.

6.) data escaping

If the developer assigns methods to escape data, this happens automatically. This is handled through an ObjectProxy which handles all requests to the inner object. If you need direct/raw access to unescaped data, you can use $context->__raw(’fieldName’);

This makes escaping easy, automatic, and avoidable if you know what you’re doing.

Teh End.

There are a few other nuances that I can share in another post, but those are the basics. Also, I want to really thank Greg Beaver who contributed many of the ideas for the latest version of Savant – including the title of this post, so thanks Greg!

So feel free to try it out and give some feedback. And so far things are shaping up nicely in the PEAR2 universe – definitely something to keep an eye on in my biased opinion.

A full example is available in the repository.

The development version of PEAR2_Templates_Savant is available through the svn repository, or installable with pyrus.

SVN:
svn checkout http://svn.php.net/repository/pear2/Templates_Savant/trunk

Browse online:
http://svn.php.net/viewvc/pear2/Templates_Savant/trunk/src/Templates/Savant/

On the (under construction) PEAR2 website:
PEAR2_Templates_Savant

Install with pyrus
php pyrus.phar /putithere install PEAR2_Templates_Savant-0.1.0

Security concerns aside, I thought this would be a fun/juvenile coding experiment, and something that could showcase how easy the pyrus api is for installing PEAR packages. So here it is, pushed out on github – http://github.com/saltybeagle/AutoloadPackage/blob/master/AutoloadPackage.php

Only 56 lines of code to have an autoloader that will install a PEAR2 package. Now if that’s not fun, I don’t know what is.

Oh, and you should really check out Pyrus, the new PEAR installer. Get it over at the pear2 website (under construction).

Many times I’ve been frustrated with the same-origin policy for AJAX requests. I have legitimate content on another domain that I would like to retrieve and display on another page using AJAX.

As an example, department.unl.edu would like to display a list of upcoming events from events.unl.edu/department/.

Historically you would have to serve the content out as JSON, or use a proxy to convert the content to json, and reference the resource using a script tag which gets around the same-origin policy – and for years, this has worked well.

Unfortunately this requires you to either send content out in multiple formats (html + json for these requests), or use html and send all requests for cross-site resources through a proxy script, which adds a translation delay.

Serving the content out in two formats requires more work to maintain, and if the content output is cached, requires more resources to generate. If you use a proxy to translate the content, you have an open proxy unless you lock down what resources the proxy script can retrieve and translate.

CORS is the Answer

The answer is in the Cross-Origin Resource Sharing specification, which is supported in Firefox 3.5+, Safari 4+ and albeit using agent specific methods, supported in Internet Explorer 8+.

The specification allows resources on other domains to be retrieved through AJAX methods, if the resource announces support as a Cross-Origin Resource. This is done through special headers which identify to the user-agent which alternate origin domains can request the resource and what methods are supported.

Demo

For the demo, the html and js is served off of this domain, and the CORS resource is located on ucommbieber.unl.edu.

Click here to go to the demo.

This page demonstrates both GET and POST methods, with custom callbacks, using an api just like the jQuery get and post methods.

The HTML:

<html>
<script type="text/javascript" src="http://jqueryjs.googlecode.com/files/jquery-1.3.2.min.js"></script>

<script type="text/javascript" src="cors.js"></script>
<script type="text/javascript">

function testGet()
{
    getCORS('http://ucommbieber.unl.edu/CORS/cors.php', null, function(data){alert(data);});
}
function testPost(form)
{
    postCORS('http://ucommbieber.unl.edu/CORS/cors.php', {name: form.name.value}, function(data){alert(data);});
}
</script>
<body>
<h1>CORS Examples</h1>

<p>Test GET
    This page retrieves content from another server, using CORS<br />
    <a href="#" onclick="testGet(); return false;">Get content from another server</a>
</p>

<p>Test POST:
    <form action="#" onsubmit="testPost(this); return false">

        Name: <input type="text" name="name" />
        <input type="submit" />
    </form>

</p>
<a href="http://saltybeagle.com/2009/09/cross-origin-resource-sharing-demo/">More info</a>
</body>
</html>

The javascript:

/**
 * This is for Cross-site Origin Resource Sharing (CORS) requests.
 *
 * Additionally the script will fail-over to a proxy if you have one set up.
 *
 * @param string   url      the url to retrieve
 * @param mixed    data     data to send along with the get request [optional]
 * @param function callback function to call on successful result [optional]
 * @param string   type     the type of data to be returned [optional]
 */
function getCORS(url, data, callback, type) {
    try {
        // Try using jQuery to get data
        jQuery.get(url, data, callback, type);
    } catch(e) {
        // jQuery get() failed, try IE8 CORS, or use the proxy
        if (jQuery.browser.msie && window.XDomainRequest) {
            // Use Microsoft XDR
            var xdr = new XDomainRequest();
            xdr.open("get", url);
            xdr.onload = function() {
                callback(this.responseText, 'success');
            };
            xdr.send();
        } else {
            try {
                // Ancient browser, use our proxy
                var mycallback = function() {
                    var textstatus = 'error';
                    var data = 'error';
                    if ((this.readyState == 4)
                        && (this.status == '200')) {
                        textstatus = 'success';
                        data = this.responseText;
                    }
                    callback(data, textstatus);
                };
                // proxy_xmlhttp is a separate script you'll have to set up
                request = new proxy_xmlhttp();
                request.open('GET', url, true);
                request.onreadystatechange = mycallback;
                request.send();
            } catch(e) {
                // Could not fetch using the proxy
            }
        }
    }
}

/**
 * This method is for Cross-site Origin Resource Sharing (CORS) POSTs
 *
 * @param string   url      the url to post to
 * @param mixed    data     additional data to send [optional]
 * @param function callback a function to call on success [optional]
 * @param string   type     the type of data to be returned [optional]
 */
function postCORS(url, data, callback, type)
{
    try {
        // Try using jQuery to POST
        jQuery.post(url, data, callback, type);
    } catch(e) {
        // jQuery POST failed
        var params = '';
        for (key in data) {
            params = params+'&'+key+'='+data[key];
        }
        // Try XDR, or use the proxy
        if (jQuery.browser.msie && window.XDomainRequest) {
            // Use XDR
            var xdr = new XDomainRequest();
            xdr.open("post", url);
            xdr.send(params);
            xdr.onload = function() {
                callback(xdr.responseText, 'success');
            };
        } else {
            try {
                // Use the proxy to post the data.
                request = new proxy_xmlhttp();
                request.open('POST', url, true);
                request.setRequestHeader('Content-Type', 'application/x-www-form-urlencoded');
                request.send(params);
            } catch(e) {
                // could not post using the proxy
            }
        }
    }
}

The PHP code responding from the server looks like this:

<?php

Note the special headers that have to be returned to allow the request to complete:
Access-Control-Allow-Origin: *
Access-Control-Allow-Methods: GET, POST, OPTIONS
Access-Control-Allow-Headers: X-Requested-With

The X-Requested-With allows us to use jQuery’s internal GET method which adds in the additional header.

View all the code on GitHub.

Support for proxy fallback for older browsers is left up to you to code. The proxy requires you to set up a script which translates a page into JSON and handles the response. There are many examples of how to do this.

Today’s issue was enabling virtual hosts on Apache & Mac OS X. Normally not a big deal, but I was stumped for a while by a simple error. Apache would not start, and apachectl was giving me no error.

The workaround to find out what the heck was going on was just to execute httpd directly, which showed me what the problem was:

Syntax error on line 37 of /private/etc/apache2/extra/httpd-vhosts.conf:
CustomLog takes two or three arguments, a file name, a custom log format string or format name, and an optional "env=" clause (see docs)

Well the issue is, the default vhosts file on Mac OS X has a misplaced double quote:

CustomLog "/private/var/log/apache2/dummy-host2.example.com-access_log common"

Which should be:

CustomLog "/private/var/log/apache2/dummy-host2.example.com-access_log" common

of course.

So, the simple instructions:
edit /etc/apache2/httpd.conf and uncomment the line that says:
Include /private/etc/apache2/extra/httpd-vhosts.conf

Now add your virtual hosts by editing the
/etc/apache2/extra/httpd-vhosts.conf file, make sure you place that double quote in the correct place if you’re defining custom log files.

Then run sudo apachectl graceful

I’ve added in the patch from Sune, and released it as Salty_PEAR_Server_RemoteReleaseDeployer-0.1.0.

You can grab the release here, or install it with

pear channel-discover pear.saltybeagle.com
pear install salty/Salty_PEAR_Server_RemoteReleaseDeployer-0.1.0

Thanks Sune!

Meetup if you’re interested.