<?php

/**
 * Utility methods
 *
 * @package Simple Lightbox
 * @subpackage Utilities
 * @author Archetyped
 *
 */
class SLB_Utilities {

	/* Properties */

	/**
	 * Instance parent
	 * @var object
	 */
	private $_parent = null;

	/**
	 * Plugin Base
	 * @var string
	 */
	private $_plugin = array(
		'base'		=> null,
		'file'		=> null,
		'name'		=> null,
		'data'		=> null,
		'uri'		=> null,
		'headers'	=> array (
			'Name'			=> 'Plugin Name',
			'PluginURI'		=> 'Plugin URI',
			'SupportURI'	=> 'Support URI',
			'Version'		=> 'Version',
			'Description'	=> 'Description',
			'Author'		=> 'Author',
			'AuthorURI'		=> 'Author URI',
		)
	);

	/**
	 * Plugin base path
	 * @var string
	 */
	private $_path_base = null;

	/**
	 * Standard hook priorities
	 * @var array
	 */
	private $_priorities = array (
		'high'							=> 1,
		'low'							=> 99,
		'safe'							=> 15,
		'client_footer_output'			=> 25,
	);

	/* Constructors */

	function __construct($obj) {
		if ( is_object($obj) ) {
			$this->_parent = $obj;
		}
	}

	/**
	 * Returns callback array to instance method
	 * @param object $obj Instance object
	 * @param string $method Name of method
	 * @return array Callback array
	 */
	function m($obj, $method = '') {
		if ( is_string($obj) ) {
			$method = $obj;
			$obj = null;
		}
		if ( !is_object($obj) && isset($this) ) {
			$obj = $this;
		}
		$cb = array($obj, $method);
		return $cb;
	}

	/* Helper Functions */

	/*-** Prefix **-*/

	/**
	 * Get valid separator
	 * @param string $sep (optional) Separator supplied
	 * @return string Separator
	 */
	function get_sep($sep = false) {
		if ( is_null($sep) )
			$sep = '';
		return ( is_string($sep) ) ? $sep : '_';
	}

	/**
	 * Retrieve class prefix (with separator if set)
	 * @param bool|string $sep Separator to append to class prefix (Default: no separator)
	 * @return string Class prefix
	 */
	function get_prefix($sep = null) {
		$sep = $this->get_sep($sep);
		$prefix = ( !empty($this->_parent->prefix) ) ? $this->_parent->prefix . $sep : '';
		return $prefix;
	}

	/**
	 * Check if a string is prefixed
	 * @param string|array $text Text to check for prefix
	 * @param string $sep (optional) Separator used
	 */
	function has_prefix($text, $sep = null) {
		if ( empty($text) )
			return false;
		if ( !is_array($text) )
			$text = array($text);
		$text = array_values($text);
		$text = $text[0];
		return ( !empty($text) && stripos($text, $this->get_prefix($sep)) === 0 );
	}

	/**
	 * Prepend plugin prefix to some text
	 * @param string|array $text Text to add to prefix
	 * @param string $sep (optional) Text used to separate prefix and text
	 * @param bool $once (optional) Whether to add prefix to text that already contains a prefix or not
	 * @return string Text with prefix prepended
	 */
	function add_prefix($text, $sep = '_', $once = true) {
		// Normalize data type (array)
		if ( empty($text) )
			$text = array('');
		if ( !is_array($text) )
			$text = array($text);
		// Add prefix (if necessary)
		if ( !$once || ( $once && !$this->has_prefix($text, $sep) ) )
			array_unshift($text, $this->get_prefix());
		return implode($sep, $text);
	}

	/**
	 * Prepend uppercased plugin prefix to some text
	 * @param string|array $text Text to add to prefix
	 * @param string $sep (optional) Text used to separate prefix and text
	 * @param bool $once (optional) Whether to add prefix to text that already contains a prefix or not
	 * @return string Text with prefix prepended
	 */
	function add_prefix_uc($text, $sep = '_', $once = true) {
		$args = func_get_args();
		$var = call_user_func_array($this->m($this, 'add_prefix'), $args);
		$pre = $this->get_prefix();
		return str_replace($pre . $sep, strtoupper($pre) . $sep, $var);
	}

	/**
	 * Add prefix to variable reference
	 * Updates actual variable rather than return value
	 * @uses add_prefix() to add prefix to variable
	 * @param string $var Variable to add prefix to
	 * @param string $sep (optional) Separator text
	 * @param bool $once (optional) Add prefix only once
	 * @return void
	 */
	function add_prefix_ref(&$var, $sep = null, $once = true) {
		$args = func_get_args();
		$var = call_user_func_array($this->m($this, 'add_prefix'), $args);
	}

	/**
	 * Remove prefix from specified string
	 * @param string $text String to remove prefix from
	 * @param string $sep (optional) Separator used with prefix
	 */
	function remove_prefix($text, $sep = '_') {
		if ( $this->has_prefix($text,$sep) )
			$text = substr($text, strlen($this->get_prefix($sep)));
		return $text;
	}

	/**
	 * Returns Database prefix for plugin-related DB Tables
	 * @return string Database prefix
	 */
	function get_db_prefix() {
		global $wpdb;
		return $wpdb->prefix . $this->get_prefix('_');
	}

	/*-** Priority **-*/

	/**
	 * Retrieve standard priority
	 * @var string $id Priority ID to retrieve
	 * @return int Priority
	 */
	public function priority($id = null) {
		$pri = 10;
		if ( !is_null($id) && array_key_exists($id, $this->_priorities) ) {
			$pri = $this->_priorities[$id];
		}
		return $pri;
	}

	/* Wrapped Values */

	/**
	 * Create wrapper object
	 * Properties
	 *   > start
	 *   > end
	 * @param string|array $start Start text (Can also be array defining start & end values)
	 * @param string $end (optional) End text
	 * If $end not defined, then $start is used
	 * @return obj Wrapper
	 */
	function get_wrapper($start = null, $end = null) {
		// Validate existing wrapper
		if ( is_object($start) && isset($start->start) && isset($start->end) )
			return $start;

		// Initialize wrapper
		$w = array (
			'start'		=> '[',
			'end'		=> ']',
		);

		if ( !empty($start) ) {
			if ( is_string($start) ) {
				$w['start'] = $start;
			} elseif ( is_array($start) ) {
				$start = array_values($start);
				if ( is_string($start) ) {
					$w['start'] = $start[0];
				}
				if ( isset($start[1]) && is_string($start[1]) ) {
					$w['end'] = $start[1];
				}
			}
		}
		if ( is_string($end) ) {
			$w['end'] = $end;
		}

		return (object) $w;
	}

	/**
	 * Check if text is wrapped by specified character(s)
	 * @uses this->get_wrapper() to Validate wrapper text
	 * @param string $text Text to check
	 * @param string|array $start (optional) Start text (Array defines both start/end text)
	 * @param string $end (optional) End text
	 */
	function has_wrapper($text, $start = null, $end = null) {
		if ( !is_string($text) || empty($text) )
			return false;
		// Validate wrapper
		$w = $this->get_wrapper($start, $end);

		// Check for wrapper
		return ( substr($text, 0, strlen($w->start)) == $w->start && substr($text, -1, strlen($w->end)) == $w->end ) ? true : false;
	}

