PageRenderTime 44ms CodeModel.GetById 19ms RepoModel.GetById 0ms app.codeStats 0ms

/wp-includes/shortcodes.php

https://bitbucket.org/abnopanda/wordpress
PHP | 335 lines | 116 code | 25 blank | 194 comment | 19 complexity | c87e1379c177234a7150347dab3116df MD5 | raw file
  1. <?php
  2. /**
  3. * WordPress API for creating bbcode like tags or what WordPress calls
  4. * "shortcodes." The tag and attribute parsing or regular expression code is
  5. * based on the Textpattern tag parser.
  6. *
  7. * A few examples are below:
  8. *
  9. * [shortcode /]
  10. * [shortcode foo="bar" baz="bing" /]
  11. * [shortcode foo="bar"]content[/shortcode]
  12. *
  13. * Shortcode tags support attributes and enclosed content, but does not entirely
  14. * support inline shortcodes in other shortcodes. You will have to call the
  15. * shortcode parser in your function to account for that.
  16. *
  17. * {@internal
  18. * Please be aware that the above note was made during the beta of WordPress 2.6
  19. * and in the future may not be accurate. Please update the note when it is no
  20. * longer the case.}}
  21. *
  22. * To apply shortcode tags to content:
  23. *
  24. * <code>
  25. * $out = do_shortcode($content);
  26. * </code>
  27. *
  28. * @link http://codex.wordpress.org/Shortcode_API
  29. *
  30. * @package WordPress
  31. * @subpackage Shortcodes
  32. * @since 2.5
  33. */
  34. /**
  35. * Container for storing shortcode tags and their hook to call for the shortcode
  36. *
  37. * @since 2.5
  38. * @name $shortcode_tags
  39. * @var array
  40. * @global array $shortcode_tags
  41. */
  42. $shortcode_tags = array();
  43. /**
  44. * Add hook for shortcode tag.
  45. *
  46. * There can only be one hook for each shortcode. Which means that if another
  47. * plugin has a similar shortcode, it will override yours or yours will override
  48. * theirs depending on which order the plugins are included and/or ran.
  49. *
  50. * Simplest example of a shortcode tag using the API:
  51. *
  52. * <code>
  53. * // [footag foo="bar"]
  54. * function footag_func($atts) {
  55. * return "foo = {$atts[foo]}";
  56. * }
  57. * add_shortcode('footag', 'footag_func');
  58. * </code>
  59. *
  60. * Example with nice attribute defaults:
  61. *
  62. * <code>
  63. * // [bartag foo="bar"]
  64. * function bartag_func($atts) {
  65. * extract(shortcode_atts(array(
  66. * 'foo' => 'no foo',
  67. * 'baz' => 'default baz',
  68. * ), $atts));
  69. *
  70. * return "foo = {$foo}";
  71. * }
  72. * add_shortcode('bartag', 'bartag_func');
  73. * </code>
  74. *
  75. * Example with enclosed content:
  76. *
  77. * <code>
  78. * // [baztag]content[/baztag]
  79. * function baztag_func($atts, $content='') {
  80. * return "content = $content";
  81. * }
  82. * add_shortcode('baztag', 'baztag_func');
  83. * </code>
  84. *
  85. * @since 2.5
  86. * @uses $shortcode_tags
  87. *
  88. * @param string $tag Shortcode tag to be searched in post content.
  89. * @param callable $func Hook to run when shortcode is found.
  90. */
  91. function add_shortcode($tag, $func) {
  92. global $shortcode_tags;
  93. if ( is_callable($func) )
  94. $shortcode_tags[$tag] = $func;
  95. }
  96. /**
  97. * Removes hook for shortcode.
  98. *
  99. * @since 2.5
  100. * @uses $shortcode_tags
  101. *
  102. * @param string $tag shortcode tag to remove hook for.
  103. */
  104. function remove_shortcode($tag) {
  105. global $shortcode_tags;
  106. unset($shortcode_tags[$tag]);
  107. }
  108. /**
  109. * Clear all shortcodes.
  110. *
  111. * This function is simple, it clears all of the shortcode tags by replacing the
  112. * shortcodes global by a empty array. This is actually a very efficient method
  113. * for removing all shortcodes.
  114. *
  115. * @since 2.5
  116. * @uses $shortcode_tags
  117. */
  118. function remove_all_shortcodes() {
  119. global $shortcode_tags;
  120. $shortcode_tags = array();
  121. }
  122. /**
  123. * Search content for shortcodes and filter shortcodes through their hooks.
  124. *
  125. * If there are no shortcode tags defined, then the content will be returned
  126. * without any filtering. This might cause issues when plugins are disabled but
  127. * the shortcode will still show up in the post or content.
  128. *
  129. * @since 2.5
  130. * @uses $shortcode_tags
  131. * @uses get_shortcode_regex() Gets the search pattern for searching shortcodes.
  132. *
  133. * @param string $content Content to search for shortcodes
  134. * @return string Content with shortcodes filtered out.
  135. */
  136. function do_shortcode($content) {
  137. global $shortcode_tags;
  138. if (empty($shortcode_tags) || !is_array($shortcode_tags))
  139. return $content;
  140. $pattern = get_shortcode_regex();
  141. return preg_replace_callback( "/$pattern/s", 'do_shortcode_tag', $content );
  142. }
  143. /**
  144. * Retrieve the shortcode regular expression for searching.
  145. *
  146. * The regular expression combines the shortcode tags in the regular expression
  147. * in a regex class.
  148. *
  149. * The regular expression contains 6 different sub matches to help with parsing.
  150. *
  151. * 1 - An extra [ to allow for escaping shortcodes with double [[]]
  152. * 2 - The shortcode name
  153. * 3 - The shortcode argument list
  154. * 4 - The self closing /
  155. * 5 - The content of a shortcode when it wraps some content.
  156. * 6 - An extra ] to allow for escaping shortcodes with double [[]]
  157. *
  158. * @since 2.5
  159. * @uses $shortcode_tags
  160. *
  161. * @return string The shortcode search regular expression
  162. */
  163. function get_shortcode_regex() {
  164. global $shortcode_tags;
  165. $tagnames = array_keys($shortcode_tags);
  166. $tagregexp = join( '|', array_map('preg_quote', $tagnames) );
  167. // WARNING! Do not change this regex without changing do_shortcode_tag() and strip_shortcode_tag()
  168. // Also, see shortcode_unautop() and shortcode.js.
  169. return
  170. '\\[' // Opening bracket
  171. . '(\\[?)' // 1: Optional second opening bracket for escaping shortcodes: [[tag]]
  172. . "($tagregexp)" // 2: Shortcode name
  173. . '(?![\\w-])' // Not followed by word character or hyphen
  174. . '(' // 3: Unroll the loop: Inside the opening shortcode tag
  175. . '[^\\]\\/]*' // Not a closing bracket or forward slash
  176. . '(?:'
  177. . '\\/(?!\\])' // A forward slash not followed by a closing bracket
  178. . '[^\\]\\/]*' // Not a closing bracket or forward slash
  179. . ')*?'
  180. . ')'
  181. . '(?:'
  182. . '(\\/)' // 4: Self closing tag ...
  183. . '\\]' // ... and closing bracket
  184. . '|'
  185. . '\\]' // Closing bracket
  186. . '(?:'
  187. . '(' // 5: Unroll the loop: Optionally, anything between the opening and closing shortcode tags
  188. . '[^\\[]*+' // Not an opening bracket
  189. . '(?:'
  190. . '\\[(?!\\/\\2\\])' // An opening bracket not followed by the closing shortcode tag
  191. . '[^\\[]*+' // Not an opening bracket
  192. . ')*+'
  193. . ')'
  194. . '\\[\\/\\2\\]' // Closing shortcode tag
  195. . ')?'
  196. . ')'
  197. . '(\\]?)'; // 6: Optional second closing brocket for escaping shortcodes: [[tag]]
  198. }
  199. /**
  200. * Regular Expression callable for do_shortcode() for calling shortcode hook.
  201. * @see get_shortcode_regex for details of the match array contents.
  202. *
  203. * @since 2.5
  204. * @access private
  205. * @uses $shortcode_tags
  206. *
  207. * @param array $m Regular expression match array
  208. * @return mixed False on failure.
  209. */
  210. function do_shortcode_tag( $m ) {
  211. global $shortcode_tags;
  212. // allow [[foo]] syntax for escaping a tag
  213. if ( $m[1] == '[' && $m[6] == ']' ) {
  214. return substr($m[0], 1, -1);
  215. }
  216. $tag = $m[2];
  217. $attr = shortcode_parse_atts( $m[3] );
  218. if ( isset( $m[5] ) ) {
  219. // enclosing tag - extra parameter
  220. return $m[1] . call_user_func( $shortcode_tags[$tag], $attr, $m[5], $tag ) . $m[6];
  221. } else {
  222. // self-closing tag
  223. return $m[1] . call_user_func( $shortcode_tags[$tag], $attr, null, $tag ) . $m[6];
  224. }
  225. }
  226. /**
  227. * Retrieve all attributes from the shortcodes tag.
  228. *
  229. * The attributes list has the attribute name as the key and the value of the
  230. * attribute as the value in the key/value pair. This allows for easier
  231. * retrieval of the attributes, since all attributes have to be known.
  232. *
  233. * @since 2.5
  234. *
  235. * @param string $text
  236. * @return array List of attributes and their value.
  237. */
  238. function shortcode_parse_atts($text) {
  239. $atts = array();
  240. $pattern = '/(\w+)\s*=\s*"([^"]*)"(?:\s|$)|(\w+)\s*=\s*\'([^\']*)\'(?:\s|$)|(\w+)\s*=\s*([^\s\'"]+)(?:\s|$)|"([^"]*)"(?:\s|$)|(\S+)(?:\s|$)/';
  241. $text = preg_replace("/[\x{00a0}\x{200b}]+/u", " ", $text);
  242. if ( preg_match_all($pattern, $text, $match, PREG_SET_ORDER) ) {
  243. foreach ($match as $m) {
  244. if (!empty($m[1]))
  245. $atts[strtolower($m[1])] = stripcslashes($m[2]);
  246. elseif (!empty($m[3]))
  247. $atts[strtolower($m[3])] = stripcslashes($m[4]);
  248. elseif (!empty($m[5]))
  249. $atts[strtolower($m[5])] = stripcslashes($m[6]);
  250. elseif (isset($m[7]) and strlen($m[7]))
  251. $atts[] = stripcslashes($m[7]);
  252. elseif (isset($m[8]))
  253. $atts[] = stripcslashes($m[8]);
  254. }
  255. } else {
  256. $atts = ltrim($text);
  257. }
  258. return $atts;
  259. }
  260. /**
  261. * Combine user attributes with known attributes and fill in defaults when needed.
  262. *
  263. * The pairs should be considered to be all of the attributes which are
  264. * supported by the caller and given as a list. The returned attributes will
  265. * only contain the attributes in the $pairs list.
  266. *
  267. * If the $atts list has unsupported attributes, then they will be ignored and
  268. * removed from the final returned list.
  269. *
  270. * @since 2.5
  271. *
  272. * @param array $pairs Entire list of supported attributes and their defaults.
  273. * @param array $atts User defined attributes in shortcode tag.
  274. * @return array Combined and filtered attribute list.
  275. */
  276. function shortcode_atts($pairs, $atts) {
  277. $atts = (array)$atts;
  278. $out = array();
  279. foreach($pairs as $name => $default) {
  280. if ( array_key_exists($name, $atts) )
  281. $out[$name] = $atts[$name];
  282. else
  283. $out[$name] = $default;
  284. }
  285. return $out;
  286. }
  287. /**
  288. * Remove all shortcode tags from the given content.
  289. *
  290. * @since 2.5
  291. * @uses $shortcode_tags
  292. *
  293. * @param string $content Content to remove shortcode tags.
  294. * @return string Content without shortcode tags.
  295. */
  296. function strip_shortcodes( $content ) {
  297. global $shortcode_tags;
  298. if (empty($shortcode_tags) || !is_array($shortcode_tags))
  299. return $content;
  300. $pattern = get_shortcode_regex();
  301. return preg_replace_callback( "/$pattern/s", 'strip_shortcode_tag', $content );
  302. }
  303. function strip_shortcode_tag( $m ) {
  304. // allow [[foo]] syntax for escaping a tag
  305. if ( $m[1] == '[' && $m[6] == ']' ) {
  306. return substr($m[0], 1, -1);
  307. }
  308. return $m[1] . $m[6];
  309. }
  310. add_filter('the_content', 'do_shortcode', 11); // AFTER wpautop()