stump-cli 0.1.0 → 0.1.1

data/lib/wp/wp-includes/session.php

@@ -0,0 +1,430 @@
+<?php
+/**
+ * Abstract class for managing user session tokens.
+ *
+ * @since 4.0.0
+ */
+abstract class WP_Session_Tokens {
+
+	/**
+	 * User ID.
+	 *
+	 * @since 4.0.0
+	 * @access protected
+	 * @var int User ID.
+	 */
+	protected $user_id;
+
+	/**
+	 * Protected constructor.
+	 *
+	 * @since 4.0.0
+	 *
+	 * @param int $user_id User whose session to manage.
+	 */
+	protected function __construct( $user_id ) {
+		$this->user_id = $user_id;
+	}
+
+	/**
+	 * Get a session token manager instance for a user.
+	 *
+	 * This method contains a filter that allows a plugin to swap out
+	 * the session manager for a subclass of WP_Session_Tokens.
+	 *
+	 * @since 4.0.0
+	 * @access public
+	 * @static
+	 *
+	 * @param int $user_id User whose session to manage.
+	 */
+	final public static function get_instance( $user_id ) {
+		/**
+		 * Filter the session token manager used.
+		 *
+		 * @since 4.0.0
+		 *
+		 * @param string $session Name of class to use as the manager.
+		 *                        Default 'WP_User_Meta_Session_Tokens'.
+		 */
+		$manager = apply_filters( 'session_token_manager', 'WP_User_Meta_Session_Tokens' );
+		return new $manager( $user_id );
+	}
+
+	/**
+	 * Hashes a session token for storage.
+	 *
+	 * @since 4.0.0
+	 * @access private
+	 *
+	 * @param string $token Session token to hash.
+	 * @return string A hash of the session token (a verifier).
+	 */
+	final private function hash_token( $token ) {
+		// If ext/hash is not present, use sha1() instead.
+		if ( function_exists( 'hash' ) ) {
+			return hash( 'sha256', $token );
+		} else {
+			return sha1( $token );
+		}
+	}
+
+	/**
+	 * Get a user's session.
+	 *
+	 * @since 4.0.0
+	 * @access public
+	 *
+	 * @param string $token Session token
+	 * @return array User session
+	 */
+	final public function get( $token ) {
+		$verifier = $this->hash_token( $token );
+		return $this->get_session( $verifier );
+	}
+
+	/**
+	 * Validate a user's session token as authentic.
+	 *
+	 * Checks that the given token is present and hasn't expired.
+	 *
+	 * @since 4.0.0
+	 * @access public
+	 *
+	 * @param string $token Token to verify.
+	 * @return bool Whether the token is valid for the user.
+	 */
+	final public function verify( $token ) {
+		$verifier = $this->hash_token( $token );
+		return (bool) $this->get_session( $verifier );
+	}
+
+	/**
+	 * Generate a session token and attach session information to it.
+	 *
+	 * A session token is a long, random string. It is used in a cookie
+	 * link that cookie to an expiration time and to ensure the cookie
+	 * becomes invalidated upon logout.
+	 *
+	 * This function generates a token and stores it with the associated
+	 * expiration time (and potentially other session information via the
+	 * `attach_session_information` filter).
+	 *
+	 * @since 4.0.0
+	 * @access public
+	 *
+	 * @param int $expiration Session expiration timestamp.
+	 * @return string Session token.
+	 */
+	final public function create( $expiration ) {
+		/**
+		 * Filter the information attached to the newly created session.
+		 *
+		 * Could be used in the future to attach information such as
+		 * IP address or user agent to a session.
+		 *
+		 * @since 4.0.0
+		 *
+		 * @param array $session Array of extra data.
+		 * @param int   $user_id User ID.
+		 */
+		$session = apply_filters( 'attach_session_information', array(), $this->user_id );
+		$session['expiration'] = $expiration;
+
+		$token = wp_generate_password( 43, false, false );
+
+		$this->update( $token, $session );
+
+		return $token;
+	}
+
+	/**
+	 * Update a session token.
+	 *
+	 * @since 4.0.0
+	 * @access public
+	 *
+	 * @param string $token Session token to update.
+	 * @param array  $session Session information.
+	 */
+	final public function update( $token, $session ) {
+		$verifier = $this->hash_token( $token );
+		$this->update_session( $verifier, $session );
+	}
+
+	/**
+	 * Destroy a session token.
+	 *
+	 * @since 4.0.0
+	 * @access public
+	 *
+	 * @param string $token Session token to destroy.
+	 */
+	final public function destroy( $token ) {
+		$verifier = $this->hash_token( $token );
+		$this->update_session( $verifier, null );
+	}
+
+	/**
+	 * Destroy all session tokens for this user,
+	 * except a single token, presumably the one in use.
+	 *
+	 * @since 4.0.0
+	 * @access public
+	 *
+	 * @param string $token_to_keep Session token to keep.
+	 */
+	final public function destroy_others( $token_to_keep ) {
+		$verifier = $this->hash_token( $token_to_keep );
+		$session = $this->get_session( $verifier );
+		if ( $session ) {
+			$this->destroy_other_sessions( $verifier );
+		} else {
+			$this->destroy_all_sessions();
+		}
+	}
+
+	/**
+	 * Determine whether a session token is still valid,
+	 * based on expiration.
+	 *
+	 * @since 4.0.0
+	 * @access protected
+	 *
+	 * @param array $session Session to check.
+	 * @return bool Whether session is valid.
+	 */
+	final protected function is_still_valid( $session ) {
+		return $session['expiration'] >= time();
+	}
+
+	/**
+	 * Destroy all session tokens for a user.
+	 *
+	 * @since 4.0.0
+	 * @access public
+	 */
+	final public function destroy_all() {
+		$this->destroy_all_sessions();
+	}
+
+	/**
+	 * Destroy all session tokens for all users.
+	 *
+	 * @since 4.0.0
+	 * @access public
+	 * @static
+	 */
+	final public static function destroy_all_for_all_users() {
+		$manager = apply_filters( 'session_token_manager', 'WP_User_Meta_Session_Tokens' );
+		call_user_func( array( $manager, 'drop_sessions' ) );
+	}
+
+	/**
+	 * Retrieve all sessions of a user.
+	 *
+	 * @since 4.0.0
+	 * @access public
+	 *
+	 * @return array Sessions of a user.
+	 */
+	final public function get_all() {
+		return array_values( $this->get_sessions() );
+	}
+
+	/**
+	 * This method should retrieve all sessions of a user, keyed by verifier.
+	 *
+	 * @since 4.0.0
+	 * @access protected
+	 *
+	 * @return array Sessions of a user, keyed by verifier.
+	 */
+	abstract protected function get_sessions();
+
+	/**
+	 * This method should look up a session by its verifier (token hash).
+	 *
+	 * @since 4.0.0
+	 * @access protected
+	 *
+	 * @param string $verifier Verifier of the session to retrieve.
+	 * @return array|null The session, or null if it does not exist.
+	 */
+	abstract protected function get_session( $verifier );
+
+	/**
+	 * This method should update a session by its verifier.
+	 *
+	 * Omitting the second argument should destroy the session.
+	 *
+	 * @since 4.0.0
+	 * @access protected
+	 *
+	 * @param string $verifier Verifier of the session to update.
+	 */
+	abstract protected function update_session( $verifier, $session = null );
+
+	/**
+	 * This method should destroy all session tokens for this user,
+	 * except a single session passed.
+	 *
+	 * @since 4.0.0
+	 * @access protected
+	 *
+	 * @param string $verifier Verifier of the session to keep.
+	 */
+	abstract protected function destroy_other_sessions( $verifier );
+
+	/**
+	 * This method should destroy all sessions for a user.
+	 *
+	 * @since 4.0.0
+	 * @access protected
+	 */
+	abstract protected function destroy_all_sessions();
+
+	/**
+	 * This static method should destroy all session tokens for all users.
+	 *
+	 * @since 4.0.0
+	 * @access public
+	 * @static
+	 */
+	public static function drop_sessions() {}
+}
+
+/**
+ * Meta-based user sessions token manager.
+ *
+ * @since 4.0.0
+ */
+class WP_User_Meta_Session_Tokens extends WP_Session_Tokens {
+
+	/**
+	 * Get all sessions of a user.
+	 *
+	 * @since 4.0.0
+	 * @access protected
+	 *
+	 * @return array Sessions of a user.
+	 */
+	protected function get_sessions() {
+		$sessions = get_user_meta( $this->user_id, 'session_tokens', true );
+
+		if ( ! is_array( $sessions ) ) {
+			return array();
+		}
+
+		$sessions = array_map( array( $this, 'prepare_session' ), $sessions );
+		return array_filter( $sessions, array( $this, 'is_still_valid' ) );
+	}
+
+	/**
+	 * Converts an expiration to an array of session information.
+	 *
+	 * @param mixed $session Session or expiration.
+	 * @return array Session.
+	 */
+	protected function prepare_session( $session ) {
+		if ( is_int( $session ) ) {
+			return array( 'expiration' => $session );
+		}
+
+		return $session;
+	}
+
+	/**
+	 * Retrieve a session by its verifier (token hash).
+	 *
+	 * @since 4.0.0
+	 * @access protected
+	 *
+	 * @param string $verifier Verifier of the session to retrieve.
+	 * @return array|null The session, or null if it does not exist
+	 */
+	protected function get_session( $verifier ) {
+		$sessions = $this->get_sessions();
+
+		if ( isset( $sessions[ $verifier ] ) ) {
+			return $sessions[ $verifier ];
+		}
+
+		return null;
+	}
+
+	/**
+	 * Update a session by its verifier.
+	 *
+	 * @since 4.0.0
+	 * @access protected
+	 *
+	 * @param string $verifier Verifier of the session to update.
+	 * @param array  $session  Optional. Session. Omitting this argument destroys the session.
+	 */
+	protected function update_session( $verifier, $session = null ) {
+		$sessions = $this->get_sessions();
+
+		if ( $session ) {
+			$sessions[ $verifier ] = $session;
+		} else {
+			unset( $sessions[ $verifier ] );
+		}
+
+		$this->update_sessions( $sessions );
+	}
+
+	/**
+	 * Update a user's sessions in the usermeta table.
+	 *
+	 * @since 4.0.0
+	 * @access protected
+	 *
+	 * @param array $sessions Sessions.
+	 */
+	protected function update_sessions( $sessions ) {
+		if ( ! has_filter( 'attach_session_information' ) ) {
+			$sessions = wp_list_pluck( $sessions, 'expiration' );
+		}
+
+		if ( $sessions ) {
+			update_user_meta( $this->user_id, 'session_tokens', $sessions );
+		} else {
+			delete_user_meta( $this->user_id, 'session_tokens' );
+		}
+	}
+
+	/**
+	 * Destroy all session tokens for a user, except a single session passed.
+	 *
+	 * @since 4.0.0
+	 * @access protected
+	 *
+	 * @param string $verifier Verifier of the session to keep.
+	 */
+	protected function destroy_other_sessions( $verifier ) {
+		$session = $this->get_session( $verifier );
+		$this->update_sessions( array( $verifier => $session ) );
+	}
+
+	/**
+	 * Destroy all session tokens for a user.
+	 *
+	 * @since 4.0.0
+	 * @access protected
+	 */
+	protected function destroy_all_sessions() {
+		$this->update_sessions( array() );
+	}
+
+	/**
+	 * Destroy all session tokens for all users.
+	 *
+	 * @since 4.0.0
+	 * @access public
+	 * @static
+	 */
+	public static function drop_sessions() {
+		delete_metadata( 'user', false, 'session_tokens', false, true );
+	}
+}