	/**
	 * Remove wrapper from specified text
	 * @uses this->has_wrapper() to check if text is wrapped
	 * @uses this->get_wrapper() to retrieve wrapper object
	 * @param string $text Text to check
	 * @param string|array $start (optional) Start text (Array defines both start/end text)
	 * @param string $end (optional) End text
	 * @return string Unwrapped text
	 */
	function remove_wrapper($text, $start = null, $end = null) {
		if ( $this->has_wrapper($text, $start, $end) ) {
			$w = $this->get_wrapper($start, $end);
			$text = substr($text, strlen($w->start), strlen($text) - strlen($w->start) - strlen($w->end) );
		}

		return $text;
	}

	/**
	 * Add wrapper to specified text
	 * @uses Utilities::get_wrapper() to retrieve wrapper object
	 * @param string $text Text to wrap
	 * @param string|array $start (optional) Start text (Array defines both start/end text)
	 * @param string $end (optional) End text
	 * @param bool $once (optional) Whether to wrap text only once (Default: TRUE)
	 * @return string Wrapped text
	 */
	function add_wrapper($text, $start = null, $end = null, $once = true) {
		$w = $this->get_wrapper($start, $end);
		if ( !$once || !$this->has_wrapper($text, $w) )
			$text = $w->start . $text . $w->end;
		return $text;
	}

	/*-** Client **-*/

	/**
	 * Parses client files array
	 * > Adds ID property (prefixed file key)
	 * > Parses and validates internal dependencies
	 * > Converts properties array to object
	 * Properties
	 * > file (string|array): File name (string) or callback (array) to retrieve file name
	 * > deps (array) [optional]: Dependencies
	 *   > Values wrapped in square brackets (`[` & `]`) are internal files
	 * > callback (string|array) [optional]: Global callback to determine whether file should be loaded
	 *   > Values wrapped in square brackets (`[` & `]`) are internal methods (of parent object)
	 * > context (array) [optional]: Context(s) in which to load the file
	 *   Acceptable values
	 *   > string: Context name
	 *   > array: Context name + callback (both must return TRUE to load file)
	 *     > Callback follows same pattern as `callback` member
	 * @param array $files Files array
	 * @return object Client files
	 */
	function parse_client_files($files, $type = 'scripts') {
		if ( is_array($files) && !empty($files) ) {
			// Defaults
			$defaults = array(
				'file'		=> null,
				'deps' 		=> array(),
				'callback'	=> null,
				'context'	=> array(),
				'enqueue'	=> true,
				'enqueued'  => false
			);
			switch ( $type ) {
				case 'styles':
					$defaults['media'] = 'all';
					break;
				default:
					$defaults['in_footer'] = false;
			}
			// Iterate through files
			/**
			 * $h (string) handle
			 * $p (array) properties
			 */
			foreach ( $files as $h => $p ) {
				unset($file, $cb, $ctxs, $ctx);
				// Set ID
				$p['id'] = $this->add_prefix($h);
				// Type Validation
				/**
				 * $m (string) property name
				 * $d (mixed) default value
				 */
				foreach ( $defaults as $m => $d ) {
					// Check if value requires validation
					if ( !is_array($d) || !isset($p[$m]) || is_array($p[$m]) )
						continue;
					// Wrap value in array or destroy it
					if ( is_scalar($p[$m]) )
						$p[$m] = array($p[$m]);
					else
						unset($p[$m]);
				}

				// Normalize file properties
				$p = array_merge($defaults, $p);

				/* File name */

				// Validate file
				$file =& $p['file'];

				// Determine if filename or callback
				if ( !$this->is_file($file) )
					$file = ( is_callable($file) ) ? $file : null;
				// Remove invalid file and move on to next
				if ( empty($file) ) {
					unset($files[$h]);
					continue;
				}

				/* Dependencies */

				// Format internal dependencies
				foreach ( $p['deps'] as $idx => $dep ) {
					if ( $this->has_wrapper($dep) ) {
						$dep = $this->remove_wrapper($dep);
						$p['deps'][$idx] = $this->add_prefix($dep);
					}
				}

				/* Context */

				// Validate callback
				$cb =& $p['callback'];
				if ( !is_null($cb) && !is_callable($cb) ) {
					// Remove files with invalid callbacks (will never be loaded)
					unset($files[$h]);
					continue;
				}

				// Validate contexts
				$ctxs =& $p['context'];
				$ctxs = array_unique($ctxs);
				$has_contexts = ( count($ctxs) > 0 ) ? true : false;
				foreach ( $ctxs as $idx => $ctx ) {
					// Convert to array
					$ctx = array_values( array_slice( (array) $ctx, 0, 2 ) );
					switch ( count($ctx) ) {
						case 1 :
							// Simple context
							$ctx = $ctx[0];
							break;
						case 2 :
							// Context + Callback
							if ( is_callable($ctx[1]) ) {
								break;
							}
							// Continue to default case if callback is invalid
						default :
							// Context is invalid
							$ctx = false;
							break;
					}

					// Remove invalid contexts
					if ( empty($ctx) ) {
						unset($ctxs[$idx]);
					} else {
						$ctxs[$idx] = $ctx;
					}
				}
				// Remove file if all specified contexts invalid (no context is OK)
				if ( $has_contexts && empty($ctxs) ) {
					unset($files[$h]);
					continue;
				}
				$ctxs = array_values($ctxs);

				/* Finalize Properties */

				// Convert properties to object
				$files[$h] = (object) $p;
			}
		}
		// Cast to object before returning
		$files = (object) $files;
		return $files;
	}

	/**
	 * Build JS client object
	 * @param string (optional) $path Additional object path
	 * @return string Client object
	 */
	function get_client_object($path = null) {
		$obj = strtoupper($this->get_prefix());
		if ( !empty($path) && is_string($path) ) {
			if ( 0 !== strpos($path, '[') )
				$obj .= '.';
			$obj .= $path;
		}
		return $obj;
	}

	/**
	 * Build jQuery JS expression to add data to specified client object
	 * @param string|obj $obj Name of client object (Set to root object if not a valid name)
	 * @param mixed $data Data to add to client object
	 * @param bool (optional) $out Whether or not to output code (Default: false)
	 * @return string JS expression to extend client object
	 */
	function extend_client_object($obj, $data = null, $out = false) {
		// Validate parameters
		$args = func_get_args();
		switch ( count($args) ) {
			case 2:
				if ( !is_scalar($args[0]) ) {
					if ( is_bool($args[1]) )
						$out = $args[1];
				} else {
					break;
				}
			case 1:
				$data = $args[0];
				$obj = null;
				break;
		}
		// Default client object
		if ( !is_string($obj) || empty($obj) )
			$obj = null;
		// Default data
		if ( is_array($data) ) {
			$data = (object)$data;
		}
		// Build expression
		if ( empty($data) || ( empty($obj) && is_scalar($data) ) ) {
			$ret = '';
		} else {
			$c_obj = $this->get_client_object($obj);
			$ret = $this->validate_client_object($obj, sprintf('{$.extend(%1$s, %2$s);}', $c_obj, json_encode($data)) );
			if ( $out )
				echo $this->build_script_element($ret, 'context', true, true);
		}
		return $ret;
	}

