WordPress.org

Plugin Directory

Changeset 1413324 for feedwordpress


Ignore:
Timestamp:
05/09/16 20:40:45 (15 months ago)
Author:
radgeek
Message:

Version 2016.0420, my dudes.

Location:
feedwordpress/trunk
Files:
1 added
6 edited

Legend:

Unmodified
Added
Removed
  • feedwordpress/trunk/diagnostics-page.php

    r960798 r1413324  
    357357    </tr> 
    358358    </table> 
    359  
     359    </td> 
     360    </tr> 
     361 
     362    <tr> 
     363    <th>XPath:</th> 
     364    <td><div><input type="text" name="http_test_xpath" value="" placeholder="xpath-like query" /></div> 
     365    <div><p>Leave blank to test HTTP, fill in to test a query.</p></div> 
     366    </td> 
     367    </tr> 
     368     
    360369    <?php if (isset($page->test_html['http_test'])) : ?> 
     370    <tr> 
     371    <th scope="row">RESULTS:</th> 
     372    <td> 
     373    <div>URL: <code><?php print esc_html($page->test_html['url']); ?></code></div> 
    361374    <div style="position: relative"> 
    362375    <div style="width: 100%; overflow: scroll; background-color: #eed"> 
     
    364377    </div> 
    365378    </div> 
    366     <?php endif; ?> 
    367379    </td> 
    368380    </tr> 
     381    <?php endif; ?> 
    369382</table> 
    370383 
     
    372385    } /* FeedWordPressDiagnosticsPage::tests_box () */ 
    373386 
    374     var $test_html; 
    375     static function do_http_test ($post) { 
     387    private $test_html; 
     388    public function do_http_test ($post) { 
    376389        if (isset($post['http_test_url']) and isset($post['http_test_method'])) : 
    377390            $url = $post['http_test_url']; 
     
    411424            endswitch; 
    412425             
     426            $this->test_html['url'] = $url; 
    413427            $this->test_html['http_test'] = esc_html(MyPHP::val($out)); 
    414428        endif; 
  • feedwordpress/trunk/feedwordpress-elements.js

    r680650 r1413324  
    630630    if (response.results instanceof Array) { 
    631631        for (var i = 0; i < response.results.length; i++) { 
    632             resultsHtml += '<li>result['+i.toString()+'] = <code>'+response.results[i]+'</code></li>'; 
     632            resultsHtml += '<li>result['+(i+1).toString()+'] = <code>'+response.results[i]+'</code></li>'; 
    633633        } 
    634634    } else { 
  • feedwordpress/trunk/feedwordpress.php

    r1160703 r1413324  
    44Plugin URI: http://feedwordpress.radgeek.com/ 
    55Description: simple and flexible Atom/RSS syndication for WordPress 
    6 Version: 2015.0514 
     6Version: 2016.0420 
    77Author: Charles Johnson 
    88Author URI: http://radgeek.com/ 
     
    1212/** 
    1313 * @package FeedWordPress 
    14  * @version 2015.0514 
     14 * @version 2016.0420 
    1515 */ 
    1616 
     
    3333# -- Don't change these unless you know what you're doing... 
    3434 
    35 define ('FEEDWORDPRESS_VERSION', '2015.0514'); 
     35define ('FEEDWORDPRESS_VERSION', '2016.0420'); 
    3636define ('FEEDWORDPRESS_AUTHOR_CONTACT', 'http://radgeek.com/contact'); 
    3737 
  • feedwordpress/trunk/readme.txt

    r1160703 r1413324  
    44Tags: syndication, aggregation, feed, atom, rss 
    55Requires at least: 3.0 
    6 Tested up to: 4.2.2 
    7 Stable tag: 2015.0514 
     6Tested up to: 4.5.2 
     7Stable tag: 2016.0420 
    88 
    99FeedWordPress syndicates content from feeds you choose into your WordPress weblog.  
     
    2121templating engine as the back-end of an aggregation ("planet") website. It was 
    2222developed, originally, because I needed a more flexible replacement for 
    23 [Planet][] to use at [Feminist Blogs][]. 
     23[Planet][] to use at Feminist Blogs, an aggregator site that I used to administer. 
    2424 
    2525[Planet]: http://www.planetplanet.org/ 
     
    9494 
    9595== Changelog == 
     96 
     97= 2016.0420 = 
     98 
     99*   WORDPRESS COMPATIBILITY: Tested with new versions of WordPress up to 4.5. 
     100 
     101*   FILTERS AND ADD-ONS: Allow filters and add-ons to filter terms and taxonomy 
     102    (categories, tags, custom taxonomies, etc.) more thoroughly and more 
     103    fine-grainedly using syndicated_post_terms_match, syndicated_post_terms_match_{taxonomy}, 
     104    syndicated_post_terms_unfamiliar, syndicated_post_terms_mapping, 
     105    syndicated_item_feed_terms, and syndicated_item_preset_terms filters. 
     106 
     107*   FILTERS AND ADD-ONS: Globals $fwp_channel and $fwp_feedmeta REMOVED. 
     108    These global variables, originally introduced to allow filters access to 
     109    information about the source feed in `syndicated_item` filters were 
     110    deprecated 6+ years ago. If you have any filters or add-ons which still 
     111    depend on these global variables, you've been using obsolete techniques 
     112    and you should see about fixing them to access data about the source feed 
     113    using the SyndicatedPost::link element instead. For documentation, see 
     114    the FeedWordPress documentation wiki at 
     115    <http://feedwordpress.radgeek.com/wiki/syndicatedpost> and 
     116    <http://feedwordpress.radgeek.com/wiki/syndicatedlink>. 
     117 
     118*   BUGFIX: Syndication > Diagnostics HTTP diagnostic test widget was broken due to 
     119    a dumb error on my part. Now fixed. 
     120     
     121*   SMALL CODING CHANGES: Lots of small changes to code organization, incorporation 
     122    of some PHP 5.x coding conventions, etc. 
    96123 
    97124= 2015.0514 = 
  • feedwordpress/trunk/syndicatedpost.class.php

    r1160703 r1413324  
    22require_once(dirname(__FILE__).'/feedtime.class.php'); 
    33require_once(dirname(__FILE__).'/syndicatedpostterm.class.php'); 
     4require_once(dirname(__FILE__).'/syndicatedpostxpathquery.class.php'); 
    45 
    56/** 
     
    4344     * @param SyndicatedLink $source The feed it was syndicated from. 
    4445     */ 
    45     function SyndicatedPost ($item, &$source) { 
     46    function __construct ($item, &$source) { 
    4647        global $wpdb; 
    4748 
     
    8687        // Fucking SimplePie. 
    8788        $this->xmlns['reverse']['rss'][] = ''; 
    88  
    89         # These globals were originally an ugly kludge around a bug in 
    90         # apply_filters from WordPress 1.5. The bug was fixed in 1.5.1, 
    91         # and I sure hope at this point that nobody writing filters for 
    92         # FeedWordPress is still relying on them. 
    93         # 
    94         # Anyway, I hereby declare them DEPRECATED as of 8 February 
    95         # 2010. I'll probably remove the globals within 1-2 releases in 
    96         # the interests of code hygiene and memory usage. If you 
    97         # currently use them in your filters, I advise you switch off to 
    98         # accessing the public members SyndicatedPost::feed and 
    99         # SyndicatedPost::feedmeta. 
    100  
    101         global $fwp_channel, $fwp_feedmeta; 
    102         $fwp_channel = $this->feed; $fwp_feedmeta = $this->feedmeta; 
    10389 
    10490        // Trigger global syndicated_item filter. 
     
    266252            $this->post['meta']['syndication_item_hash'] = $this->update_hash(); 
    267253 
    268             // Categories: start with default categories, if any. 
    269             $cats = array(); 
    270             if ('no' != $this->link->setting('add/category', NULL, 'yes')) : 
    271                 $fc = get_option("feedwordpress_syndication_cats"); 
    272                 if ($fc) : 
    273                     $cats = array_merge($cats, explode("\n", $fc)); 
    274                 endif; 
    275             endif; 
    276  
    277             $fc = $this->link->setting('cats', NULL, array()); 
    278             if (is_array($fc)) : 
    279                 $cats = array_merge($cats, $fc); 
    280             endif; 
    281             $this->preset_terms['category'] = $cats; 
    282  
    283             // Now add categories from the post, if we have 'em 
    284             $cats = array(); 
    285             $post_cats = $this->entry->get_categories(); 
    286             if (is_array($post_cats)) : foreach ($post_cats as $cat) : 
    287                 $cat_name = $cat->get_term(); 
    288                 if (!$cat_name) : $cat_name = $cat->get_label(); endif; 
    289  
    290                 if ($this->link->setting('cat_split', NULL, NULL)) : 
    291                     $pcre = "\007".$this->feedmeta['cat_split']."\007"; 
    292                     $cats = array_merge( 
    293                         $cats, 
    294                         preg_split( 
    295                             $pcre, 
    296                             $cat_name, 
    297                             -1 /*=no limit*/, 
    298                             PREG_SPLIT_NO_EMPTY 
    299                         ) 
    300                     ); 
    301                 else : 
    302                     $cats[] = $cat_name; 
    303                 endif; 
    304             endforeach; endif; 
    305  
    306             $this->feed_terms['category'] = apply_filters('syndicated_item_categories', $cats, $this); 
    307  
    308             // Tags: start with default tags, if any 
    309             $tags = array(); 
    310             if ('no' != $this->link->setting('add/post_tag', NULL, 'yes')) : 
    311                 $ft = get_option("feedwordpress_syndication_tags", NULL); 
    312                 $tags = (is_null($ft) ? array() : explode(FEEDWORDPRESS_CAT_SEPARATOR, $ft)); 
    313             endif; 
    314  
    315             $ft = $this->link->setting('tags', NULL, array()); 
    316             if (is_array($ft)) : 
    317                 $tags = array_merge($tags, $ft); 
    318             endif; 
    319             $this->preset_terms['post_tag'] = $tags; 
    320  
    321             // Scan post for /a[@rel='tag'] and use as tags if present 
    322             $tags = $this->inline_tags(); 
    323             $this->feed_terms['post_tag'] = apply_filters('syndicated_item_tags', $tags, $this); 
    324  
    325             $taxonomies = $this->link->taxonomies(); 
    326             $feedTerms = $this->link->setting('terms', NULL, array()); 
    327             $globalTerms = get_option('feedwordpress_syndication_terms', array()); 
    328  
    329             $specials = array('category' => 'cats', 'post_tag' => 'tags'); 
    330             foreach ($taxonomies as $tax) : 
    331                 if (!isset($specials[$tax])) : 
    332                     $terms = array(); 
    333  
    334                     // See if we should get the globals 
    335                     if ('no' != $this->link->setting("add/$tax", NULL, 'yes')) : 
    336                         if (isset($globalTerms[$tax])) : 
    337                             $terms = $globalTerms[$tax]; 
    338                         endif; 
    339                     endif; 
    340  
    341                     // Now merge in the locals 
    342                     if (isset($feedTerms[$tax])) : 
    343                         $terms = array_merge($terms, $feedTerms[$tax]); 
    344                     endif; 
    345  
    346                     // That's all, folks. 
    347                     $this->preset_terms[$tax] = $terms; 
    348                 endif; 
    349             endforeach; 
     254            // Categories, Tags, and other Terms: from settings assignments (global settings, subscription settings), 
     255            // and from feed assignments (item metadata, post content) 
     256            $this->preset_terms = apply_filters('syndicated_item_preset_terms', $this->get_terms_from_settings(), $this); 
     257            $this->feed_terms = apply_filters('syndicated_item_feed_terms', $this->get_terms_from_feeds(), $this); 
    350258 
    351259            $this->post['post_type'] = apply_filters('syndicated_post_type', $this->link->setting('syndicated post type', 'syndicated_post_type', 'post'), $this); 
    352260        endif; 
    353261         
    354     } /* SyndicatedPost::SyndicatedPost() */ 
     262    } /* SyndicatedPost::__construct() */ 
    355263 
    356264    ##################################### 
     
    384292     */ 
    385293     function query ($path) { 
    386         $urlHash = array(); 
    387  
    388         // Allow {url} notation for namespaces. URLs will contain : and /, so... 
    389         preg_match_all('/{([^}]+)}/', $path, $match, PREG_SET_ORDER); 
    390         foreach ($match as $ref) : 
    391             $urlHash[md5($ref[1])] = $ref[1]; 
    392         endforeach; 
    393  
    394         foreach ($urlHash as $hash => $url) : 
    395             $path = str_replace('{'.$url.'}', '{#'.$hash.'}', $path); 
    396         endforeach; 
    397  
    398         $path = explode('/', $path); 
    399         foreach ($path as $index => $node) : 
    400             if (preg_match('/{#([^}]+)}/', $node, $ref)) : 
    401                 if (isset($urlHash[$ref[1]])) : 
    402                     $path[$index] = str_replace( 
    403                         '{#'.$ref[1].'}', 
    404                         '{'.$urlHash[$ref[1]].'}', 
    405                         $node 
    406                     ); 
    407                 endif; 
    408             endif; 
    409         endforeach; 
    410  
    411         // Start out with a get_item_tags query. 
    412         $node = ''; 
    413         while (strlen($node)==0 and !is_null($node)) : 
    414             $node = array_shift($path); 
    415         endwhile; 
    416  
    417         switch ($node) : 
    418         case 'feed' : 
    419         case 'channel' : 
    420             $node = array_shift($path); 
    421             $data = $this->get_feed_root_element(); 
    422             $data = array_merge($data, $this->get_feed_channel_elements()); 
    423             break; 
    424         case 'item' : 
    425             $node = array_shift($path); 
    426         default : 
    427             $data = array($this->entry->data); 
    428             $method = NULL; 
    429         endswitch; 
    430  
    431         while (!is_null($node)) : 
    432             if (strlen($node) > 0) : 
    433                 $matches = array(); 
    434  
    435                 list($axis, $element) = $this->xpath_name_and_axis($node); 
    436  
    437                 foreach ($data as $datum) : 
    438                     if (!is_string($datum) and isset($datum[$axis])) : 
    439                         foreach ($datum[$axis] as $ns => $elements) : 
    440                             if (isset($elements[$element])) : 
    441                                 // Potential match. 
    442                                 // Check namespace. 
    443                                 if (is_string($elements[$element])) : // Attribute 
    444                                     $addenda = array($elements[$element]); 
    445                                     $contexts = array($datum); 
    446                                 else : // Element 
    447                                     $addenda = $elements[$element]; 
    448                                     $contexts = $elements[$element]; 
    449                                 endif; 
    450  
    451                                 foreach ($addenda as $index => $addendum) : 
    452                                     $context = $contexts[$index]; 
    453  
    454                                     $namespaces = $this->xpath_possible_namespaces($node, $context); 
    455                                     if (in_array($ns, $namespaces)) : 
    456                                         $matches[] = $addendum; 
    457                                     endif; 
    458                                 endforeach; 
    459                             endif; 
    460                         endforeach; 
    461                     endif; 
    462                 endforeach; 
    463  
    464                 $data = $matches; 
    465             endif; 
    466             $node = array_shift($path); 
    467         endwhile; 
    468  
    469         $matches = array(); 
    470         foreach ($data as $datum) : 
    471             if (is_string($datum)) : 
    472                 $matches[] = $datum; 
    473             elseif (isset($datum['data'])) : 
    474                 $matches[] = $datum['data']; 
    475             endif; 
    476         endforeach; 
     294        $xq = new SyndicatedPostXPathQuery(array("path" => $path)); 
     295 
     296        $feedChannel = array_merge( 
     297            $this->get_feed_root_element(), 
     298            $this->get_feed_channel_elements() 
     299        ); 
     300 
     301        $matches = $xq->match(array( 
     302        "type" => $this->link->simplepie->get_type(), 
     303        "xmlns" => $this->xmlns, 
     304        "map" => array( 
     305            "/" => array($this->entry->data), 
     306            "item" => array($this->entry->data), 
     307            "feed" => $feedChannel, 
     308            "channel" => $feedChannel 
     309        ), 
     310        "context" => $this->entry->data, 
     311        "parent" => $feedChannel, 
     312        )); 
     313 
    477314        return $matches; 
    478315    } /* SyndicatedPost::query() */ 
     
    505342        return $matches; 
    506343    } /* SyndicatedPost::get_feed_channel_elements() */ 
    507  
    508     function xpath_default_namespace () { 
    509         // Get the default namespace. 
    510         $type = $this->link->simplepie->get_type(); 
    511         if ($type & SIMPLEPIE_TYPE_ATOM_10) : 
    512             $defaultNS = SIMPLEPIE_NAMESPACE_ATOM_10; 
    513         elseif ($type & SIMPLEPIE_TYPE_ATOM_03) : 
    514             $defaultNS = SIMPLEPIE_NAMESPACE_ATOM_03; 
    515         elseif ($type & SIMPLEPIE_TYPE_RSS_090) : 
    516             $defaultNS = SIMPLEPIE_NAMESPACE_RSS_090; 
    517         elseif ($type & SIMPLEPIE_TYPE_RSS_10) : 
    518             $defaultNS = SIMPLEPIE_NAMESPACE_RSS_10; 
    519         elseif ($type & SIMPLEPIE_TYPE_RSS_20) : 
    520             $defaultNS = SIMPLEPIE_NAMESPACE_RSS_20; 
    521         else : 
    522             $defaultNS = SIMPLEPIE_NAMESPACE_RSS_20; 
    523         endif; 
    524         return $defaultNS; 
    525     } /* SyndicatedPost::xpath_default_namespace() */ 
    526  
    527     function xpath_name_and_axis ($node) { 
    528         $ns = NULL; $element = NULL; 
    529  
    530         if (substr($node, 0, 1)=='@') : 
    531             $axis = 'attribs'; $node = substr($node, 1); 
    532         else : 
    533             $axis = 'child'; 
    534         endif; 
    535  
    536         if (preg_match('/^{([^}]*)}(.*)$/', $node, $ref)) : 
    537             $element = $ref[2]; 
    538         elseif (strpos($node, ':') !== FALSE) : 
    539             list($xmlns, $element) = explode(':', $node, 2); 
    540         else : 
    541             $element = $node; 
    542         endif; 
    543         return array($axis, $element); 
    544     } /* SyndicatedPost::xpath_local_name () */ 
    545  
    546     function xpath_possible_namespaces ($node, $datum = array()) { 
    547         $ns = NULL; $element = NULL; 
    548  
    549         if (substr($node, 0, 1)=='@') : 
    550             $attr = '@'; $node = substr($node, 1); 
    551         else : 
    552             $attr = ''; 
    553         endif; 
    554  
    555         if (preg_match('/^{([^}]*)}(.*)$/', $node, $ref)) : 
    556             $ns = array($ref[1]); 
    557         elseif (strpos($node, ':') !== FALSE) : 
    558             list($xmlns, $element) = explode(':', $node, 2); 
    559  
    560             if (isset($this->xmlns['reverse'][$xmlns])) : 
    561                 $ns = $this->xmlns['reverse'][$xmlns]; 
    562             else : 
    563                 $ns = array($xmlns); 
    564             endif; 
    565  
    566             // Fucking SimplePie. For attributes in default xmlns. 
    567             $defaultNS = $this->xpath_default_namespace(); 
    568             if (isset($this->xmlns['forward'][$defaultNS]) 
    569             and ($xmlns==$this->xmlns['forward'][$defaultNS])) : 
    570                 $ns[] = ''; 
    571             endif; 
    572  
    573             if (isset($datum['xmlns'])) : 
    574                 if (isset($datum['xmlns'][$xmlns])) : 
    575                     $ns[] = $datum['xmlns'][$xmlns]; 
    576                 endif; 
    577             endif; 
    578         else : 
    579             // Often in SimplePie, the default namespace gets stored 
    580             // as an empty string rather than a URL. 
    581             $ns = array($this->xpath_default_namespace(), ''); 
    582         endif; 
    583         return array_unique($ns); 
    584     } /* SyndicatedPost::xpath_possible_namespaces() */ 
    585344 
    586345    function get_categories ($params = array()) { 
     
    976735        return $author; 
    977736    } /* SyndicatedPost::author() */ 
     737 
     738    /** 
     739     * SyndicatedPost::get_terms_from_settings(): Return an array of terms to associate with the incoming 
     740     * post based on the Categories, Tags, and other terms associated with each new post by the user's 
     741     * settings (global and feed-specific). 
     742     * 
     743     * @since 2016.0331 
     744     * @return array of lists, each element has the taxonomy for a key ('category', 'post_tag', etc.), 
     745     *      and a list of term codes (either alphanumeric names, or ID numbers encoded in a format that 
     746     *      SyndicatedLink::category_ids() can understand) within that taxonomy 
     747     *    
     748     */ 
     749    public function get_terms_from_settings () { 
     750        // Categories: start with default categories, if any. 
     751        $cats = array(); 
     752        if ('no' != $this->link->setting('add/category', NULL, 'yes')) : 
     753            $fc = get_option("feedwordpress_syndication_cats"); 
     754            if ($fc) : 
     755                $cats = array_merge($cats, explode("\n", $fc)); 
     756            endif; 
     757        endif; 
     758 
     759        $fc = $this->link->setting('cats',NULL, array()); 
     760        if (is_array($fc)) : 
     761            $cats = array_merge($cats, $fc); 
     762        endif; 
     763        $preset_terms['category'] = $cats; 
     764 
     765        // Tags: start with default tags, if any 
     766        $tags = array(); 
     767        if ('no' != $this->link->setting('add/post_tag', NULL, 'yes')) : 
     768            $ft = get_option("feedwordpress_syndication_tags", NULL); 
     769            $tags = (is_null($ft) ? array() : explode(FEEDWORDPRESS_CAT_SEPARATOR, $ft)); 
     770        endif; 
     771 
     772        $ft = $this->link->setting('tags', NULL, array()); 
     773        if (is_array($ft)) : 
     774            $tags = array_merge($tags, $ft); 
     775        endif; 
     776        $preset_terms['post_tag'] = $tags; 
     777 
     778        $taxonomies = $this->link->taxonomies(); 
     779        $feedTerms = $this->link->setting('terms', NULL, array()); 
     780        $globalTerms = get_option('feedwordpress_syndication_terms', array()); 
     781        $specials = array('category' => 'cats', 'post_tag' => 'tags'); 
     782 
     783        foreach ($taxonomies as $tax) : 
     784            // category and tag settings have already previously been handled 
     785            // but if this is from another taxonomy, then... 
     786            if (!isset($specials[$tax])) : 
     787                $terms = array(); 
     788 
     789                // See if we should get the globals 
     790                if ('no' != $this->link->setting("add/$tax", NULL, 'yes')) : 
     791                    if (isset($globalTerms[$tax])) : 
     792                        $terms = $globalTerms[$tax]; 
     793                    endif; 
     794                endif; 
     795 
     796                // Now merge in the locals 
     797                if (isset($feedTerms[$tax])) : 
     798                    $terms = array_merge($terms, $feedTerms[$tax]); 
     799                endif; 
     800 
     801                // That's all, folks. 
     802                $preset_terms[$tax] = $terms; 
     803            endif; 
     804        endforeach; 
     805         
     806        return $preset_terms; 
     807    } /* SyndicatedPost::get_terms_from_settings () */ 
     808         
     809    /** 
     810     * SyndicatedPost::get_terms_from_feeds(): Return an array of terms to associate with the incoming 
     811     * post based on the contents of the subscribed feed (atom:category and rss:category elements, dc:subject 
     812     * elements, tags embedded using microformats in the post content, etc.) 
     813     * 
     814     * @since 2016.0331 
     815     * @return array of lists, each element has the taxonomy for a key ('category', 'post_tag', etc.), 
     816     *      and a list of alphanumeric term names 
     817     */ 
     818    public function get_terms_from_feeds () {    
     819        // Now add categories from the post, if we have 'em 
     820        $cats = array(); 
     821        $post_cats = $this->entry->get_categories(); 
     822        if (is_array($post_cats)) : foreach ($post_cats as $cat) : 
     823            $cat_name = $cat->get_term(); 
     824            if (!$cat_name) : $cat_name = $cat->get_label(); endif; 
     825 
     826            if ($this->link->setting('cat_split', NULL, NULL)) : 
     827                $pcre = "\007".$this->feedmeta['cat_split']."\007"; 
     828                $cats = array_merge( 
     829                    $cats, 
     830                    preg_split( 
     831                        $pcre, 
     832                        $cat_name, 
     833                        -1 /*=no limit*/, 
     834                        PREG_SPLIT_NO_EMPTY 
     835                    ) 
     836                ); 
     837            else : 
     838                $cats[] = $cat_name; 
     839            endif; 
     840        endforeach; endif; 
     841 
     842        $feed_terms['category'] = apply_filters('syndicated_item_categories', $cats, $this); 
     843 
     844        // Scan post for /a[@rel='tag'] and use as tags if present 
     845        $tags = $this->inline_tags(); 
     846        $feed_terms['post_tag'] = apply_filters('syndicated_item_tags', $tags, $this); 
     847 
     848        return $feed_terms; 
     849    } /* SyndicatedPost::get_terms_from_feeds () */ 
    978850 
    979851    /** 
     
    15691441        // the author_id lookup 
    15701442        if ($this->has_fresh_content()) : 
    1571             $consider = array( 
    1572                 'category' => array('abbr' => 'cats', 'domain' => array('category', 'post_tag')), 
    1573                 'post_tag' => array('abbr' => 'tags', 'domain' => array('post_tag')), 
    1574             ); 
     1443            $mapping = apply_filters('syndicated_post_terms_mapping', array( 
     1444                'category' => array('abbr' => 'cats', 'unfamiliar' => 'category', 'domain' => array('category', 'post_tag')), 
     1445                'post_tag' => array('abbr' => 'tags', 'unfamiliar' => 'post_tag', 'domain' => array('post_tag')), 
     1446            ), $this); 
    15751447 
    15761448            $termSet = array(); $valid = null; 
    1577             foreach ($consider as $what => $taxes) : 
     1449            foreach ($this->feed_terms as $what => $anTerms) : 
     1450                // Default to using the inclusive procedures (for cats) rather than exclusive (for inline tags) 
     1451                $taxes = (isset($mapping[$what]) ? $mapping[$what] : $mapping['category']); 
     1452                $unfamiliar = $taxes['unfamiliar']; 
     1453                 
    15781454                if (!is_null($this->post)) : // Not filtered out yet 
    15791455                    # -- Look up, or create, numeric ID for categories 
     
    15831459                    $taxonomies = array_filter($taxonomies, 'remove_dummy_zero'); 
    15841460 
     1461                    // Allow FWP add-on filters to control the taxonomies we use to search for a term 
     1462                    $taxonomies = apply_filters("syndicated_post_terms_match", $taxonomies, $what, $this); 
     1463                    $taxonomies = apply_filters("syndicated_post_terms_match_${what}", $taxonomies, $this); 
     1464 
     1465                    // Allow FWP add-on filters to control with greater precision what happens on unmatched 
     1466                    $unmatched = apply_filters("syndicated_post_terms_unfamiliar", 
     1467                        $this->link->setting( 
     1468                            "unfamiliar {$unfamiliar}", 
     1469                            "unfamiliar_{$unfamiliar}", 
     1470                            'create:'.$unfamiliar 
     1471                        ), 
     1472                        $what, 
     1473                        $this 
     1474                    ); 
     1475 
    15851476                    $terms = $this->category_ids ( 
    1586                         $this->feed_terms[$what], 
    1587                         $this->link->setting("unfamiliar {$what}", "unfamiliar_{$what}", 'create:'.$what), 
     1477                        $anTerms, 
     1478                        $unmatched, 
    15881479                        /*taxonomies=*/ $taxonomies, 
    15891480                        array( 
     
    17281619        $dbpost = $this->normalize_post(/*new=*/ true); 
    17291620 
     1621        $ret = null; 
     1622 
    17301623        if (!is_null($dbpost)) : 
    17311624            $dbpost['post_pingback'] = false; // Tell WP 2.1 and 2.2 not to process for pingbacks 
     
    17921685            endif; 
    17931686             
    1794             // Now that we've made sure the original exists, insert 
    1795             // this version here as a revision. 
    1796             $revision_id = _wp_put_post_revision($dbpost, /*autosave=*/ false); 
    1797  
    1798             if (!$this->this_revision_needs_original_post()) : 
     1687            // Sanity check: if the attempt to insert post 
     1688            // returned an error, then feeding that error 
     1689            // object in to _wp_put_post_revision() would 
     1690            // cause a fatal error. Better to break out. 
     1691            if (!is_wp_error($this->_wp_id)) : 
     1692                // Now that we've made sure the original exists, insert 
     1693                // this version here as a revision. 
     1694                $revision_id = _wp_put_post_revision($dbpost, /*autosave=*/ false); 
     1695 
     1696                if (!$this->this_revision_needs_original_post()) : 
    17991697             
    1800                 if ($this->this_revision_is_current()) : 
    1801  
    1802                     wp_restore_post_revision($revision_id); 
    1803  
    1804                 else : 
    1805  
    1806                     // If we do not activate this revision, then the 
    1807                     // add_rss_meta will not be called, which is 
    1808                     // more or less as it should be, but that means 
    1809                     // we have to actively record this revision's 
    1810                     // update hash from here. 
    1811                     $postId = $this->post['ID']; 
    1812                     $key = 'syndication_item_hash'; 
    1813                     $hash = $this->update_hash(); 
    1814                     FeedWordPress::diagnostic('syndicated_posts:meta_data', "Adding post meta-datum to post [$postId]: [$key] = ".FeedWordPress::val($hash, /*no newlines=*/ true)); 
    1815                     add_post_meta(  $postId, $key, $hash, /*unique=*/ false ); 
     1698                    if ($this->this_revision_is_current()) : 
     1699 
     1700                        wp_restore_post_revision($revision_id); 
     1701 
     1702                    else : 
     1703 
     1704                        // If we do not activate this revision, then the 
     1705                        // add_rss_meta will not be called, which is 
     1706                        // more or less as it should be, but that means 
     1707                        // we have to actively record this revision's 
     1708                        // update hash from here. 
     1709                        $postId = $this->post['ID']; 
     1710                        $key = 'syndication_item_hash'; 
     1711                        $hash = $this->update_hash(); 
     1712                        FeedWordPress::diagnostic('syndicated_posts:meta_data', "Adding post meta-datum to post [$postId]: [$key] = ".FeedWordPress::val($hash, /*no newlines=*/ true)); 
     1713                        add_post_meta(  $postId, $key, $hash, /*unique=*/ false ); 
     1714                    endif; 
    18161715                endif; 
    18171716            endif; 
     
    18381737 
    18391738            $this->validate_post_id($dbpost, $update, array(__CLASS__, __FUNCTION__)); 
    1840         endif; 
     1739             
     1740            $ret = $this->_wp_id; 
     1741        endif; 
     1742        return $ret; 
    18411743    } /* function SyndicatedPost::insert_post () */ 
    18421744 
     
    18851787    } 
    18861788 
     1789    public function db_sanitize_post_check_encoding ($out) { 
     1790        // Check encoding recursively: every string field needs to be checked 
     1791        // for character encoding issues. This is a bit problematic because we 
     1792        // *should* be using DB_CHARSET, but DB_CHARSET sometimes has values 
     1793        // that work for MySQL but not for PHP mb_check_encoding. So instead 
     1794        // we must rely on WordPress setting blog_charset and hope that the user 
     1795        // has got their database encoding set up to roughly match 
     1796        $charset = get_option('blog_charset', 'utf8'); 
     1797         
     1798        foreach ($out as $key => $value) : 
     1799            if (is_string($value)) : 
     1800                 
     1801                if (!function_exists('mb_check_encoding') or mb_check_encoding($value, $charset)) : 
     1802                    $out[$key] = $value; 
     1803                else : 
     1804                    $fromCharset = mb_detect_encoding($value, mb_detect_order(), /*strict=*/ true); 
     1805                    $out[$key] = mb_convert_encoding($value, $charset, $fromCharset); 
     1806                endif; 
     1807                 
     1808            elseif (is_array($value)) : 
     1809                $out[$key] = $this->db_sanitize_post_check_encoding($value); 
     1810 
     1811            else : 
     1812                $out[$key] = $value; 
     1813            endif; 
     1814             
     1815        endforeach; 
     1816         
     1817        return $out; 
     1818    } /* SyndicatedPost::db_sanitize_post_check_encoding () */ 
     1819     
    18871820    function db_sanitize_post ($out) { 
    1888         // < 3.6. Core API, including wp_insert_post(), will expect 
    1889         // properly slashed data. If wp_slash() exists, then this is 
    1890         // after the big change-over, and wp_insert_post() etc. will 
    1891         // expect *un*-slashed data. 
     1821        global $wp_db_version; 
     1822         
     1823        $out = $this->db_sanitize_post_check_encoding($out); 
     1824                 
     1825        // < 3.6. Core API, including `wp_insert_post()`, expects 
     1826        // properly slashed data. If `wp_slash()` exists, then 
     1827        // this is after the big change-over in how data slashing 
     1828        // was handled. 
    18921829        if (!function_exists('wp_slash')) : 
    18931830         
     
    18991836                endif; 
    19001837            endforeach; 
    1901  
     1838             
     1839        // For revisions [@23416,@23554), core API expects 
     1840        // unslashed data. Cf. <https://core.trac.wordpress.org/browser/trunk/wp-includes/post.php?rev=23416> 
     1841        //  NOOP for those revisions. 
     1842         
     1843        // In revisions @23554 to present, `wp_insert_post()` 
     1844        // expects slashed data once again. 
     1845        // Cf. <https://core.trac.wordpress.org/changeset/23554/trunk/wp-includes/post.php?contextall=1> 
     1846        // But at least now we can use the wp_slash API function to do that. 
     1847        // Hooray. 
     1848         
     1849        elseif ($wp_db_version >= 23524) : 
     1850         
     1851            $out = wp_slash($out); 
     1852             
    19021853        endif; 
    19031854 
     
    23392290 
    23402291} /* class SyndicatedPost */ 
    2341  
  • feedwordpress/trunk/syndicatedpostterm.class.php

    r960798 r1413324  
    5959     
    6060    protected function search () { 
     61         
     62        // Initialize 
     63        $found = null; 
    6164         
    6265        // Either this is a numbered term code, which supplies the ID 
     
    9194              .json_encode($this->term) 
    9295              .' across '.json_encode($this->tax) 
    93               . ' with result: '.json_encode($record)  
     96              . ' with result: '.json_encode($found)  
    9497        ); 
    9598         
Note: See TracChangeset for help on using the changeset viewer.