In the last few days, I’ve put together a quick site to try to help introduce people to the BackPress project. From the site:

BackPress is a PHP library of core functionality for web applications. It grew out of the immensely popular WordPress project, and is also the core of the bbPress and GlotPress sister-projects.

So effectively, BackPress takes all of the best core functionality (on a code level) from WordPress and bbPress, and makes it available to you and your next PHP-based web application/project. By using BackPress in your projects, you are then able to use most of the code you’ve come to rely on while working on WordPress-based projects, such as $wpdb, trailingslashit(), make_clickable(), __(), wp_remote_fopen() and more. The site includes some details on how to use BackPress in your project, and has the beginnings of a collection of documentation covering the main parts of the code library.

I’m personally really excited about this because I think BackPress has huge potential as a library for other folks and other projects. It allows them to benefit from the lessons learned through years (and thousands of “man-hours” worth of development) on the WordPress and bbPress projects. I’m using it as the core of my HTFS project (not released yet), and I know that some other projects are starting to use it as well. As a developer who has spent a lot of time in “WordPress land”, it makes life so much easier to be able to continue using a lot of the design patterns and techniques that I’ve become accustomed to.

Check it out, and please let me know what else we could get on the site, what needs more documentation etc!

Some LDAP Terminology

• LDAP – Lightweight Directory Access Protocol. It’s a system for accessing a “directory” of information in a structured way
• DN – Distinguished Name. It identifies a specific entry by either a series of RDNs, or a search string, to locate that particular entry.
• RDN – Relative Distinguished Name. Basically a portion of a DN.
• CN – Common Name. This is the general purpose “name” of an entry, and is usually used as part of the DN for an entry.
• DC – Domain Component. This is also part of a DN/RDN, and is often used to define the name of your service/directory/top-level-domain.
• directory – your collection of entries that you want to access via LDAP (it’s the D in LDAP!)
• schema – the “design” of your directory. Refers to the hierarchy of entries within your directory.
• top – the “root” level entry of your schema.
• objectClass – a group of attributes, commonly used to describe a particular type of information. For example the inetOrgPerson objectClass contains a group of attributes for describing a person, with common internet-based communication methods.
• attribute – a single piece of information belonging to an entry in your directory
• LDIF – LDAP Data Interchange Format. This is a simple, text-based format used to read/write LDAP entries. It is in “attributeName: value” format, with one entry per line, so it’s very easy to read/handle on the command line or via code.

Setting Up an LDAP Server

• OpenLDAP is easy to install/configure, and is available via package managers for most common *NIX OSes.
• You need to set up your DC correctly in the slapd configuration files so that you have something to connect to.
• Run slapd in debug mode so that you can get some useful information and see what is and isn’t working while you’re figuring things out.

Custom objectClass Creation

In our case, we needed some attributes that weren’t available in any of the objectClasses that were being loaded by OpenLDAP, so we decided to create our own. OpenLDAP was loading the config files for a lot of attributes, but until they’re included in an objectClass, and that objectClass is referenced in your entry, you can’t use those attributes. Here’s what we came up with:

objectclass ( 1.1.1.1.1.1.1.1.1.1.1.1.1 NAME 'vCardPerson' SUP inetOrgPerson STRUCTURAL
 MAY ( additionalName $ personalTitle $ honorificSuffix $ bday $ tz $ sourceURI ) )

Basically we just created an objectClass called “vCardPerson” which inherited everything (SUP) from inetOrgPerson, then added a few optional (MAY) attributes. The 1.1.1….. is a garbage number that we made up. You’re supposed to register and get a unique number to identify every objectClass from IANA, but, well, we were working on an experimental project so we didn’t bother

Working with LDAP via PHP

• If you get an error message: “Object Class violation”, then you’re probably trying to set an attribute which isn’t available. You might need to include another objectClass (or define your own) so that you have access to that attribute.
• Connecting and Binding to an LDAP server is pretty easy once you have things set up. You will probably use something similar to this:

  $ldap = ldap_connect( 'ldap://ldaphostname.com/' );
  if ( $ldap ) {
   $bind = ldap_bind( $ldap, 'cn=admin,dc=nodomain', 'password' );
   if ( !$bind ) {
   echo 'Failed to connect to LDAP server!';
   exit;
   }
  }

