The syntax is straightforward. Any attribute prefixed with data- will be treated as data storage.

<div class="test" data-foo="bar"></div>

jQuery accesses this data like so…

var data = $( 'div.test' ).data( 'foo' ); // returns bar

Support for the data attribute has been added since jQuery version 1.4.3. jQuery’s implementation is smart enough that it can parse the attribute easily and even determine the correct data type used.

What I have found really useful is the fact that the jQuery can parse JSON syntax and return a JSON object. This makes passing data in PHP trivial, using the json_encode method. We also need to use htmlspecialchars method to escape or convert any quotes in the JSON string.

<?php  
$test = array( 'row' => 1, 'col' => 6, 'color' => 'pink' ); //create array of data you want to pass to jquery
$test = json_encode( $test ); //convert array to a JSON string
$test = htmlspecialchars( $test, ENT_QUOTES ); //convert any quotes into HTML entities so JSON string behaves as a proper HTML attribute.
?>
<div class="test" data-complex="<?php echo $test ; ?>"></div>

The jQuery parses the JSON string like so…

var test = $( 'div.test' ).data( 'complex' ); // returns JSON Object

console.log( test.color ); // outputs pink!

Important to note that this method is also backward compatible with older browsers, so there is no excuse not to give it a go!

If you have the IP addresses, then it is trivial.

//First check IP address is valid
$request_ip = $_SERVER['REMOTE_ADDR'];

if ( !preg_match( "/^(([1-9]?[0-9]|1[0-9]{2}|2[0-4][0-9]|25[0-5]).){3}([1-9]?[0-9]|1[0-9]{2}|2[0-4][0-9]|25[0-5])$/", $request_ip ) )
    return false;

$blacklist = array(
'111.222.12.11',
'222.111.21.22',
'221.112.11.12'
);

//check that ip is not blacklisted
if ( in_array( $request_ip, $blacklist ) )
    return false;

If you want to include a range of IP addresses, best to use a regular expression.

$blacklist_ip_range = array(
    '/^122\.244\.(\d+)\.(\d+)/', //for IP address in the range 122.244.0.0 - 122.244.255.255
    '/^123\.(\d+)\.(\d+)\.(\d+)/', //for IP address in the range 123.0.0.0 - 123.255.255.255
);

foreach( $blacklist_ip_range as $ip ) {
    if( preg_match( $ip, $request_ip ) )
       	return false;
    }

If you have a better solution, then please let me know.

This is a handy command to debug your PHP on your server where you may have errors hidden.

• The tail command shows the end of a file.
• The -f flag tells it to keep the file open, while you debug your code
• The /tmp/php-error is ( I assume! ) a temporary error log file that stores PHP errors on the server.

.

Update:

If you use error_log(print_r(debug_backtrace(), true )) with this command, you can monitor the call stack in real time. Super useful when debugging!

/**
*  Takes XML string and returns a boolean result where valid XML returns true
*/
function is_valid_xml ( $xml ) {
    libxml_use_internal_errors( true );
    
    $doc = new DOMDocument('1.0', 'utf-8');
    
    $doc->loadXML( $xml );
    
    $errors = libxml_get_errors();
    
    return empty( $errors );
}

/**
* Takes an array and returns an array of duplicate items
*/
function get_duplicates( $array ) {
	return array_unique( array_diff_assoc( $array, array_unique( $array ) ) );
}

$string = "Tom\tThumb\t                is sooooooo\t\t\tdumb";
$string = preg_replace( '/\s+/', ' ', $string );
echo $string;
//will echo "Tom Thumb is sooooooo dumb"

/**
 * Convert a comma separated file into an associated array.
 * The first row should contain the array keys.
 * 
 * Example:
 * 
 * @param string $filename Path to the CSV file
 * @param string $delimiter The separator used in the file
 * @return array
 * @link http://gist.github.com/385876
 * @author Jay Williams <http://myd3.com/>
 * @copyright Copyright (c) 2010, Jay Williams
 * @license http://www.opensource.org/licenses/mit-license.php MIT License
 */
function csv_to_array($filename='', $delimiter=',')
{
	if(!file_exists($filename) || !is_readable($filename))
		return FALSE;

	$header = NULL;
	$data = array();
	if (($handle = fopen($filename, 'r')) !== FALSE)
	{
		while (($row = fgetcsv($handle, 1000, $delimiter)) !== FALSE)
		{
			if(!$header)
				$header = $row;
			else
				$data[] = array_combine($header, $row);
		}
		fclose($handle);
	}
	return $data;
}

