I’m really impressed with the WordPress plugin API and distribution system.  It’s well organized with great documentation.  I was psyched to see the little “upgrade available” button next to my own plugin once I published it to the WordPress plugin directory!  Even though I prefer object-oriented code, I have to admit the procedural style of WordPress code is consistent and easy to follow.

In the process I also had get my hands dirty with SimplePie RSS library that WordPress uses.  It does a nice job of parsing all kinds of RSS but I found it a bit difficult to debug feed errors.  Its also a little touchy with eBay feeds and there seems to be some glitches using set_feed_url(), so I would up accessing feed_url directly, which doesn’t seem right.  But it works so it’ll have to do for now.

If you give the plugin a try, feel free to leave a comment on directly the HungryFEED page.

The solution so far is to write a custom authentication plugin plus a component for Joomla.  The plugin handles sign-on and the component allows us to render basically anything within the content area of the Joomla site.  I was able to get proof-of-concept running today and not only does the Phreeze code render correctly inside the Joomla system, it wasn’t even necessary to merge the Phreeze code, it runs just fine with the source code in a separate folder from Joomla.  The component just has to do a little magic and configure some paths to make Phreeze happy.

This seems to be one of those rare moments where strict coding practices actually pays off.  I designed Phreeze to be an extremely modular MVC / ORM with the idea that we might one day use another rendering engine, or switch data engines.  We’re even in the process of swapping out direct database connection with REST services with no change to the views, which will be exciting.  Dependency injection is used for all the various parts so you can swap anything.  But I hadn’t really considered running the entire framework within another system.  So I was somewhat surprised when the code just ran with almost no configuration.

The biggest problem is with relative URLs.  Joomla I must say is pretty great about passing control to a component and then staying out of the way, even if you throw lots of weird querystring parameters on the end of the URL.  However, the relative paths to scripts, styles, images, etc are proving to be problematic.

I haven’t decided on the best approach yet but I’m considering simply writing new Views for Joomla.  This allows us to re-use all of our Model and Controller code.  I’d prefer to just use everything exactly as-is in each application but in some ways it might make more sense for the apps to render themselves differently when inside the Joomla system vs when running stand-alone.

Phreeze has a URL writer class which does help to solve the relative URL problem, however we didn’t use it consistently in all the views and so there is some cleanup to do.  Also this class isn’t accessible from within static JavaScript code, so that might get messy with some of the more advanced pages that make a lot of Ajax calls.

This is possibly my nerdiest post ever but it’s exciting to spend so much effort at writing adaptable code and then finally the day comes where you get to see it work in a totally unexpected way.

As you go through this walk-through, it helps to understand that WordPress MU was originally designed to create a branded, automated community of blogs using sub-domains such as user1.wordpress.com, user2.wordpress.com, etc.  You can sign up on wordpress.com right now and get your own instant blog, hosted on their servers.  You become a part of the wordpress.com community.  WordPress MU was designed to allow you to create your own communities under your own domain name branding.

This walk-through addresses a slightly different type of user which is perhaps a server admin or simply a person who runs several blogs.  There is no “community” and you don’t allow anonymous users to stop by and create a blog.  You might currently have WordPress installations on multiple servers with totally unrelated domains.  Keeping the code and plugins updated for multiple blogs gets to be a hassle, so the idea of a single, centralized WordPress install is appealing for maintenance reasons.  Thanks to WordPress’s flexible architecture you can do this, but it’s not part of the original design.

The reason I write all of this is to hopefully explain why TLDs are outside the scope of WordPress’s original design.  You can still set it up without understanding any of this, however it will make things easier if you know how the pieces fit together.

Requirements

To keep this simple I’m only going to write about the multi-site configuration.  I’m assuming you know how to install WordPress, edit config files on your server, create a MySQL database on your host and map sub-domains.  These things may be done differently depending on your host so you will need to do the research for your own host server.  If you run your own server you may have to know how to configure it for multiple domains as well.

DNS Configuration

Again, I’m not going to get into DNS configuration.  However, I will say that a simple setup is to simply point all of your domains to the same IP address and let WordPress do the rest.  You can also assign one domain an IP and then park each additional domain onto this one, which may save hosting fees.  WordPress relies on the hostname, so it doesn’t matter how you’ve configured Apache or IP addresses, so long as the domain maps to the physical location of your WordPress install.

As a handy tip – you can edit your local hosts file to point a domain to the IP of your WordPress installation and WordPress will install easily this way.  This is a great way to experiment and migrate over an existing site without taking the domain name offline.  If you don’t understand what this means, then don’t worry about it!

1. Install WordPress

