1. <?php
  2. /*
  3. Plugin Name: Page Links To
  4. Plugin URI: http://txfx.net/wordpress-plugins/page-links-to/
  5. Description: Allows you to point WordPress pages or posts to a URL of your choosing. Good for setting up navigational links to non-WP sections of your site or to off-site resources.
  6. Version: 2.9.9
  7. Author: Mark Jaquith
  8. Author URI: http://coveredwebservices.com/
  9. Text Domain: page-links-to
  10. Domain Path: /languages
  11. */
  13. /* Copyright 2005-2017 Mark Jaquith
  15. This program is free software; you can redistribute it and/or modify
  16. it under the terms of the GNU General Public License as published by
  17. the Free Software Foundation; either version 2 of the License, or
  18. (at your option) any later version.
  20. This program is distributed in the hope that it will be useful,
  21. but WITHOUT ANY WARRANTY; without even the implied warranty of
  22. MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  23. GNU General Public License for more details.
  25. You should have received a copy of the GNU General Public License
  26. along with this program; if not, write to the Free Software
  27. Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
  28. */
  30. // Pull in WP Stack plugin library
  31. include( dirname( __FILE__ ) . '/lib/wp-stack-plugin.php' );
  33. class CWS_PageLinksTo extends WP_Stack_Plugin {
  34. static $instance;
  35. const LINKS_CACHE_KEY = 'plt_cache__links';
  36. const TARGETS_CACHE_KEY = 'plt_cache__targets';
  37. const LINK_META_KEY = '_links_to';
  38. const TARGET_META_KEY = '_links_to_target';
  39. const VERSION_KEY = 'txfx_plt_schema_version';
  40. const FILE = __FILE__;
  41. const CSS_JS_VERSION = '2.9.8';
  43. function __construct() {
  44. self::$instance = $this;
  45. $this->hook( 'init' );
  46. }
  48. /**
  49. * Bootstraps the upgrade process and registers all the hooks.
  50. */
  51. function init() {
  52. // Check to see if any of our data needs to be upgraded
  53. $this->maybe_upgrade();
  55. // Load translation files
  56. load_plugin_textdomain( 'page-links-to', false, basename( dirname( self::FILE ) ) . '/languages' );
  58. // Register hooks
  59. $this->register_hooks();
  60. }
  62. /**
  63. * Registers all the hooks
  64. */
  65. function register_hooks() {
  66. // Hook in to URL generation
  67. $this->hook( 'page_link', 'link', 20 );
  68. $this->hook( 'post_link', 'link', 20 );
  69. $this->hook( 'post_type_link', 'link', 20 );
  70. $this->hook( 'attachment_link', 'link', 20 );
  72. // Non-standard priority hooks
  73. $this->hook( 'do_meta_boxes', 20 );
  74. // $this->hook( 'wp_enqueue_scripts', 'start_buffer', -9999 );
  75. $this->hook( 'wp_enqueue_scripts' );
  76. // $this->hook( 'wp_enqueue_scripts', 'jquery_protection', 9999 );
  77. // $this->hook( 'wp_head', 'end_buffer', 9999 );
  79. // Non-standard callback hooks
  80. $this->hook( 'load-post.php', 'load_post' );
  81. $this->hook( 'wp_default_scripts', 'log_jquery' );
  83. // Standard hooks
  84. $this->hook( 'wp_list_pages' );
  85. $this->hook( 'template_redirect' );
  86. $this->hook( 'save_post' );
  87. $this->hook( 'edit_attachment' );
  88. $this->hook( 'wp_nav_menu_objects' );
  89. $this->hook( 'plugin_row_meta' );
  91. // Metadata validation grants users editing privileges for our custom fields
  92. register_meta( 'post', self::LINK_META_KEY, null, '__return_true' );
  93. register_meta( 'post', self::TARGET_META_KEY, null, '__return_true' );
  94. }
  96. /**
  97. * Performs an upgrade for older versions
  98. *
  99. * * Version 3: Underscores the keys so they only show in the plugin's UI.
  100. */
  101. function maybe_upgrade() {
  102. // In earlier versions, the meta keys were stored without a leading underscore.
  103. // Since then, underscore has been codified as the standard for "something manages this" post meta.
  104. if ( get_option( self::VERSION_KEY ) < 3 ) {
  105. global $wpdb;
  106. $total_affected = 0;
  107. foreach ( array( '', '_target', '_type' ) as $meta_key ) {
  108. $meta_key = 'links_to' . $meta_key;
  109. $affected = $wpdb->update( $wpdb->postmeta, array( 'meta_key' => '_' . $meta_key ), compact( 'meta_key' ) );
  110. if ( $affected ) {
  111. $total_affected += $affected;
  112. }
  113. }
  114. // Only flush the cache if something changed
  115. if ( $total_affected > 0 ) {
  116. wp_cache_flush();
  117. }
  118. if ( update_option( self::VERSION_KEY, 3 ) ) {
  119. $this->flush_links_cache();
  120. $this->flush_targets_cache();
  121. }
  122. }
  123. }
  125. /**
  126. * Logs data about core's jQuery
  127. */
  128. public function log_jquery( $wp_scripts ) {
  129. $this->jquery = $wp_scripts->registered['jquery'];
  130. $this->jquery_core = $wp_scripts->registered['jquery-core'];
  131. }
  133. /**
  134. * Prevents jQuery from being incorrectly overwritten
  135. */
  136. public function jquery_protection() {
  137. global $wp_scripts;
  139. if ( $wp_scripts->registered['jquery-core'] !== $this->jquery_core ) {
  140. $wp_scripts->registered['jquery-core'] = $this->jquery_core;
  141. }
  143. if ( $wp_scripts->registered['jquery'] !== $this->jquery ) {
  144. $wp_scripts->registered['jquery'] = $this->jquery;
  145. }
  146. }
  148. /**
  149. * Enqueues front end scripts
  150. */
  151. function wp_enqueue_scripts() {
  152. wp_enqueue_script( 'page-links-to', $this->get_url() . 'js/new-tab.min.js', array( 'jquery' ), self::CSS_JS_VERSION, true );
  153. }
  155. /**
  156. * Starts a buffer, for rescuing the jQuery object
  157. */
  158. function start_buffer() {
  159. ob_start( array( $this, 'buffer_callback' ) );
  160. }
  162. /**
  163. * Collects the buffer, and injects a `jQueryWP` JS object as a
  164. * copy of `jQuery`, so that dumb themes and plugins can't hurt it
  165. *
  166. * @return string the modified buffer
  167. */
  168. function buffer_callback( $content ) {
  169. $pattern = "#wp-includes/js/jquery/jquery\.js\?ver=([^']+)'></script>#";
  170. if ( preg_match( $pattern, $content ) ) {
  171. $content = preg_replace( $pattern, '$0<script>jQueryWP = jQuery;</script>', $content );
  172. }
  173. return $content;
  174. }
  176. /**
  177. * Flushes the buffer
  178. */
  179. function end_buffer() {
  180. ob_end_flush();
  181. }
  183. /**
  184. * Returns post ids and meta values that have a given key
  185. *
  186. * @param string $key post meta key
  187. * @return array|false objects with post_id and meta_value properties
  188. */
  189. function meta_by_key( $key ) {
  190. global $wpdb;
  191. return $wpdb->get_results( $wpdb->prepare( "SELECT post_id, meta_value FROM $wpdb->postmeta WHERE meta_key = %s", $key ) );
  192. }
  194. /**
  195. * Returns a single piece of post meta
  196. * @param integer $post_id a post ID
  197. * @param string $key a post meta key
  198. * @return string|false the post meta, or false, if it doesn't exist
  199. */
  200. function get_post_meta( $post_id, $key ) {
  201. $meta = get_post_meta( absint( $post_id ), $key, true );
  202. if ( '' === $meta ) {
  203. return false;
  204. }
  205. return $meta;
  206. }
  208. /**
  209. * Returns all links for the current site
  210. *
  211. * @return array an array of links, keyed by post ID
  212. */
  213. function get_links() {
  214. if ( false === $links = get_transient( self::LINKS_CACHE_KEY ) ) {
  215. $db_links = $this->meta_by_key( self::LINK_META_KEY );
  216. $links = array();
  217. if ( $db_links ) {
  218. foreach ( $db_links as $link ) {
  219. $links[ intval( $link->post_id ) ] = $link->meta_value;
  220. }
  221. }
  222. set_transient( self::LINKS_CACHE_KEY, $links, 10 * 60 );
  223. }
  224. return $links;
  225. }
  227. /**
  228. * Returns the link for the specified post ID
  229. *
  230. * @param integer $post_id a post ID
  231. * @return mixed either a URL or false
  232. */
  233. function get_link( $post_id ) {
  234. return $this->get_post_meta( $post_id, self::LINK_META_KEY );
  235. }
  237. /**
  238. * Returns all targets for the current site
  239. *
  240. * @return array an array of targets, keyed by post ID
  241. */
  242. function get_targets() {
  243. if ( false === $targets = get_transient( self::TARGETS_CACHE_KEY ) ) {
  244. $db_targets = $this->meta_by_key( self::TARGET_META_KEY );
  245. $targets = array();
  246. if ( $db_targets ) {
  247. foreach ( $db_targets as $target ) {
  248. $targets[ intval( $target->post_id ) ] = true;
  249. }
  250. }
  251. set_transient( self::TARGETS_CACHE_KEY, $targets, 10 * 60 );
  252. }
  253. return $targets;
  254. }
  256. /**
  257. * Returns the _blank target status for the specified post ID
  258. *
  259. * @param integer $post_id a post ID
  260. * @return bool whether it should open in a new tab
  261. */
  262. function get_target( $post_id ) {
  263. return (bool) $this->get_post_meta( $post_id, self::TARGET_META_KEY );
  264. }
  266. /**
  267. * Adds the meta box to the post or page edit screen
  268. *
  269. * @param string $page the name of the current page
  270. * @param string $context the current context
  271. */
  272. function do_meta_boxes( $page, $context ) {
  273. // Plugins that use custom post types can use this filter to hide the
  274. // PLT UI in their post type.
  275. $plt_post_types = apply_filters( 'page-links-to-post-types', array_keys( get_post_types( array('show_ui' => true ) ) ) );
  277. if ( in_array( $page, $plt_post_types ) && 'advanced' === $context ) {
  278. add_meta_box( 'page-links-to', _x( 'Page Links To', 'Meta box title', 'page-links-to'), array( $this, 'meta_box' ), $page, 'advanced', 'low' );
  279. }
  280. }
  282. /**
  283. * Outputs the Page Links To post screen meta box
  284. */
  285. function meta_box() {
  286. $null = null;
  287. $post = get_post( $null );
  288. echo '<p>';
  289. wp_nonce_field( 'cws_plt_' . $post->ID, '_cws_plt_nonce', false, true );
  290. echo '</p>';
  291. $url = $this->get_link( $post->ID );
  292. if ( ! $url ) {
  293. $linked = false;
  294. $url = 'http://';
  295. } else {
  296. $linked = true;
  297. }
  298. ?>
  299. <p><?php _e( 'Point this content to:', 'page-links-to' ); ?></p>
  300. <p><label><input type="radio" id="cws-links-to-choose-wp" name="cws_links_to_choice" value="wp" <?php checked( !$linked ); ?> /> <?php _e( 'Its normal WordPress URL', 'page-links-to' ); ?></label></p>
  301. <p><label><input type="radio" id="cws-links-to-choose-custom" name="cws_links_to_choice" value="custom" <?php checked( $linked ); ?> /> <?php _e( 'A custom URL', 'page-links-to' ); ?></label></p>
  302. <div style="webkit-box-sizing:border-box;-moz-box-sizing:border-box;box-sizing:border-box;margin-left: 30px;" id="cws-links-to-custom-section" class="<?php echo ! $linked ? 'hide-if-js' : ''; ?>">
  303. <p><input name="cws_links_to" type="text" style="width:75%" id="cws-links-to" value="<?php echo esc_attr( $url ); ?>" /></p>
  304. <p><label for="cws-links-to-new-tab"><input type="checkbox" name="cws_links_to_new_tab" id="cws-links-to-new-tab" value="_blank" <?php checked( (bool) $this->get_target( $post->ID ) ); ?>> <?php _e( 'Open this link in a new tab', 'page-links-to' ); ?></label></p>
  305. </div>
  306. <script src="<?php echo $this->get_url() . 'js/page-links-to.min.js?v=' . self::CSS_JS_VERSION; ?>"></script>
  307. <?php
  308. }
  310. /**
  311. * Saves data on attachment save
  312. *
  313. * @param int $post_id
  314. * @return int the attachment post ID that was passed in
  315. */
  316. function edit_attachment( $post_id ) {
  317. return $this->save_post( $post_id );
  318. }
  320. /**
  321. * Saves data on post save
  322. *
  323. * @param int $post_id a post ID
  324. * @return int the post ID that was passed in
  325. */
  326. function save_post( $post_id ) {
  327. if ( isset( $_REQUEST['_cws_plt_nonce'] ) && wp_verify_nonce( $_REQUEST['_cws_plt_nonce'], 'cws_plt_' . $post_id ) ) {
  328. if ( ( ! isset( $_POST['cws_links_to_choice'] ) || 'custom' == $_POST['cws_links_to_choice'] ) && isset( $_POST['cws_links_to'] ) && strlen( $_POST['cws_links_to'] ) > 0 && $_POST['cws_links_to'] !== 'http://' ) {
  329. $url = $this->clean_url( stripslashes( $_POST['cws_links_to'] ) );
  330. $this->flush_links_if( $this->set_link( $post_id, $url ) );
  331. if ( isset( $_POST['cws_links_to_new_tab'] ) )
  332. $this->flush_targets_if( $this->set_link_new_tab( $post_id ) );
  333. else
  334. $this->flush_targets_if( $this->set_link_same_tab( $post_id ) );
  335. } else {
  336. $this->flush_links_if( $this->delete_link( $post_id ) );
  337. }
  338. }
  339. return $post_id;
  340. }
  342. /**
  343. * Cleans up a URL
  344. *
  345. * @param string $url URL
  346. * @return string cleaned up URL
  347. */
  348. function clean_url( $url ) {
  349. $url = trim( $url );
  350. // Starts with 'www.'. Probably a mistake. So add 'http://'.
  351. if ( 0 === strpos( $url, 'www.' ) ) {
  352. $url = 'http://' . $url;
  353. }
  354. return $url;
  355. }
  357. /**
  358. * Have a post point to a custom URL
  359. *
  360. * @param int $post_id post ID
  361. * @param string $url the URL to point the post to
  362. * @return bool whether anything changed
  363. */
  364. function set_link( $post_id, $url ) {
  365. return $this->flush_links_if( (bool) update_post_meta( $post_id, self::LINK_META_KEY, $url ) );
  366. }
  368. /**
  369. * Tell an custom URL post to open in a new tab
  370. *
  371. * @param int $post_id post ID
  372. * @return bool whether anything changed
  373. */
  374. function set_link_new_tab( $post_id ) {
  375. return $this->flush_targets_if( (bool) update_post_meta( $post_id, self::TARGET_META_KEY, '_blank' ) );
  376. }
  378. /**
  379. * Tell an custom URL post to open in the same tab
  380. *
  381. * @param int $post_id post ID
  382. * @return bool whether anything changed
  383. */
  384. function set_link_same_tab( $post_id ) {
  385. return $this->flush_targets_if( delete_post_meta( $post_id, self::TARGET_META_KEY ) );
  386. }
  388. /**
  389. * Discard a custom URL and point a post to its normal URL
  390. *
  391. * @param int $post_id post ID
  392. * @return bool whether the link was deleted
  393. */
  394. function delete_link( $post_id ) {
  395. $return = $this->flush_links_if( delete_post_meta( $post_id, self::LINK_META_KEY ) );
  396. $this->flush_targets_if( delete_post_meta( $post_id, self::TARGET_META_KEY ) );
  398. // Old, unused data that we can delete on the fly
  399. delete_post_meta( $post_id, '_links_to_type' );
  401. return $return;
  402. }
  404. /**
  405. * Flushes the links transient cache if the condition is true
  406. *
  407. * @param bool $condition whether to proceed with the flush
  408. * @return bool whether the flush happened
  409. */
  410. function flush_links_if( $condition ) {
  411. if ( $condition ) {
  412. $this->flush_links_cache();
  413. return true;
  414. } else {
  415. return false;
  416. }
  417. }
  419. /**
  420. * Flushes the targets transient cache if the condition is true
  421. *
  422. * @param bool $condition whether to proceed with the flush
  423. * @return bool whether the flush happened
  424. */
  425. function flush_targets_if( $condition ) {
  426. if ( $condition ) {
  427. $this->flush_targets_cache();
  428. return true;
  429. } else {
  430. return false;
  431. }
  432. }
  434. /**
  435. * Flushes the links transient cache
  436. *
  437. * @param bool $condition whether to flush the cache
  438. * @param string $type which cache to flush
  439. * @return bool whether the flush attempt occurred
  440. */
  441. function flush_links_cache() {
  442. delete_transient( self::LINKS_CACHE_KEY );
  443. }
  445. /**
  446. * Flushes the targets transient cache
  447. *
  448. * @param bool $condition whether to flush the cache
  449. * @param string $type which cache to flush
  450. * @return bool whether the flush attempt occurred
  451. */
  452. function flush_targets_cache() {
  453. delete_transient( self::TARGETS_CACHE_KEY );
  454. }
  456. /**
  457. * Filter for Post links
  458. *
  459. * @param string $link the URL for the post or page
  460. * @param int|WP_Post $post post ID or object
  461. * @return string output URL
  462. */
  463. function link( $link, $post ) {
  464. $post = get_post( $post );
  466. $meta_link = $this->get_link( $post->ID );
  468. if ( $meta_link ) {
  469. $link = esc_url( $meta_link );
  470. if ( ! is_admin() && $this->get_target( $post->ID ) ) {
  471. $link .= '#new_tab';
  472. }
  473. }
  475. return $link;
  476. }
  478. /**
  479. * Performs a redirect
  480. */
  481. function template_redirect() {
  482. $link = $this->get_redirect();
  484. if ( $link ) {
  485. wp_redirect( $link, 301 );
  486. exit;
  487. }
  488. }
  490. /**
  491. * gets the redirection URL
  492. *
  493. * @return string|bool the redirection URL, or false
  494. */
  495. function get_redirect() {
  496. if ( ! is_singular() || ! get_queried_object_id() ) {
  497. return false;
  498. }
  500. $link = $this->get_link( get_queried_object_id() );
  502. // Convert server- and protocol-relative URLs to absolute URLs
  503. if ( "/" === $link[0] ) {
  504. // Protocol-relative
  505. if ( "/" === $link[1] ) {
  506. $link = set_url_scheme( 'http:' . $link );
  507. } else {
  508. // Host-relative
  509. $link = set_url_scheme( 'http://' . $_SERVER["HTTP_HOST"] . $link );
  510. }
  511. }
  513. if ( 'mailto' !== parse_url( $link, PHP_URL_SCHEME ) ) {
  514. $link = str_replace( '@', '%40', $link );
  515. }
  517. return $link;
  518. }
  520. /**
  521. * Filters the list of pages to alter the links and targets
  522. *
  523. * @param string $pages the wp_list_pages() HTML block from WordPress
  524. * @return string the modified HTML block
  525. */
  526. function wp_list_pages( $pages ) {
  527. $highlight = false;
  529. // We use the "fetch all" versions here, because the pages might not be queried here
  530. $links = $this->get_links();
  531. $targets = $this->get_targets();
  532. $targets_by_url = array();
  533. foreach( array_keys( $targets ) as $targeted_id )
  534. $targets_by_url[$links[$targeted_id]] = true;
  536. if ( ! $links ) {
  537. return $pages;
  538. }
  540. $this_url = ( is_ssl() ? 'https' : 'http' ) . '://' . $_SERVER['HTTP_HOST'] . $_SERVER['REQUEST_URI'];
  542. foreach ( (array) $links as $id => $page ) {
  543. if ( isset( $targets_by_url[$page] ) ) {
  544. $page .= '#new_tab';
  545. }
  546. if ( str_replace( 'http://www.', 'http://', $this_url ) === str_replace( 'http://www.', 'http://', $page ) || ( is_home() && str_replace( 'http://www.', 'http://', trailingslashit( get_bloginfo( 'url' ) ) ) === str_replace( 'http://www.', 'http://', trailingslashit( $page ) ) ) ) {
  547. $highlight = true;
  548. $current_page = esc_url( $page );
  549. }
  550. }
  552. if ( count( $targets_by_url ) ) {
  553. foreach ( array_keys( $targets_by_url ) as $p ) {
  554. $p = esc_url( $p . '#new_tab' );
  555. $pages = str_replace( '<a href="' . $p . '"', '<a href="' . $p . '" target="_blank"', $pages );
  556. }
  557. }
  559. if ( $highlight ) {
  560. $pages = preg_replace( '| class="([^"]+)current_page_item"|', ' class="$1"', $pages ); // Kill default highlighting
  561. $pages = preg_replace( '|<li class="([^"]+)"><a href="' . preg_quote( $current_page ) . '"|', '<li class="$1 current_page_item"><a href="' . $current_page . '"', $pages );
  562. }
  563. return $pages;
  564. }
  566. /**
  567. * Filters nav menu objects and adds target=_blank to the ones that need it
  568. *
  569. * @param array $items nav menu items
  570. * @return array modified nav menu items
  571. */
  572. function wp_nav_menu_objects( $items ) {
  573. $new_items = array();
  574. foreach ( $items as $item ) {
  575. if ( isset( $item->object_id ) && $this->get_target( $item->object_id ) ) {
  576. $item->target = '_blank';
  577. }
  578. $new_items[] = $item;
  579. }
  580. return $new_items;
  581. }
  583. /**
  584. * Hooks in as a post is being loaded for editing and conditionally adds a notice
  585. */
  586. function load_post() {
  587. if ( isset( $_GET['post'] ) && $this->get_link( (int) $_GET['post'] ) ) {
  588. $this->hook( 'admin_notices', 'notify_of_external_link' );
  589. }
  590. }
  592. /**
  593. * Outputs a notice that the current post item is pointed to a custom URL
  594. */
  595. function notify_of_external_link() {
  596. ?><div class="updated"><p><?php _e( '<strong>Note</strong>: This content is pointing to a custom URL. Use the &#8220;Page Links To&#8221; box to change this behavior.', 'page-links-to' ); ?></p></div><?php
  597. }
  599. /**
  600. * Adds a GitHub link to the plugin meta
  601. *
  602. * @param array $links the current array of links
  603. * @param string $file the current plugin being processed
  604. * @return array the modified array of links
  605. */
  606. function plugin_row_meta( $links, $file ) {
  607. if ( $file === plugin_basename( self::FILE ) ) {
  608. return array_merge(
  609. $links,
  610. array( '<a href="https://github.com/markjaquith/page-links-to" target="_blank">GitHub</a>' )
  611. );
  612. } else {
  613. return $links;
  614. }
  615. }
  617. /**
  618. * Returns the URL of this plugin's directory
  619. *
  620. * @return string this plugin's directory URL
  621. */
  622. public function get_url() {
  623. return plugin_dir_url( self::FILE );
  624. }
  626. /**
  627. * Returns the filesystem path of this plugin's directory
  628. *
  629. * @return string this plugin's directory filesystem path
  630. */
  631. public function get_path() {
  632. return plugin_dir_path( self::FILE );
  633. }
  634. }
  636. // Bootstrap everything
  637. new CWS_PageLinksTo;