Found here, courtesy of jaywilliams

As I work with Automattic, the keepers of WordPress.com, I get the opportunity to work on the WordPress Platform. WordPress have their own standards that are sensible without being pedantic and are similar to the PEAR standard. The emphasis of the standard (in my opinion), is to present your code so collaboration is as easy as possible. It would prefer if you wrote code that is easier to read and understand, even if it is a little longer, than some compressed, ubersmart block of code that only you can follow.

Sometimes I look back at old code I did, like when I first wrote a WordPress plugin, and see places where it is not consistent with the WordPress standards… and I’d to get the itch to fix it, line by line, which is time consuming and dull work.

So I looked into ways to automate this in my text editor but alas no feature or option existed. While its not really possible to automate for all the standards, it should be possible to correct the formatting.

What can be automated?, well…

• Braces style. It should use K&R style.
• Indentation. Need to remove spacing and use tabs instead.
• Spacing. Add spacing to make code more readable.
• No shorthand PHP. So no <? allowed.

If you are using Coda, there is an excellent plugin called Coda PHP & Web Toolkit written by Mario Fischer. This is easy to install, and all you have to do to tidy your HTML, PHP, Javascript and CSS is right click on your code and select the plugin’s Tidy option.

The best thing about this, it meets WordPress PHP formatting standards with only a couple of exceptions. To fix them, you need to locate the phptidy-coda.php file, usually found here…
/Users/[your user name]/Library/Application Support/Coda/Plug-ins/PhpPlugin.codaplugin/Contents/Resources/phptidy-coda.php

If you can’t locate it, go to root and use the following search command.
sudo find . -name "*.php" -exec grep -H "phptidy" {} \;

