WordPress.org

Make WordPress Core

Ticket #7652: 7652-blogger.diff

File 7652-blogger.diff, 18.3 KB (added by rmccue, 8 years ago)

Blogger Importer conversion

  • blogger-importer.php

     
    1515
    1616// Load Importer API
    1717require_once ABSPATH . 'wp-admin/includes/import.php';
     18require_once ABSPATH . 'wp-includes/class-feed.php';
    1819
    1920if ( !class_exists( 'WP_Importer' ) ) {
    2021        $class_wp_importer = ABSPATH . 'wp-admin/includes/class-wp-importer.php';
     
    152153                        if ( ! $sock ) return;
    153154                        $response = $this->_txrx( $sock, $request );
    154155
    155                         // Quick and dirty XML mining.
    156156                        list( $headers, $xml ) = explode( "\r\n\r\n", $response );
    157                         $p = xml_parser_create();
    158                         xml_parse_into_struct($p, $xml, $vals, $index);
    159                         xml_parser_free($p);
     157                        $feed = new SimplePie();
     158                        $feed->set_raw_data($xml);
     159                        $feed->init();
    160160
    161                         $this->title = $vals[$index['TITLE'][0]]['value'];
     161                        $this->title = $feed->get_title();
    162162
    163163                        // Give it a few retries... this step often flakes out the first time.
    164                         if ( empty( $index['ENTRY'] ) ) {
     164                        if ( $feed->error() ) {
    165165                                if ( $iter < 3 ) {
    166166                                        return $this->show_blogs($iter + 1);
    167167                                } else {
     
    174174                                }
    175175                        }
    176176
    177                         foreach ( $index['ENTRY'] as $i ) {
     177                        foreach ( $feed->get_items() as $item ) {
    178178                                $blog = array();
    179                                 while ( ( $tag = $vals[$i] ) && ! ( $tag['tag'] == 'ENTRY' && $tag['type'] == 'close' ) ) {
    180                                         if ( $tag['tag'] == 'TITLE' ) {
    181                                                 $blog['title'] = $tag['value'];
    182                                         } elseif ( $tag['tag'] == 'SUMMARY' ) {
    183                                                 $blog['summary'] = $tag['value'];
    184                                         } elseif ( $tag['tag'] == 'LINK' ) {
    185                                                 if ( $tag['attributes']['REL'] == 'alternate' && $tag['attributes']['TYPE'] == 'text/html' ) {
    186                                                         $parts = parse_url( $tag['attributes']['HREF'] );
     179                                $blog['title'] = $item->get_title();
     180                                $blog['summary'] = $item->get_description();
     181                                // Messy, but SimplePie doesn't let us get a link by "type"
     182                                foreach ((array) $item->get_item_tags(SIMPLEPIE_NAMESPACE_ATOM_10, 'link') as $link) {
     183                                        $attribs = $link['attribs'][''];
     184                                        if (isset($attribs['href'])) {
     185                                                if ( ( !isset($attribs['rel']) || $attribs['rel'] == 'alternate' ) && isset($attribs['type']) && $attribs['type'] == 'text/html' ) {
     186                                                        $parts = parse_url( $item->sanitize($attribs['href'], SIMPLEPIE_CONSTRUCT_IRI, $item->get_base($link)) );
    187187                                                        $blog['host'] = $parts['host'];
    188                                                 } elseif ( $tag['attributes']['REL'] == 'edit' )
    189                                                         $blog['gateway'] = $tag['attributes']['HREF'];
     188                                                } elseif ( $attribs['rel'] == 'edit' ) {
     189                                                        $blog['gateway'] = $item->sanitize($attribs['href'], SIMPLEPIE_CONSTRUCT_IRI, $item->get_base($link));
     190                                                }
    190191                                        }
    191                                         ++$i;
    192192                                }
    193193                                if ( ! empty ( $blog ) ) {
    194194                                        $blog['total_posts'] = $this->get_total_results('posts', $blog['host']);
     
    197197                                        $this->blogs[] = $blog;
    198198                                }
    199199                        }
     200                        unset($feed);
    200201
    201202                        if ( empty( $this->blogs ) ) {
    202203                                $this->uh_oh(
     
    382383                if ( ! $sock ) return;
    383384                $response = $this->_txrx( $sock, $request );
    384385                $response = $this->parse_response( $response );
    385                 $parser = xml_parser_create();
    386                 xml_parse_into_struct($parser, $response['body'], $struct, $index);
    387                 xml_parser_free($parser);
    388                 $total_results = $struct[$index['OPENSEARCH:TOTALRESULTS'][0]]['value'];
     386                $feed = new SimplePie();
     387                $feed->set_raw_data($response['body']);
     388                $feed->init();
     389                $results = $feed->get_channel_tags('http://a9.com/-/spec/opensearchrss/1.0/', 'totalResults');
     390                $total_results = $results[0]['data'];
     391                unset($feed);
    389392                return (int) $total_results;
    390393        }
    391394
     
    436439
    437440                                $response = $this->parse_response( $response );
    438441
     442                                $feed = new SimplePie();
     443                                $feed->set_item_class('WP_SimplePieAtomPub_Item');
     444                                $feed->set_raw_data($response['body']);
     445                                $feed->init();
     446
    439447                                // Extract the entries and send for insertion
    440                                 preg_match_all( '/<entry[^>]*>.*?<\/entry>/s', $response['body'], $matches );
    441                                 if ( count( $matches[0] ) ) {
    442                                         $entries = array_reverse($matches[0]);
    443                                         foreach ( $entries as $entry ) {
    444                                                 $entry = "<feed>$entry</feed>";
    445                                                 $AtomParser = new AtomParser();
    446                                                 $AtomParser->parse( $entry );
    447                                                 $result = $this->import_post($AtomParser->entry);
     448                                if ( $feed->get_item_quantity() > 0 ) {
     449                                        foreach ( $feed->get_items() as $item ) {
     450                                                $result = $this->import_post($item);
    448451                                                if ( is_wp_error( $result ) )
    449452                                                        return $result;
    450                                                 unset($AtomParser);
     453                                                unset($item);
    451454                                        }
    452455                                } else break;
    453456
    454457                                // Get the 'previous' query string which we'll use on the next iteration
    455                                 $query = '';
    456                                 $links = preg_match_all('/<link([^>]*)>/', $response['body'], $matches);
    457                                 if ( count( $matches[1] ) )
    458                                         foreach ( $matches[1] as $match )
    459                                                 if ( preg_match('/rel=.previous./', $match) )
    460                                                         $query = @html_entity_decode( preg_replace('/^.*href=[\'"].*\?(.+)[\'"].*$/', '$1', $match), ENT_COMPAT, get_option('blog_charset') );
     458                                $query = $feed->get_link(0, 'previous');
     459                                unset($feed);
    461460
    462461                                if ( $query ) {
    463462                                        parse_str($query, $q);
     
    496495
    497496                                $response = $this->parse_response( $response );
    498497
     498                                $feed = new SimplePie();
     499                                $feed->set_raw_data($response['body']);
     500                                $feed->init();
     501
    499502                                // Extract the comments and send for insertion
    500                                 preg_match_all( '/<entry[^>]*>.*?<\/entry>/s', $response['body'], $matches );
    501                                 if ( count( $matches[0] ) ) {
    502                                         $entries = array_reverse( $matches[0] );
    503                                         foreach ( $entries as $entry ) {
    504                                                 $entry = "<feed>$entry</feed>";
    505                                                 $AtomParser = new AtomParser();
    506                                                 $AtomParser->parse( $entry );
    507                                                 $this->import_comment($AtomParser->entry);
    508                                                 unset($AtomParser);
     503                                if ( $feed->get_item_quantity() < 1 ) {
     504                                        foreach ( $feed->get_items() as $item ) {
     505                                                $this->import_comment($item);
     506                                                unset($item);
    509507                                        }
    510508                                }
    511509
    512510                                // Get the 'previous' query string which we'll use on the next iteration
    513                                 $query = '';
    514                                 $links = preg_match_all('/<link([^>]*)>/', $response['body'], $matches);
    515                                 if ( count( $matches[1] ) )
    516                                         foreach ( $matches[1] as $match )
    517                                                 if ( preg_match('/rel=.previous./', $match) )
    518                                                         $query = @html_entity_decode( preg_replace('/^.*href=[\'"].*\?(.+)[\'"].*$/', '$1', $match), ENT_COMPAT, get_option('blog_charset') );
     511                                $query = $feed->get_link(0, 'previous');
     512                                unset($feed);
    519513
    520514                                parse_str($query, $q);
    521515
     
    531525                die('done');
    532526        }
    533527
    534         function convert_date( $date ) {
    535             preg_match('#([0-9]{4})-([0-9]{2})-([0-9]{2})T([0-9]{2}):([0-9]{2}):([0-9]{2})(?:\.[0-9]+)?(Z|[\+|\-][0-9]{2,4}){0,1}#', $date, $date_bits);
    536             $offset = iso8601_timezone_to_offset( $date_bits[7] );
    537                 $timestamp = gmmktime($date_bits[4], $date_bits[5], $date_bits[6], $date_bits[2], $date_bits[3], $date_bits[1]);
    538                 $timestamp -= $offset; // Convert from Blogger local time to GMT
    539                 $timestamp += get_option('gmt_offset') * 3600; // Convert from GMT to WP local time
    540                 return gmdate('Y-m-d H:i:s', $timestamp);
     528        function convert_category( $category ) {
     529                $cat = $category->get_label();
     530                return addslashes($cat);
    541531        }
    542532
    543         function no_apos( $string ) {
    544                 return str_replace( '&apos;', "'", $string);
    545         }
    546 
    547         function min_whitespace( $string ) {
    548                 return preg_replace( '|\s+|', ' ', $string );
    549         }
    550 
    551         function _normalize_tag( $matches ) {
    552                 return '<' . strtolower( $matches[1] );
    553         }
    554 
    555         function import_post( $entry ) {
     533        function import_post( &$entry ) {
    556534                global $importing_blog;
    557535
    558536                // The old permalink is all Blogger gives us to link comments to their posts.
    559                 if ( isset( $entry->draft ) )
     537                if ( $entry->get_draft_status() )
    560538                        $rel = 'self';
    561539                else
    562540                        $rel = 'alternate';
    563                 foreach ( $entry->links as $link ) {
    564                         if ( $link['rel'] == $rel ) {
    565                                 $parts = parse_url( $link['href'] );
    566                                 $entry->old_permalink = $parts['path'];
    567                                 break;
    568                         }
    569                 }
     541                $parts = parse_url( $entry->get_link(0, $rel) );
     542                $old_permalink = $parts['path'];
    570543
    571                 $post_date    = $this->convert_date( $entry->published );
    572                 $post_content = trim( addslashes( $this->no_apos( @html_entity_decode( $entry->content, ENT_COMPAT, get_option('blog_charset') ) ) ) );
    573                 $post_title   = trim( addslashes( $this->no_apos( $this->min_whitespace( $entry->title ) ) ) );
    574                 $post_status  = isset( $entry->draft ) ? 'draft' : 'publish';
     544                $post_date    = gmdate('Y-m-d H:i:s', $entry->get_gmdate('U') + get_option('gmt_offset') * 3600);
     545                $post_content = addslashes( $entry->get_content() );
     546                $post_title   = addslashes( $entry->get_title() );
     547                $post_status  = $entry->get_draft_status() ? 'draft' : 'publish';
    575548
    576                 // Clean up content
    577                 $post_content = preg_replace_callback('|<(/?[A-Z]+)|', array( &$this, '_normalize_tag' ), $post_content);
    578                 $post_content = str_replace('<br>', '<br />', $post_content);
    579                 $post_content = str_replace('<hr>', '<hr />', $post_content);
    580 
    581549                // Checks for duplicates
    582                 if ( isset( $this->blogs[$importing_blog]['posts'][$entry->old_permalink] ) ) {
     550                if ( isset( $this->blogs[$importing_blog]['posts'][$old_permalink] ) ) {
    583551                        ++$this->blogs[$importing_blog]['posts_skipped'];
    584552                } elseif ( $post_id = post_exists( $post_title, $post_content, $post_date ) ) {
    585                         $this->blogs[$importing_blog]['posts'][$entry->old_permalink] = $post_id;
     553                        $this->blogs[$importing_blog]['posts'][$old_permalink] = $post_id;
    586554                        ++$this->blogs[$importing_blog]['posts_skipped'];
    587555                } else {
    588556                        $post = compact('post_date', 'post_content', 'post_title', 'post_status');
     
    591559                        if ( is_wp_error( $post_id ) )
    592560                                return $post_id;
    593561
    594                         wp_create_categories( array_map( 'addslashes', $entry->categories ), $post_id );
     562                        wp_create_categories( array_map( array(&$this, 'convert_category'), (array) $entry->get_categories() ), $post_id );
    595563
    596                         $author = $this->no_apos( strip_tags( $entry->author ) );
     564                        $author = $entry->get_author();
    597565
    598566                        add_post_meta( $post_id, 'blogger_blog', $this->blogs[$importing_blog]['host'], true );
    599                         add_post_meta( $post_id, 'blogger_author', $author, true );
    600                         add_post_meta( $post_id, 'blogger_permalink', $entry->old_permalink, true );
     567                        add_post_meta( $post_id, 'blogger_author', $author->get_name(), true );
     568                        add_post_meta( $post_id, 'blogger_authoruri', $author->get_link(), true );
     569                        add_post_meta( $post_id, 'blogger_permalink', $old_permalink, true );
    601570
    602                         $this->blogs[$importing_blog]['posts'][$entry->old_permalink] = $post_id;
     571                        $this->blogs[$importing_blog]['posts'][$old_permalink] = $post_id;
    603572                        ++$this->blogs[$importing_blog]['posts_done'];
    604573                }
    605574                $this->save_vars();
    606575                return;
    607576        }
    608577
    609         function import_comment( $entry ) {
     578        function import_comment( &$entry ) {
    610579                global $importing_blog;
    611580
    612581                // Drop the #fragment and we have the comment's old post permalink.
    613                 foreach ( $entry->links as $link ) {
    614                         if ( $link['rel'] == 'alternate' ) {
    615                                 $parts = parse_url( $link['href'] );
    616                                 $entry->old_permalink = $parts['fragment'];
    617                                 $entry->old_post_permalink = $parts['path'];
    618                                 break;
    619                         }
    620                 }
     582                $parts = parse_url( $entry->get_link(0, 'alternate') );
     583                $old_permalink = $parts['fragment'];
     584                $old_post_permalink = $parts['path'];
    621585
    622                 $comment_post_ID = (int) $this->blogs[$importing_blog]['posts'][$entry->old_post_permalink];
    623                 preg_match('#<name>(.+?)</name>.*(?:\<uri>(.+?)</uri>)?#', $entry->author, $matches);
    624                 $comment_author  = addslashes( $this->no_apos( strip_tags( (string) $matches[1] ) ) );
    625                 $comment_author_url = addslashes( $this->no_apos( strip_tags( (string) $matches[2] ) ) );
    626                 $comment_date    = $this->convert_date( $entry->updated );
    627                 $comment_content = addslashes( $this->no_apos( @html_entity_decode( $entry->content, ENT_COMPAT, get_option('blog_charset') ) ) );
     586                $comment_post_ID = (int) $this->blogs[$importing_blog]['posts'][$old_post_permalink];
     587                $author = $entry->get_author();
     588                $comment_author  = addslashes( $author->get_name() );
     589                $comment_author_url = addslashes( $author->get_uri() );
     590                $comment_date    = gmdate('Y-m-d H:i:s', $entry->get_gmupdated('U') + get_option('gmt_offset') * 3600);
     591                $comment_content = addslashes( $entry->get_content() );
    628592
    629                 // Clean up content
    630                 $comment_content = preg_replace_callback('|<(/?[A-Z]+)|', array( &$this, '_normalize_tag' ), $comment_content);
    631                 $comment_content = str_replace('<br>', '<br />', $comment_content);
    632                 $comment_content = str_replace('<hr>', '<hr />', $comment_content);
    633 
    634593                // Checks for duplicates
    635594                if (
    636                         isset( $this->blogs[$importing_blog]['comments'][$entry->old_permalink] ) ||
     595                        isset( $this->blogs[$importing_blog]['comments'][$old_permalink] ) ||
    637596                        comment_exists( $comment_author, $comment_date )
    638597                ) {
    639598                        ++$this->blogs[$importing_blog]['comments_skipped'];
     
    643602                        $comment = wp_filter_comment($comment);
    644603                        $comment_id = wp_insert_comment($comment);
    645604
    646                         $this->blogs[$importing_blog]['comments'][$entry->old_permalink] = $comment_id;
     605                        $this->blogs[$importing_blog]['comments'][$old_permalink] = $comment_id;
    647606
    648607                        ++$this->blogs[$importing_blog]['comments_done'];
    649608                }
     
    907866$blogger_import = new Blogger_Import();
    908867
    909868register_importer('blogger', __('Blogger', 'blogger-importer'), __('Import posts, comments, and users from a Blogger blog.', 'blogger-importer'), array ($blogger_import, 'start'));
    910 
    911 class AtomEntry {
    912         var $links = array();
    913         var $categories = array();
    914 }
    915 
    916 class AtomParser {
    917 
    918         var $ATOM_CONTENT_ELEMENTS = array('content','summary','title','subtitle','rights');
    919         var $ATOM_SIMPLE_ELEMENTS = array('id','updated','published','draft','author');
    920 
    921         var $depth = 0;
    922         var $indent = 2;
    923         var $in_content;
    924         var $ns_contexts = array();
    925         var $ns_decls = array();
    926         var $is_xhtml = false;
    927         var $skipped_div = false;
    928 
    929         var $entry;
    930 
    931         function AtomParser() {
    932                 $this->entry = new AtomEntry();
    933         }
    934 
    935         function _map_attrs_func( $k, $v ) {
    936                 return "$k=\"$v\"";
    937         }
    938 
    939         function _map_xmlns_func( $p, $n ) {
    940                 $xd = "xmlns";
    941                 if ( strlen( $n[0] ) > 0 )
    942                         $xd .= ":{$n[0]}";
    943 
    944                 return "{$xd}=\"{$n[1]}\"";
    945         }
    946 
    947         function parse($xml) {
    948 
    949                 global $app_logging;
    950                 array_unshift($this->ns_contexts, array());
    951 
    952                 $parser = xml_parser_create_ns();
    953                 xml_set_object($parser, $this);
    954                 xml_set_element_handler($parser, "start_element", "end_element");
    955                 xml_parser_set_option($parser,XML_OPTION_CASE_FOLDING,0);
    956                 xml_parser_set_option($parser,XML_OPTION_SKIP_WHITE,0);
    957                 xml_set_character_data_handler($parser, "cdata");
    958                 xml_set_default_handler($parser, "_default");
    959                 xml_set_start_namespace_decl_handler($parser, "start_ns");
    960                 xml_set_end_namespace_decl_handler($parser, "end_ns");
    961 
    962                 $contents = "";
    963 
    964                 xml_parse($parser, $xml);
    965 
    966                 xml_parser_free($parser);
    967 
    968                 return true;
    969         }
    970 
    971         function start_element($parser, $name, $attrs) {
    972 
    973                 $tag = array_pop(split(":", $name));
    974 
    975                 array_unshift($this->ns_contexts, $this->ns_decls);
    976 
    977                 $this->depth++;
    978 
    979                 if (!empty($this->in_content)) {
    980                         $attrs_prefix = array();
    981 
    982                         // resolve prefixes for attributes
    983                         foreach($attrs as $key => $value) {
    984                                 $attrs_prefix[$this->ns_to_prefix($key)] = $this->xml_escape($value);
    985                         }
    986                         $attrs_str = join(' ', array_map( array( &$this, '_map_attrs_func' ), array_keys($attrs_prefix), array_values($attrs_prefix)));
    987                         if (strlen($attrs_str) > 0) {
    988                                 $attrs_str = " " . $attrs_str;
    989                         }
    990 
    991                         $xmlns_str = join(' ', array_map( array( &$this, '_map_xmlns_func' ), array_keys($this->ns_contexts[0]), array_values($this->ns_contexts[0])));
    992                         if (strlen($xmlns_str) > 0) {
    993                                 $xmlns_str = " " . $xmlns_str;
    994                         }
    995 
    996                         // handle self-closing tags (case: a new child found right-away, no text node)
    997                         if (count($this->in_content) == 2) {
    998                                 array_push($this->in_content, ">");
    999                         }
    1000 
    1001                         array_push($this->in_content, "<". $this->ns_to_prefix($name) ."{$xmlns_str}{$attrs_str}");
    1002                 } else if (in_array($tag, $this->ATOM_CONTENT_ELEMENTS) || in_array($tag, $this->ATOM_SIMPLE_ELEMENTS)) {
    1003                         $this->in_content = array();
    1004                         $this->is_xhtml = $attrs['type'] == 'xhtml';
    1005                         array_push($this->in_content, array($tag,$this->depth));
    1006                 } else if ($tag == 'link') {
    1007                         array_push($this->entry->links, $attrs);
    1008                 } else if ($tag == 'category') {
    1009                         array_push($this->entry->categories, $attrs['term']);
    1010                 }
    1011 
    1012                 $this->ns_decls = array();
    1013         }
    1014 
    1015         function end_element($parser, $name) {
    1016 
    1017                 $tag = array_pop(split(":", $name));
    1018 
    1019                 if (!empty($this->in_content)) {
    1020                         if ($this->in_content[0][0] == $tag &&
    1021                         $this->in_content[0][1] == $this->depth) {
    1022                                 array_shift($this->in_content);
    1023                                 if ($this->is_xhtml) {
    1024                                         $this->in_content = array_slice($this->in_content, 2, count($this->in_content)-3);
    1025                                 }
    1026                                 $this->entry->$tag = join('',$this->in_content);
    1027                                 $this->in_content = array();
    1028                         } else {
    1029                                 $endtag = $this->ns_to_prefix($name);
    1030                                 if (strpos($this->in_content[count($this->in_content)-1], '<' . $endtag) !== false) {
    1031                                         array_push($this->in_content, "/>");
    1032                                 } else {
    1033                                         array_push($this->in_content, "</$endtag>");
    1034                                 }
    1035                         }
    1036                 }
    1037 
    1038                 array_shift($this->ns_contexts);
    1039 
    1040                 #print str_repeat(" ", $this->depth * $this->indent) . "end_element('$name')" ."\n";
    1041 
    1042                 $this->depth--;
    1043         }
    1044 
    1045         function start_ns($parser, $prefix, $uri) {
    1046                 #print str_repeat(" ", $this->depth * $this->indent) . "starting: " . $prefix . ":" . $uri . "\n";
    1047                 array_push($this->ns_decls, array($prefix,$uri));
    1048         }
    1049 
    1050         function end_ns($parser, $prefix) {
    1051                 #print str_repeat(" ", $this->depth * $this->indent) . "ending: #" . $prefix . "#\n";
    1052         }
    1053 
    1054         function cdata($parser, $data) {
    1055                 #print str_repeat(" ", $this->depth * $this->indent) . "data: #" . $data . "#\n";
    1056                 if (!empty($this->in_content)) {
    1057                         // handle self-closing tags (case: text node found, need to close element started)
    1058                         if (strpos($this->in_content[count($this->in_content)-1], '<') !== false) {
    1059                                 array_push($this->in_content, ">");
    1060                         }
    1061                         array_push($this->in_content, $this->xml_escape($data));
    1062                 }
    1063         }
    1064 
    1065         function _default($parser, $data) {
    1066                 # when does this gets called?
    1067         }
    1068 
    1069 
    1070         function ns_to_prefix($qname) {
    1071                 $components = split(":", $qname);
    1072                 $name = array_pop($components);
    1073 
    1074                 if (!empty($components)) {
    1075                         $ns = join(":",$components);
    1076                         foreach ($this->ns_contexts as $context) {
    1077                                 foreach ($context as $mapping) {
    1078                                         if ($mapping[1] == $ns && strlen($mapping[0]) > 0) {
    1079                                                 return "$mapping[0]:$name";
    1080                                         }
    1081                                 }
    1082                         }
    1083                 }
    1084                 return $name;
    1085         }
    1086 
    1087         function xml_escape($string)
    1088         {
    1089                          return str_replace(array('&','"',"'",'<','>'),
    1090                                 array('&amp;','&quot;','&apos;','&lt;','&gt;'),
    1091                                 $string );
    1092         }
    1093 }
    1094869} // class_exists( 'WP_Importer' )
    1095870
    1096871function blogger_importer_init() {