	/**
	 * Validate client object $obj before running command $cmd
	 *
	 * @param string $obj Full object name
	 * @param string $cmd (optional) Command to wrap in validation
	 * @return string Command wrapped in validation block
	 * If no command is specified the validation conditions are returned
	 */
	public function validate_client_object($obj, $cmd = null) {
		// Get base object
		$base = $this->get_client_object();

		// Build condition
		$sep = '.';
		$obj = trim($obj, $sep);
		//  Strip base object
		if ( 0 === strpos($obj, $base . $sep) ) {
			$obj = substr($obj, strlen($base . $sep));
		}
		$fmt = '!!window.%1$s';
		if ( !empty($obj) ) {
			$fmt .= ' && %1$s.has_child(\'%2$s\')';
		}
		$condition = sprintf($fmt, $base, $obj);

		// Wrap command in validation
		if ( !empty($cmd) && is_string($cmd) ) {
			$condition = sprintf('if ( %1$s ) { %2$s }', $condition, $cmd);
		}
		return $condition;
	}

	/**
	 * Build client method call
	 * @uses get_client_object() to generate the body of the method call
	 * @param string $method Method name
	 * @param array|string $params (optional) Parameters to pass to method
	 * @param bool $encode (optional) JSON-encode parameters? (Default: TRUE)
	 * @param bool $validate (optional) Validate method before calling it?
	 * @return string Method call
	 */
	function call_client_method($method, $params = null, $encode = true, $validate = true) {
		$ret = '';
		if ( !is_string($method) || empty($method) ) {
			return $ret;
		}
		$encode = !!$encode;
		$validate = !!$validate;

		// Build parameters
		if ( !is_null($params) ) {
			if ( $encode ) {
				$params = wp_json_encode($params);
			} elseif ( is_array($params) ) {
				$params = implode(',', $params);
			}
		}
		if ( !is_string($params) ) {
			$params = '';
		}
		$ret = sprintf('%s(%s);', $this->get_client_object($method), $params);
		if ( $validate ) {
			$ret = $this->validate_client_object($method, $ret);
		}
		return $ret;
	}

	/*-** WP **-*/

	/**
	 * Checks if $post is a valid Post object
	 * If $post is not valid, assigns global post object to $post (if available)
	 * @return bool TRUE if $post is valid object by end of function processing
	 * @param object $post Post object to evaluate
	 */
	function check_post(&$post) {
		if (empty($post)) {
			if (isset($GLOBALS['post'])) {
				$post = $GLOBALS['post'];
				$GLOBALS['post'] =& $post;
			}
			else
				return false;
		}
		if (is_array($post))
			$post = (object) $post;
		elseif (is_numeric($post))
			$post = get_post($post);
		if (!is_object($post))
			return false;
		return true;
	}


	/**
	 * Retrieve parent object
	 * @return obj|bool Parent object (FALSE if no valid parent set)
	 */
	function get_parent() {
		if ( is_object($this->_parent) ) {
			return $this->_parent;
		} else {
			return false;
		}
	}

	/**
	 * Retrieve parent property value
	 * @uses self::get_parent()
	 * @param string $prop Property name
	 * @param mixed $default Default value
	 * @return mixed Parent property value
	 */
	function get_parent_property($prop, $default = '') {
		$p = $this->get_parent();
		return ( !!$p && property_exists($p, $prop) ) ? $p->{$prop} : $default;
	}

	/* Hooks */

	/**
	 * Retrieve formatted name for internal hooks
	 * Prefixes with parent prefix and hook prefix
	 * @uses self::get_parent_property() to retrieve hook prefix
	 * @uses self::add_prefix()
	 * @param string $tag Base tag
	 * @param bool|string $hook_prefix (optional) Secondary prefix to use for hook (Default: Use predefined hook name, FALSE: no secondary hook)
	 * @return string Formatted hook
	 */
	function get_hook($tag, $hook_prefix = true) {
		// Hook prefix
		$hook = '';
		if ( is_bool($hook_prefix) && $hook_prefix ) {
			$hook = $this->get_parent_property('hook_prefix', '');
		} elseif ( is_string($hook_prefix) ) {
			$hook = $hook_prefix;
		}
		if ( !empty($hook) )
			$hook .= '_';
		// Prefix
		return $this->add_prefix($hook . $tag);
	}

	/**
	 * Run internal action
	 * Namespaces $tag
	 * @uses self::get_hook()
	 * @see do_action()
	 * @param string|array $tag Action hook. If array, get hook prefix
	 */
	function do_action($tag, $arg = '') {
		// Handle hook prefix
		$hook_prefix = true;
		if ( is_array($tag) ) {
			$hook_prefix = $tag[1];
			$tag = $tag[0];
		}
		$args = func_get_args();
		$args[0] = $this->get_hook($tag, $hook_prefix);
		return call_user_func_array('do_action', $args);
	}

	/**
	 * Run internal action passing arguments in array
	 * @uses do_action_ref_array()
	 * @param bool|string $hook_prefix (optional) Secondary prefix to use for hook (Default: Use predefined hook name, FALSE: no secondary hook)
	 */
	function do_action_ref_array($tag, $args, $hook_prefix = true) {
		return do_action_ref_array($this->get_hook($tag, $hook_prefix), $args);
	}

	/**
	 * Run internal filter
	 * Namespaces $tag
	 * @uses self::get_hook()
	 * @see apply_filters()
	 * @param string|array $tag Action hook. If array, get hook prefix
	 */
	function apply_filters($tag, $value) {
		// Handle hook prefix
		$hook_prefix = true;
		if ( is_array($tag) ) {
			$hook_prefix = $tag[1];
			$tag = $tag[0];
		}
		$args = func_get_args();
		$args[0] = $this->get_hook($tag, $hook_prefix);
		return call_user_func_array('apply_filters', $args);
	}

	/**
	 * Run internal filter passing arguments in array
	 * @uses apply_filters_ref_array()
	 * @param bool|string $hook_prefix (optional) Secondary prefix to use for hook (Default: Use predefined hook name, FALSE: no secondary hook)
	 */
	function apply_filters_ref_array($tag, $args, $hook_prefix = true) {
		return apply_filters_ref_array($this->get_hook($tag, $hook_prefix), $args);
	}

	/**
	 * Add internal action
	 * Namespaces $tag
	 * @uses self::get_hook()
	 * @see add_action()
	 * @param bool|string $hook_prefix (optional) Secondary prefix to use for hook (Default: Use predefined hook name, FALSE: no secondary hook)
	 */
	function add_action($tag, $function_to_add, $priority = 10, $accepted_args = 1, $hook_prefix = true) {
		return add_action($this->get_hook($tag, $hook_prefix), $function_to_add, $priority, $accepted_args);
	}

	/**
	 * Add internal filter
	 * Namespaces $tag
	 * @uses self::get_hook()
	 * @see add_filter()
	 * @param bool|string $hook_prefix (optional) Secondary prefix to use for hook (Default: Use predefined hook name, FALSE: no secondary hook)
	 */
	function add_filter($tag, $function_to_add, $priority = 10, $accepted_args = 1, $hook_prefix = true) {
		return add_filter($this->get_hook($tag, $hook_prefix), $function_to_add, $priority, $accepted_args);
	}

