PluginProbe
FeedWordPress / 2008.1105
FeedWordPress v2008.1105
trunk 0.8 0.9 0.91 0.95 0.96 0.97 0.98 0.981 0.99 0.991 0.992 0.993 2008.1030 2008.1101 2008.1105 2008.1214 2009.0612 2009.0613 2009.0618 2009.0707 2009.1111 2009.1112 2010.0127 2010.0528 All 65 releases
← All changes | feedwordpress.php +785 -503 2009.0618 → 2008.1105 View file →
@@ -2,12 +2,13 @@
2 2 /*
3 3 Plugin Name: FeedWordPress
4 4 Plugin URI: http://projects.radgeek.com/feedwordpress
5 5 Description: simple and flexible Atom/RSS syndication for WordPress
6 -Version: 2009.0618
6 +Version: 2008.1105
7 7 Author: Charles Johnson
8 8 Author URI: http://radgeek.com/
9 9 License: GPL
10 +Last modified: 2008-11-05 4:35pm PST
10 11 */
11 12
12 13 # This uses code derived from:
13 14 # - wp-rss-aggregate.php by Kellan Elliot-McCrea <kellan@protest.net>
@@ -14,30 +15,24 @@
14 15 # - HTTP Navigator 2 by Keyvan Minoukadeh <keyvan@k1m.com>
15 16 # - Ultra-Liberal Feed Finder by Mark Pilgrim <mark@diveintomark.org>
16 17 # according to the terms of the GNU General Public License.
17 18 #
18 -# INSTALLATION: see readme.txt or <http://projects.radgeek.com/install>
19 +# INSTALLATION: see README.text or <http://projects.radgeek.com/install>
19 20 #
20 21 # USAGE: once FeedWordPress is installed, you manage just about everything from
21 -# the WordPress Dashboard, under the Syndication menu. To ensure that fresh
22 -# content is added as it becomes available, you can convince your contributors
23 -# to put your XML-RPC URI (if WordPress is installed at
22 +# the WordPress Dashboard, under Options --> Syndication or Links --> Syndicated
23 +# To ensure that fresh content is added as it becomes available, get your
24 +# contributors to put your XML-RPC URI (if WordPress is installed at
24 25 # <http://www.zyx.com/blog>, XML-RPC requests should be sent to
25 -# <http://www.zyx.com/blog/xmlrpc.php>), or update manually under the
26 -# Syndication menu, or set up automatic updates under Syndication --> Settings,
27 -# or use a cron job.
26 +# <http://www.zyx.com/blog/xmlrpc.php>), or see `update-feeds.php`
28 27
29 28 # -- Don't change these unless you know what you're doing...
30 29
31 -define ('FEEDWORDPRESS_VERSION', '2009.0612');
30 +define ('FEEDWORDPRESS_VERSION', '2008.1105');
32 31 define ('FEEDWORDPRESS_AUTHOR_CONTACT', 'http://radgeek.com/contact');
33 32 define ('DEFAULT_SYNDICATION_CATEGORY', 'Contributors');
34 33
35 -$feedwordpress_debug = get_option('feedwordpress_debug');
36 -if (is_string($feedwordpress_debug)) :
37 - $feedwordpress_debug = ($feedwordpress_debug == 'yes');
38 -endif;
39 -define ('FEEDWORDPRESS_DEBUG', $feedwordpress_debug);
34 +define ('FEEDWORDPRESS_DEBUG', false);
40 35
41 36 define ('FEEDWORDPRESS_CAT_SEPARATOR_PATTERN', '/[:\n]/');
42 37 define ('FEEDWORDPRESS_CAT_SEPARATOR', "\n");
43 38
@@ -50,9 +45,8 @@
50 45 define ('FWP_SCHEMA_21', 4772); // Database schema # for WP 2.1
51 46 define ('FWP_SCHEMA_23', 5495); // Database schema # for WP 2.3
52 47 define ('FWP_SCHEMA_25', 7558); // Database schema # for WP 2.5
53 48 define ('FWP_SCHEMA_26', 8201); // Database schema # for WP 2.6
54 -define ('FWP_SCHEMA_27', 9872); // Database schema # for WP 2.7
55 49
56 50 if (FEEDWORDPRESS_DEBUG) :
57 51 // Help us to pick out errors, if any.
58 52 ini_set('error_reporting', E_ALL & ~E_NOTICE);
@@ -91,9 +85,8 @@
91 85 endif;
92 86 endif;
93 87
94 88 require_once(dirname(__FILE__) . '/compatability.php'); // LEGACY API: Replicate or mock up functions for legacy support purposes
95 -require_once(dirname(__FILE__) . '/feedwordpresshtml.class.php');
96 89
97 90 // Magic quotes are just about the stupidest thing ever.
98 91 if (is_array($_POST)) :
99 92 $fwp_post = stripslashes_deep($_POST);
@@ -167,11 +160,9 @@
167 160 remove_filter('pre_link_url', 'wp_filter_kses');
168 161
169 162 # Admin menu
170 163 add_action('admin_menu', 'fwp_add_pages');
171 - add_action('admin_notices', 'fwp_check_debug');
172 - add_action('admin_notices', 'fwp_check_magpie');
173 -
164 +
174 165 # Inbound XML-RPC update methods
175 166 add_filter('xmlrpc_methods', 'feedwordpress_xmlrpc_hook');
176 167
177 168 # Outbound XML-RPC ping reform
@@ -195,12 +186,10 @@
195 186 endif;
196 187
197 188 # Cron-less auto-update. Hooray!
198 189 add_action('init', 'feedwordpress_auto_update');
199 - add_action('init', 'feedwordpress_check_for_magpie_fix');
200 190
201 191 # Default sanitizers
202 - add_filter('syndicated_item_content', array('SyndicatedPost', 'resolve_relative_uris'), 0, 2);
203 192 add_filter('syndicated_item_content', array('SyndicatedPost', 'sanitize_content'), 0, 2);
204 193
205 194 else :
206 195 # Hook in the menus, which will just point to the upgrade interface
@@ -206,33 +195,8 @@
206 195 # Hook in the menus, which will just point to the upgrade interface
207 196 add_action('admin_menu', 'fwp_add_pages');
208 197 endif; // if (!FeedWordPress::needs_upgrade())
209 198
210 -function feedwordpress_check_for_magpie_fix () {
211 - if (isset($_POST['action']) and $_POST['action']=='fix_magpie_version') :
212 - FeedWordPressCompatibility::validate_http_request(/*action=*/ 'feedwordpress_fix_magpie', /*capability=*/ 'edit_files');
213 -
214 - $back_to = $_SERVER['REQUEST_URI'];
215 - if (isset($_POST['ignore'])) :
216 - // kill error message by telling it we ignored the upgrade request for this version
217 - update_option('feedwordpress_magpie_ignored_upgrade_to', EXPECTED_MAGPIE_VERSION);
218 - $ret = 'ignored';
219 - elseif (isset($_POST['upgrade'])) :
220 - $source = dirname(__FILE__)."/MagpieRSS-upgrade/rss.php";
221 - $destination = ABSPATH . WPINC . '/rss.php';
222 - $success = @copy($source, $destination);
223 - $ret = (int) $success;
224 - endif;
225 -
226 - if (strpos($back_to, '?')===false) : $sep = '?';
227 - else : $sep = '&';
228 - endif;
229 -
230 - header("Location: {$back_to}{$sep}feedwordpress_magpie_fix=".$ret);
231 - exit;
232 - endif;
233 -} /* feedwordpress_check_for_magpie_fix() */
234 -
235 199 function feedwordpress_auto_update () {
236 200 if (FeedWordPress::stale()) :
237 201 $feedwordpress =& new FeedWordPress;
238 202 $feedwordpress->update();
@@ -396,13 +360,9 @@
396 360
397 361 function feedwordpress_preserve_syndicated_content ($text) {
398 362 global $feedwordpress_the_syndicated_content;
399 363
400 - $globalExpose = (get_option('feedwordpress_formatting_filters') == 'yes');
401 - $localExpose = get_post_custom_values('_feedwordpress_formatting_filters');
402 - $expose = ($globalExpose or ((count($localExpose) > 0) and $localExpose[0]));
403 -
404 - if ( is_syndicated() and !$expose ) :
364 + if ( is_syndicated() and get_option('feedwordpress_formatting_filters') != 'yes' ) :
405 365 $feedwordpress_the_syndicated_content = $text;
406 366 else :
407 367 $feedwordpress_the_syndicated_content = NULL;
408 368 endif;
@@ -461,142 +421,14 @@
461 421 function fwp_add_pages () {
462 422 global $fwp_capability;
463 423 global $fwp_path;
464 424
465 - $menu = array('Syndicated Sites', 'Syndication', $fwp_capability['manage_links'], $fwp_path.'/syndication.php', NULL);
466 - if (fwp_test_wp_version(FWP_SCHEMA_27)) :
467 - // add icon parameter
468 - $menu[] = WP_PLUGIN_URL.'/'.$fwp_path.'/feedwordpress-tiny.png';
469 - endif;
425 + add_menu_page('Syndicated Sites', 'Syndication', $fwp_capability['manage_links'], $fwp_path.'/syndication.php');
426 + add_submenu_page($fwp_path.'/syndication.php', 'Syndicated Authors', 'Authors', $fwp_capability['manage_options'], $fwp_path.'/authors.php');
427 + add_submenu_page($fwp_path.'/syndication.php', 'Syndication Options', 'Options', $fwp_capability['manage_options'], $fwp_path.'/syndication-options.php');
428 + add_options_page('Syndication Options', 'Syndication', $fwp_capability['manage_options'], $fwp_path.'/syndication-options.php');
429 +} // function fwp_add_pages () */
470 430
471 - if (fwp_test_wp_version(FWP_SCHEMA_26)) :
472 - $options = __('Settings');
473 - $longoptions = __('Syndication Settings');
474 - else :
475 - $options = __('Options');
476 - $longoptions = __('Syndication Options');
477 - endif;
478 -
479 - call_user_func_array('add_menu_page', $menu);
480 - add_submenu_page($fwp_path.'/syndication.php', 'Syndicated Posts', 'Posts', $fwp_capability['manage_options'], $fwp_path.'/posts-page.php');
481 - add_submenu_page($fwp_path.'/syndication.php', 'Syndicated Authors', 'Authors', $fwp_capability['manage_options'], $fwp_path.'/authors-page.php');
482 - add_submenu_page($fwp_path.'/syndication.php', 'Categories & Tags', 'Categories & Tags', $fwp_capability['manage_options'], $fwp_path.'/categories-page.php');
483 - add_submenu_page($fwp_path.'/syndication.php', $longoptions, $options, $fwp_capability['manage_options'], $fwp_path.'/syndication-options.php');
484 -
485 - add_options_page($longoptions, 'Syndication', $fwp_capability['manage_options'], $fwp_path.'/syndication-options.php');
486 -} /* function fwp_add_pages () */
487 -
488 -function fwp_check_debug () {
489 - // This is a horrible fucking kludge that I have to do because the
490 - // admin notice code is triggered before the code that updates the
491 - // setting.
492 - if (isset($_POST['feedwordpress_debug'])) :
493 - $feedwordpress_debug = $_POST['feedwordpress_debug'];
494 - else :
495 - $feedwordpress_debug = get_option('feedwordpress_debug');
496 - endif;
497 - if ($feedwordpress_debug==='yes') :
498 -?>
499 - <div class="error">
500 -<p><strong>FeedWordPress warning.</strong> Debugging mode is <strong>ON</strong>.
501 -While it remains on, FeedWordPress displays many diagnostic error messages,
502 -warnings, and notices that are ordinarily suppressed, and also turns off all
503 -caching of feeds. Use with caution: this setting is absolutely inappropriate
504 -for a production server.</p>
505 - </div>
506 -<?php
507 - endif;
508 -} /* function fwp_check_debug () */
509 -
510 -define('EXPECTED_MAGPIE_VERSION', '2009.0618');
511 -function fwp_check_magpie () {
512 - if (isset($_REQUEST['feedwordpress_magpie_fix'])) :
513 - if ($_REQUEST['feedwordpress_magpie_fix']=='ignored') :
514 -?>
515 -<div class="updated fade">
516 -<p>O.K., we'll ignore the problem for now. FeedWordPress will not display any
517 -more error messages.</p>
518 -</div>
519 -<?php
520 - elseif ((bool) $_REQUEST['feedwordpress_magpie_fix']) :
521 -?>
522 -<div class="updated fade">
523 -<p>Congratulations! Your MagpieRSS has been successfully upgraded to the version
524 -shipped with FeedWordPress.</p>
525 -</div>
526 -<?php
527 - else :
528 - $source = dirname(__FILE__)."/MagpieRSS-upgrade/rss.php";
529 - $destination = ABSPATH . WPINC . '/rss.php';
530 - $cmd = "cp '".htmlspecialchars(addslashes($source))."' '".htmlspecialchars(addslashes($destination))."'";
531 - $cmd = wordwrap($cmd, /*width=*/ 75, /*break=*/ " \\\n\t");
532 -
533 -?>
534 -<div class="error">
535 -<p><strong>FeedWordPress was unable to automatically upgrade your copy of MagpieRSS.</strong></p>
536 -<p>It's likely that you need to change the file permissions on <code><?php print htmlspecialchars($source); ?></code>
537 -to allow FeedWordPress to overwrite it.</p>
538 -<p><strong>To perform the upgrade manually,</strong> you can
539 -use a SFTP or FTP client to upload a copy of <code>rss.php</code> from the
540 -<code>MagpieRSS-upgrades/</code> directory of your FeedWordPress archive so that
541 -it overwrites <code><?php print htmlspecialchars($destination); ?></code>. Or,
542 -if your web host provides shell access, you can issue the following command from
543 -a command prompt to perform the upgrade:</p>
544 -<pre>
545 -<samp>$</samp> <kbd><?php print $cmd; ?></kbd>
546 -</pre>
547 -<p><strong>If you've fixed the file permissions,</strong> you can try the
548 -automatic upgrade again.</p>
549 -
550 -<?php feedwordpress_upgrade_old_and_busted_buttons(); ?>
551 -</div>
552 -<?php
553 - endif;
554 - else :
555 - $magpie_version = FeedWordPress::magpie_version();
556 -
557 - $ignored = get_option('feedwordpress_magpie_ignored_upgrade_to');
558 - if (EXPECTED_MAGPIE_VERSION != $magpie_version and EXPECTED_MAGPIE_VERSION != $ignored) :
559 - if (current_user_can('edit_files')) :
560 - $youAre = 'you are';
561 - $itIsRecommendedThatYou = 'It is <strong>strongly recommended</strong> that you';
562 - else :
563 - $youAre = 'this site is';
564 - $itIsRecommendedThatYou = 'You may want to contact the administrator of the site; it is <strong>strongly recommended</strong> that they';
565 - endif;
566 - print '<div class="error">';
567 -?>
568 -<p style="font-style: italic"><strong>FeedWordPress has detected that <?php print $youAre; ?> currently using a version of
569 -MagpieRSS other than the upgraded version that ships with this version of FeedWordPress.</strong></p>
570 -<ul>
571 -<li><strong>Currently running:</strong> MagpieRSS <?php print $magpie_version; ?></li>
572 -<li><strong>Version included with FeedWordPress <?php print FEEDWORDPRESS_VERSION; ?>:</strong> MagpieRSS <?php print EXPECTED_MAGPIE_VERSION; ?></li>
573 -</ul>
574 -<p><?php print $itIsRecommendedThatYou; ?> install the upgraded
575 -version of MagpieRSS supplied with FeedWordPress. The version of
576 -MagpieRSS that ships with WordPress is very old and buggy, and
577 -encounters a number of errors when trying to parse modern Atom
578 -and RSS feeds.</p>
579 -<?php
580 - feedwordpress_upgrade_old_and_busted_buttons();
581 - print '</div>';
582 - endif;
583 - endif;
584 -}
585 -
586 -function feedwordpress_upgrade_old_and_busted_buttons() {
587 - if (current_user_can('edit_files')) :
588 -?>
589 -<form action="" method="post"><div>
590 -<?php FeedWordPressCompatibility::stamp_nonce('feedwordpress_fix_magpie'); ?>
591 -<input type="hidden" name="action" value="fix_magpie_version" />
592 -<input class="button-secondary" type="submit" name="ignore" value="<?php _e('Ignore this problem'); ?>" />
593 -<input class="button-primary" type="submit" name="upgrade" value="<?php _e('Upgrade'); ?>" />
594 -</div></form>
595 -<?php
596 - endif;
597 -}
598 -
599 431 ################################################################################
600 432 ## fwp_hold_pings() and fwp_release_pings(): Outbound XML-RPC ping reform ####
601 433 ## ... 'coz it's rude to send 500 pings the first time your aggregator runs ####
602 434 ################################################################################
@@ -862,9 +694,9 @@
862 694 if (function_exists('wp_insert_link')) { // WordPress 2.x
863 695 $link_id = wp_insert_link(array(
864 696 "link_name" => $name,
865 697 "link_url" => $uri,
866 - "link_category" => (fwp_test_wp_version(0, FWP_SCHEMA_21) ? $cat_id : array($cat_id)),
698 + "link_category" => array($cat_id),
867 699 "link_rss" => $rss
868 700 ));
869 701 } else { // WordPress 1.5.x
870 702 $result = $wpdb->query("
@@ -950,12 +782,12 @@
950 782 // WordPress 2.3 introduces a new taxonomy/term API
951 783 if (function_exists('is_term')) :
952 784 $cat_id = is_term($cat, 'link_category');
953 785 // WordPress 2.1 and 2.2 use a common table for both link and post categories
954 - elseif (fwp_test_wp_version(FWP_SCHEMA_21, FWP_SCHEMA_23)) :
786 + elseif (isset($wp_db_version) and ($wp_db_version >= FWP_SCHEMA_21 and $wp_db_version < FWP_SCHEMA_23) ) :
955 787 $cat_id = $wpdb->get_var("SELECT cat_id FROM {$wpdb->categories} WHERE cat_name='$cat'");
956 788 // WordPress 1.5 and 2.0.x have a separate table for link categories
957 - elseif (fwp_test_wp_version(0, FWP_SCHEMA_21)):
789 + elseif (!isset($wp_db_version) or $wp_db_version < FWP_SCHEMA_21) :
958 790 $cat_id = $wpdb->get_var("SELECT cat_id FROM {$wpdb->linkcategories} WHERE cat_name='$cat'");
959 791 // This should never happen.
960 792 else :
961 793 FeedWordPress::critical_bug('FeedWordPress::link_category_id::wp_db_version', $wp_db_version, __LINE__);
@@ -968,12 +800,12 @@
968 800 if (function_exists('wp_insert_term')) :
969 801 $term = wp_insert_term($cat, 'link_category');
970 802 $cat_id = $term['term_id'];
971 803 // WordPress 2.1, 2.2 category API. By the way, why the fuck is this API function only available in a wp-admin module?
972 - elseif (function_exists('wp_insert_category') and !fwp_test_wp_version(FWP_SCHEMA_20, FWP_SCHEMA_21)) :
804 + elseif (function_exists('wp_insert_category')) :
973 805 $cat_id = wp_insert_category(array('cat_name' => $cat));
974 806 // WordPress 1.5 and 2.0.x
975 - elseif (fwp_test_wp_version(0, FWP_SCHEMA_21)) :
807 + elseif (!isset($wp_db_version) or $wp_db_version < FWP_SCHEMA_21) :
976 808 $result = $wpdb->query("
977 809 INSERT INTO $wpdb->linkcategories
978 810 SET
979 811 cat_id = 0,
@@ -1091,15 +923,8 @@
1091 923 CREATE INDEX {$wpdb->posts}_guid_idx ON {$wpdb->posts}(guid)
1092 924 ");
1093 925 } /* FeedWordPress::create_guid_index () */
1094 926
1095 - function magpie_version () {
1096 - if (!defined('MAGPIE_VERSION')) : $magpie_version = $GLOBALS['wp_version'].'-default';
1097 - else : $magpie_version = MAGPIE_VERSION;
1098 - endif;
1099 - return $magpie_version;
1100 - }
1101 -
1102 927 # Utility functions for handling text settings
1103 928 function negative ($f, $setting) {
1104 929 $nego = array ('n', 'no', 'f', 'false');
1105 930 return (isset($f[$setting]) and in_array(strtolower($f[$setting]), $nego));
@@ -1114,29 +939,18 @@
1114 939 # Internal debugging functions
1115 940 function critical_bug ($varname, $var, $line) {
1116 941 global $wp_version;
1117 942
1118 - if (defined('MAGPIE_VERSION')) : $mv = MAGPIE_VERSION;
1119 - else : $mv = 'WordPress '.$wp_version.' default.';
1120 - endif;
1121 -
1122 943 echo '<p>There may be a bug in FeedWordPress. Please <a href="'.FEEDWORDPRESS_AUTHOR_CONTACT.'">contact the author</a> and paste the following information into your e-mail:</p>';
1123 944 echo "\n<plaintext>";
1124 945 echo "Triggered at line # ".$line."\n";
1125 946 echo "FeedWordPress version: ".FEEDWORDPRESS_VERSION."\n";
1126 - echo "MagpieRSS version: {$mv}\n";
1127 - echo "WordPress version: {$wp_version}\n";
947 + echo "WordPress version: $wp_version\n";
1128 948 echo "PHP version: ".phpversion()."\n";
1129 949 echo "\n";
1130 950 echo $varname.": "; var_dump($var); echo "\n";
1131 951 die;
1132 952 }
1133 -
1134 - function noncritical_bug ($varname, $var, $line) {
1135 - if (FEEDWORDPRESS_DEBUG) : // halt only when we are doing debugging
1136 - FeedWordPress::critical_bug($varname, $var, $line);
1137 - endif;
1138 - }
1139 953 } // class FeedWordPress
1140 954
1141 955 class SyndicatedPost {
1142 956 var $item = null;
@@ -1145,8 +959,9 @@
1145 959 var $feed = null;
1146 960 var $feedmeta = null;
1147 961
1148 962 var $post = array ();
963 + var $_base = null;
1149 964
1150 965 var $_freshness = null;
1151 966 var $_wp_id = null;
1152 967
@@ -1190,11 +1005,9 @@
1190 1005 $this->post['named']['author'] = apply_filters('syndicated_item_author', $this->author(), $this);
1191 1006
1192 1007 # Identify content and sanitize it.
1193 1008 # ---------------------------------
1194 - if (isset($this->item['atom_content'])) :
1195 - $content = $this->item['atom_content'];
1196 - elseif (isset($this->item['xhtml']['body'])) :
1009 + if (isset($this->item['xhtml']['body'])) :
1197 1010 $content = $this->item['xhtml']['body'];
1198 1011 elseif (isset($this->item['xhtml']['div'])) :
1199 1012 $content = $this->item['xhtml']['div'];
1200 1013 elseif (isset($this->item['content']['encoded']) and $this->item['content']['encoded']):
@@ -1243,26 +1056,8 @@
1243 1056
1244 1057 // Unique ID (hopefully a unique tag: URI); failing that, the permalink
1245 1058 $this->post['guid'] = apply_filters('syndicated_item_guid', $this->guid(), $this);
1246 1059
1247 - // User-supplied custom settings to apply to each post. Do first so that FWP-generated custom settings will overwrite if necessary; thus preventing any munging
1248 - $default_custom_settings = get_option('feedwordpress_custom_settings');
1249 - if ($default_custom_settings) :
1250 - $default_custom_settings = unserialize($default_custom_settings);
1251 - endif;
1252 - if (!is_array($default_custom_settings)) :
1253 - $default_custom_settings = array();
1254 - endif;
1255 -
1256 - $custom_settings = (isset($this->link->settings['postmeta']) ? $this->link->settings['postmeta'] : null);
1257 - if ($custom_settings) :
1258 - $custom_settings = unserialize($custom_settings);
1259 - endif;
1260 - if (!is_array($custom_settings)) :
1261 - $custom_settings = array();
1262 - endif;
1263 - $this->post['meta'] = array_merge($default_custom_settings, $custom_settings);
1264 -
1265 1060 // RSS 2.0 / Atom 1.0 enclosure support
1266 1061 if ( isset($this->item['enclosure#']) ) :
1267 1062 for ($i = 1; $i <= $this->item['enclosure#']; $i++) :
1268 1063 $eid = (($i > 1) ? "#{$id}" : "");
@@ -1317,10 +1112,10 @@
1317 1112 // Store a hash of the post content for checking whether something needs to be updated
1318 1113 $this->post['meta']['syndication_item_hash'] = $this->update_hash();
1319 1114
1320 1115 // Feed-by-feed options for author and category creation
1321 - $this->post['named']['unfamiliar']['author'] = (isset($this->feedmeta['unfamiliar author']) ? $this->feedmeta['unfamiliar author'] : null);
1322 - $this->post['named']['unfamiliar']['category'] = (isset($this->feedmeta['unfamiliar category']) ? $this->feedmeta['unfamiliar category'] : null);
1116 + $this->post['named']['unfamiliar']['author'] = $this->feedmeta['unfamiliar author'];
1117 + $this->post['named']['unfamiliar']['category'] = $this->feedmeta['unfamiliar category'];
1323 1118
1324 1119 // Categories: start with default categories, if any
1325 1120 $fc = get_option("feedwordpress_syndication_cats");
1326 1121 if ($fc) :
@@ -1328,9 +1123,9 @@
1328 1123 else :
1329 1124 $this->post['named']['preset/category'] = array();
1330 1125 endif;
1331 1126
1332 - if (isset($this->feedmeta['cats']) and is_array($this->feedmeta['cats'])) :
1127 + if (is_array($this->feedmeta['cats'])) :
1333 1128 $this->post['named']['preset/category'] = array_merge($this->post['named']['preset/category'], $this->feedmeta['cats']);
1334 1129 endif;
1335 1130
1336 1131 // Now add categories from the post, if we have 'em
@@ -1352,14 +1147,14 @@
1352 1147
1353 1148 // Tags: start with default tags, if any
1354 1149 $ft = get_option("feedwordpress_syndication_tags");
1355 1150 if ($ft) :
1356 - $this->post['tags_input'] = explode(FEEDWORDPRESS_CAT_SEPARATOR, $ft);
1151 + $this->post['tags_input'] = explode('FEEDWORDPRESS_CAT_SEPARATOR', $ft);
1357 1152 else :
1358 1153 $this->post['tags_input'] = array();
1359 1154 endif;
1360 1155
1361 - if (isset($this->feedmeta['tags']) and is_array($this->feedmeta['tags'])) :
1156 + if (is_array($this->feedmeta['tags'])) :
1362 1157 $this->post['tags_input'] = array_merge($this->post['tags_input'], $this->feedmeta['tags']);
1363 1158 endif;
1364 1159
1365 1160 endif;
@@ -1503,223 +1298,187 @@
1503 1298 } // function SyndicatedPost::store ()
1504 1299
1505 1300 function insert_new () {
1506 1301 global $wpdb, $wp_db_version;
1507 -
1508 - $dbpost = $this->normalize_post(/*new=*/ true);
1509 - if (!is_null($dbpost)) :
1510 - if ($this->use_api('wp_insert_post')) :
1511 - $dbpost['post_pingback'] = false; // Tell WP 2.1 and 2.2 not to process for pingbacks
1512 -
1513 - // This is a ridiculous fucking kludge necessitated by WordPress 2.6 munging authorship meta-data
1514 - add_action('_wp_put_post_revision', array($this, 'fix_revision_meta'));
1515 -
1516 - // Kludge to prevent kses filters from stripping the
1517 - // content of posts when updating without a logged in
1518 - // user who has `unfiltered_html` capability.
1519 - add_filter('content_save_pre', array($this, 'avoid_kses_munge'), 11);
1520 -
1521 - $this->_wp_id = wp_insert_post($dbpost);
1522 -
1523 - // Turn off ridiculous fucking kludges #1 and #2
1524 - remove_action('_wp_put_post_revision', array($this, 'fix_revision_meta'));
1525 - remove_filter('content_save_pre', array($this, 'avoid_kses_munge'), 11);
1526 -
1527 - $this->validate_post_id($dbpost, array(__CLASS__, __FUNCTION__));
1528 -
1529 - // Unfortunately, as of WordPress 2.3, wp_insert_post()
1530 - // *still* offers no way to use a guid of your choice,
1531 - // and munges your post modified timestamp, too.
1532 - $result = $wpdb->query("
1533 - UPDATE $wpdb->posts
1534 - SET
1535 - guid='{$dbpost['guid']}',
1536 - post_modified='{$dbpost['post_modified']}',
1537 - post_modified_gmt='{$dbpost['post_modified_gmt']}'
1538 - WHERE ID='{$this->_wp_id}'
1539 - ");
1302 +
1303 + // Why the fuck doesn't wp_insert_post already do this?
1304 + foreach ($this->post as $key => $value) :
1305 + if (is_string($value)) :
1306 + $dbpost[$key] = $wpdb->escape($value);
1540 1307 else :
1541 - # The right way to do this is the above. But, alas,
1542 - # in earlier versions of WordPress, wp_insert_post has
1543 - # too much behavior (mainly related to pings) that can't
1544 - # be overridden. In WordPress 1.5, it's enough of a
1545 - # resource hog to make PHP segfault after inserting
1546 - # 50-100 posts. This can get pretty annoying, especially
1547 - # if you are trying to update your feeds for the first
1548 - # time.
1549 -
1550 - $result = $wpdb->query("
1551 - INSERT INTO $wpdb->posts
1552 - SET
1553 - guid = '{$dbpost['guid']}',
1554 - post_author = '{$dbpost['post_author']}',
1555 - post_date = '{$dbpost['post_date']}',
1556 - post_date_gmt = '{$dbpost['post_date_gmt']}',
1557 - post_content = '{$dbpost['post_content']}',"
1558 - .(isset($dbpost['post_excerpt']) ? "post_excerpt = '{$dbpost['post_excerpt']}'," : "")."
1559 - post_title = '{$dbpost['post_title']}',
1560 - post_name = '{$dbpost['post_name']}',
1561 - post_modified = '{$dbpost['post_modified']}',
1562 - post_modified_gmt = '{$dbpost['post_modified_gmt']}',
1563 - comment_status = '{$dbpost['comment_status']}',
1564 - ping_status = '{$dbpost['ping_status']}',
1565 - post_status = '{$dbpost['post_status']}'
1566 - ");
1567 - $this->_wp_id = $wpdb->insert_id;
1568 -
1569 - $this->validate_post_id($dbpost, array(__CLASS__, __FUNCTION__));
1570 -
1571 - // WordPress 1.5.x - 2.0.x
1572 - wp_set_post_cats('1', $this->wp_id(), $this->post['post_category']);
1573 -
1574 - // Since we are not going through official channels, we need to
1575 - // manually tell WordPress that we've published a new post.
1576 - // We need to make sure to do this in order for FeedWordPress
1577 - // to play well with the staticize-reloaded plugin (something
1578 - // that a large aggregator website is going to *want* to be
1579 - // able to use).
1580 - do_action('publish_post', $this->_wp_id);
1308 + $dbpost[$key] = $value;
1581 1309 endif;
1310 + endforeach;
1311 +
1312 + if (strlen($dbpost['post_title'].$dbpost['post_content'].$dbpost['post_excerpt']) == 0) :
1313 + // FIXME: Option for filtering out empty posts
1582 1314 endif;
1583 - } /* SyndicatedPost::insert_new() */
1315 + if (strlen($dbpost['post_title'])==0) :
1316 + $dbpost['post_title'] = $this->post['meta']['syndication_source']
1317 + .' '.gmdate('Y-m-d H:i:s', $this->published() + $offset);
1318 + // FIXME: Option for what to fill a blank title with...
1319 + endif;
1584 1320
1585 - function update_existing () {
1586 - global $wpdb;
1321 + if ($this->use_api('wp_insert_post')) :
1322 + $dbpost['post_pingback'] = false; // Tell WP 2.1 and 2.2 not to process for pingbacks
1587 1323
1588 - // Why the fuck doesn't wp_insert_post already do this?
1589 - $dbpost = $this->normalize_post(/*new=*/ false);
1590 - if (!is_null($dbpost)) :
1591 - if ($this->use_api('wp_insert_post')) :
1592 - $dbpost['post_pingback'] = false; // Tell WP 2.1 and 2.2 not to process for pingbacks
1593 -
1594 - // This is a ridiculous fucking kludge necessitated by WordPress 2.6 munging authorship meta-data
1595 - add_action('_wp_put_post_revision', array($this, 'fix_revision_meta'));
1596 -
1597 - // Kludge to prevent kses filters from stripping the
1598 - // content of posts when updating without a logged in
1599 - // user who has `unfiltered_html` capability.
1600 - add_filter('content_save_pre', array($this, 'avoid_kses_munge'), 11);
1324 + // This is a ridiculous fucking kludge necessitated by WordPress 2.6 munging authorship meta-data
1325 + add_action('_wp_put_post_revision', array($this, 'fix_revision_meta'));
1326 +
1327 + // Kludge to prevent kses filters from stripping the
1328 + // content of posts when updating without a logged in
1329 + // user who has `unfiltered_html` capability.
1330 + add_filter('content_save_pre', array($this, 'avoid_kses_munge'), 11);
1331 +
1332 + $this->_wp_id = wp_insert_post($dbpost);
1601 1333
1602 - // Don't munge status fields that the user may have reset manually
1603 - if (function_exists('get_post_field')) :
1604 - $doNotMunge = array('post_status', 'comment_status', 'ping_status');
1605 - foreach ($doNotMunge as $field) :
1606 - $dbpost[$field] = get_post_field($field, $this->wp_id());
1607 - endforeach;
1608 - endif;
1334 + // Turn off ridiculous fucking kludges #1 and #2
1335 + remove_action('_wp_put_post_revision', array($this, 'fix_revision_meta'));
1336 + remove_filter('content_save_pre', array($this, 'avoid_kses_munge'), 11);
1609 1337
1610 - $this->_wp_id = wp_insert_post($dbpost);
1338 + // This should never happen.
1339 + if (!is_numeric($this->_wp_id) or ($this->_wp_id == 0)) :
1340 + FeedWordPress::critical_bug('SyndicatedPost (_wp_id problem)', array("dbpost" => $dbpost, "this" => $this), __LINE__);
1341 + endif;
1611 1342
1612 - // Turn off ridiculous fucking kludges #1 and #2
1613 - remove_action('_wp_put_post_revision', array($this, 'fix_revision_meta'));
1614 - remove_filter('content_save_pre', array($this, 'avoid_kses_munge'), 11);
1615 -
1616 - $this->validate_post_id($dbpost, array(__CLASS__, __FUNCTION__));
1617 -
1618 - // Unfortunately, as of WordPress 2.3, wp_insert_post()
1619 - // munges your post modified timestamp.
1620 - $result = $wpdb->query("
1621 - UPDATE $wpdb->posts
1622 - SET
1623 - post_modified='{$dbpost['post_modified']}',
1624 - post_modified_gmt='{$dbpost['post_modified_gmt']}'
1625 - WHERE ID='{$this->_wp_id}'
1626 - ");
1627 - else :
1628 -
1629 - $result = $wpdb->query("
1343 + // Unfortunately, as of WordPress 2.3, wp_insert_post()
1344 + // *still* offers no way to use a guid of your choice,
1345 + // and munges your post modified timestamp, too.
1346 + $result = $wpdb->query("
1630 1347 UPDATE $wpdb->posts
1631 1348 SET
1632 - post_author = '{$dbpost['post_author']}',
1633 - post_content = '{$dbpost['post_content']}',"
1634 - .(isset($dbpost['post_excerpt']) ? "post_excerpt = '{$dbpost['post_excerpt']}'," : "")."
1635 - post_title = '{$dbpost['post_title']}',
1636 - post_name = '{$dbpost['post_name']}',
1637 - post_modified = '{$dbpost['post_modified']}',
1638 - post_modified_gmt = '{$dbpost['post_modified_gmt']}'
1639 - WHERE guid='{$dbpost['guid']}'
1640 - ");
1641 -
1642 - // WordPress 2.1.x and up
1643 - if (function_exists('wp_set_post_categories')) :
1644 - wp_set_post_categories($this->wp_id(), $this->post['post_category']);
1645 - // WordPress 1.5.x - 2.0.x
1646 - elseif (function_exists('wp_set_post_cats')) :
1647 - wp_set_post_cats('1', $this->wp_id(), $this->post['post_category']);
1648 - // This should never happen.
1649 - else :
1650 - FeedWordPress::critical_bug(__CLASS__.'::'.__FUNCTION.'(): no post categorizing function', array("dbpost" => $dbpost, "this" => $this), __LINE__);
1651 - endif;
1652 -
1653 - // Since we are not going through official channels, we need to
1654 - // manually tell WordPress that we've published a new post.
1655 - // We need to make sure to do this in order for FeedWordPress
1656 - // to play well with the staticize-reloaded plugin (something
1657 - // that a large aggregator website is going to *want* to be
1658 - // able to use).
1659 - do_action('edit_post', $this->post['ID']);
1349 + guid='{$dbpost['guid']}',
1350 + post_modified='{$dbpost['post_modified']}',
1351 + post_modified_gmt='{$dbpost['post_modified_gmt']}'
1352 + WHERE ID='{$this->_wp_id}'
1353 + ");
1354 + else :
1355 + # The right way to do this is the above. But, alas,
1356 + # in earlier versions of WordPress, wp_insert_post has
1357 + # too much behavior (mainly related to pings) that can't
1358 + # be overridden. In WordPress 1.5, it's enough of a
1359 + # resource hog to make PHP segfault after inserting
1360 + # 50-100 posts. This can get pretty annoying, especially
1361 + # if you are trying to update your feeds for the first
1362 + # time.
1363 +
1364 + $result = $wpdb->query("
1365 + INSERT INTO $wpdb->posts
1366 + SET
1367 + guid = '{$dbpost['guid']}',
1368 + post_author = '{$dbpost['post_author']}',
1369 + post_date = '{$dbpost['post_date']}',
1370 + post_date_gmt = '{$dbpost['post_date_gmt']}',
1371 + post_content = '{$dbpost['post_content']}',"
1372 + .(isset($dbpost['post_excerpt']) ? "post_excerpt = '{$dbpost['post_excerpt']}'," : "")."
1373 + post_title = '{$dbpost['post_title']}',
1374 + post_name = '{$dbpost['post_name']}',
1375 + post_modified = '{$dbpost['post_modified']}',
1376 + post_modified_gmt = '{$dbpost['post_modified_gmt']}',
1377 + comment_status = '{$dbpost['comment_status']}',
1378 + ping_status = '{$dbpost['ping_status']}',
1379 + post_status = '{$dbpost['post_status']}'
1380 + ");
1381 + $this->_wp_id = $wpdb->insert_id;
1382 +
1383 + // This should never happen.
1384 + if (!is_numeric($this->_wp_id) or ($this->_wp_id == 0)) :
1385 + FeedWordPress::critical_bug('SyndicatedPost (_wp_id problem)', array("dbpost" => $dbpost, "this" => $this), __LINE__);
1660 1386 endif;
1387 +
1388 + // WordPress 1.5.x - 2.0.x
1389 + wp_set_post_cats('1', $this->wp_id(), $this->post['post_category']);
1390 +
1391 + // Since we are not going through official channels, we need to
1392 + // manually tell WordPress that we've published a new post.
1393 + // We need to make sure to do this in order for FeedWordPress
1394 + // to play well with the staticize-reloaded plugin (something
1395 + // that a large aggregator website is going to *want* to be
1396 + // able to use).
1397 + do_action('publish_post', $this->_wp_id);
1661 1398 endif;
1662 - } /* SyndicatedPost::update_existing() */
1399 + } /* SyndicatedPost::insert_new() */
1663 1400
1664 - /**
1665 - * SyndicatedPost::normalize_post()
1666 - *
1667 - * @param bool $new If true, this post is to be inserted anew. If false, it is an update of an existing post.
1668 - * @return array A normalized representation of the post ready to be inserted into the database or sent to the WordPress API functions
1669 - */
1670 - function normalize_post ($new = true) {
1401 + function update_existing () {
1671 1402 global $wpdb;
1672 1403
1673 - $out = array();
1674 -
1675 1404 // Why the fuck doesn't wp_insert_post already do this?
1405 + $dbpost = array();
1676 1406 foreach ($this->post as $key => $value) :
1677 1407 if (is_string($value)) :
1678 - $out[$key] = $wpdb->escape($value);
1408 + $dbpost[$key] = $wpdb->escape($value);
1679 1409 else :
1680 - $out[$key] = $value;
1410 + $dbpost[$key] = $value;
1681 1411 endif;
1682 1412 endforeach;
1683 1413
1684 - if (strlen($out['post_title'].$out['post_content'].$out['post_excerpt']) == 0) :
1685 - // FIXME: Option for filtering out empty posts
1686 - endif;
1687 - if (strlen($out['post_title'])==0) :
1688 - $offset = (int) get_option('gmt_offset') * 60 * 60;
1689 - $out['post_title'] =
1690 - $this->post['meta']['syndication_source']
1691 - .' '.gmdate('Y-m-d H:i:s', $this->published() + $offset);
1692 - // FIXME: Option for what to fill a blank title with...
1693 - endif;
1414 + if ($this->use_api('wp_insert_post')) :
1415 + $dbpost['post_pingback'] = false; // Tell WP 2.1 and 2.2 not to process for pingbacks
1694 1416
1695 - return $out;
1696 - }
1417 + // This is a ridiculous fucking kludge necessitated by WordPress 2.6 munging authorship meta-data
1418 + add_action('_wp_put_post_revision', array($this, 'fix_revision_meta'));
1697 1419
1698 - /**
1699 - * SyndicatedPost::validate_post_id()
1700 - *
1701 - * @param array $dbpost An array representing the post we attempted to insert or update
1702 - * @param mixed $ns A string or array representing the namespace (class, method) whence this method was called.
1703 - */
1704 - function validate_post_id ($dbpost, $ns) {
1705 - if (is_array($ns)) : $ns = implode('::', $ns);
1706 - else : $ns = (string) $ns; endif;
1707 -
1708 - // This should never happen.
1709 - if (!is_numeric($this->_wp_id) or ($this->_wp_id == 0)) :
1710 - FeedWordPress::critical_bug(
1711 - /*name=*/ $ns.'::_wp_id',
1712 - /*var =*/ array(
1713 - "\$this->_wp_id" => $this->_wp_id,
1714 - "\$dbpost" => $dbpost,
1715 - "\$this" => $this
1716 - ),
1717 - /*line # =*/ __LINE__
1718 - );
1420 + // Kludge to prevent kses filters from stripping the
1421 + // content of posts when updating without a logged in
1422 + // user who has `unfiltered_html` capability.
1423 + add_filter('content_save_pre', array($this, 'avoid_kses_munge'), 11);
1424 +
1425 + $this->_wp_id = wp_insert_post($dbpost);
1426 +
1427 + // Turn off ridiculous fucking kludges #1 and #2
1428 + remove_action('_wp_put_post_revision', array($this, 'fix_revision_meta'));
1429 + remove_filter('content_save_pre', array($this, 'avoid_kses_munge'), 11);
1430 +
1431 + // This should never happen.
1432 + if (!is_numeric($this->_wp_id) or ($this->_wp_id == 0)) :
1433 + FeedWordPress::critical_bug('SyndicatedPost (_wp_id problem)', array("dbpost" => $dbpost, "this" => $this), __LINE__);
1434 + endif;
1435 +
1436 + // Unfortunately, as of WordPress 2.3, wp_insert_post()
1437 + // munges your post modified timestamp.
1438 + $result = $wpdb->query("
1439 + UPDATE $wpdb->posts
1440 + SET
1441 + post_modified='{$dbpost['post_modified']}',
1442 + post_modified_gmt='{$dbpost['post_modified_gmt']}'
1443 + WHERE ID='{$this->_wp_id}'
1444 + ");
1445 + else :
1446 +
1447 + $result = $wpdb->query("
1448 + UPDATE $wpdb->posts
1449 + SET
1450 + post_author = '{$dbpost['post_author']}',
1451 + post_content = '{$dbpost['post_content']}',"
1452 + .(isset($dbpost['post_excerpt']) ? "post_excerpt = '{$dbpost['post_excerpt']}'," : "")."
1453 + post_title = '{$dbpost['post_title']}',
1454 + post_name = '{$dbpost['post_name']}',
1455 + post_modified = '{$dbpost['post_modified']}',
1456 + post_modified_gmt = '{$dbpost['post_modified_gmt']}'
1457 + WHERE guid='{$dbpost['guid']}'
1458 + ");
1459 +
1460 + // WordPress 2.1.x and up
1461 + if (function_exists('wp_set_post_categories')) :
1462 + wp_set_post_categories($this->wp_id(), $this->post['post_category']);
1463 + // WordPress 1.5.x - 2.0.x
1464 + elseif (function_exists('wp_set_post_cats')) :
1465 + wp_set_post_cats('1', $this->wp_id(), $this->post['post_category']);
1466 + // This should never happen.
1467 + else :
1468 + FeedWordPress::critical_bug('SyndicatedPost (_wp_id problem)', array("dbpost" => $dbpost, "this" => $this), __LINE__);
1469 + endif;
1470 +
1471 + // Since we are not going through official channels, we need to
1472 + // manually tell WordPress that we've published a new post.
1473 + // We need to make sure to do this in order for FeedWordPress
1474 + // to play well with the staticize-reloaded plugin (something
1475 + // that a large aggregator website is going to *want* to be
1476 + // able to use).
1477 + do_action('edit_post', $this->post['ID']);
1719 1478 endif;
1720 - } /* SyndicatedPost::validate_post_id() */
1721 -
1479 + } /* SyndicatedPost::update_existing() */
1480 +
1722 1481 /**
1723 1482 * SyndicatedPost::fix_revision_meta() - Fixes the way WP 2.6+ fucks up
1724 1483 * meta-data (authorship, etc.) when storing revisions of an updated
1725 1484 * syndicated post.
@@ -1982,9 +1741,9 @@
1982 1741 $cat_ids[] = $cat_id;
1983 1742 elseif (get_category($cat_id)) :
1984 1743 $cat_ids[] = $cat_id;
1985 1744 endif;
1986 - elseif (strlen($cat_name) > 0) :
1745 + else :
1987 1746 $esc = $wpdb->escape($cat_name);
1988 1747 $resc = $wpdb->escape(preg_quote($cat_name));
1989 1748
1990 1749 // WordPress 2.3+
@@ -2006,13 +1765,9 @@
2006 1765 elseif ('tag'==$unfamiliar_category) :
2007 1766 $tags[] = $cat_name;
2008 1767 elseif ('create'===$unfamiliar_category) :
2009 1768 $term = wp_insert_term($cat_name, 'category');
2010 - if (is_wp_error($term)) :
2011 - FeedWordPress::noncritical_bug('term insertion problem', array('cat_name' => $cat_name, 'term' => $term, 'this' => $this), __LINE__);
2012 - else :
2013 - $cat_ids[] = $term['term_id'];
2014 - endif;
1769 + $cat_ids[] = $term['term_id'];
2015 1770 endif;
2016 1771
2017 1772 // WordPress 1.5.x - 2.2.x
2018 1773 else :
@@ -2244,87 +1999,25 @@
2244 1999
2245 2000 return $author;
2246 2001 } // SyndicatedPost::author()
2247 2002
2248 - var $uri_attrs = array (
2249 - array('a', 'href'),
2250 - array('applet', 'codebase'),
2251 - array('area', 'href'),
2252 - array('blockquote', 'cite'),
2253 - array('body', 'background'),
2254 - array('del', 'cite'),
2255 - array('form', 'action'),
2256 - array('frame', 'longdesc'),
2257 - array('frame', 'src'),
2258 - array('iframe', 'longdesc'),
2259 - array('iframe', 'src'),
2260 - array('head', 'profile'),
2261 - array('img', 'longdesc'),
2262 - array('img', 'src'),
2263 - array('img', 'usemap'),
2264 - array('input', 'src'),
2265 - array('input', 'usemap'),
2266 - array('ins', 'cite'),
2267 - array('link', 'href'),
2268 - array('object', 'classid'),
2269 - array('object', 'codebase'),
2270 - array('object', 'data'),
2271 - array('object', 'usemap'),
2272 - array('q', 'cite'),
2273 - array('script', 'src')
2274 - ); /* var SyndicatedPost::$uri_attrs */
2275 -
2276 - var $_base = null;
2277 -
2278 - function resolve_single_relative_uri ($refs) {
2279 - $tag = FeedWordPressHTML::attributeMatch($refs);
2280 - $url = Relative_URI::resolve($tag['value'], $this->_base);
2281 - return $tag['prefix'] . $url . $tag['suffix'];
2282 - } /* function SyndicatedPost::resolve_single_relative_uri() */
2283 -
2284 - function resolve_relative_uris ($content, $obj) {
2285 - # The MagpieRSS upgrade has some `xml:base` support baked in.
2286 - # However, sometimes people do silly things, like putting
2287 - # relative URIs out on a production RSS 2.0 feed or other feeds
2288 - # with no good support for `xml:base`. So we'll do our best to
2289 - # try to catch any remaining relative URIs and resolve them as
2290 - # best we can.
2291 - $obj->_base = $obj->item['link']; // Reset the base for resolving relative URIs
2292 -
2293 - foreach ($obj->uri_attrs as $pair) :
2294 - list($tag, $attr) = $pair;
2295 - $pattern = FeedWordPressHTML::attributeRegex($tag, $attr);
2296 - $content = preg_replace_callback (
2297 - $pattern,
2298 - array(&$obj, 'resolve_single_relative_uri'),
2299 - $content
2300 - );
2301 - endforeach;
2302 -
2303 - return $content;
2304 - } /* function SyndicatedPost::resolve_relative_uris () */
2305 -
2306 2003 var $strip_attrs = array (
2307 - array('[a-z]+', 'target'),
2308 -// array('[a-z]+', 'style'),
2309 -// array('[a-z]+', 'on[a-z]+'),
2004 + array('[a-z]+', 'style'),
2005 + array('[a-z]+', 'target'),
2310 2006 );
2311 -
2312 - function strip_attribute_from_tag ($refs) {
2313 - $tag = FeedWordPressHTML::attributeMatch($refs);
2314 - return $tag['before_attribute'].$tag['after_attribute'];
2315 - }
2316 -
2317 2007 function sanitize_content ($content, $obj) {
2008 + # FeedWordPress used to resolve URIs relative to the
2009 + # feed URI. It now relies on the xml:base support
2010 + # baked in to the MagpieRSS upgrade. So all we do here
2011 + # now is to sanitize problematic attributes.
2012 + #
2318 2013 # This kind of sucks. I intend to replace it with
2319 2014 # lib_filter sometime soon.
2320 2015 foreach ($obj->strip_attrs as $pair):
2321 2016 list($tag,$attr) = $pair;
2322 - $pattern = FeedWordPressHTML::attributeRegex($tag, $attr);
2323 -
2324 - $content = preg_replace_callback (
2325 - $pattern,
2326 - array(&$obj, 'strip_attribute_from_tag'),
2017 + $content = preg_replace (
2018 + ":(<$tag [^>]*)($attr=(\"[^\">]*\"|[^>\\s]+))([^>]*>):i",
2019 + "\\1\\4",
2327 2020 $content
2328 2021 );
2329 2022 endforeach;
2330 2023 return $content;
@@ -2330,10 +2023,438 @@
2330 2023 return $content;
2331 2024 }
2332 2025 } // class SyndicatedPost
2333 2026
2334 -require_once(dirname(__FILE__) . '/syndicatedlink.class.php');
2027 +# class SyndicatedLink: represents a syndication feed stored within the
2028 +# WordPress database
2029 +#
2030 +# To keep things compact and editable from within WordPress, we use all the
2031 +# links under a particular category in the WordPress "Blogroll" for the list of
2032 +# feeds to syndicate. "Contributors" is the category used by default; you can
2033 +# configure that under Options --> Syndication.
2034 +#
2035 +# Fields used are:
2036 +#
2037 +# * link_rss: the URI of the Atom/RSS feed to syndicate
2038 +#
2039 +# * link_notes: user-configurable options, with keys and values
2040 +# like so:
2041 +#
2042 +# key: value
2043 +# cats: computers\nweb
2044 +# feed/key: value
2045 +#
2046 +# Keys that start with "feed/" are gleaned from the data supplied
2047 +# by the feed itself, and will be overwritten with each update.
2048 +#
2049 +# Values have linebreak characters escaped with C-style
2050 +# backslashes (so, for example, a newline becomes "\n").
2051 +#
2052 +# The value of `cats` is used as a newline-separated list of
2053 +# default categories for any post coming from a particular feed.
2054 +# (In the example above, any posts from this feed will be placed
2055 +# in the "computers" and "web" categories--*in addition to* any
2056 +# categories that may already be applied to the posts.)
2057 +#
2058 +# Values of keys in link_notes are accessible from templates using
2059 +# the function `get_feed_meta($key)` if this plugin is activated.
2335 2060
2061 +class SyndicatedLink {
2062 + var $id = null;
2063 + var $link = null;
2064 + var $settings = array ();
2065 + var $magpie = null;
2066 +
2067 + function SyndicatedLink ($link) {
2068 + global $wpdb;
2069 +
2070 + if (is_object($link)) :
2071 + $this->link = $link;
2072 + $this->id = $link->link_id;
2073 + else :
2074 + $this->id = $link;
2075 + if (function_exists('get_bookmark')) : // WP 2.1+
2076 + $this->link = get_bookmark($link);
2077 + else :
2078 + $this->link = $wpdb->get_row("
2079 + SELECT * FROM $wpdb->links
2080 + WHERE (link_id = '".$wpdb->escape($link)."')"
2081 + );
2082 + endif;
2083 + endif;
2084 +
2085 + if (strlen($this->link->link_rss) > 0) :
2086 + // Read off feed settings from link_notes
2087 + $notes = explode("\n", $this->link->link_notes);
2088 + foreach ($notes as $note):
2089 + list($key, $value) = explode(": ", $note, 2);
2090 +
2091 + if (strlen($key) > 0) :
2092 + // Unescape and trim() off the whitespace.
2093 + // Thanks to Ray Lischner for pointing out the
2094 + // need to trim off whitespace.
2095 + $this->settings[$key] = stripcslashes (trim($value));
2096 + endif;
2097 + endforeach;
2098 +
2099 + // "Magic" feed settings
2100 + $this->settings['link/uri'] = $this->link->link_rss;
2101 + $this->settings['link/name'] = $this->link->link_name;
2102 + $this->settings['link/id'] = $this->link->link_id;
2103 +
2104 + // `hardcode categories` and `unfamiliar categories` are deprecated in favor of `unfamiliar category`
2105 + if (
2106 + isset($this->settings['unfamiliar categories'])
2107 + and !isset($this->settings['unfamiliar category'])
2108 + ) :
2109 + $this->settings['unfamiliar category'] = $this->settings['unfamiliar categories'];
2110 + endif;
2111 + if (
2112 + FeedWordPress::affirmative($this->settings, 'hardcode categories')
2113 + and !isset($this->settings['unfamiliar category'])
2114 + ) :
2115 + $this->settings['unfamiliar category'] = 'default';
2116 + endif;
2117 +
2118 + // Set this up automagically for del.icio.us
2119 + $bits = parse_url($this->link->link_rss);
2120 + $tagspacers = array('del.icio.us', 'feeds.delicious.com');
2121 + if (!isset($this->settings['cat_split']) and in_array($bits['host'], $tagspacers)) :
2122 + $this->settings['cat_split'] = '\s'; // Whitespace separates multiple tags in del.icio.us RSS feeds
2123 + endif;
2124 +
2125 + if (isset($this->settings['cats'])):
2126 + $this->settings['cats'] = preg_split(FEEDWORDPRESS_CAT_SEPARATOR_PATTERN, $this->settings['cats']);
2127 + endif;
2128 + if (isset($this->settings['tags'])):
2129 + $this->settings['tags'] = preg_split(FEEDWORDPRESS_CAT_SEPARATOR_PATTERN, $this->settings['tags']);
2130 + endif;
2131 +
2132 + if (isset($this->settings['map authors'])) :
2133 + $author_rules = explode("\n\n", $this->settings['map authors']);
2134 + $ma = array();
2135 + foreach ($author_rules as $rule) :
2136 + list($rule_type, $author_name, $author_action) = explode("\n", $rule);
2137 +
2138 + // Normalize for case and whitespace
2139 + $rule_type = strtolower(trim($rule_type));
2140 + $author_name = strtolower(trim($author_name));
2141 + $author_action = strtolower(trim($author_action));
2142 +
2143 + $ma[$rule_type][$author_name] = $author_action;
2144 + endforeach;
2145 + $this->settings['map authors'] = $ma;
2146 + endif;
2147 + endif;
2148 + } /* SyndicatedLink::SyndicatedLink () */
2149 +
2150 + function found () {
2151 + return is_object($this->link);
2152 + } /* SyndicatedLink::found () */
2153 +
2154 + function stale () {
2155 + $stale = true;
2156 + if (isset($this->settings['update/hold']) and ($this->settings['update/hold']=='ping')) :
2157 + $stale = false; // don't update on any timed updates; pings only
2158 + elseif (isset($this->settings['update/hold']) and ($this->settings['update/hold']=='next')) :
2159 + $stale = true; // update on the next timed update
2160 + elseif (!isset($this->settings['update/ttl']) or !isset($this->settings['update/last'])) :
2161 + $stale = true; // initial update
2162 + else :
2163 + $after = ((int) $this->settings['update/last'])
2164 + +((int) $this->settings['update/ttl'] * 60);
2165 + $stale = (time() >= $after);
2166 + endif;
2167 + return $stale;
2168 + } /* SyndicatedLink::stale () */
2169 +
2170 + function poll ($crash_ts = NULL) {
2171 + global $wpdb;
2172 +
2173 + $this->magpie = fetch_rss($this->link->link_rss);
2174 + $new_count = NULL;
2175 +
2176 + $resume = FeedWordPress::affirmative($this->settings, 'update/unfinished');
2177 + if ($resume) :
2178 + // pick up where we left off
2179 + $processed = array_map('trim', explode("\n", $this->settings['update/processed']));
2180 + else :
2181 + // begin at the beginning
2182 + $processed = array();
2183 + endif;
2184 +
2185 + if (is_object($this->magpie)) :
2186 + $new_count = array('new' => 0, 'updated' => 0);
2187 +
2188 + # -- Update Link metadata live from feed
2189 + $channel = $this->magpie->channel;
2190 +
2191 + if (!isset($channel['id'])) :
2192 + $channel['id'] = $this->link->link_rss;
2193 + endif;
2194 +
2195 + $update = array();
2196 + if (!$this->hardcode('url') and isset($channel['link'])) :
2197 + $update[] = "link_url = '".$wpdb->escape($channel['link'])."'";
2198 + endif;
2199 +
2200 + if (!$this->hardcode('name') and isset($channel['title'])) :
2201 + $update[] = "link_name = '".$wpdb->escape($channel['title'])."'";
2202 + endif;
2203 +
2204 + if (!$this->hardcode('description')) :
2205 + if (isset($channel['tagline'])) :
2206 + $update[] = "link_description = '".$wpdb->escape($channel['tagline'])."'";
2207 + elseif (isset($channel['description'])) :
2208 + $update[] = "link_description = '".$wpdb->escape($channel['description'])."'";
2209 + endif;
2210 + endif;
2211 +
2212 + $this->settings = array_merge($this->settings, $this->flatten_array($channel));
2213 +
2214 + $this->settings['update/last'] = time(); $ttl = $this->ttl();
2215 + if (!is_null($ttl)) :
2216 + $this->settings['update/ttl'] = $ttl;
2217 + $this->settings['update/timed'] = 'feed';
2218 + else :
2219 + $this->settings['update/ttl'] = rand(30, 120); // spread over time interval for staggered updates
2220 + $this->settings['update/timed'] = 'automatically';
2221 + endif;
2222 +
2223 + if (!isset($this->settings['update/hold']) or $this->settings['update/hold']!='ping') :
2224 + $this->settings['update/hold'] = 'scheduled';
2225 + endif;
2226 +
2227 + $this->settings['update/unfinished'] = 'yes';
2228 +
2229 + $update[] = "link_notes = '".$wpdb->escape($this->settings_to_notes())."'";
2230 +
2231 + $update_set = implode(',', $update);
2232 +
2233 + // Update the properties of the link from the feed information
2234 + $result = $wpdb->query("
2235 + UPDATE $wpdb->links
2236 + SET $update_set
2237 + WHERE link_id='$this->id'
2238 + ");
2239 +
2240 + # -- Add new posts from feed and update any updated posts
2241 + $crashed = false;
2242 +
2243 + if (is_array($this->magpie->items)) :
2244 + foreach ($this->magpie->items as $item) :
2245 + $post =& new SyndicatedPost($item, $this);
2246 + if (!$resume or !in_array(trim($post->guid()), $processed)) :
2247 + $processed[] = $post->guid();
2248 + if (!$post->filtered()) :
2249 + $new = $post->store();
2250 + if ( $new !== false ) $new_count[$new]++;
2251 + endif;
2252 +
2253 + if (!is_null($crash_ts) and (time() > $crash_ts)) :
2254 + $crashed = true;
2255 + break;
2256 + endif;
2257 + endif;
2258 + endforeach;
2259 + endif;
2260 +
2261 + // Copy back any changes to feed settings made in the course of updating (e.g. new author rules)
2262 + $to_notes = $this->settings;
2263 +
2264 + $this->settings['update/processed'] = $processed;
2265 + if (!$crashed) :
2266 + $this->settings['update/unfinished'] = 'no';
2267 + endif;
2268 +
2269 + $update_set = "link_notes = '".$wpdb->escape($this->settings_to_notes())."'";
2270 +
2271 + // Update the properties of the link from the feed information
2272 + $result = $wpdb->query("
2273 + UPDATE $wpdb->links
2274 + SET $update_set
2275 + WHERE link_id='$this->id'
2276 + ");
2277 + endif;
2278 +
2279 + return $new_count;
2280 + } /* SyndicatedLink::poll() */
2281 +
2282 + function map_name_to_new_user ($name, $newuser_name) {
2283 + global $wpdb;
2284 +
2285 + if (strlen($newuser_name) > 0) :
2286 + $userdata = array();
2287 + $userdata['ID'] = NULL;
2288 +
2289 + $userdata['user_login'] = sanitize_user($newuser_name);
2290 + $userdata['user_login'] = apply_filters('pre_user_login', $userdata['user_login']);
2291 +
2292 + $userdata['user_nicename'] = sanitize_title($newuser_name);
2293 + $userdata['user_nicename'] = apply_filters('pre_user_nicename', $userdata['user_nicename']);
2294 +
2295 + $userdata['display_name'] = $wpdb->escape($newuser_name);
2296 +
2297 + $newuser_id = wp_insert_user($userdata);
2298 + if (is_numeric($newuser_id)) :
2299 + if (is_null($name)) : // Unfamiliar author
2300 + $this->settings['unfamiliar author'] = $newuser_id;
2301 + else :
2302 + $this->settings['map authors']['name'][$name] = $newuser_id;
2303 + endif;
2304 + else :
2305 + // TODO: Add some error detection and reporting
2306 + endif;
2307 + else :
2308 + // TODO: Add some error reporting
2309 + endif;
2310 + } /* SyndicatedLink::map_name_to_new_user () */
2311 +
2312 + function settings_to_notes () {
2313 + $to_notes = $this->settings;
2314 +
2315 + unset($to_notes['link/id']); // Magic setting; don't save
2316 + unset($to_notes['link/uri']); // Magic setting; don't save
2317 + unset($to_notes['link/name']); // Magic setting; don't save
2318 + unset($to_notes['hardcode categories']); // Deprecated
2319 + unset($to_notes['unfamiliar categories']); // Deprecated
2320 +
2321 + // Collapse array settings
2322 + if (isset($to_notes['update/processed']) and (is_array($to_notes['update/processed']))) :
2323 + $to_notes['update/processed'] = implode("\n", $to_notes['update/processed']);
2324 + endif;
2325 +
2326 + if (is_array($to_notes['cats'])) :
2327 + $to_notes['cats'] = implode(FEEDWORDPRESS_CAT_SEPARATOR, $to_notes['cats']);
2328 + endif;
2329 + if (is_array($to_notes['tags'])) :
2330 + $to_notes['tags'] = implode(FEEDWORDPRESS_CAT_SEPARATOR, $to_notes['tags']);
2331 + endif;
2332 +
2333 + // Collapse the author mapping rule structure back into a flat string
2334 + if (isset($to_notes['map authors'])) :
2335 + $ma = array();
2336 + foreach ($to_notes['map authors'] as $rule_type => $author_rules) :
2337 + foreach ($author_rules as $author_name => $author_action) :
2338 + $ma[] = $rule_type."\n".$author_name."\n".$author_action;
2339 + endforeach;
2340 + endforeach;
2341 + $to_notes['map authors'] = implode("\n\n", $ma);
2342 + endif;
2343 +
2344 + $notes = '';
2345 + foreach ($to_notes as $key => $value) :
2346 + $notes .= $key . ": ". addcslashes($value, "\0..\37".'\\') . "\n";
2347 + endforeach;
2348 + return $notes;
2349 + } /* SyndicatedLink::settings_to_notes () */
2350 +
2351 + function uri () {
2352 + return (is_object($this->link) ? $this->link->link_rss : NULL);
2353 + } /* SyndicatedLink::uri () */
2354 +
2355 + function homepage () {
2356 + return (isset($this->settings['feed/link']) ? $this->settings['feed/link'] : NULL);
2357 + } /* SyndicatedLink::homepage () */
2358 +
2359 + function ttl () {
2360 + if (is_object($this->magpie)) :
2361 + $channel = $this->magpie->channel;
2362 + else :
2363 + $channel = array();
2364 + endif;
2365 +
2366 + if (isset($channel['ttl'])) :
2367 + // "ttl stands for time to live. It's a number of
2368 + // minutes that indicates how long a channel can be
2369 + // cached before refreshing from the source."
2370 + // <http://blogs.law.harvard.edu/tech/rss#ltttlgtSubelementOfLtchannelgt>
2371 + $ret = $channel['ttl'];
2372 + elseif (isset($channel['sy']['updatefrequency']) or isset($channel['sy']['updateperiod'])) :
2373 + $period_minutes = array (
2374 + 'hourly' => 60, /* minutes in an hour */
2375 + 'daily' => 1440, /* minutes in a day */
2376 + 'weekly' => 10080, /* minutes in a week */
2377 + 'monthly' => 43200, /* minutes in a month */
2378 + 'yearly' => 525600, /* minutes in a year */
2379 + );
2380 +
2381 + // "sy:updatePeriod: Describes the period over which the
2382 + // channel format is updated. Acceptable values are:
2383 + // hourly, daily, weekly, monthly, yearly. If omitted,
2384 + // daily is assumed." <http://web.resource.org/rss/1.0/modules/syndication/>
2385 + if (isset($channel['sy']['updateperiod'])) : $period = $channel['sy']['updateperiod'];
2386 + else : $period = 'daily';
2387 + endif;
2388 +
2389 + // "sy:updateFrequency: Used to describe the frequency
2390 + // of updates in relation to the update period. A
2391 + // positive integer indicates how many times in that
2392 + // period the channel is updated. ... If omitted a value
2393 + // of 1 is assumed." <http://web.resource.org/rss/1.0/modules/syndication/>
2394 + if (isset($channel['sy']['updatefrequency'])) : $freq = (int) $channel['sy']['updatefrequency'];
2395 + else : $freq = 1;
2396 + endif;
2397 +
2398 + $ret = (int) ($period_minutes[$period] / $freq);
2399 + else :
2400 + $ret = NULL;
2401 + endif;
2402 + return $ret;
2403 + } /* SyndicatedLink::ttl() */
2404 +
2405 + // SyndicatedLink::flatten_array (): flatten an array. Useful for
2406 + // hierarchical and namespaced elements.
2407 + //
2408 + // Given an array which may contain array or object elements in it,
2409 + // return a "flattened" array: a one-dimensional array of scalars
2410 + // containing each of the scalar elements contained within the array
2411 + // structure. Thus, for example, if $a['b']['c']['d'] == 'e', then the
2412 + // returned array for FeedWordPress::flatten_array($a) will contain a key
2413 + // $a['feed/b/c/d'] with value 'e'.
2414 + function flatten_array ($arr, $prefix = 'feed/', $separator = '/') {
2415 + $ret = array ();
2416 + if (is_array($arr)) :
2417 + foreach ($arr as $key => $value) :
2418 + if (is_scalar($value)) :
2419 + $ret[$prefix.$key] = $value;
2420 + else :
2421 + $ret = array_merge($ret, $this->flatten_array($value, $prefix.$key.$separator, $separator));
2422 + endif;
2423 + endforeach;
2424 + endif;
2425 + return $ret;
2426 + } /* SyndicatedLink::flatten_array () */
2427 +
2428 + function hardcode ($what) {
2429 + $default = get_option("feedwordpress_hardcode_$what");
2430 + if ( $default === 'yes' ) :
2431 + // If the default is to hardcode, then we want the
2432 + // negation of negative(): TRUE by default and FALSE if
2433 + // the setting is explicitly "no"
2434 + $ret = !FeedWordPress::negative($this->settings, "hardcode $what");
2435 + else :
2436 + // If the default is NOT to hardcode, then we want
2437 + // affirmative(): FALSE by default and TRUE if the
2438 + // setting is explicitly "yes"
2439 + $ret = FeedWordPress::affirmative($this->settings, "hardcode $what");
2440 + endif;
2441 + return $ret;
2442 + } /* SyndicatedLink::hardcode () */
2443 +
2444 + function syndicated_status ($what, $default) {
2445 + global $wpdb;
2446 +
2447 + $ret = get_option("feedwordpress_syndicated_{$what}_status");
2448 + if ( isset($this->settings["$what status"]) ) :
2449 + $ret = $this->settings["$what status"];
2450 + elseif (!$ret) :
2451 + $ret = $default;
2452 + endif;
2453 + return $wpdb->escape(trim(strtolower($ret)));
2454 + } /* SyndicatedLink:syndicated_status () */
2455 +} // class SyndicatedLink
2456 +
2336 2457 ################################################################################
2337 2458 ## XML-RPC HOOKS: accept XML-RPC update pings from Contributors ################
2338 2459 ################################################################################
2339 2460
@@ -2354,8 +2475,169 @@
2354 2475
2355 2476 return array('flerror' => false, 'message' => "Thanks for the ping.".implode(' and', $mesg));
2356 2477 endif;
2357 2478 }
2479 +
2480 +################################################################################
2481 +## class FeedFinder: find likely feeds using autodetection and/or guesswork ####
2482 +################################################################################
2483 +
2484 +class FeedFinder {
2485 + var $uri = NULL;
2486 + var $_cache_uri = NULL;
2487 +
2488 + var $verify = FALSE;
2489 +
2490 + var $_data = NULL;
2491 + var $_head = NULL;
2492 +
2493 + # -- Recognition patterns
2494 + var $_feed_types = array(
2495 + 'application/rss+xml',
2496 + 'text/xml',
2497 + 'application/atom+xml',
2498 + 'application/x.atom+xml',
2499 + 'application/x-atom+xml'
2500 + );
2501 + var $_feed_markers = array('\\<feed', '\\<rss', 'xmlns="http://purl.org/rss/1.0');
2502 + var $_html_markers = array('\\<html');
2503 + var $_obvious_feed_url = array('[./]rss', '[./]rdf', '[./]atom', '[./]feed', '\.xml');
2504 + var $_maybe_feed_url = array ('rss', 'rdf', 'atom', 'feed', 'xml');
2505 +
2506 + function FeedFinder ($uri = NULL, $verify = TRUE) {
2507 + $this->uri = $uri; $this->verify = $verify;
2508 + } /* FeedFinder::FeedFinder () */
2509 +
2510 + function find ($uri = NULL) {
2511 + $ret = array ();
2512 + if (!is_null($this->data($uri))) {
2513 + if ($this->is_feed($uri)) {
2514 + $ret = array($this->uri);
2515 + } else {
2516 + // Assume that we have HTML or XHTML (even if we don't, who's it gonna hurt?)
2517 + // Autodiscovery is the preferred method
2518 + $href = $this->_link_rel_feeds();
2519 +
2520 + // ... but we'll also take the little orange buttons
2521 + $href = array_merge($href, $this->_a_href_feeds(TRUE));
2522 +
2523 + // If all that failed, look harder
2524 + if (count($href) == 0) $href = $this->_a_href_feeds(FALSE);
2525 +
2526 + // Verify feeds and resolve relative URIs
2527 + foreach ($href as $u) {
2528 + $the_uri = Relative_URI::resolve($u, $this->uri);
2529 + if ($this->verify) {
2530 + $feed =& new FeedFinder($the_uri);
2531 + if ($feed->is_feed()) $ret[] = $the_uri;
2532 + $feed = NULL;
2533 + } else {
2534 + $ret[] = $the_uri;
2535 + }
2536 + } /* foreach */
2537 + } /* if */
2538 + } /* if */
2539 + return array_unique($ret);
2540 + } /* FeedFinder::find () */
2541 +
2542 + function data ($uri = NULL) {
2543 + $this->_get($uri);
2544 + return $this->_data;
2545 + }
2546 +
2547 + function is_feed ($uri = NULL) {
2548 + $data = $this->data($uri);
2549 +
2550 + return (
2551 + preg_match (
2552 + "\007(".implode('|',$this->_feed_markers).")\007i",
2553 + $data
2554 + ) and !preg_match (
2555 + "\007(".implode('|',$this->_html_markers).")\007i",
2556 + $data
2557 + )
2558 + );
2559 + } /* FeedFinder::is_feed () */
2560 +
2561 + # --- Private methods ---
2562 + function _get ($uri = NULL) {
2563 + if ($uri) $this->uri = $uri;
2564 +
2565 + // Is the result not yet cached?
2566 + if ($this->_cache_uri !== $this->uri) :
2567 + // Snoopy is an HTTP client in PHP
2568 + $client = new Snoopy();
2569 +
2570 + // Prepare headers and internal settings
2571 + $client->rawheaders['Connection'] = 'close';
2572 + $client->accept = 'application/atom+xml application/rdf+xml application/rss+xml application/xml text/html */*';
2573 + $client->agent = 'feedfinder/1.2 (compatible; PHP FeedFinder) +http://projects.radgeek.com/feedwordpress';
2574 + $client->read_timeout = 25;
2575 +
2576 + // Fetch the HTML or feed
2577 + @$client->fetch($this->uri);
2578 + $this->_data = $client->results;
2579 +
2580 + // Kilroy was here
2581 + $this->_cache_uri = $this->uri;
2582 + endif;
2583 + } /* FeedFinder::_get () */
2584 +
2585 + function _link_rel_feeds () {
2586 + $links = $this->_tags('link');
2587 + $link_count = count($links);
2588 +
2589 + // now figure out which one points to the RSS file
2590 + $href = array ();
2591 + for ($n=0; $n<$link_count; $n++) {
2592 + if (strtolower($links[$n]['rel']) == 'alternate') {
2593 + if (in_array(strtolower($links[$n]['type']), $this->_feed_types)) {
2594 + $href[] = $links[$n]['href'];
2595 + } /* if */
2596 + } /* if */
2597 + } /* for */
2598 + return $href;
2599 + }
2600 +
2601 + function _a_href_feeds ($obvious = TRUE) {
2602 + $pattern = ($obvious ? $this->_obvious_feed_url : $this->_maybe_feed_url);
2603 +
2604 + $links = $this->_tags('a');
2605 + $link_count = count($links);
2606 +
2607 + // now figure out which one points to the RSS file
2608 + $href = array ();
2609 + for ($n=0; $n<$link_count; $n++) {
2610 + if (preg_match("\007(".implode('|',$pattern).")\007i", $links[$n]['href'])) {
2611 + $href[] = $links[$n]['href'];
2612 + } /* if */
2613 + } /* for */
2614 + return $href;
2615 + }
2616 +
2617 + function _tags ($tag) {
2618 + $html = $this->data();
2619 +
2620 + // search through the HTML, save all <link> tags
2621 + // and store each link's attributes in an associative array
2622 + preg_match_all('/<'.$tag.'\s+(.*?)\s*\/?>/si', $html, $matches);
2623 + $links = $matches[1];
2624 + $ret = array();
2625 + $link_count = count($links);
2626 + for ($n=0; $n<$link_count; $n++) {
2627 + $attributes = preg_split('/\s+/s', $links[$n]);
2628 + foreach($attributes as $attribute) {
2629 + $att = preg_split('/\s*=\s*/s', $attribute, 2);
2630 + if (isset($att[1])) {
2631 + $att[1] = preg_replace('/([\'"]?)(.*)\1/', '$2', $att[1]);
2632 + $final_link[strtolower($att[0])] = $att[1];
2633 + } /* if */
2634 + } /* foreach */
2635 + $ret[$n] = $final_link;
2636 + } /* for */
2637 + return $ret;
2638 + }
2639 +} /* class FeedFinder */
2358 2640
2359 2641 # Relative URI static class: PHP class for resolving relative URLs
2360 2642 #
2361 2643 # This class is derived (under the terms of the GPL) from URL Class 0.3 by