Install using all defaults is fine.  You should install this onto the domain that you plan to use as your “master” domain.  My recommendation is to install it at the top level of your domain, for example “domain.com” (without the “www” prefix).  If you plan to use sub-domains for different sites then this will keep things simple.  You can always add “www” during site configuration, but you can’t remove it from your sub-domain sites if it was installed that way.  For example your sites will look like this: site1.www.domain.com  instead of simply site1.domain.com.

Verify that WordPress is running but don’t bother putting any content in at this point.  In the next few steps we’re going to enable new menu items one after the next that are necessary to use the multi-site feature.

2.Enable the WordPress Multi-Site Feature

Assuming WordPress is running, edit wp-config.php and add the following line:

define(‘WP_ALLOW_MULTISITE’, true);

After you add this line and save the file, return to the Worpress Admin page and look for a new menu item Tools->Network.  Navigate to this new menu and you’ll be prompted to “Create a Network” in order to enable the multi-site feature.

You have some choices as to whether you want to use sub-domains or sub-folders for your network.  Leave all the defaults and choose sub-domains.  We’re going to be using separate TLDs anyway so choosing sub-domains seems to make more sense to me.  If you choose folders, you’ll be on your own from this point forward.

Once you enable the network, you will be given text that you must copy and paste into an .htaccess file and some additional variables to be pasted into wp-config.php.  Do this as directed on the Network page.

After you edit these files and re-login you should see another new menu “Super Admin” which is above the dashboard menu.  Your site is now ready for multiple sites.

3. Install Plugin WordPress MU Domain Mapping

At this point your server is already setup to handle multiple sites, but we need to install a plugin in order to support TLDs.  The plugin to use is called “wordpress-mu-domain-mapping“  This plugin also includes a special file known as a “drop-in” which must be manually copied and hooks into the lower levels of the WordPress API.

You can install this plugin by manually uploading it, or through “Plugins->Add New.”  Just make sure
you install version .052 or higher.   After you have installed it, go ahead and activate the plugin.  You’ll notice that plugins now have an option to “Network Activate” which activates a plugin for all sites.

Once the plugin is installed, you need to manually install the Sunrise “drop-in”  which is included with the plugin source files.  You may either copy sunrise.php from /wp-content/plugins/wordpress-mu-domain-mapping/ to /wp-content/ or if you prefer  you can create a symbolic link (for example ln -s plugins/wordpress-mu-domain-mapping/sunrise.php.  I prefer the link myself).

Once you’ve copied or linked the file, you have to edit wp-config.php one last time and add the following line which will tell WordPress to activate the drop-in:

define( ‘SUNRISE’, ‘on’ );

Once you re-load the console you’ll once again have some new menu items.  This time they appear under the Super Admin menu and they are Domain Mapping and Domains.  The Domain Mapping has some settings that don’t actually need to be changed.  The Domains page is where we’ll map TLDs to a site (in the next step).

4. Create a Second Site

At this point your server is fully ready to support TLD sites, you just need to know how to add them.  The basic concept is that you create a site first using WordPress’s normal functionality.  Then you using the domain mapping plugin to map the TLD to the new site based on it’s Id.  Because WordPress doesn’t yet natively support TLDs, you have to do a little fudging with the forms.

First, under Super Admin go to the Sites page.  You’ll be confused because you have to choose a sub-domain for your site, even though we’re going to use a TLD.  That’s ok, just enter whatever you want as the sub-domain and add the site.

Now that you’ve added the site, you can click “Edit” under the new site and this will bring up a long page with lots of settings.  Don’t worry about changing everything right now but you do want to change these two fields: Domain and Fileupload URL.  These need to be changed to your new TLD:

At some point once WordPress natively supports TLDs you would probably be done at this point.  In fact you will be able to visit your new site if your domain is already configured, but you won’t be able to log into the admin panel for the site.  So we need to map the domain over to the new site.

Before you leave the Sites page, make a note of the ID of your new site.  (In the screenshot above, my site “whatever” has the ID of “8″).  If it’s a new install, then your ID will probably be “2″.

Head to the Super Admin -> Domains page and there is a form at the bottom to add a new Domain.  Leave the Primary checkbox checked.  Enter your site ID from above and the domain.  Click Save to add the mapping.

At this point you’re done and you should be able visit your site using your TLD as well as login to the admin panel.  I hope this tutorial worked for you and helped you to understand how WordPress MU feature works as well as some of it’s current shortcomings.

Please leave a comment if you have any suggestions to make this walk-through easier.

Fortunately there’s a simple solution . Just set  minHeight=”0″ and it will tell the component to not expand beyond the height of it’s Parent.  This works for any container with a vertical layout as well including Panels