	/**
	 * Remove internal action
	 * Namespaces $tag
	 * @uses self::get_hook()
	 * @uses remove_action()
	 * @param bool|string $hook_prefix (optional) Secondary prefix to use for hook (Default: Use predefined hook name, FALSE: no secondary hook)
	 */
	function remove_action($tag, $function_to_remove, $priority = 10, $accepted_args = 1, $hook_prefix = true) {
		return remove_action($this->get_hook($tag, $hook_prefix), $function_to_remove, $priority, $accepted_args);
	}

	/**
	 * Remove internal filter
	 * Namespaces $tag
	 * @uses self::get_hook()
	 * @uses remove_filter()
	 * @param bool|string $hook_prefix (optional) Secondary prefix to use for hook (Default: Use predefined hook name, FALSE: no secondary hook)
	 */
	function remove_filter($tag, $function_to_remove, $priority = 10, $accepted_args = 1, $hook_prefix = true) {
		return remove_filter($this->get_hook($tag, $hook_prefix), $function_to_remove, $priority, $accepted_args);
	}

	/* Shortcode */

	/**
	 * Process specific shortcode(s) in content
	 * Default: Process all existing shortcodes
	 * @uses $shortcode_tags - array tag => callback
	 * @uses do_shortcode()
	 *
	 * @param string $content Content to process for shortcodes
	 * @param string|array $shortcode Single tag or array of tags to process
	 *  > Associative array sets temporary callbacks for shortcodes (`tag => callback`)
	 */
	public function do_shortcode($content, $shortcode = null) {
		global $shortcode_tags;

		// Process custom shortcodes
		if ( !is_null($shortcode) ) {
			// Cast to array
			$shortcode = (array) $shortcode;
			// Backup and reset shortcode handlers
			$tags_temp = $shortcode_tags;
			$shortcode_tags = array();
			// Register specified tags
			foreach ( $shortcode as $key => $val ) {
				if ( is_string($key) && is_callable($val) ) {
					// Tag w/custom callback
					$shortcode_tags[$key] = $val;
				} elseif ( is_int($key) && is_string($val) && isset($tags_temp[$val]) ) {
					// Tag with default callback
					$shortcode_tags[$val] = $tags_temp[$val];
				}
			}
		}

		// Process shortcodes in content
		$content = do_shortcode($content);

		// Restore default shortcode handlers
		if ( isset($tags_temp) ) {
			$shortcode_tags = $tags_temp;
			unset($tags_temp);
		}

		return $content;
	}

	/**
	 * Build shortcode tag
	 * @param string $tag Shortcode base
	 * @param array (optional) $attr Shortcode attributes
	 * @param string (optional) $content Shortcode content
	 * @return string Shortcode tag
	 */
	public function make_shortcode($tag, $attr = null, $content = null) {
		return $this->build_element(array (
			'tag'			=> $tag,
			'attributes'	=> $attr,
			'content'		=> $content,
		));
	}

	/* Meta */

	/**
	 * Retrieves post metadata for internal methods
	 * Metadata set internally is wrapped in an array so it is unwrapped before returned the retrieved value
	 * @see get_post_meta()
	 * @param int $post_id Post ID
	 * @param string $key Name of metadata to retrieve
	 * @param boolean $single Whether or not to retrieve single value or not
	 * @return mixed Retrieved post metadata
	 */
	function post_meta_get($post_id, $key, $single = false) {
		$meta_value = get_post_meta($post_id, $this->post_meta_get_key($key), $single);
		if (is_array($meta_value) && count($meta_value) == 1)
			$meta_value = $meta_value[0];
		return $meta_value;
	}

	/**
	 * Wraps metadata in array for storage in database
	 * @param mixed $meta_value Value to be set as metadata
	 * @return array Wrapped metadata value
	 */
	function post_meta_prepare_value($meta_value) {
		return array($meta_value);
	}

	/**
	 * Adds Metadata for a post to database
	 * For internal methods
	 * @see add_post_meta
	 * @param $post_id
	 * @param $meta_key
	 * @param $meta_value
	 * @param $unique
	 * @return boolean Result of operation
	 */
	function post_meta_add($post_id, $meta_key, $meta_value, $unique = false) {
		$meta_value = $this->post_meta_value_prepare($meta_value);
		return add_post_meta($post_id, $meta_key, $meta_value, $unique);
	}

	/**
	 * Updates post metadata for internal data/methods
	 * @see update_post_meta()
	 * @param $post_id
	 * @param $meta_key
	 * @param $meta_value
	 * @param $prev_value
	 * @return boolean Result of operation
	 */
	function post_meta_update($post_id, $meta_key, $meta_value, $prev_value = '') {
		$meta_value = $this->post_meta_prepare_value($meta_value);
		return update_post_meta($post_id, $meta_key, $meta_value, $prev_value);
	}

	/**
	 * Builds postmeta key for custom data set by plugin
	 * @param string $key Base key name
	 * @return string Formatted postmeta key
	 */
	function post_meta_get_key($key) {
		$sep = '_';
		if ( strpos($key, $sep . $this->prefix) !== 0 ) {
			$key_base = func_get_args();
			if ( !empty($key_base) ) {
				$key = array_merge((array)$this->prefix, $key_base);
				return $sep . implode($sep, $key);
			}
		}

		return $key;
	}

	/**
	 * Creates a meta key for storing post meta data
	 * Prefixes standard prefixed text with underscore to hide meta data on post edit forms
	 * @param string $text Text to use as base of meta key
	 * @return string Formatted meta key
	 */
	function make_meta_key($text = '') {
		return '_' . $this->add_prefix($text);
	}

	/* Class */

	/**
	 * Retrieve name of internal class
	 * @param string $class Base name of class
	 * @return string Full name of internal class
	 */
	function get_class($class) {
		return $this->add_prefix_uc($class);
	}

	/* Context */

	/**
	 * Retrieve context for current request
	 * @return array Context
	 */
	function get_context() {
		// Context
		static $ctx = null;
		if ( !is_array($ctx) ) {
			// Standard
			$ctx = array($this->build_context());
			// Action
			$action = $this->get_action();
			if ( !empty($action) ) {
				$ctx[] = $this->build_context('action', $action);
			}
			// Post type
			$post_type = $this->get_post_type();
			if ( !empty($action) ) {
				$ctx[] = $this->build_context('post-type', $post_type);
			}
			// Admin page
			if ( is_admin() ) {
				global $pagenow;
				$pg = $this->strip_file_extension($pagenow);
				$ctx[] = $this->build_context('page', $pg);
				// Query String
				if ( isset($_SERVER['QUERY_STRING']) ) {
					parse_str($_SERVER['QUERY_STRING'], $qv);
					if ( isset($qv['page']) ) {
						$ctx[] = $this->build_context('page', $qv['page']);
						if ( stripos($qv['page'], $this->get_prefix()) === 0 ) {
							$ctx[] = $this->build_context('page', $this->get_prefix());
						}
					}
				}
				// Action
				if ( !empty($action) ) {
					$ctx[] = $this->build_context('page', $pg, 'action', $action);
					$ctx[] = $this->build_context('post-type', $post_type, 'action', $action);
				}
			}
			// User
			$u = wp_get_current_user();
			$ctx[] = $this->build_context('user', ( $u->ID ) ? 'registered' : 'guest', false);
		}

		return $ctx;
	}