data/lib/wp/wp-includes/shortcodes.php

@@ -0,0 +1,410 @@
+<?php
+/**
+ * WordPress API for creating bbcode like tags or what WordPress calls
+ * "shortcodes." The tag and attribute parsing or regular expression code is
+ * based on the Textpattern tag parser.
+ *
+ * A few examples are below:
+ *
+ * [shortcode /]
+ * [shortcode foo="bar" baz="bing" /]
+ * [shortcode foo="bar"]content[/shortcode]
+ *
+ * Shortcode tags support attributes and enclosed content, but does not entirely
+ * support inline shortcodes in other shortcodes. You will have to call the
+ * shortcode parser in your function to account for that.
+ *
+ * {@internal
+ * Please be aware that the above note was made during the beta of WordPress 2.6
+ * and in the future may not be accurate. Please update the note when it is no
+ * longer the case.}}
+ *
+ * To apply shortcode tags to content:
+ *
+ * <code>
+ * $out = do_shortcode($content);
+ * </code>
+ *
+ * @link http://codex.wordpress.org/Shortcode_API
+ *
+ * @package WordPress
+ * @subpackage Shortcodes
+ * @since 2.5.0
+ */
+
+/**
+ * Container for storing shortcode tags and their hook to call for the shortcode
+ *
+ * @since 2.5.0
+ *
+ * @name $shortcode_tags
+ * @var array
+ * @global array $shortcode_tags
+ */
+$shortcode_tags = array();
+
+/**
+ * Add hook for shortcode tag.
+ *
+ * There can only be one hook for each shortcode. Which means that if another
+ * plugin has a similar shortcode, it will override yours or yours will override
+ * theirs depending on which order the plugins are included and/or ran.
+ *
+ * Simplest example of a shortcode tag using the API:
+ *
+ * <code>
+ * // [footag foo="bar"]
+ * function footag_func($atts) {
+ * 	return "foo = {$atts[foo]}";
+ * }
+ * add_shortcode('footag', 'footag_func');
+ * </code>
+ *
+ * Example with nice attribute defaults:
+ *
+ * <code>
+ * // [bartag foo="bar"]
+ * function bartag_func($atts) {
+ * 	$args = shortcode_atts(array(
+ * 		'foo' => 'no foo',
+ * 		'baz' => 'default baz',
+ * 	), $atts);
+ *
+ * 	return "foo = {$args['foo']}";
+ * }
+ * add_shortcode('bartag', 'bartag_func');
+ * </code>
+ *
+ * Example with enclosed content:
+ *
+ * <code>
+ * // [baztag]content[/baztag]
+ * function baztag_func($atts, $content='') {
+ * 	return "content = $content";
+ * }
+ * add_shortcode('baztag', 'baztag_func');
+ * </code>
+ *
+ * @since 2.5.0
+ *
+ * @uses $shortcode_tags
+ *
+ * @param string $tag Shortcode tag to be searched in post content.
+ * @param callable $func Hook to run when shortcode is found.
+ */
+function add_shortcode($tag, $func) {
+	global $shortcode_tags;
+
+	if ( is_callable($func) )
+		$shortcode_tags[$tag] = $func;
+}
+
+/**
+ * Removes hook for shortcode.
+ *
+ * @since 2.5.0
+ *
+ * @uses $shortcode_tags
+ *
+ * @param string $tag shortcode tag to remove hook for.
+ */
+function remove_shortcode($tag) {
+	global $shortcode_tags;
+
+	unset($shortcode_tags[$tag]);
+}
+
+/**
+ * Clear all shortcodes.
+ *
+ * This function is simple, it clears all of the shortcode tags by replacing the
+ * shortcodes global by a empty array. This is actually a very efficient method
+ * for removing all shortcodes.
+ *
+ * @since 2.5.0
+ *
+ * @uses $shortcode_tags
+ */
+function remove_all_shortcodes() {
+	global $shortcode_tags;
+
+	$shortcode_tags = array();
+}
+
+/**
+ * Whether a registered shortcode exists named $tag
+ *
+ * @since 3.6.0
+ *
+ * @global array $shortcode_tags
+ * @param string $tag
+ * @return boolean
+ */
+function shortcode_exists( $tag ) {
+	global $shortcode_tags;
+	return array_key_exists( $tag, $shortcode_tags );
+}
+
+/**
+ * Whether the passed content contains the specified shortcode
+ *
+ * @since 3.6.0
+ *
+ * @global array $shortcode_tags
+ * @param string $tag
+ * @return boolean
+ */
+function has_shortcode( $content, $tag ) {
+	if ( false === strpos( $content, '[' ) ) {
+		return false;
+	}
+
+	if ( shortcode_exists( $tag ) ) {
+		preg_match_all( '/' . get_shortcode_regex() . '/s', $content, $matches, PREG_SET_ORDER );
+		if ( empty( $matches ) )
+			return false;
+
+		foreach ( $matches as $shortcode ) {
+			if ( $tag === $shortcode[2] ) {
+				return true;
+			} elseif ( ! empty( $shortcode[5] ) && has_shortcode( $shortcode[5], $tag ) ) {
+				return true;
+			}
+		}
+	}
+	return false;
+}
+
+/**
+ * Search content for shortcodes and filter shortcodes through their hooks.
+ *
+ * If there are no shortcode tags defined, then the content will be returned
+ * without any filtering. This might cause issues when plugins are disabled but
+ * the shortcode will still show up in the post or content.
+ *
+ * @since 2.5.0
+ *
+ * @uses $shortcode_tags
+ * @uses get_shortcode_regex() Gets the search pattern for searching shortcodes.
+ *
+ * @param string $content Content to search for shortcodes
+ * @return string Content with shortcodes filtered out.
+ */
+function do_shortcode($content) {
+	global $shortcode_tags;
+
+	if ( false === strpos( $content, '[' ) ) {
+		return $content;
+	}
+
+	if (empty($shortcode_tags) || !is_array($shortcode_tags))
+		return $content;
+
+	$pattern = get_shortcode_regex();
+	return preg_replace_callback( "/$pattern/s", 'do_shortcode_tag', $content );
+}
+
+/**
+ * Retrieve the shortcode regular expression for searching.
+ *
+ * The regular expression combines the shortcode tags in the regular expression
+ * in a regex class.
+ *
+ * The regular expression contains 6 different sub matches to help with parsing.
+ *
+ * 1 - An extra [ to allow for escaping shortcodes with double [[]]
+ * 2 - The shortcode name
+ * 3 - The shortcode argument list
+ * 4 - The self closing /
+ * 5 - The content of a shortcode when it wraps some content.
+ * 6 - An extra ] to allow for escaping shortcodes with double [[]]
+ *
+ * @since 2.5.0
+ *
+ * @uses $shortcode_tags
+ *
+ * @return string The shortcode search regular expression
+ */
+function get_shortcode_regex() {
+	global $shortcode_tags;
+	$tagnames = array_keys($shortcode_tags);
+	$tagregexp = join( '|', array_map('preg_quote', $tagnames) );
+
+	// WARNING! Do not change this regex without changing do_shortcode_tag() and strip_shortcode_tag()
+	// Also, see shortcode_unautop() and shortcode.js.
+	return
+		  '\\['                              // Opening bracket
+		. '(\\[?)'                           // 1: Optional second opening bracket for escaping shortcodes: [[tag]]
+		. "($tagregexp)"                     // 2: Shortcode name
+		. '(?![\\w-])'                       // Not followed by word character or hyphen
+		. '('                                // 3: Unroll the loop: Inside the opening shortcode tag
+		.     '[^\\]\\/]*'                   // Not a closing bracket or forward slash
+		.     '(?:'
+		.         '\\/(?!\\])'               // A forward slash not followed by a closing bracket
+		.         '[^\\]\\/]*'               // Not a closing bracket or forward slash
+		.     ')*?'
+		. ')'
+		. '(?:'
+		.     '(\\/)'                        // 4: Self closing tag ...
+		.     '\\]'                          // ... and closing bracket
+		. '|'
+		.     '\\]'                          // Closing bracket
+		.     '(?:'
+		.         '('                        // 5: Unroll the loop: Optionally, anything between the opening and closing shortcode tags
+		.             '[^\\[]*+'             // Not an opening bracket
+		.             '(?:'
+		.                 '\\[(?!\\/\\2\\])' // An opening bracket not followed by the closing shortcode tag
+		.                 '[^\\[]*+'         // Not an opening bracket
+		.             ')*+'
+		.         ')'
+		.         '\\[\\/\\2\\]'             // Closing shortcode tag
+		.     ')?'
+		. ')'
+		. '(\\]?)';                          // 6: Optional second closing brocket for escaping shortcodes: [[tag]]
+}
+
+/**
+ * Regular Expression callable for do_shortcode() for calling shortcode hook.
+ * @see get_shortcode_regex for details of the match array contents.
+ *
+ * @since 2.5.0
+ * @access private
+ * @uses $shortcode_tags
+ *
+ * @param array $m Regular expression match array
+ * @return mixed False on failure.
+ */
+function do_shortcode_tag( $m ) {
+	global $shortcode_tags;
+
+	// allow [[foo]] syntax for escaping a tag
+	if ( $m[1] == '[' && $m[6] == ']' ) {
+		return substr($m[0], 1, -1);
+	}
+
+	$tag = $m[2];
+	$attr = shortcode_parse_atts( $m[3] );
+
+	if ( isset( $m[5] ) ) {
+		// enclosing tag - extra parameter
+		return $m[1] . call_user_func( $shortcode_tags[$tag], $attr, $m[5], $tag ) . $m[6];
+	} else {
+		// self-closing tag
+		return $m[1] . call_user_func( $shortcode_tags[$tag], $attr, null,  $tag ) . $m[6];
+	}
+}
+
+/**
+ * Retrieve all attributes from the shortcodes tag.
+ *
+ * The attributes list has the attribute name as the key and the value of the
+ * attribute as the value in the key/value pair. This allows for easier
+ * retrieval of the attributes, since all attributes have to be known.
+ *
+ * @since 2.5.0
+ *
+ * @param string $text
+ * @return array List of attributes and their value.
+ */
+function shortcode_parse_atts($text) {
+	$atts = array();
+	$pattern = '/(\w+)\s*=\s*"([^"]*)"(?:\s|$)|(\w+)\s*=\s*\'([^\']*)\'(?:\s|$)|(\w+)\s*=\s*([^\s\'"]+)(?:\s|$)|"([^"]*)"(?:\s|$)|(\S+)(?:\s|$)/';
+	$text = preg_replace("/[\x{00a0}\x{200b}]+/u", " ", $text);
+	if ( preg_match_all($pattern, $text, $match, PREG_SET_ORDER) ) {
+		foreach ($match as $m) {
+			if (!empty($m[1]))
+				$atts[strtolower($m[1])] = stripcslashes($m[2]);
+			elseif (!empty($m[3]))
+				$atts[strtolower($m[3])] = stripcslashes($m[4]);
+			elseif (!empty($m[5]))
+				$atts[strtolower($m[5])] = stripcslashes($m[6]);
+			elseif (isset($m[7]) and strlen($m[7]))
+				$atts[] = stripcslashes($m[7]);
+			elseif (isset($m[8]))
+				$atts[] = stripcslashes($m[8]);
+		}
+	} else {
+		$atts = ltrim($text);
+	}
+	return $atts;
+}
+
+/**
+ * Combine user attributes with known attributes and fill in defaults when needed.
+ *
+ * The pairs should be considered to be all of the attributes which are
+ * supported by the caller and given as a list. The returned attributes will
+ * only contain the attributes in the $pairs list.
+ *
+ * If the $atts list has unsupported attributes, then they will be ignored and
+ * removed from the final returned list.
+ *
+ * @since 2.5.0
+ *
+ * @param array $pairs Entire list of supported attributes and their defaults.
+ * @param array $atts User defined attributes in shortcode tag.
+ * @param string $shortcode Optional. The name of the shortcode, provided for context to enable filtering
+ * @return array Combined and filtered attribute list.
+ */
+function shortcode_atts( $pairs, $atts, $shortcode = '' ) {
+	$atts = (array)$atts;
+	$out = array();
+	foreach($pairs as $name => $default) {
+		if ( array_key_exists($name, $atts) )
+			$out[$name] = $atts[$name];
+		else
+			$out[$name] = $default;
+	}
+	/**
+	 * Filter a shortcode's default attributes.
+	 *
+	 * If the third parameter of the shortcode_atts() function is present then this filter is available.
+	 * The third parameter, $shortcode, is the name of the shortcode.
+	 *
+	 * @since 3.6.0
+	 *
+	 * @param array $out The output array of shortcode attributes.
+	 * @param array $pairs The supported attributes and their defaults.
+	 * @param array $atts The user defined shortcode attributes.
+	 */
+	if ( $shortcode )
+		$out = apply_filters( "shortcode_atts_{$shortcode}", $out, $pairs, $atts );
+
+	return $out;
+}
+
+/**
+ * Remove all shortcode tags from the given content.
+ *
+ * @since 2.5.0
+ *
+ * @uses $shortcode_tags
+ *
+ * @param string $content Content to remove shortcode tags.
+ * @return string Content without shortcode tags.
+ */
+function strip_shortcodes( $content ) {
+	global $shortcode_tags;
+
+	if ( false === strpos( $content, '[' ) ) {
+		return $content;
+	}
+
+	if (empty($shortcode_tags) || !is_array($shortcode_tags))
+		return $content;
+
+	$pattern = get_shortcode_regex();
+
+	return preg_replace_callback( "/$pattern/s", 'strip_shortcode_tag', $content );
+}
+
+function strip_shortcode_tag( $m ) {
+	// allow [[foo]] syntax for escaping a tag
+	if ( $m[1] == '[' && $m[6] == ']' ) {
+		return substr($m[0], 1, -1);
+	}
+
+	return $m[1] . $m[6];
+}
+
+add_filter('the_content', 'do_shortcode', 11); // AFTER wpautop()