There’s additionally an autoLayout property which can be set to false, however I can’t get consistent results with that.  It seems like there would be some more intuitive property name to control this behavior, but at least there is a solution.

// create an XML object with one child.
var parentXml:XML = ;

// parentXml.child is an XMLList.  add two new elements
parentXml.child[parentXml.child.length()] = ;
parentXml.child[parentXml.child.length()] = ;

// remove the 2nd item
delete parentXml.child[1];

Put this code inside a function and step through it in the debugger to see what’s happening.

One thing to note is that if you are binding controls to “parentXml”, the UI doens’t necessarily receive update events when the child nodes are manipulated.  In this case you may have to dispatch an event to force the UI to re-call the getter for parentXml.  Although, that is a subject for another post…

On the iPhone, though, the Address field in the account setup brings up a limited character keyboard and the comma is not one of the characters that you can type.  This would seem to indicate that the iPhone doesn’t support multiple addresses without adding a separate account for each.

What you can do, though is type your addresses, separated by commas in the Description field and then copy/paste the whole thing into the Account field.  The craziest part is that it actually works!  Once you paste your email addresses, you will see a “From” field when composing emails.  Clicking this field will allow you to choose your reply address – the same as the Mail desktop app.

It’s a little strange and surprising that Apple prevents you from typing the comma into that field, yet manages to support multiple reply-to addresses anyway.  It probably has some security implications for any application that rely on a limited character keyboard for input validation.  Because originally there was no copy/paste on the iPhone, it would have been impossible to type illegal characters.  With copy/paste, though, you can circumvent that limitation.

It’s my opinion that great programmers comment their code even if they’re the only person working on a project.  Not only does the small investment pay off later, it’s a simple habit that forces you to plan and proof-read your own work.  A poorly conceived function will become more apparent as you try to explain your thinking in the comments.  JavaDoc can be written before the code itself which helps to flesh out ideas before writing a lot of code.

To write effective comments, I try to find a balance between two things.  First, that someone might be reading only the generated documentation without access to the source code.  Second, comments that simply repeat the function and argument names are not helpful.  Great comments may briefly explain *what* a function does, but more importantly it should explain *why* the function exists.

Take this function as an example:

/**
 * this function adjusts the print margins
 */
private void adjustPrintMargins(int x, int y) {}

The comments for this function are basically worthless because it doesn’t give any information that wasn’t already apparent. The purpose of the function is fairly obvious and you might even thing that it could get by without comments.  Judging by the function name it obviously adjusts the print margin and x & y are an increment of some sort.  The function itself is possibly simple, but there’s actually a lot of vagueness.  This would probably require looking into the source code to figure out what it really does, which takes time.  Here’s the same function with some better documentation:

/**
 * Adjusts the margins of this document based on the printable area
 * allowed by the selected printer.  This function is called by Printer.preRender()
 * immediately before the document is spooled for printing.
 *
 * @todo: add validation to ensure x/y are legitimate values
 * @param int the minimum horizontal margin (in pixels) supported by the printer
 * @param int the minimum vertical margin (in pixels) supported by the printer
 */
private void adjustPrintMargins(int x, int y) {}