	/**
	 * Builds context from multiple components
	 * Usage:
	 * > $prefix can be omitted and context strings can be added as needed
	 * > Multiple context strings may be passed to be joined together
	 *
	 * @param string (optional) $context Variable number of components to add to context
	 * @param bool (optional) $prefix Whether or not to prefix context with request type (public or admin) [Default: TRUE]
	 * @return string Context
	 */
	function build_context($context = null, $prefix = true) {
		$args = func_get_args();
		// Get prefix option
		if ( !empty($args) ) {
			$prefix = ( is_bool($args[count($args) - 1]) ) ? array_pop($args) : true;
		}

		// Validate
		$context = array_filter($args, 'is_string');
		$sep = '_';

		// Context Prefix
		if ( $prefix )
			array_unshift($context, ( is_admin() ) ? 'admin' : 'public' );
		return implode($sep, $context);
	}

	/**
	 * Check if context exists in current request
	 * @param string $context Context to check for
	 * @return bool TRUE if context exists FALSE otherwise
	 */
	function is_context($context) {
		$ret = false;
		if ( is_scalar($context) )
			$context = array($context);
		if ( is_array($context) && !empty($context) ) {
			$ictx = array_intersect($this->get_context(), $context);
			if ( !empty($ictx) )
				$ret = true;
		}
		return $ret;
	}

	/**
	 * Output current context to client-side
	 * @uses `wp_head` action hook
	 * @uses `admin_head` action hook
	 * @return void
	 */
	function set_client_context() {
		$ctx = new stdClass();
		$ctx->context = $this->get_context();
		$this->extend_client_object($ctx, true);
	}

	/* Path */

	/**
	 * Joins and normalizes the slashes in the paths passed to method
	 * All forward/back slashes are converted to forward slashes
	 * Multiple path segments can be passed as additional argments
	 * @param string $path Path to normalize
	 * @param bool|array $trailing_slash (optional) Whether or not normalized path should have a trailing slash or not (Default: FALSE)
	 *  If array is passed, first index is trailing, second is leading slash
	 * If multiple path segments are passed, $trailing_slash will be the LAST parameter (default value used if omitted)
	 */
	function normalize_path($path, $trailing_slash = false) {
		$sl_f = '/';
		$sl_b = '\\';
		$parts = func_get_args();
		// Slash defaults (trailing, leading);
		$slashes = array(false, true);
		if ( func_num_args() > 1 ) {
			// Get last argument
			$arg_last = $parts[count($parts) - 1];
			if ( is_bool($arg_last) ) {
				$arg_last = array($arg_last);
			}

			if ( is_array($arg_last) && count($arg_last) > 0 && is_bool($arg_last[0]) ) {
				// Remove slash paramter from args array
				array_pop($parts);
				// Normalize slashes options
				if ( isset($arg_last[0]) )
					$slashes[0] = $arg_last[0];
				if ( isset($arg_last[1]) )
					$slashes[1] = $arg_last[1];
			}
		}
		// Extract to slash options local variables
		list($trailing_slash, $leading_slash) = $slashes;

		// Clean path segments
		foreach ( $parts as $key => $part ) {
			// Trim slashes/spaces
			$parts[$key] = trim($part, " " . $sl_f . $sl_b);

			// Verify path segment still contains value
			if ( empty($parts[$key]) ) {
				unset($parts[$key]);
				continue;
			}
		}

		// Join path parts together
		$parts = implode($sl_b, $parts);
		$parts = str_replace($sl_b, $sl_f, $parts);
		// Add trailing slash (if necessary)
		if ( $trailing_slash )
			$parts .= $sl_f;
		// Add leading slash (if necessary)
		$regex = '#^.+:[\\/]#';
		if ( $leading_slash && !preg_match($regex, $parts) ) {
			$parts = $sl_f . $parts;
		}
		return $parts;
	}

	/**
	 * Returns URL of file (assumes that it is in plugin directory)
	 * @param string $file name of file get URL
	 * @param string|bool $relative Path that URI should be relative to (Default: full path)
	 * @return string File URL
	 */
	function get_file_url($file, $relative = null) {
		if ( is_string($file) && '' != trim($file) ) {
			$file = str_replace(' ', '%20', $this->normalize_path($this->get_url_base(false, $relative), $file));
		}
		return $file;
	}

	/**
	 * Returns path to plugin file
	 * @param string $file file name
	 * @return string File path
	 */
	function get_file_path($file, $relative = null) {
		// Build path
		if ( is_string($file) && '' != trim($file) ) {
			$file = $this->normalize_path($this->get_path_base($relative), $file);
		}
		return $file;
	}

	function get_plugin_file_path($file, $trailing_slash = false) {
		if ( is_string($file) && '' != trim($file) )
			$file = $this->normalize_path($this->get_plugin_base(), $file, $trailing_slash);
		return $file;
	}

	/**
	 * Checks if value is valid file name
	 * @param string $filename File name to check
	 * @return bool TRUE if valid file name, FALSE otherwise
	 */
	function is_file($filename) {
		$ext = $this->get_file_extension($filename);
		return ( empty($ext) ) ? false : true;
	}

	/**
	 * Check if string is valid URI
	 * @param string $uri String to check
	 * @return bool TRUE if string is valid URI
	 */
	function is_uri($uri) {
		return ( preg_match('|^(https?:)?//|', $uri) ) ? true : false;
	}

	/**
	 * Retrieves file extension
	 * @param string $file file name/path
	 * @param bool (optional) $lowercase Whether lowercase extension should be returned (Default: TRUE)
	 * @return string File's extension
	 */
	function get_file_extension($file, $lowercase = true) {
		$ret = '';
		$sep = '.';
		// Validate
		if ( !is_string($file) )
			return $ret;
		// Strip query string (if necessary)
		if ( ( $qpos = strpos($file, '?') ) && $qpos !== false ) {
			$file = substr($file, 0, $qpos);
		}
		if ( ( $rpos = strrpos($file, $sep) ) > 0 )
			$ret = substr($file, $rpos + 1);
		if ( !!$lowercase )
			$ret = strtolower($ret);
		return $ret;
	}

	/**
	 * Checks if file has specified extension
	 * @uses get_file_extension()
	 * @param string $file File name/path
	 * @param string|array $extension File ending(s) to check $file for
	 * @param bool (optional) Whether check should be case senstive or not (Default: FALSE)
	 * @return bool TRUE if file has extension
	 */
	function has_file_extension($file, $extension, $case_sensitive = false) {
		if ( !is_array($extension) )
			$extension = array(strval($extension));
		if ( !$case_sensitive ) {
			// Normalize extensions
			$extension = array_map('strtolower', $extension);
		}
		return ( in_array($this->get_file_extension($file, !$case_sensitive), $extension) ) ? true : false;
	}

