PygmentsonPHP&?WordPress

There is a list of available lexers on their site.

The final step on python is creating the HTML formatter, performing the highlighting and outputing the HTML code containing the highlighted code.

formatter = HtmlFormatter(linenos=False, encoding='utf-8', nowrap=True)
highlighted = highlight(code, lexer, formatter)
print highlighted

For the formatter it&＃8217;s passed linenos=False to not generate lines numbers and nowrap=True to not allow p wrapping the generate code. This is a personal decision, the code would be wrapped using PHP.

Next it&＃8217;s passed code containing the actual code, lexer containing the language lexer and the formatter we just create in the line above which tell the highlight how we want our code formatted.

Finally it&＃8217;s output the code.

That&＃8217;s about it for python, that the script that is going to build the highlight.

Here is the complete file: build.py

import sys
from pygments import highlight
from pygments.formatters import HtmlFormatter
# If there isn't only 2 args something weird is going on
expecting = 2;
if ( len(sys.argv) != expecting + 1 ):
  exit(128)
# Get the code
language = (sys.argv[1]).lower()
filename = sys.argv[2] 
f = open(filename, 'rb')
code = f.read()
f.close()
# PHP
if language == 'php':
  from pygments.lexers import PhpLexer
  lexer = PhpLexer(startinline=True)
# GUESS
elif language == 'guess':
  from pygments.lexers import guess_lexer
  lexer = guess_lexer( code )
# GET BY NAME
else:
  from pygments.lexers import get_lexer_by_name
  lexer = get_lexer_by_name( language )
# OUTPUT
formatter = HtmlFormatter(linenos=False, encoding='utf-8', nowrap=True)
highlighted = highlight(code, lexer, formatter)
print highlighted

PHP &＃8211; WordPress

Let&＃8217;s jump to WordPress and create a basic plugin to handle the code that needs to be highlighted.

It&＃8217;s does not matter if you have never create a plugin for WordPress in your entire life, this plugin is just a file with php functions in it, so you would be just fine without the WordPress plugin development knowledge, but you need knowledge on WordPress development though.

Create a folder inside wp-content/plugins named wp-pygments (can be whatever you want) and inside it copy build.py the python script we just created and create a new php file named wp-pygments.php (maybe the same name as the directory).

The code below just let WordPress know what&＃8217;s the plugin&＃8217;s name and other informations, this code is going to be at the top of wp-pygments.php.

Add a filter on the_content to look for

 tags. the code expected is: 

$name = "World";
echo "Hello, " . $name;

NOTE: html tags needs to be encoded; for example < needs to be < so the parse don&＃8217;t get confused and do it all wrong.
Where class is the language of the code inside pre tags, if there is not class or is empty would pass guess to build.py.
add_filter( 'the_content', 'mb_pygments_content_filter' );
function mb_pygments_content_filter( $content )
{
  $cOntent= preg_replace_callback('/]?.*?>.*?(.*?)<\/code>.*?<\/pre>/sim', 'mb_pygments_convert_code', $content);
  return $content;
}

preg_replace_callback function would execute mb_pygments_convert_code callback function every time there's a match on the content using the regex pattern provided: /]?.*?>.*?(.*?)<\/code>.*?<\/pre>/sim, it should match on any 
 on a post/page content.

What about sim?, these are three pattern modifiers flags. From php.net: 

  
s: If this modifier is set, a dot metacharacter in the pattern matches all characters, including newlines.
  
i: If this modifier is set, letters in the pattern match both upper and lower case letters.
  
m: By default, PCRE treats the subject string as consisting of a single "line" of characters (even if it actually contains several newlines).


This can be done with DOMDocument(); as well. replace /]?.*?>.*?(.*?).*?/sim with this: 

// This prevent throwing error
libxml_use_internal_errors(true);
// Get all pre from post content
$dom = new DOMDocument();
$dom->loadHTML($content);
$pres = $dom->getElementsByTagName('pre');
foreach ($pres as $pre) {
  $class = $pre->attributes->getNamedItem('class')->nodeValue;
  $code = $pre->nodeValue;
  $args = array(
    2 => $class, // Element at position [2] is the class
    3 => $code // And element at position [2] is the code
  );
  // convert the code
  $new_code = mb_pygments_convert_code($args);
  // Replace the actual pre with the new one.
  $new_pre = $dom->createDocumentFragment();
  $new_pre->appendXML($new_code);
  $pre->parentNode->replaceChild($new_pre, $pre);
}
// Save the HTML of the new code.
$cOntent= $dom->saveHTML();

The code below is from mb_pygments_convert_code function.
define( 'MB_WPP_BASE', dirname(__FILE__) );
function mb_pygments_convert_code( $matches )
{
  $pygments_build = MB_WPP_BASE . '/build.py';
  $source_code    = isset($matches[3])?$matches[3]:'';
  $class_name     = isset($matches[2])?$matches[2]:'';
  // Creates a temporary filename
  $temp_file      = tempnam(sys_get_temp_dir(), 'MB_Pygments_');
  // Populate temporary file
  $filehandle = fopen($temp_file, "w");
  fwrite($filehandle, html_entity_decode($source_code, ENT_COMPAT, 'UTF-8') );
  fclose($filehandle);
  // Creates pygments command
  $language   = $class_name?$class_name:'guess';
  $command    = sprintf('python %s %s %s', $pygments_build, $language, $temp_file);
  // Executes the command
  $retVal = -1;
  exec( $command, $output, $retVal );
  unlink($temp_file);
  // Returns Source Code
  $format = '%s';
  if ( $retVal == 0 )
    $source_code = implode("\n", $output);
  $highlighted_code = sprintf($format, $language, $source_code);
  return $highlighted_code;
}