• A DN should probably include a unique identifier to make life easier, ours ended up looking something like this (where uid changed for each entry):

  uid=123,dc=1234,dc=nodomain

• Creating an entry (and saving it in LDAP) is as easy as creating an array and then calling a PHP function. Each of the array elements matches up to an LDAP attribute, and you just need to be sure to include an objectClass entry to define which attributes you’re using. Here’s an example (assuming you’re connected to an LDAP server via $ldap and have defined a new, unique DN via $dn):

  $entry = array();
  $entry['objectClass']     = array( 'top', 'person', 'organizationalPerson', 'inetOrgPerson', 'hCard' );
  $entry['cn']              = array( 'Billy Bob' ); // Common Name
  $entry['sn']              = array( 'Bob' ); // Surname/Family Name
  $entry['gn']              = array( 'Billy' ); // Given Name
  $entry['displayName']     = array( 'BillyBob' ); // Nickname
  $entry['mail']            = array( 'billy@bob.com' ); // Email
  $entry['labeledURI']      = array( 'http://billybob.com' );
  $entry['mobile']          = array( '+12345678912' ); // Mobile number
  
  if ( !ldap_add( $ldap, $dn, $entry ) ) {
   echo ldap_error( $ldap );
  } else {
   echo 'Successfully added entry';
  }

Hopefully I’ll be able to add to this over time as I learn some more bits and pieces with LDAP. Do you have any good pointers or explanations for how LDAP works? Please add them in the comments!

That project is available for download now, under the name ListML. Check it out, I use it all the time, so will probably continue developing it. At the moment it’s just a simple script that you drop into a directory, then drop other TXT files in there to view them as HTML. We’ll see where it ends up. If you’ve got any suggestions or find any bugs, feel free to post them as a comment here and I’ll fix things up. I already have some ideas on new features:

• Ability to load external files (from URL)
• List files in the current directory if none specified
• Cut out the parsing engine properly to make it more portable
• Make the HTML view (optionally) into a lightweight editor as well
• Quick UI for grabbing the HTML snippet of just the list (sans CSS/extras)

Please grab a copy, try it out and let me know what you think. It hasn’t actually been used for anything useful yet, so I’m also interested to hear what you’re using it for!

<?php

$zero_string  = '0';
$zero_int     = 0;
$false        = false;
$empty_string = '';
$array        = array();
$obj          = new stdClass();

echo empty( $zero_string ) ? "'0' = empty\n" : '';
echo empty( $zero_int ) ? "0 = empty\n" : '';
echo empty( $false ) ? "false = empty\n" : '';
echo empty( $empty_string ) ? "'' = empty\n" : '';
echo empty( $array ) ? "array() = empty\n" : '';
echo empty( $obj ) ? "stdClass() = empty\n" : '';
echo empty( $foo ) ? "foo is empty (and the variable was never set)\n" : '';

As it turns out, it’s been quite a project. LiveJournal’s API is, shall we say, “challenging” to work with, and the sheer size of Guav’s journal (over 3,700 posts and nearly 200,000 comments) meant that I kept running into time, memory and database limits that would crash the importer. After a lot of back and forth with Guav though, I’m happy to present the new importer (find it under Tools > Import > LiveJournal), sporting the following features:

• Just enter your LiveJournal username and password and you’re ready to go
• Via the API, it connects directly to LiveJournal and imports all of your posts,
  • Posts marked as “Friends Only” are assigned a password within WordPress,
  • Posts marked as “Private (you only)” are marked as Private within WordPress, which means that only authors on your new blog can read them,
  • lj-cut tags are converted to the WordPress equivalent, the <! — more — > tag,
  • lj-user tags are converted to normal links, and have class=”lj-user” attached to them to make it easier to style them if you like,
  • Tags are imported properly,
  • If you closed the comments on a post in LiveJournal, then they’ll be closed in WordPress as well,
  • Lots of the “meta” information related to posts is also imported using WordPress’ Custom Fields feature. You could then use these values to reproduce some of LiveJournal’s functionality within your new theme if you like. The fields imported are:
    • If your post contains adult content (lj_adult_content),
    • Your current co-ordinates and location (lj_current_coords and lj_current_location),
    • Your current mood (lj_current_mood),
    • Current music (lj_current_music),
    • Your userpic keyword (lj_picture_keyword)