	/**
	 * Removes file extension from file name
	 * The extension is the text following the last period ('.') in the file name
	 * @uses get_file_extension()
	 * @param string $file File name
	 * @return string File name without extension
	 */
	function strip_file_extension($file) {
		$ext = $this->get_file_extension($file);
		if ( !empty($ext) ) {
			$file = substr($file, 0, (strlen($ext) + 1) * -1);
		}
		return $file;
	}

	/**
	 * Retrieve base URL for plugin-specific files
	 * @uses get_plugin_base()
	 * @uses normalize_path()
	 * @return string Base URL
	 */
	function get_url_base($trailing_slash = false, $relative = null) {
		$ret = $this->_plugin['uri'];
		if ( empty($ret) ) {
			$ret = $this->normalize_path(plugins_url(), $this->get_plugin_base());
		}
		// Trailing slash
		if ( !!$trailing_slash ) {
			$ret .= '/';
		}
		// Relative
		if ( !empty($relative) ) {
			// Default
			if ( is_bool($relative) ) {
				$relative = site_url();
			}
			// Custom
			if ( is_string($relative) ) {
				$ret = $this->get_relative_path($ret, $relative);
			}
		}

		return $ret;
	}

	/**
	 * Retrieve plugin's base path
	 * @uses WP_PLUGIN_DIR
	 * @uses get_plugin_base()
	 * @uses normalize_path()
	 * @return string Base path
	 */
	function get_path_base($relative = null) {
		$ret = $this->_path_base;
		if ( empty($ret) ) {
			// Get base directory of parent object
			if ( $this->get_parent() ) {
				$r = new ReflectionClass(get_class($this->get_parent()));
				$base = $r->getFileName();
				unset($r);
			} else {
				$base = __FILE__;
			}
			// Extract base path
			$base = $this->normalize_path($base);
			if ( 0 === strpos($base, $this->normalize_path(WP_PLUGIN_DIR)) ) {
				$end = strpos($base, '/', strlen(WP_PLUGIN_DIR) + 1);
				$base = substr($base, 0, $end);
			}
			$ret = $this->_path_base = $base;
		}
		// Make relative path
		if ( !empty($relative) ) {
			// Default
			if ( is_bool($relative) ) {
				$relative = ABSPATH;
			}
			// Custom
			if ( is_string($relative) ) {
				$ret = $this->get_relative_path($ret, $relative);
			}
		}
		return $ret;
	}

	/**
	 * Retrieve relative path for absolute paths
	 * @param string $path Path to modify
	 * @param string $relative (optional) Base path to make $path relative to (Default: Site's base path)
	 * @return string Relative path
	 */
	function get_relative_path($path, $relative = true) {
		// Default base path
		if ( !is_string($relative) ) {
			$relative = ABSPATH;
		}
		if ( !empty($relative) && !empty($path) ) {
			$relative = $this->normalize_path($relative);
			$path = $this->normalize_path($path);
			// Strip base path
			if ( strpos($path, $relative) === 0 ) {
				$path = substr($path, strlen($relative));
			}
		}
		return $path;
	}

	/**
	 * Retrieve plugin's base directory
	 * @uses WP_PLUGIN_DIR
	 * @uses Utilities::get_path_base() to retrieve plugin base path
	 * @uses Utilities::_plugin_base to save plugin base
	 * @return string Base directory
	 */
	function get_plugin_base() {
		$ret = $this->_plugin['base'];
		if ( empty($ret) ) {
			$ret = $this->_plugin['base'] = basename($this->get_path_base());
		}
		return $ret;
	}

	/**
	 * Retrieve plugin's base file path
	 * @uses get_path_base()
	 * @uses get_file_path()
	 * @return string Base file path
	 */
	function get_plugin_base_file() {
		$ret = $this->_plugin['file'];
		if ( empty($ret) ) {
			$dir = @opendir($this->get_path_base());
			if ( $dir ) {
				while ( ($ftemp = readdir($dir)) !== false ) {
					// Only process PHP files
					$ftemp = $this->get_file_path($ftemp);
					if ( !$this->has_file_extension($ftemp, 'php') || !is_readable($ftemp) )
						continue;
					// Check for data
					$data = get_file_data($ftemp, $this->_plugin['headers']);
					if ( !empty($data['Name']) ) {
						// Set base file
						$ret = $ftemp;
						// Save plugin data
						$this->set_plugin_info($data);
						break;
					}
				}
			}
			@closedir($dir);
		}
		// Return
		return $ret;
	}

	/**
	 * Retrieve plugin's internal name
	 * Internal name is used by WP core
	 * @uses get_plugin_base_file()
	 * @uses plugin_basename()
	 * @return string Internal plugin name
	 */
	function get_plugin_base_name() {
		$ret = $this->_plugin['name'];
		if ( empty($ret) ) {
			$ret = $this->_plugin['name'] = plugin_basename( $this->get_plugin_base_file() );
		}
		return $ret;
	}

	private function set_plugin_info($data) {
		if ( is_array($data) ) {
			$this->_plugin['data'] = $data;
		}
	}

	/**
	 * Retrieve plugin info
	 * Parses info comment in main plugin file
	 * @uses get_plugin_base_file() to retrieve plugin info
	 * @return array|string Plugin info (specific value if field set)
	 */
	function get_plugin_info($field = null) {
		$ret = $this->_plugin['data'];
		// Get plugin data
		if ( empty($ret) ) {
			$this->get_plugin_base_file();
			$ret = $this->_plugin['data'];
		}
		// Return specified field
		if ( !empty($field) ) {
			$ret = ( is_array($ret) && isset($ret[$field]) ) ? $ret[$field] : '';
		}
		return $ret;
	}

	/**
	 * Retrieve plugin version
	 * @uses get_plugin_info()
	 * @param bool $strip_desc Strip any additional version text
	 * @return string Plugin version
	 */
	function get_plugin_version($strip_desc = true) {
		// Retrieve version
		$ret = $this->get_plugin_info('Version');
		// Format
		if ( !empty($ret) && $strip_desc ) {
			$ret = explode(' ', $ret, 2);
			$ret = $ret[0];
		}
		// Return
		return $ret;
	}

	/**
	 * Retrieve current post type based on URL query variables
	 * @return string|null Current post type
	 */
	public function get_post_type() {
		if ( isset($_GET['post_type']) && !empty($_GET['post_type']) ) {
			return $_GET['post_type'];
		}
		$pt = null;
		if ( isset($_GET['post']) && is_numeric($_GET['post']) ) {
			$pt = get_post_type($_GET['post']);
		}
		return $pt;
	}

	/**
	 * Retrieve current action based on URL query variables
	 * @param mixed $default (optional) Default action if no action exists
	 * @return string Current action
	 */
	function get_action($default = null) {
		$action = '';

		// Check if action is set in URL
		if ( isset($_GET['action']) )
			$action = $_GET['action'];
		// Otherwise, Determine action based on plugin admin page suffix
		elseif ( isset($_GET['page']) && ($pos = strrpos($_GET['page'], '-')) && $pos !== false && ( $pos != strlen($_GET['page']) - 1 ) )
			$action = trim(substr($_GET['page'], $pos + 1), '-_');

		// Determine action for core admin pages
		if ( ( !isset($_GET['page']) || empty($action) ) && isset($_SERVER['SCRIPT_NAME']) ) {
			$actions = array(
				'add'			=> array('page-new', 'post-new'),
				'edit-item'		=> array('page', 'post'),
				'edit'			=> array('edit', 'edit-pages')
			);
			$page = basename($_SERVER['SCRIPT_NAME'], '.php');

			foreach ( $actions as $act => $pages ) {
				if ( in_array($page, $pages) ) {
					$action = $act;
					break;
				}
			}
		}
		if ( empty($action) )
			$action = $default;
		return $action;
	}