The first exception is, that for functions and classes, it pushes the opening curly bracket, {, to the next line.
To fix this, open phptidy-coda.php in an editor and change the line

// from
$curly_brace_newline = array(T_CLASS, T_FUNCTION);
// to...
$curly_brace_newline = false;

The other exception is, it does not add spacing after a start round bracket (, or before an end round bracket, ).

In phptidy-coda.php, find the phptidy function and add a default for this formatting with the other defaults…

// Enable the single cleanup functions
$fix_token_case = true;
$fix_builtin_functions_case = true;
$replace_inline_tabs = true;
$replace_phptags = true;
$replace_shell_comments = true;
$fix_statement_brackets = true;
$fix_separation_whitespace = true;
$fix_comma_space = true;

//add new default in here
$fix_round_bracket_space = true;

$add_file_docblock = false;
$add_function_docblocks = false;
$add_doctags = false;
$fix_docblock_format = true;
$fix_docblock_space = false;
$add_blank_lines = false;
$indent = true;

Then look for the phptidy function and add a check for this default to format the spacing for round brackets.

// Simple formatting
if ( $GLOBALS['fix_token_case'] ) fix_token_case( $tokens );
if ( $GLOBALS['fix_builtin_functions_case'] ) fix_builtin_functions_case( $tokens );
if ( $GLOBALS['replace_inline_tabs'] ) replace_inline_tabs( $tokens );
if ( $GLOBALS['replace_phptags'] ) replace_phptags( $tokens );
if ( $GLOBALS['replace_shell_comments'] ) replace_shell_comments( $tokens );
if ( $GLOBALS['fix_statement_brackets'] ) fix_statement_brackets( $tokens );
if ( $GLOBALS['fix_separation_whitespace'] ) fix_separation_whitespace( $tokens );
if ( $GLOBALS['fix_comma_space'] ) fix_comma_space( $tokens );
// Add in you call to new function here
if ( $GLOBALS['fix_round_bracket_space'] ) fix_round_bracket_space( $tokens );

Lastly, add in the function to format the code to add in spacing after the start round bracket and before the end round bracket where appropriate.

/**
 * Adds one space after a start round bracket and before an end round bracket
 *
 * @param array   $tokens (reference)
 */
function fix_round_bracket_space( &$tokens ) {

	foreach ( $tokens as $key => &$token ) {
		if ( !is_string( $token ) ) continue;
		if (
			// If the current token is a start round bracket...
			$token === "(" and
			// ...and the next token is no whitespace
			!( isset( $tokens[$key+1][0] ) and $tokens[$key+1][0] === T_WHITESPACE ) and
			// ...and the next token is not an end round bracket
			!( isset( $tokens[$key+1][0] ) and $tokens[$key+1][0] === ')' )
		) {
			// Insert one space
			array_splice( $tokens, $key+1, 0, array(
					array( T_WHITESPACE, " " )
				) );
		}
		else if (
			// If the current token is an end round bracket...
			$token === ")" and
			// ...and the previous token is no whitespace
			!( isset( $tokens[$key-1][0] ) and $tokens[$key-1][0] === T_WHITESPACE ) and
			// ...and the previous token is a start round bracket
			!( isset( $tokens[$key-1][0] ) and $tokens[$key-1][0] === '(' )
		) {
			// Insert one space
			array_splice( $tokens, $key, 0, array(
					array( T_WHITESPACE, " " )
				) );
		}
	}
}

Then save the file. You may need to edit this file using sudo in order to change it.
Restart Coda and tidy your PHP.

UPDATE:: Mario has told me that he will include these changes in a future update But in case it is not in the next update, you should make a backup of the phptidy-coda.php file, as the next plugin update may overwrite it.

UPDATE 2:: Mario has indeed included these changes into the lastest version of the plugin. He has also made the format configurable so if you don’t want your curly brackets on the same line, you can set it so.

Now that is all good and well if you have Coda, but what of the TextWrangler folk. Well the plugin for Coda uses an open sourced library called phptidy, written by Magnus Rosenbaum, which is impressive not least for the brevity of the documentation.

To get it to work with TextWrangler is fairly straightforward. Follow these steps and if I have left any out place highlight them in the comments below.

Note: I had to make some minor changes to the phptidy library to get it to work with TextWrangler. As well as the 2 changes above, I also had to suppress any text echo’d by the library.

• Download my phptidy library.
• Uncompress the zip file and copy the Tidy PHP.sh file to the Filters directory, you can find out how to do that here
• Open terminal and copy the phptidy.php file to your /usr/bin folder
• Go to the /usr/bin folder and change the file permissions of the phptidy.php by typing, sudo chmod 755 phptidy.php

Now you should be ready to try out the filter in TextWrangler.

At a later date, I plan to use John Godley’s CodeSniffer code, to validate the code and get a detailed explanation of where the code does not follow the WordPress standard.

Then I found this excellent explanation of using UTF8 with PHP, which is well worth a read.

Encoding gives me a headache but from this explanation this is how I see it.

I had some character that the parser does not know how to interput because it was outside the byte range of the UTF8 format. Some of the PHP functions, like iconv, still let some non-UTF8 characters through which breaks the parser. The preg_replace just rips out any non-UTF8 character based on it’s byte sequence and replaces it with a question mark.

From that article above, I use the following code to remove any non-UTF8 characters.

//reject overly long 2 byte sequences, as well as characters above U+10000 and replace with ?
$some_string = preg_replace('/[\x00-\x08\x10\x0B\x0C\x0E-\x19\x7F]'.
 '|[\x00-\x7F][\x80-\xBF]+'.
 '|([\xC0\xC1]|[\xF0-\xFF])[\x80-\xBF]*'.
 '|[\xC2-\xDF]((?![\x80-\xBF])|[\x80-\xBF]{2,})'.
 '|[\xE0-\xEF](([\x80-\xBF](?![\x80-\xBF]))|(?![\x80-\xBF]{2})|[\x80-\xBF]{3,})/S',
 '?', $some_string );

//reject overly long 3 byte sequences and UTF-16 surrogates and replace with ?
$some_string = preg_replace('/\xE0[\x80-\x9F][\x80-\xBF]'.
 '|\xED[\xA0-\xBF][\x80-\xBF]/S','?', $some_string );

I choose OAuth as I thought it would be simplest. I found it was pretty straightforward but there were gaps in Google’s documentation that made the process a tad frustrating.

Here’s a brief outline…

Couple of things you’ll need before you can start any coding.

Register with Google – You’ll need to register with Google to get an API or a consumer key/secret that will be needed to access API.

Get the OAuth Library – You will be essentially making signed HTTP requests to Google URLs and this library helps to make sure these requests are constructed properly. I used Andy Smith’s PHP library.

I have a Google PHP class that handles the authorization and uploading data to a Google Spreadsheet.

One critical step in authenticating that I couldn’t find in the Google documentation is the following step. When you get the request token, a token secret is sent in the response. You need to save the request token secret so you can use this token secret again when you request the access token. I am saving it as meta data but you can easily use a session variable.

Uploading data to Google also has a few hoops. You can only upload a max of 1MB so you may need to break up the upload into multiple documents. They recommend using Resumable Upload when uploading bigger lumps of data. This requires you to chuck the data and use the Content-Range to specify the chuck sizes.

define( 'CONSUMER_KEY', 'domain.com' );
define( 'CONSUMER_SECRET', '324lewrl34j234kp234' );

class Google_Doc {
	private $user;

	public function __construct( $user = false ) {
		global $current_user;

		$this->user = $user;
		if ( $user === false )
			$this->user = $current_user;
	}

	private function get_token() {
		return $this->user->get_meta( 'google_oauth_token' );
	}

	public function is_authorised() {
		$access_token = $this->get_token();

		if ( $access_token instanceof OAuthToken )
			return true;
		return false;
	}

	public function authorise() {
		$authorize_url = '';
		$parameters    = array();

		if ( isset( $_REQUEST['oauth_verifier'] ) ) {
			// This is the callback from Google after verifying
			$oauth_verifier = $_REQUEST['oauth_verifier'];

			$parameters[ 'oauth_verifier' ] = $oauth_verifier;
			if ( isset( $_REQUEST['oauth_token'] ) ) {
				$parameters[ 'oauth_token' ] = $_REQUEST['oauth_token'];

				$access_token = $this->get_access_token( $parameters );

				// Delete the meta secret token
				delete_metadata( 'user', $this->user->get_id(), 'google_token_secret' );

				if ( $access_token ) {
					// Store the token
					$this->user->set_meta( 'google_oauth_token', $access_token );
					return true;
				}
			}
		}
		else {
			// Unauthorised - send user to Google
			$parameters = array(
				'scope'          => 'http://docs.google.com/feeds/',
				'oauth_callback' => "http://{$_SERVER['HTTP_HOST']}{$_SERVER['REQUEST_URI']}"
			);

			$request_token = $this->get_request_token( $parameters );
			if ( $request_token ) {
				$authorize_url = 'https://www.google.com/accounts/OAuthAuthorizeToken?'.$request_token;
				pd_redirect( $authorize_url );
			}
		}

		return false;
	}

	public static function max_upload_size() {
		return 1024 * 1024;
	}

	private function get_request_token( $parameters ) {
		$consumer     = new OAuthConsumer( CONSUMER_KEY, CONSUMER_SECRET );
		$sig_method   = new OAuthSignatureMethod_HMAC_SHA1();
		$token = $key = $secret = NULL;

		$token_endpoint = 'https://www.google.com/accounts/OAuthGetRequestToken';

		$request = OAuthRequest::from_consumer_and_token( $consumer, $token, 'GET', $token_endpoint, $parameters );
		$request->sign_request( $sig_method, $consumer, $token);

		$response = send_signed_request( $request->get_normalized_http_method(), $token_endpoint, $request->to_header(), NULL, false );

		// Parse out oauth_token (access token) and oauth_token_secret
		if ( preg_match( '/oauth_token=(.*)&oauth_token_secret=(.*)&/', $response, $matches ) > 0 ) {
			$key    = urldecode( $matches[1] );
			$secret = urldecode( $matches[2] );

			$this->user->set_meta( 'google_token_secret', $secret );
			$token = new OAuthToken( $key, $secret );
		}

		return $token;
	}

	private function get_access_token( $parameters ) {
		$consumer   = new OAuthConsumer( CONSUMER_KEY, CONSUMER_SECRET );
		$sig_method = new OAuthSignatureMethod_HMAC_SHA1();
		$token      = new OAuthToken( $parameters['oauth_token'], $this->user->get_meta( 'google_token_secret' ) );

		$token_endpoint = 'https://www.google.com/accounts/OAuthGetAccessToken';

		$request = OAuthRequest::from_consumer_and_token( $consumer, $token, 'GET', $token_endpoint, $parameters );
		$request->sign_request( $sig_method, $consumer, $token );

		$response = send_signed_request( $request->get_normalized_http_method(), $token_endpoint, $request->to_header(), NULL, false );

		// Parse out oauth_token (access token) and oauth_token_secret
		$token = false;
		if ( preg_match('/oauth_token=(.*)&oauth_token_secret=(.*)/', $response, $matches) > 0 )
			$token = new OAuthToken( urldecode( $matches[1] ), urldecode( $matches[2] ) );

		return $token;
	}

	public function upload( $data, $slug ) {
		// Squirt it over to Google
		$consumer       = new OAuthConsumer( CONSUMER_KEY, CONSUMER_SECRET );
		$sig_method     = new OAuthSignatureMethod_HMAC_SHA1();
		$token_endpoint = 'http://docs.google.com/feeds/upload/create-session/default/private/full';

		$access_token = $this->get_token();

		$filesize = strlen( $data );

		$request = OAuthRequest::from_consumer_and_token( $consumer, $access_token, 'POST', $token_endpoint, NULL );
		$request->sign_request( $sig_method, $consumer, $access_token );

		$headers = array(
			'Content-Type: text/csv',
			'Content-Length: 0',
			"Slug: ".$slug,
			'GData-Version: 3.0',
			'X-Upload-Content-Type: text/csv',
			"X-Upload-Content-Length: {$filesize}",
			$request->to_header()
		);

		$response = send_signed_request( $request->get_normalized_http_method(), $token_endpoint, $headers, NULL, true );

		if ( preg_match( '/Location:(.*)/', $response, $matches ) > 0 ) {
			$url = trim( $matches[1] );

			$chunk_size = 256 * 1024;
			$start      = 0;

			while ( $start < $filesize ) {
				$chunk = substr( $data, $start, min( $filesize - $start, $chunk_size ) );

				$headers = array(
					'Content-Type: text/csv',
					"Content-Length: ".strlen( $chunk ),
					sprintf( "Content-Range: bytes %d-%d/%d", $start, strlen( $chunk ) - 1, $filesize )
				);

				$curl = curl_init( $url );

				curl_setopt( $curl, CURLOPT_RETURNTRANSFER, true );
				curl_setopt( $curl, CURLOPT_FAILONERROR, true );
				curl_setopt( $curl, CURLOPT_SSL_VERIFYPEER, false );
				curl_setopt( $curl, CURLOPT_HTTPHEADER, $headers );
				curl_setopt( $curl, CURLOPT_CUSTOMREQUEST, 'PUT' );
				curl_setopt( $curl, CURLOPT_POSTFIELDS, $chunk );
				curl_setopt( $curl, CURLOPT_TIMEOUT, 10 );

				$response = curl_exec( $curl );
				$http_status = curl_getinfo( $curl, CURLINFO_HTTP_CODE );

				curl_close( $curl );

				if ( $response !== false ) {
					// Is this the last chunk?
					if ( $http_status == 201 ) {
						// Parse out the doc URL
						$xml = simplexml_load_string( $response );
						if ( $xml ) {
							foreach ( $xml->link AS $link ) {
								if ( $link['rel'] == 'alternate' )
									return (string)$link['href'];
							}
						}

						return false;
					}

					$start += strlen( $chunk );
				}
				else
					return $this->failed();
			}
		}

		return $this->failed();
	}

	/**
	 * Operation failed so delete the auth token
	 */
	private function failed() {
		delete_metadata( 'user', $this->user->get_id(), 'google_oauth_token' );
		return false;
	}
}
/**
 * Makes an HTTP request to the specified URL
 *
 * @param string  $http_method           The HTTP method (GET, POST, PUT, DELETE)
 * @param string  $url                   Full URL of the resource to access
 * @param string  $auth_header           (optional) Authorization header
 * @param string  $postData              (optional) POST/PUT request body
 * @param bool    $returnResponseHeaders True if resp. headers should be returned.
 * @return string Response body from the server
 */
function send_signed_request($http_method, $url, $auth_header=null, $postData=null, $returnResponseHeaders=true)
{
	$curl = curl_init($url);
	curl_setopt($curl, CURLOPT_RETURNTRANSFER, true);
	curl_setopt($curl, CURLOPT_FAILONERROR, false);
	curl_setopt($curl, CURLOPT_SSL_VERIFYPEER, false);

	if ($returnResponseHeaders) {
		curl_setopt($curl, CURLOPT_HEADER, true);
		curl_setopt($curl, CURLINFO_HEADER_OUT, true);
	}

	if ($auth_header) {
		if ( is_string( $auth_header ) )
			$auth_header = array( $auth_header );
		curl_setopt($curl, CURLOPT_HTTPHEADER, $auth_header);
	}

	if ($http_method == 'POST') {
		curl_setopt($curl, CURLOPT_POST, 1);
		curl_setopt($curl, CURLOPT_POSTFIELDS, $postData);
	}
	$response = curl_exec($curl);
	if (!$response) {
		$response = curl_error($curl);
	}
	curl_close($curl);
	return $response;
}

To use this class, just place the following code in a page.

$google = new Google_Doc();

if ( $google->is_authorised() ) {
	$google->upload( $data, $slug );
}
else {
	if ( $google->authorise() ) {
		$google->upload( $data, $slug );
	}
}