Make WordPress Core

Ticket #6269: rss-importer-rewrite.diff

File rss-importer-rewrite.diff, 19.7 KB (added by solarissmoke, 14 years ago)
  • uninstall.php

     
     1<?php
     2if( ! defined('ABSPATH') && ! defined( 'WP_UNINSTALL_PLUGIN' ) )
     3        exit;
     4delete_option('rss_importer');
     5?>
     6 No newline at end of file
  • parsers.php

     
     1<?php
     2/**
     3 * WordPress RSS file parser implementations
     4 *
     5 * @package WordPress
     6 * @subpackage Importer
     7 */
     8
     9/**
     10 * WordPress Importer class for managing parsing of RSS files.
     11 */
     12class RSS_Parser {
     13        function parse( $file ) {
     14                // Attempt to use simpleXML
     15                if ( extension_loaded( 'simplexml' ) ) {
     16                        $parser = new RSS_Parser_SimpleXML;
     17                        $result = $parser->parse( $file );
     18
     19                        // If SimpleXML succeeds or this is an invalid file then return the results
     20                        if ( ! is_wp_error( $result ) || 'SimpleXML_parse_error' != $result->get_error_code() )
     21                                return $result;
     22                }
     23                else {
     24                        $parser = new RSS_Parser_XML;
     25                        $result = $parser->parse( $file );
     26
     27                        // If XMLParser succeeds or this is an invalid file then return the results
     28                        if ( ! is_wp_error( $result ) || 'XML_parse_error' != $result->get_error_code() )
     29                                return $result;
     30                }
     31
     32                // We have a malformed XML file, so display the error and fallthrough to regex
     33                if ( isset( $result ) && defined( 'IMPORT_DEBUG' ) && IMPORT_DEBUG ) {
     34                        echo '<pre>';
     35                        if ( 'SimpleXML_parse_error' == $result->get_error_code() ) {
     36                                foreach  ( $result->get_error_data() as $error )
     37                                        echo $error->line . ':' . $error->column . ' ' . esc_html( $error->message ) . "\n";
     38                        } else if ( 'XML_parse_error' == $result->get_error_code() ) {
     39                                $error = $result->get_error_data();
     40                                echo $error[0] . ':' . $error[1] . ' ' . esc_html( $error[2] );
     41                        }
     42                        echo '</pre>';
     43                        echo '<p><strong>' . __( 'There was an error when reading this RSS file', 'rss-importer' ) . '</strong><br />';
     44                }
     45        }
     46}
     47
     48/**
     49 * RSS Parser that makes use of the SimpleXML PHP extension.
     50 */
     51class RSS_Parser_SimpleXML {
     52        function parse( $file ) {
     53                libxml_use_internal_errors( true );
     54               
     55                $posts = array();
     56
     57                $xml = simplexml_load_file( $file );
     58                // halt if loading produces an error
     59                if ( ! $xml )
     60                        return new WP_Error( 'SimpleXML_parse_error', __( 'There was an error when reading this RSS file.', 'rss-importer' ), libxml_get_errors() );
     61
     62                $attributes = $xml->attributes();
     63                error_log( var_export( $attributes, true ) );
     64                if ( ! isset( $attributes['version'] ) || strval( $attributes['version'] ) != '2.0' )
     65                        return new WP_Error( 'RSS_parse_error', __( 'This does not appear to be a RSS 2.0 file, missing/invalid RSS version number.', 'rss-importer' ) );
     66
     67                // grab posts
     68                foreach ( $xml->channel->item as $item ) {
     69                        $post = array();
     70                        $dc = $item->children( 'http://purl.org/dc/elements/1.1/' );
     71                        $content = $item->children( 'http://purl.org/rss/1.0/modules/content/' );
     72                       
     73                        $post['post_title'] = (string) $item->title;
     74                        if( isset( $item->guid ) )
     75                                $post['guid'] =  (string) $item->guid;
     76                       
     77                        $published = false;
     78                        // attempt to find publication date
     79                        if ( isset( $item->pubDate ) )
     80                                $published = strtotime( (string) $item->pubDate );
     81                        else if ( $dc->date ) {
     82                                // if we don't already have something from pubDate
     83                                $published = preg_replace( '|([-+])([0-9]+):([0-9]+)$|', '\1\2\3', (string) $dc->date );
     84                                $published = str_replace( 'T', ' ', $published );
     85                                $published = strtotime( $published );
     86                        }
     87                       
     88                        if( $published ) {
     89                                $post['post_date_gmt'] = gmdate( 'Y-m-d H:i:s', $published );
     90                                $post['post_date'] = get_date_from_gmt( $post['post_date_gmt'] );
     91                        }
     92                       
     93                        $categories = array();
     94                        foreach ( $item->category as $c )
     95                                $categories[] = html_entity_decode( (string) $c );
     96                        foreach( $dc->subject as $c )
     97                                $categories[] = html_entity_decode( (string) $c );      // CHECK
     98                               
     99                        // need to handle these categories
     100                        $post['categories'] = $categories;      // need to check this
     101                       
     102                        // if no content, use the description
     103                        $post['post_content'] = isset( $content->encoded ) ? (string) $content->encoded : (string) $item->description;
     104                        $post['post_excerpt'] = isset( $content->encoded ) ? (string) $item->description : '';
     105                       
     106                        if( isset( $dc->creator ) )
     107                                $post['imported_author_name'] = (string) $dc->creator;  // for later
     108
     109                        $posts[] = $post;
     110                }
     111
     112                return $posts;
     113        }
     114}
     115
     116/**
     117 * RSS Parser that makes use of the XML Parser PHP extension.
     118 */
     119class RSS_Parser_XML {
     120        function parse( $file ) {
     121                $this->cdata = false;
     122                $this->posts = array();
     123                $this->post = array();
     124                $this->post['categories'] = array();
     125                $this->in_item = false;
     126                $this->rss_version = false;
     127
     128                $xml = xml_parser_create( 'UTF-8' );
     129                xml_parser_set_option( $xml, XML_OPTION_SKIP_WHITE, 1 );
     130                xml_parser_set_option( $xml, XML_OPTION_CASE_FOLDING, 0 );
     131                xml_set_object( $xml, $this );
     132                xml_set_character_data_handler( $xml, 'cdata' );
     133                xml_set_element_handler( $xml, 'tag_open', 'tag_close' );
     134
     135                if ( ! xml_parse( $xml, file_get_contents( $file ), true ) ) {
     136                        $current_line = xml_get_current_line_number( $xml );
     137                        $current_column = xml_get_current_column_number( $xml );
     138                        $error_code = xml_get_error_code( $xml );
     139                        $error_string = xml_error_string( $error_code );
     140                        return new WP_Error( 'XML_parse_error', __( 'There was an error when reading this RSS file.', 'rss-importer' ), array( $current_line, $current_column, $error_string ) );
     141                }
     142                xml_parser_free( $xml );
     143               
     144                if( '2.0' != $this->rss_version )
     145                        return new WP_Error( 'RSS_parse_error', __( 'This does not appear to be a RSS 2.0 file, missing/invalid RSS version number.', 'rss-importer' ) );
     146
     147                return $this->posts;
     148        }
     149
     150        function tag_open( $parse, $tag, $attr ) {
     151                if( 'rss' == $tag )
     152                        $this->rss_version = isset( $attr['version'] ) ? $attr['version'] : false;
     153                if( 'item' == $tag )
     154                        $this->in_item = true;
     155        }
     156
     157        function cdata( $parser, $cdata ) {
     158                if ( ! trim( $cdata ) )
     159                        return;
     160
     161                $this->cdata .= trim( $cdata );
     162        }
     163
     164        function tag_close( $parser, $tag ) {
     165                if( ! $this->in_item ) {
     166                        $this->cdata = false;
     167                        return;
     168                }
     169               
     170                switch ( $tag ) {
     171                        case 'title':
     172                                $this->post['post_title'] = $this->cdata;
     173                                break;
     174                        case 'guid':
     175                                $this->post['guid'] = $this->cdata;
     176                                break;
     177                        case 'pubDate':
     178                        case 'dc:date':
     179                                if( isset( $this->post['post_date'] ) )
     180                                        break;
     181                                if( 'pubDate' == $tag ) {
     182                                        $published = strtotime( $this->cdata );
     183                                }
     184                                else {
     185                                        // if we don't already have something from pubDate
     186                                        $published = preg_replace( '|([-+])([0-9]+):([0-9]+)$|', '\1\2\3', $this->cdata );
     187                                        $published = str_replace( 'T', ' ', $published );
     188                                        $published = strtotime( $published );
     189                                }
     190                                $this->post['post_date_gmt'] = gmdate( 'Y-m-d H:i:s', $published );
     191                                $this->post['post_date'] = get_date_from_gmt( $this->post['post_date_gmt'] );
     192                                break;
     193                        case 'category':
     194                                $this->post['categories'][] = $this->cdata;
     195                                break;
     196                        case 'content:encoded':
     197                                $this->post['post_content'] = $this->cdata;
     198                                break;
     199                        case 'description':
     200                                $this->post['post_excerpt'] = $this->cdata;
     201                                break;
     202                        case 'dc:creator':
     203                                $this->post['imported_author_name'] = $this->cdata;
     204                                break;
     205                        case 'item':
     206                                // tidy up
     207                                if( empty( $this->post['post_content'] ) && ! empty( $this->post['post_excerpt'] ) ) {
     208                                        $this->post['post_content'] = $this->post['post_excerpt'];
     209                                        unset( $this->post['post_excerpt'] );
     210                                }
     211
     212                                $this->posts[] = $this->post;
     213                               
     214                                // reset
     215                                $this->post = array();
     216                                $this->post['categories'] = array();
     217                                $this->in_item = false;
     218                               
     219                                break;
     220                }
     221
     222                $this->cdata = false;
     223        }
     224}
     225 No newline at end of file
  • rss-importer.php

     
    55Description: Import posts from an RSS feed.
    66Author: wordpressdotorg
    77Author URI: http://wordpress.org/
    8 Version: 0.2
     8Version: 0.3b
    99Stable tag: 0.2
    1010License: GPL version 2 or later - http://www.gnu.org/licenses/old-licenses/gpl-2.0.html
    1111*/
    1212
    13 if ( !defined('WP_LOAD_IMPORTERS') )
     13if ( ! defined( 'WP_LOAD_IMPORTERS' ) )
    1414        return;
    1515
     16// use for debug
     17define( 'IMPORT_DEBUG', false );
     18
    1619// Load Importer API
    1720require_once ABSPATH . 'wp-admin/includes/import.php';
    1821
    19 if ( !class_exists( 'WP_Importer' ) ) {
     22if ( ! class_exists( 'WP_Importer' ) ) {
    2023        $class_wp_importer = ABSPATH . 'wp-admin/includes/class-wp-importer.php';
    2124        if ( file_exists( $class_wp_importer ) )
    22                 require_once $class_wp_importer;
     25                require $class_wp_importer;
    2326}
    2427
     28require dirname( __FILE__ ) . '/parsers.php';
     29
    2530/**
    2631 * RSS Importer
    2732 *
     
    3843 *
    3944 * @since unknown
    4045 */
    41 if ( class_exists( 'WP_Importer' ) ) {
     46if ( class_exists( 'WP_Importer' ) ) :
    4247class RSS_Import extends WP_Importer {
    43 
     48        var $id; // WXR attachment ID
    4449        var $posts = array ();
    4550        var $file;
    46 
    47         function header() {
    48                 echo '<div class="wrap">';
    49                 screen_icon();
    50                 echo '<h2>'.__('Import RSS', 'rss-importer').'</h2>';
    51         }
    52 
    53         function footer() {
    54                 echo '</div>';
    55         }
    56 
     51       
    5752        function greet() {
    5853                echo '<div class="narrow">';
    59                 echo '<p>'.__('Howdy! This importer allows you to extract posts from an RSS 2.0 file into your WordPress site. This is useful if you want to import your posts from a system that is not handled by a custom import tool. Pick an RSS file to upload and click Import.', 'rss-importer').'</p>';
    60                 wp_import_upload_form("admin.php?import=rss&amp;step=1");
     54                echo '<p>' . __( 'Howdy! This importer allows you to extract posts from an RSS 2.0 file into your WordPress site. This is useful if you want to import your posts from a system that is not handled by a custom import tool. Pick an RSS file to upload and click Import.', 'rss-importer' ) . '</p>';
     55                wp_import_upload_form( 'admin.php?import=rss&amp;step=1' );
    6156                echo '</div>';
    6257        }
    6358
    64         function _normalize_tag( $matches ) {
    65                 return '<' . strtolower( $matches[1] );
    66         }
    67 
    68         function get_posts() {
    69                 global $wpdb;
    70 
    71                 set_magic_quotes_runtime(0);
    72                 $datalines = file($this->file); // Read the file into an array
    73                 $importdata = implode('', $datalines); // squish it
    74                 $importdata = str_replace(array ("\r\n", "\r"), "\n", $importdata);
    75 
    76                 preg_match_all('|<item>(.*?)</item>|is', $importdata, $this->posts);
    77                 $this->posts = $this->posts[1];
    78                 $index = 0;
    79                 foreach ($this->posts as $post) {
    80                         preg_match('|<title>(.*?)</title>|is', $post, $post_title);
    81                         $post_title = str_replace(array('<![CDATA[', ']]>'), '', $wpdb->escape( trim($post_title[1]) ));
    82 
    83                         preg_match('|<pubdate>(.*?)</pubdate>|is', $post, $post_date_gmt);
    84 
    85                         if ($post_date_gmt) {
    86                                 $post_date_gmt = strtotime($post_date_gmt[1]);
    87                         } else {
    88                                 // if we don't already have something from pubDate
    89                                 preg_match('|<dc:date>(.*?)</dc:date>|is', $post, $post_date_gmt);
    90                                 $post_date_gmt = preg_replace('|([-+])([0-9]+):([0-9]+)$|', '\1\2\3', $post_date_gmt[1]);
    91                                 $post_date_gmt = str_replace('T', ' ', $post_date_gmt);
    92                                 $post_date_gmt = strtotime($post_date_gmt);
    93                         }
    94 
    95                         $post_date_gmt = gmdate('Y-m-d H:i:s', $post_date_gmt);
    96                         $post_date = get_date_from_gmt( $post_date_gmt );
    97 
    98                         preg_match_all('|<category>(.*?)</category>|is', $post, $categories);
    99                         $categories = $categories[1];
    100 
    101                         if (!$categories) {
    102                                 preg_match_all('|<dc:subject>(.*?)</dc:subject>|is', $post, $categories);
    103                                 $categories = $categories[1];
    104                         }
    105 
    106                         $cat_index = 0;
    107                         foreach ($categories as $category) {
    108                                 $categories[$cat_index] = $wpdb->escape( html_entity_decode( $category ) );
    109                                 $cat_index++;
    110                         }
    111 
    112                         preg_match('|<guid.*?>(.*?)</guid>|is', $post, $guid);
    113                         if ($guid)
    114                                 $guid = $wpdb->escape(trim($guid[1]));
    115                         else
    116                                 $guid = '';
    117 
    118                         preg_match('|<content:encoded>(.*?)</content:encoded>|is', $post, $post_content);
    119                         $post_content = str_replace(array ('<![CDATA[', ']]>'), '', $wpdb->escape(trim($post_content[1])));
    120 
    121                         if (!$post_content) {
    122                                 // This is for feeds that put content in description
    123                                 preg_match('|<description>(.*?)</description>|is', $post, $post_content);
    124                                 $post_content = $wpdb->escape( html_entity_decode( trim( $post_content[1] ) ) );
    125                         }
    126 
    127                         // Clean up content
    128                         $post_content = preg_replace_callback('|<(/?[A-Z]+)|', array( &$this, '_normalize_tag' ), $post_content);
    129                         $post_content = str_replace('<br>', '<br />', $post_content);
    130                         $post_content = str_replace('<hr>', '<hr />', $post_content);
    131 
    132                         $post_author = 1;
    133                         $post_status = 'publish';
    134                         $this->posts[$index] = compact('post_author', 'post_date', 'post_date_gmt', 'post_content', 'post_title', 'post_status', 'guid', 'categories');
    135                         $index++;
    136                 }
    137         }
    138 
    139         function import_posts() {
     59        function import_posts( $posts ) {
     60                $authors = array();     // author name => array (post_ids)
     61               
    14062                echo '<ol>';
     63                foreach ( $posts as $post ) {
     64                        echo '<li>' . __( 'Importing post...', 'rss-importer' );
    14165
    142                 foreach ($this->posts as $post) {
    143                         echo "<li>".__('Importing post...', 'rss-importer');
    144 
    145                         extract($post);
    146 
    147                         if ($post_id = post_exists($post_title, $post_content, $post_date)) {
    148                                 _e('Post already imported', 'rss-importer');
     66                        $post['post_author'] = get_current_user_id();
     67                        $post['post_status'] = 'publish';
     68                       
     69                        if ( $post_id = post_exists( $post['post_title'], $post['post_content'], $post['post_date'] ) ) {
     70                                _e( 'Post already imported.', 'rss-importer' );
    14971                        } else {
    150                                 $post_id = wp_insert_post($post);
     72                                $post_id = wp_insert_post( $post );
     73                               
    15174                                if ( is_wp_error( $post_id ) )
    15275                                        return $post_id;
    153                                 if (!$post_id) {
    154                                         _e('Couldn&#8217;t get post ID', 'rss-importer');
     76                               
     77                                if ( ! $post_id ) {
     78                                        _e( 'Couldn&#8217;t get post ID', 'rss-importer' );
    15579                                        return;
    15680                                }
    15781
    158                                 if (0 != count($categories))
    159                                         wp_create_categories($categories, $post_id);
     82                                if ( ! empty( $post['categories'] ) )
     83                                        wp_create_categories( $post['categories'], $post_id );
     84                               
    16085                                _e('Done!', 'rss-importer');
    16186                        }
     87                       
     88                        if ( isset( $post['imported_author_name'] ) ) {
     89                                $n = $post['imported_author_name'];
     90                                if ( isset( $authors[$n] ) )
     91                                        $authors[$n][] = (int) $post_id;
     92                                else
     93                                        $authors[$n] = array( (int) $post_id );
     94                        }
     95                       
    16296                        echo '</li>';
    16397                }
    16498
    16599                echo '</ol>';
    166 
     100               
     101                if( ! empty( $authors ) )
     102                        update_option( 'rss_importer', $authors );
    167103        }
    168104
    169         function import() {
     105        /**
     106         * Handles the WXR upload and initial parsing of the file to prepare for
     107         * displaying author import options
     108         *
     109         * @return bool False if error uploading or invalid file, true otherwise
     110         */
     111        function handle_upload() {
     112                check_admin_referer( 'import-upload' );
    170113                $file = wp_import_handle_upload();
    171                 if ( isset($file['error']) ) {
    172                         echo $file['error'];
    173                         return;
     114               
     115                if ( isset( $file['error'] ) ) {
     116                        echo '<p><strong>' . __( 'Sorry, there has been an error.', 'rss-importer' ) . '</strong><br />';
     117                        echo esc_html( $file['error'] ) . '</p>';
     118                        return false;
    174119                }
    175120
    176                 $this->file = $file['file'];
    177                 $this->get_posts();
    178                 $result = $this->import_posts();
     121                $parser = new RSS_Parser();
     122                $posts = $parser->parse( $file['file'] );
     123               
     124                if ( is_wp_error( $posts ) ) {
     125                        echo '<p><strong>' . __( 'Sorry, there has been an error.', 'wordpress-importer' ) . '</strong><br />' . esc_html( $posts->get_error_message() ) . '</p>';
     126                        return false;
     127                }
     128               
     129                $result = $this->import_posts( $posts );
    179130                if ( is_wp_error( $result ) )
    180131                        return $result;
    181                 wp_import_cleanup($file['id']);
    182                 do_action('import_done', 'rss');
     132               
     133                wp_import_cleanup( $file['id'] );
     134                do_action( 'import_done', 'rss' );
    183135
    184                 echo '<h3>';
    185                 printf(__('All done. <a href="%s">Have fun!</a>', 'rss-importer'), get_option('home'));
    186                 echo '</h3>';
     136                echo '<p>' . __('Import complete.', 'rss-importer') . '</p>';
     137               
     138                $this->get_author_form();
    187139        }
    188140
     141        /**
     142         * Registered callback function for the WordPress Importer
     143         *
     144         * Manages the three separate stages of the import process
     145         */
    189146        function dispatch() {
    190                 if (empty ($_GET['step']))
    191                         $step = 0;
    192                 else
    193                         $step = (int) $_GET['step'];
     147                echo '<div class="wrap">';
     148                screen_icon();
     149                echo '<h2>'.__('Import RSS', 'rss-importer').'</h2>';
    194150
    195                 $this->header();
    196 
    197                 switch ($step) {
    198                         case 0 :
     151                $step = empty( $_GET['step'] ) ? 0 : (int) $_GET['step'];
     152                switch ( $step ) {
     153                        case 0:
    199154                                $this->greet();
    200155                                break;
    201                         case 1 :
    202                                 check_admin_referer('import-upload');
    203                                 $result = $this->import();
    204                                 if ( is_wp_error( $result ) )
    205                                         echo $result->get_error_message();
     156                        case 1:
     157                               
     158                                $this->handle_upload();
    206159                                break;
     160                        case 2:
     161                                $this->update_authors();
     162                                break;
    207163                }
    208164
    209                 $this->footer();
     165                echo '</div>';
    210166        }
    211167
    212         function RSS_Import() {
    213                 // Nothing.
     168        /*
     169         * Allows the user to assign authors to posts after import
     170         */
     171        function get_author_form() {
     172                $authors = get_option( 'rss_importer', array() );
     173                if( empty( $authors ) )
     174                        return;
     175
     176                $directions = __( 'All posts were imported with the current user as author. Wordpress detected the following author names in the imported posts. Use this form to assign each imported post to a different WordPress user.', 'rss-importer' );
     177                $heading = __( 'Author mapping', 'rss-importer' );
     178                $mapthis = __( 'Map this name', 'rss-importer' );
     179                $tothis = __( 'To this Wordpress user', 'rss-importer' );
     180                $submit = esc_html( __( 'Save Changes', 'rss-importer' ) );
     181               
     182                $rows= '';
     183                $options = '';
     184
     185                $blog_users = get_users( array( 'blog_id' => get_current_blog_id() ) ) ;
     186                foreach ( $blog_users as $user ) {
     187                        $sel = selected( $user->ID, get_current_user_id(), false );
     188                        $options .= "<option value='$user->ID'$sel>$user->display_name</option>";
     189                }
     190               
     191                foreach ( array_keys( $authors ) as $author ) {
     192                        $a = esc_html( $author );
     193                        $rows .= "<tr><td><label for='author-$a'>$a</label></td><td><select name='authors[$a]' id='author-$a'>" . $options . "</select></td></tr>";
     194                }
     195               
     196                echo '<style type="text/css">#rss_import_authors th, #rss_import_authors td {padding: 3px 10px} </style>';
     197                echo "<div class='wrap'><h2>$heading</h2><p>$directions</p><form action='index.php?import=rss&amp;step=2' method='post'>";
     198                wp_nonce_field( 'import-rss' );
     199                echo "<table id='rss_import_authors'><thead><th>$mapthis</th><th>$tothis</th></thead><tbody>$rows</tbody></table><input type='submit' class='button primary' value='$submit' /></form></div>";
    214200        }
     201       
     202        function update_authors() {
     203                check_admin_referer( 'import-rss' );
     204                global $wpdb;
     205               
     206                $authors = get_option( 'rss_importer', array() );
     207                if( empty( $_POST['authors'] ) || empty( $authors ) )
     208                        return;
     209               
     210                foreach( $_POST['authors'] as $imported_name => $user_id_to_assign ) {
     211                        $post_ids = implode( ', ', $authors[$imported_name] );
     212                        $result = $wpdb->query( $wpdb->prepare("UPDATE $wpdb->posts SET post_author = %d WHERE ID IN ($post_ids)", $user_id_to_assign ) );
     213                }
     214               
     215                if ( false !== $result )
     216                        echo '<p>' . sprintf( __( 'Post authors updated. All done!' ) . ' <a href="' . trailingslashit( get_bloginfo( 'url' ) ) . '">%s</a>', __( 'Have fun!' ) ) . '</p>';
     217                else
     218                        echo '<p>' . __( 'An error occurred while trying to reassing post authors. Please try doing it manually.') . '</p>';
     219        }
    215220}
    216221
    217222$rss_import = new RSS_Import();
    218223
    219 register_importer('rss', __('RSS', 'rss-importer'), __('Import posts from an RSS feed.', 'rss-importer'), array ($rss_import, 'dispatch'));
     224register_importer( 'rss', __( 'RSS', 'rss-importer' ), __( 'Import posts from an RSS feed.', 'rss-importer' ), array ( $rss_import, 'dispatch' ) );
    220225
    221 } // class_exists( 'WP_Importer' )
     226endif; // class_exists( 'WP_Importer' )
    222227
    223228function rss_importer_init() {
    224229    load_plugin_textdomain( 'rss-importer', false, dirname( plugin_basename( __FILE__ ) ) . '/languages' );