	/*-** General **-*/

	/**
	 * Checks if a property exists in a class or object
	 * Compatibility method for PHP 4
	 * @param mixed $class Class or object to check
	 * @param string $property Name of property to look for in $class
	 */
	function property_exists($class, $property) {
		if ( !is_object($class) && !is_array($class) )
			return false;
		if ( function_exists('property_exists') && is_object($class) ) {
			return property_exists($class, $property);
		} else {
			return array_key_exists($property, $class);
		}
	}

	/**
	 * Retrieve specified property from object or array
	 * @param object|array $obj Object or array to get property from
	 * @param string $property Property name to retrieve
	 * @return mixed Property value
	 */
	function &get_property(&$obj, $property) {
		$property = trim($property);
		// Object
		if ( is_object($obj) )
			return $obj->{$property};
		// Array
		if ( is_array($obj) )
			return $obj[$property];
		// Class
		if ( is_string($obj) && class_exists($obj) ) {
			$cvars = get_class_vars($obj);
			if ( isset($cvars[$property]) )
				return $cvars[$property];
		}
	}

	/**
	 * Remap array members based on a
	 * mapping of source/destination keys
	 * @param array $properties Associative array of properties
	 * @param array $map Source/Destination mapping
	 * > Key: Source member
	 * > Val: Destination member
	 * @param bool $overwrite If TRUE, source value will be set in destination regardless of whether member already exists or not
	 * @return array Remapped properties
	 */
	function array_remap($arr, $map = array(), $overwrite = false) {
		if ( !empty($map) && is_array($map) ) {
			// Iterate through mappings
			foreach ( $map as $from => $to ) {
				if ( !array_key_exists($from, $arr) )
					continue;
				$move = $overwrite;
				// Only remap if parent property doesn't already exist in array
				if ( !array_key_exists($to, $arr) )
					$move = true;
				if ( $move ) {
					// Move member value to new key
					$arr[$to] = $arr[$from];
					// Remove source member
					unset($arr[$from]);
				}
			}
		}
		// Return remapped properties
		return $arr;
	}

	function array_filter_keys($arr, $keys) {
		if ( is_array($arr) && !empty($arr) && is_array($keys) && !empty($keys) ) {
			foreach ( $keys as $rem ) {
				if ( array_key_exists($rem, $arr) )
					unset($arr[$rem]);
			}
		}

		return $arr;
	}

	/**
	 * Insert an item into an array at the specified position
	 * @param mixed $item Item to insert into array
	 * @param int $pos Index position to insert item into array
	 * @return array Modified array
	 */
	function array_insert($array, $item, $pos = null) {
		array_splice($array, $pos, 0, $item);
		return $array;
	}

	/**
	 * Merges 1 or more arrays together
	 * Methodology
	 * - Set first parameter as base array
	 *   - All other parameters will be merged into base array
	 * - Iterate through other parameters (arrays)
	 *   - Skip all non-array parameters
	 *   - Iterate though key/value pairs of current array
	 *     - Merge item in base array with current item based on key name
	 *     - If the current item's value AND the corresponding item in the base array are BOTH arrays, recursively merge the the arrays
	 *     - If the current item's value OR the corresponding item in the base array is NOT an array, current item overwrites base item
	 * @param array Variable number of arrays
	 * @param array $arr1 Default array
	 * @return array Merged array
	 */
	function array_merge_recursive_distinct($arr1) {
		// Get all arrays passed to function
		$args = func_get_args();
		if ( empty($args) )
			return false;
		// Return empty array if first parameter is not an array
		if ( !is_array($args[0]) )
			return array();
		// Set first array as base array
		$merged = $args[0];
		// Iterate through arrays to merge
		$arg_length = count($args);
		for ( $x = 1; $x < $arg_length; $x++ ) {
			// Skip if argument is not an array (only merge arrays)
			if ( !is_array($args[$x]) )
				continue;
			// Iterate through argument items
			foreach ( $args[$x] as $key => $val ) {
				// Generate key for numeric indexes
				if ( is_int($key) ) {
					// Add new item to merged array
					$merged[] = null;
					// Get key of new item
					$key = array_pop(array_keys($merged));
				}
				if ( !isset($merged[$key]) || !is_array($merged[$key]) || !is_array($val) ) {
					$merged[$key] = $val;
				} elseif ( is_array($merged[$key]) && is_array($val) ) {
					$merged[$key] = $this->array_merge_recursive_distinct($merged[$key], $val);
				}
			}
		}
		return $merged;
	}

	/**
	 * Replaces string value in one array with the value of the matching element in a another array
	 *
	 * @param string $search Text to search for in array
	 * @param array $arr_replace Array to use for replacing values
	 * @param array $arr_subject Array to search for specified value
	 * @return array Searched array with replacements made
	 */
	function array_replace_recursive($search, $arr_replace, $arr_subject) {
		foreach ($arr_subject as $key => $val) {
			// Skip element if key does not exist in the replacement array
			if (!isset($arr_replace[$key]))
				continue;
			// If element values for both arrays are strings, replace text
			if (is_string($val) && strpos($val, $search) !== false && is_string($arr_replace[$key]))
				$arr_subject[$key] = str_replace($search, $arr_replace[$key], $val);
			// If value in both arrays are arrays, recursively replace text
			if (is_array($val) && is_array($arr_replace[$key]))
				$arr_subject[$key] = $this->array_replace_recursive($search, $arr_replace[$key], $val);
		}

		return $arr_subject;
	}

	/**
	 * Checks if item at specified path in array is set
	 * @param array $arr Array to check for item
	 * @param array $path Array of segments that form path to array (each array item is a deeper dimension in the array)
	 * @return boolean TRUE if item is set in array, FALSE otherwise
	 */
	function array_item_isset(&$arr, &$path) {
		$f_path = $this->get_array_path($path);
		return eval('return isset($arr' . $f_path . ');');
	}

	/**
	 * Build formatted string based on array values
	 * Array values in formatted string will be ordered by index order
	 * @param array $attribute Values to build string with
	 * @param string $format (optional) Format name (Default: Multidimensional array representation > ['value1']['value2']['value3'], etc.)
	 * @return string Formatted string based on array values
	 */
	function get_array_path($attribute = '', $format = null) {
		// Formatted value
		$fmtd = '';
		if (!empty($attribute)) {
			// Make sure attribute is array
			if (!is_array($attribute)) {
				$attribute = array($attribute);
			}
			// Format attribute
			$format = strtolower($format);
			switch ($format) {
				case 'id':
					$fmtd = array_shift($attribute) . '[' . implode('][', $attribute) . ']';
					break;
				case 'metadata':
				case 'attribute':
					// Join segments
					$delim = '_';
					$fmtd = implode($delim, $attribute);
					// Replace white space and repeating delimiters
					$fmtd = str_replace(' ', $delim, $fmtd);
					while (strpos($fmtd, $delim.$delim) !== false)
						$fmtd = str_replace($delim.$delim, $delim, $fmtd);
					// Prefix formatted value with delimeter for metadata keys
					if ('metadata' == $format)
						$fmtd = $delim . $fmtd;
					break;
				case 'path':
				case 'post':
				default:
					$fmtd = '["' . implode('"]["', $attribute) . '"]';
			}
		}
		return $fmtd;
	}

