PHP plist parsing

As promised I’m going to look further into parsing plist files, this time in PHP. I’m going to show some functional programming concepts applied to PHP, using it similarly to how you program in XSL.

When I say similar to XSL I mean that there will be functions which transform the nodes of the plist and which function that gets to transform which node will de decided using pattern matching, just like how templates work in XSL (and how function calling works in Haskell, for example).

The code

The goal of parsing the plist is to transform it into a PHP value structure (I’m deliberately not saying object structure). dict nodes will be transformed into associative arrays and arrays into, surprise, surprise, arrays.

First let’s look at the function which finds the appropriate function to handle a specific node. It’s called parseValue and takes a DOMElement object as input, finds a function to handle it and returns what that function returns (a PHP value).

The way it decides which function to call is simple: it looks at the node’s name and tests to see if there is a function with that name prefixed with “parse_”. If the node is a number node the function parse_number is used to transform it. This logic could be made much more complex, for example to support something similar to XPath-paths, but this simple version works for most cases. The prefix “parse_” could be anything, it completely arbitrary.

function parseValue( $valueNode ) {
  $valueType = $valueNode->nodeName;

  $transformerName = "parse_$valueType";

  if ( is_callable($transformerName) ) {
    // there is a transformer function for this node type
    return call_user_func($transformerName, $valueNode);
  }

  // if no transformer was found
  return null;
}

As we will see below, parseValue is similar to apply-templates in XSL.

Then there is the transformer functions, equivalent to templates in XSL, which handle the different node types. First let’s look at the simple cases, integer, string, date and booleans. Save for booleans it’s only a matter of returning the text content of the nodes (we could do some kind of date parsing on the date perhaps, or return a proper int instead of a string representation of an int, but it doesn’t really matter in PHP anyway). Since the booleans come as <yes/> and <no/> there needs to be a parse_yes and parse_no handling each.

function parse_integer( $integerNode ) {
	return $integerNode->textContent;
}

function parse_string( $stringNode ) {
	return $stringNode->textContent;
}

function parse_date( $dateNode ) {
	return $dateNode->textContent;
}

function parse_true( $trueNode ) {
	return true;
}

function parse_false( $trueNode ) {
	return false;
}

Handling dictionaries and arrays is a bit more complex, since they have to deal with child values:

function parse_dict( $dictNode ) {
  $dict = array();

  // for each child of this node
  for (
    $node = $dictNode->firstChild;
    $node != null;
    $node = $node->nextSibling
  ) {
    if ( $node->nodeName == "key" ) {
      $key = $node->textContent;

      $valueNode = $node->nextSibling;

      // skip text nodes
      while ( $valueNode->nodeType == XML_TEXT_NODE ) {
        $valueNode = $valueNode->nextSibling;
      }

      // recursively parse the children
      $value = parseValue($valueNode);

      $dict[$key] = $value;
    }
  }

  return $dict;
}

function parse_array( $arrayNode ) {
  $array = array();

  for (
    $node = $arrayNode->firstChild;
    $node != null;
    $node = $node->nextSibling
  ) {
    if ( $node->nodeType == XML_ELEMENT_NODE ) {
      array_push($array, parseValue($node));
    }
  }

  return $array;
}

Wraping it up

To get some data to transform, load your plist file (for example the iTunes music library file) with this code:

$plistDocument = new DOMDocument();
$plistDocument->load($path);

And then start off the parsing with this snipplet:

function parsePlist( $document ) {
  $plistNode = $document->documentElement;

  $root = $plistNode->firstChild;

  // skip any text nodes before the first value node
  while ( $root->nodeName == "#text" ) {
    $root = $root->nextSibling;
  }

  return parseValue($root);
}

Other uses

The implementation above transforms a Plist file into a PHP value structure, but it could just as well transform it into a JSON string or just about any other data interchange format.

This entry was posted on Tuesday, May 8th, 2007 at 15:01 and is filed under XSL. You can follow any responses to this entry through the RSS 2.0 feed. You can leave a response, or trackback from your own site.