Oh brother, who wants to type out all of that garbage, right?  Well if you’re using a decent IDE it would have auto-generated all of the formatting and @params as soon as you typed /**.  After that it took about one minute to type the actual text.

The comments above give a brief description of what the function does, but it also clarifies some of the vagueness and gives a little more detail about *why* the function is necessary.  Another important detail is that it mentions *when* this function would normally be called – by another function Printer.preRender().  (If this function was called from a lot of places, though, it might be better to describe when it’s called more generally, perhaps mention the circumstances or types of objects that would call it.)  Lastly, there’s a TODO in the comments which could indicate some part of the functionality that isn’t fully implemented or isn’t as clean as it could be.  This didn’t take much time to type, but there’s a lot of really helpful information that could allow you to utilize or refactor this function with a little more confidence.  Without these comments it might be easy to figure out what the function does, but perhaps no so easy why it is necessary.  You might have to set breakpoints and trace the code backwards to figure that out.  Turning on the debugger just to figure out why a particular function is called can waste a lot of time.  It might take an hour to trace the code backwards, whereas it only took about one minute to write the comments.

Auto-complete in Eclipse w/ PDT Plug-in for PHP

The comments themselves are important, but learning to write proper JavaDoc gives you even more added value.  Even if you aren’t writing in Java, it’s used as the basis for just about every language.  Of course you can use any number of open source tools to generate nicely formatted documentation.  Additionally many IDEs will parse javadoc and display it when auto-completing functions.  Even the best programmers don’t remember the arguments for every function they’ve ever written.  Having auto-complete display documentation for you inline as you type will pay off again and again, saving you huge amounts of time.

The cause of this weird behavior could be that your server’s hard drive has run out of free space.   To check your server’s drive space on a Unix machine, you use the “df” command.  This will show you a percentage of used space.  If it’s in the high 90′s then obviously you need to clean out some files or upgrade the hardware.

This can cause a wide variety of very strange symptoms including:

• Permission denied errors are thrown when opening, writing or closing files even though PHP has full permission granted
• PHP stops appending to log files
• PHP can create new files, but they are empty even though you are expecting PHP to write some data)
• PHP can’t start new sessions, or doesn’t remember user’s session (because it can’t write session files)
• Unknown error in Line 0.  (This actually occurs if you have an exception in your destructor, however this is a common place to close file handles so you might see this error)

Obviously the server is in an unreliable state so it’s likely to cause all kinds of weird and seemingly random behavior.  If you notice any other symptoms feel free to post a comment.

PDT Screenshot

Installing PDT (PHP Development Tools) Plugin for FlexBuilder allows you to work with PHP projects within the FlexBuilder environment.  This is useful if you are using AMFPHP, WebORB for PHP or some other PHP-based remote server.  There are similar instructions posted elsewhere, however I found that they have become outdated.  Because FlexBuilder 3 is based on an older release of Eclipse, you now have to specifically install older versions of the PDT files.

Note – If you are using a recent version of Eclipse with FlexBuilder plugin, or are using FlexBuilder 4 then you should not follow these instructions – instead install the most recent version of PDT.  These instructions are only necessary for FlexBuilder 3 Stand-Alone edition.

Installing PDT:

1. Open FlexBuilder 3 menu Help->Software Updates->Find and Install
2. Search for new feature to install
3. Click “New Remote Site” and enter the following:
   • Name: PDT 1.x
   • URL: http://download.eclipse.org/tools/pdt/updates/
     (note is that this URL is to the old 1.x update site)
4. After adding the site, click OK and select the following two Sites to include:
   • Europa Discovery Site
   • PDT 1.x
5. Click “Finish” to begin searching for updates
6. Once the results are displayed, un-check the box that says “Show latest version of a feature only”
7. Expand PDT 1.x and select PDT SDK 1.0.3
   (important – do not select a higher version than 1.0.3)
8. After you have selected PDT SDK, you may have required libraries missing.  You can try at this point clicking “Select Required” and they will be automatically selected from the Europa Discovery Site.  However, this sometimes causes FlexBuilder to lock up.  In which case, you have to force quit FlexBuilder, start the process over and manually select the required libraries which are:
   • Graphical Editors and Frameworks->Graphical Editing Framework 3.3.2
   • Java Development->Eclipse Java Development Tools 3.3.2
   • Models and Model Development->Eclipse Modeling Framework (EMF) Runtime + End-User Tools 2.3.2
   • Models and Model Development->XML Schema Infoset Model (XSD) Extender SDK 2.3.2
   • Web and JEE Development->Web Standard Tools (WST) Project 2.0.2
     (if any of these libraries are missing and do not appear, it probably means that you have already installed them)
9. You should now be able to click “Finish” and agree to the license.  You can then restart the app and begin working with PHP project within FlexBuilder.

Configure Smarty (TPL) Template Editing

There is another project called smartypdt – however it doesn’t seem to be compatible with the older version of PDT – at least I couldn’t get it working.  Instead I simply configure TPL files to open using the PHP editor:

1. Open the menu Window->Preferences
2. Navigate in preferences to General->Content Types
3. Expand the Text node and highlight “PHP Content Types”
4. In the File associations list, add *.tpl

At this point you should be able to open a PHP folder and edit both PHP and TPL files.  If you configure your include path correctly, you should have code insight on your PHP classes and functions.

-- the statement below is almost the same as
-- select lpad(mycolumn,'0',10) from mytable

select substr('0000000000' || mycolumn, -10, 10) from mytable

-- the statement below is almost the same as
-- select rpad(mycolumn,'0',10) from mytable

select substr(mycolumn || '0000000000', 1, 10) from mytable

The statement is fairly self-explanatory, but in case it doesn’t make sense we’re simply adding a big long string of characters to the original value and then truncating it down to the desired length.  The string used for concatenation has to be at least the same length that you are padding – 10 characters is used in this example (’0000000000′).

In most cases this workaround produces the same results as lpad/rpad except in the case where the length of your original value is greater than the length that you are padding.  In which case the original value would get truncated.  Usually when you are padding you know what the maximum length of the column anyway.

If you know of a more efficient technique, please post a comment.