Reviewing the code above: 
define( 'MB_WPP_BASE', dirname(__FILE__) );

define a absolute plugin's directory path constant.
$pygments_build = MB_WPP_BASE . '/build.py';
$source_code    = isset($matches[3])?$matches[3]:'';
$class_name     = isset($matches[2])?$matches[2]:'';

$pygments_build is the full path where the python script is located. Every time there is a match an array called $matches is passed containing 4 element. Take this as an example of a matched code from post/page content:
$name = "World";
echo "Hello, " . $name;


  

    
The element at position [0] is the whole 
 match, and its value is: 

$name = "World";
echo "Hello, " . $name;

  
  

    
The element at position [1] is the class attribute name with its value, and its value is:
class="php"

  
  

    
The element at position [2] is the class attribute value without its name, and its value is:
php

  
  

    
The element at position [3] is the code itself without its pre tags, and its value is:
$name = "World";
echo "Hello, " . $name;

  

// Creates a temporary filename
$temp_file = tempnam(sys_get_temp_dir(), 'MB_Pygments_');

it creates a temporary file containing the code that would be passed to the python script. it's a better way to handle the code would be passed. instead of passing this whole thing as a parameters it would be a mess.
// Populate temporary file
$filehandle = fopen($temp_file, "wb");
fwrite($filehandle, html_entity_decode($source_code, ENT_COMPAT, 'UTF-8') );
fclose($filehandle);

It creates the file of the code, but we decode all the HTML entities, so pygments can convert them properly.
// Creates pygments command
$language = $class_name?$class_name:'guess';
$command  = sprintf('python %s %s %s', $pygments_build, $language, $temp_file);

It creates the python command to be used, it outputs: 
python /path/to/build.py php /path/to/temp.file

// Executes the command
$retVal = -1;
exec( $command, $output, $retVal );
unlink($temp_file);
// Returns Source Code
$format = '%s';
if ( $retVal == 0 )
  $source_code = implode("\n", $output);
$highlighted_code = sprintf($format, $language, $source_code);

Executes the command just created and if returns 0 everything worked fine on the python script. exec(); return an array of the lines outputs from python script. so we join the array outputs into one string to be the source code. If not, we are going to stick with the code without highlight.
Improving it by Caching
So by now with work fine, but we have to save time and processing, imagine 100 
 tags on a content it would creates 100 files and call 100 times the python script, so let's cache this baby.

Transient API
WordPress provide the ability of storing data on the database temporarily with the Transient API.
First, let's add a action to save_post hook, so every time the post is saved we convert the code and cache it.
add_action( 'save_post', 'mb_pygments_save_post' );
function mb_pygments_save_post( $post_id )
{
  if ( wp_is_post_revision( $post_id ) )
    return;
  $cOntent= get_post_field( 'post_content', $post_id );
  mb_pygments_content_filter( $content );
}

if is a revision we don't do anything, otherwise we get the post content and call the pygments content filter function.
Let's create some functions to handle the cache.
// Cache Functions
// Expiration time (1 month), let's clear cache every month.
define('MB_WPP_EXPIRATION', 60 * 60 * 24 * 30);
// This function it returns the name of a post cache.
function get_post_cache_transient()
{
  global $post;
  $post_id = $post->ID;
  $transient = 'post_' . $post_id . '_content';
  return $transient;
}
// This creates a post cache for a month,
// containing the new content with pygments
// and last time the post was updated.
function save_post_cache($content)
{
  global $post;
  $expiration = MB_WPP_EXPIRATION;
  $value = array( 'content'=>$content, 'updated'=>$post->post_modified );
  set_transient( get_post_cache_transient(), $value, $expiration );
}
// This returns a post cache
function get_post_cache()
{
  $cached_post = get_transient( get_post_cache_transient() );
  return $cached_post;
}
// Check if a post needs to be updated.
function post_cache_needs_update()
{
  global $post;
  $cached_post = get_post_cache();
  if ( strtotime($post->post_modified) > strtotime($cached_post['updated']) )
    return TRUE;
  return FALSE;
}
// Delete a post cache.
function clear_post_cache()
{ 
  delete_transient( get_post_cache_transient() );
}

At the beginning of mb_pygments_content_filter() add some lines to check if there is a cached for the post.
function mb_pygments_content_filter( $content )
{
  if ( FALSE !== ( $cached_post = get_post_cache() ) && !post_cache_needs_update() )
    return $cached_post['content'];
  clear_post_cache();

And at the end of mb_pygments_content_filter() add a line to save the post cache.
save_post_cache( $content );

Finally, when the plugin is uninstall we need to remove all the cache we created, this is a bit tricky, so we use $wpdb object to delete all using this a query.
register_uninstall_hook(__FILE__, 'mb_wp_pygments_uninstall');
function mb_wp_pygments_uninstall() {
  global $wpdb;
  $wpdb->query( "DELETE FROM `wp_options` WHERE option_name LIKE '_transient_post_%_content' " );
}
Read the full article at:  Pygments on PHP & WordPress



Related Posts

Allow More HTML Tags in WordPress Comments
Add META Tags, Scripts, and Stylesheets to the WordPress Header and Footer
Create WordPress Shortcodes
Create a &＃8220;Recent Posts&＃8221; Module Outside of WordPress
Force Login to View WordPress Blog Pages