	/**
	 * Builds array of path elements based on arguments
	 * Each item in path array represents a deeper level in structure path is for (object, array, filesystem, etc.)
	 * @param array|string Value to add to the path
	 * @return array 1-dimensional array of path elements
	 */
	function build_path() {
		$path = array();
		$args = func_get_args();

		// Iterate through parameters and build path
		foreach ( $args as $arg ) {
			if ( empty($arg) )
				continue;

			if (is_array($arg)) {
				// Recurse through array items to pull out any more arrays
				foreach ($arg as $key => $val) {
					$path = array_merge($path, $this->build_path($val));
				}
				// $path = array_merge($path, array_values($arg));
			} elseif ( is_scalar($arg) ) {
				$path[] = $arg;
			}
		}

		return $path;
	}

	/**
	 * Build generic element
	 * @param array $args
	 * @return string Element output
	 */
	public function build_element($args = array()) {
		$ret = '';
		$args_default = array(
			'tag'			=> '',
			'wrap'			=> false,
			'content'		=> '',
			'attributes'	=> array(),
			'format'		=> array(),
		);
		$format_default = array(
			'open'	=> '[%s]',
			'close'	=> '[/%s]',
		);
		$args = wp_parse_args($args, $args_default);
		$args['format'] = wp_parse_args($args['format'], $format_default);

		// Validate
		if ( !is_string($args['tag']) || empty($args['tag']) ) {
			return $ret;
		}

		$args = (object) $args;

		$args->attributes = $this->build_attribute_string($args->attributes);
		if ( strlen($args->attributes) > 0 ) {
			$args->attributes = ' ' . $args->attributes;
		}

		// Build output
		$args->format = (object) $args->format;
		$ret = sprintf( $args->format->open, $args->tag . $args->attributes);

		// Wrap content if necessary
		if ( $args->wrap || ( is_string($args->content) && !empty($args->content) ) ) {
			$ret .= $args->content . sprintf( $args->format->close, $args->tag);
		}

		return $ret;
	}

	/**
	 * Parse string of attributes into array
	 * For XML/XHTML tag attributes
	 * @param string $txt Attribute text (Can be full tag or just attributes)
	 * @return array Attributes as associative array
	 */
	function parse_attribute_string($txt, $defaults = array()) {
		$txt = trim($txt, ' >');
		$matches = $attr = array();
		// Strip tag
		if ( $txt[0] == '<' && ($s = strpos($txt, ' ')) && $s !== false ) {
			$txt = trim(substr($txt, $s + 1));
		}
		// Parse attributes
		$rgx = "/\b(\w+.*?)=([\"'])(.*?)\\2(?:\s|$)/i";
		preg_match_all($rgx, $txt, $matches);
		if ( count($matches) > 3 ) {
			foreach ( $matches[1] as $sub_idx => $val ) {
				if ( isset($matches[3][$sub_idx]) )
					$attr[trim($val)] = trim($matches[3][$sub_idx]);
			}
		}
		// Destroy parsing vars
		unset($txt, $matches);

		return array_merge($defaults, $attr);
	}

	/**
	 * Builds attribute string for HTML element
	 * @param array $attr Attributes
	 * @return string Formatted attribute string
	 */
	function build_attribute_string($attr) {
		$ret = '';
		if ( is_object($attr) ) {
			$attr = (array) $attr;
		}
		if ( is_array($attr) && !empty($attr) ) {
			array_map('esc_attr', $attr);
			$attr_str = array();
			foreach ( $attr as $key => $val ) {
				$attr_str[] = $key . '="' . $val . '"';
			}
			$ret = implode(' ', $attr_str);
		}
		return $ret;
	}

	/* HTML */

	/**
	 * Generate HTML element based on values
	 * @param $args Element arguments
	 * @return string Generated HTML element
	 */
	public function build_html_element($args) {
		$args_default = array(
			'tag'			=> 'span',
			'content'		=> '',
			'attributes'	=> array()
		);
		$args = wp_parse_args($args, $args_default);
		$args['format'] = array(
			'open'		=> '<%s>',
			'close'		=> '</%s>',
		);
		// Build element
		return $this->build_element($args);
	}

	/**
	 * Build HTML link element
	 * @uses build_html_element() to build link output
	 * @param string $uri Link URI
	 * @param string $content Link content
	 * @param $array (optional) $attributes Additional link attributes
	 * @return string HTML link element
	 */
	function build_html_link($uri, $content, $attributes = array()) {
		$attributes = array_merge(array('href' => $uri, 'title' => $content), $attributes);
		return $this->build_html_element(array('tag' => 'a', 'wrap' => true, 'content' => $content, 'attributes' => $attributes));
	}

	/**
	 * Generate external stylesheet element
	 * @param $url Stylesheet URL
	 * @return string Stylesheet element
	 */
	function build_stylesheet_element($url) {
		$attributes = array('href' => $url, 'type' => 'text/css', 'rel' => 'stylesheet');
		return $this->build_html_element(array('tag' => 'link', 'wrap' => false, 'attributes' => $attributes));
	}

	/**
	 * Build client-side script element
	 *
	 * @param string $content Script content
	 * @param string $id (optional) Element ID
	 * @param bool $wrap_jquery (optional) Wrap commands in jQuery? (Default: Yes)
	 * @param bool $wait_doc_ready (optional) Wait until document is fully loaded before executing commands? (Default: No)
	 */
	function build_script_element($content = '', $id = '', $wrap_jquery = true, $wait_doc_ready = false) {
		// Stop processing invalid content
		if ( is_array($content) && !empty($content) ) {
			$content = implode(PHP_EOL, $content);
		}
		if ( empty($content) || !is_string($content) ) {
			return '';
		}
		$attributes = array('type' => 'text/javascript');
		$start = array('/* <![CDATA[ */');
		$end = array('/* ]]> */');
		if ( $wrap_jquery ) {
			$start[] = 'if ( !!window.jQuery ) {(function($){';
			$end[] = '})(jQuery);}';

			// Add event handler (if necessary)
			if ( $wait_doc_ready ) {
				$start[] = '$(document).ready(function(){';
				$end[] = '})';
			}
		}

		// Reverse order of end values
		$end = array_reverse($end);
		$content = implode('', array_merge($start, array($content), $end));
		if ( is_string($id) && !empty($id) ) {
			$attributes['id'] = $this->add_prefix($id);
		}
		return $this->build_html_element(array('tag' => 'script', 'content' => $content, 'wrap' => true, 'attributes' => $attributes)) . PHP_EOL;
	}
}