• Next up, all of your comments are also imported,
  • Threading is preserved, so replies to other comments show up successfully (provided you enable that feature in WordPress),
  • The “subject” of each comment is included as the first line of the comment itself, because WordPress doesn’t have a comment title/subject value,
  • LiveJournal users get links back to their LiveJournals,
  • Your own comments are linked to your WordPress account, and are linked back to your new WordPress blog,
  • Anonymous users are labeled as “Anonymous”,
  • “Screened” comments on LiveJournal are imported as “Unapproved” within WordPress, so you can decide what to do with them

So there you have it, a brand new, shiny LiveJournal importer. This should be bundled with the 2.8 release of WordPress (it’s available right now on WordPress.com), and will be available for everyone. As I mentioned, it’s been tested with one single, very large blog (and a few smaller test ones), but if you find anything wrong with it, please file a bug on the WordPress Trac!

Huge thanks again to Guav for helping with the testing of this thing (maybe now he can migrate over to WordPress as well)!

Check out FeedGrowler’s project page »

PHP was the new Perl, written for the web

Ruby (+ Rails) is the new PHP, written for web 2.0

I guess that means I’d better get on the bandwagon and figure it out!

I’m now in touch with one of their people who’s handling the actual implementation of their APIs, so hopefully I’ll be able to work out what’s going on and add LJ support to the code library soon. At the moment, my WSSE authentication is failing on the second request to their API, even though it’s working on the first one… curious.

Last night, I debugged the code that I was writing before I went to bed, in my sleep! I was working on my soon-to-be-released PHP Atom API package last night, as has been the case on many nights recently, and it got to be pretty late. I showered up, went to bed and all was well.

When I woke up this morning – I had memories of dreaming my way through the code that I had been working on the night before (1,500 lines, so no small feat ), and in my dream, I had found a style of catching errors on some of my processing which wouldn’t actually catch anything, and would always evaluate as if there was no error. I got up this morning and checked it, and sure enough – I was more coherent in my dream than I was while sitting in front of my PC coding.

My friend Ray dubbed this “nerdalicious” and I think that’s a pretty awesomely descriptive word for it, so I’m calling this ‘nerdalicious sub-conscious code de-bugging’.

function random_hex() {
	$color = '';
	for ($c = 0; $c < 6; $c++) {
		$i = rand(0, 15);
		$color .= substr("0123456789ABCDEF", $i, 1)
	}
	$color = '#' . $color;
	return $color;
}

Thanks Eric!

function random_hex() {
	$color = '';
	for ($c = 0; $c < 6; $c++) {
		$i = rand(0, 15);
		switch ($i) {
			case 10 :
				$i = 'A';
				break;
			case 11 :
				$i = 'B';
				break;
			case 12 :
				$i = 'C';
				break;
			case 13 :
				$i = 'D';
				break;
			case 14 :
				$i = 'E';
				break;
			case 15 :
				$i = 'F';
				break;
			default :
				$i = $i;
				break;
		}
		$color .= $i;
	}
	$color = '#' . $color;
	return $color;
}

This means that you can now download XooMLe and install it on your own PHP-enabled server so that you can use it locally for integrating Google search results (and cache and spelling suggestion power) into your web-based applications.

In the near future, a ‘XooMLe In Action’ page will also be added to the site, showcasing some of the ways that people are making use of XooMLe and Google.

With the new integrated authentication, when you hit webpad you are presented with a log in screen, where you enter a username/password as normal, then continue to the actual application.

I’m also currently looking at templating (thanks to a previous hack that Brad Choate made to webpad 2.0 which allowed it to selectively edit the contents of a file, only within certain regions (denoted by webpad tags of some sort). I will have this functionality included in the official release of webpad 3.0 Personal Edition, and it will definitely be a part of the Professional release.

Things may have been quiet, but they’re not completely dead!

<?php
/**
 * @return boolean
 * @param $file FileNameToWriteTo
 * @param $string StringToWriteToFile
 * @desc Writes specified string to the end of the file with a linefeed attached
 */
function file_append($file, $string) {
	if (is_file($file) && is_writable($file)) {
		$fh = fopen($file, 'a');
		if ($fh) {
			fwrite($fh, $string . "\n");
			fclose($fh);
			return true;
		} else {
			return false;
		}
	} else {
		return false;
	}
}
?>

You might want to consider making the fopen() flags ‘ab’ for binary-safe (now reccommended on php.net) and also changing the ‘\n’ part to the appropriate line-endings for your operating system (\n = *NIX, \r\n = Windows, \r = Mac).

Download blosxconfig BETA version now!

Here’s the details that I posted to the blosxom list;

WARNING: Back up all you plugins before saving changes via blosxconfig!!!

configure.php is a PHP script (duh!) so you’ll need PHP on your server to run it. You can pass a path to it to look for a specific config file via either a GET or POST request (GET use ?conf=path-to-conf.conf on the querystring, POST use variable name ‘conf’ with a value of a path to a config file). if you don’t pass a value, then blosxconfig will look for a file called blosxom.conf in the same directory as it, or die trying

The config files are very basic, and look a little bit like a Windows ini file, but it’s a custom style; The first line is similar to a unix ‘shebang’ line, and should look like this;

#@/path/to/plugins

where obviously the /path/to/plugins is the full path to where your plugins live – this should be the same as the $blosxom::plugin_dir variable configured in your blosxom cgi executable.

After that line, you have plugin sections which are defined using [plugin_name] – be careful that you use the *exact* name of the plugin, because the value is used for confirming the plugin’s existence

Under each plugin section, you define definable variables on a line each, in this format;

variable_name|type|default

variable_name is the actual name of the variable (as written in the script), without the ‘$’ or ‘@’ (in the case of arrays)

type can be one of ‘string’, ‘boolean’ or ‘code’. Arrays should be defined as ‘code’. Strings are enclosed automatically in quotes (“) and all types are followed by a semi colon when written to file. Booleans are presented to the user as a Yes/No select box (0/1 passed as values) and other types are presented as simple text input fields.

default is a value to use by default. make sure this makes sense (so for a boolean make sure it’s 0/1, for a string it’s a string etc). You don’t need to wrap it in quotes or anything, this is handled automatically.

WARNING: Back up all you plugins before saving changes via blosxconfig!!!

1. All plugin files which are referenced in your config file will be MODIFIED – they will technically be overwritten entirely, since the contents of the file are processed, then the lines that look like they define the variables in question are replaced with new lines, with the new values.
2. The config file will be updated with the new details that you specified and written back to file.
3. blosxconfig will load again, with all your new values in place, and messages telling you what happened.

Assuming all goes well, you’ve just used an external interface to reach into your plugin files and modify certain details. The hope is that authors of plugins (or community-minded participants) can supply the simple, 1 – 10 lines worth of config required to add to this configuration file, which can then be distributed with this little application to help people configure their plugins.

Please be aware that I have *NOT* tested this extensively at all, it was hacked together and seemed to work for a couple of plugins that I was running (the ones in the config file included) on a Windows test box, other than that I can’t make any promises. I’d LOVE if some people could try it out on some other plugins, on other systems, and let me know (directly if
you like) how it goes. I’ll fix any problems and then release it as public so that other people can use it.

Hope it’s useful for someone out there, and can perhaps eventually make life easier for some newbies (and pro’s alike

Oh yeah – did I mention; BACK UP YOUR PLUGINS BEFORE YOU TRY THIS!

On the suggestion of Andreas Banze, I’ve removed one small section which checked to make sure that the plugin files were executable, since as he pointed out, this is not necessary, they are just included in the main operation of the blosxom script, not executed individually.

Download blosxconfig BETA version now!

php_flag register_globals on

php_flag magic_quotes_gpc on

The next version of webpad will not require this, but for now it’s the easiest way around the problem.

If anyone knows of any other problems and/or fixes to problems with webpad, please email them in to me using the contact form or email here.

My hope is that this can be developed into a stand-alone product that could be wrapped around nearly any search system, simply adding to the functionality of said search system. So far things are looking good, but only really for something written in PHP. I would need to add other options for systems written in Perl, C etc.

In the near future, I will be posting database schemas, some notes on implementation and other bits and pieces about how I am attacking the whole process. Keep an eye on things if you are interested