WordPress.org

Make WordPress Core

Ticket #21231: 21231.2.diff

File 21231.2.diff, 87.5 KB (added by obenland, 6 years ago)
  • wp-content/themes/twentytwelve/inc/custom-header.php

     
    99 */
    1010
    1111/**
    12  * Back compat support for get_custom_header().
    13  * New since WordPress version 3.4.
    14  *
    15  * To provide backward compatibility with previous versions, we
    16  * will define our own version of this function.
    17  *
    18  * @todo Should this go into core instead?
    19  *
    20  * @return stdClass All properties represent attributes of the current header image.
    21  *
    22  * @package Twenty_Twelve
    23  * @since Twenty Twelve 1.0
    24  */
    25 if ( ! function_exists( 'get_custom_header' ) ) {
    26         function get_custom_header() {
    27                 return (object) array(
    28                         'url'           => get_header_image(),
    29                         'thumbnail_url' => get_header_image(),
    30                         'width'         => HEADER_IMAGE_WIDTH,
    31                         'height'        => HEADER_IMAGE_HEIGHT
    32                 );
    33         }
    34 }
    35 
    36 /**
    3712 * Setup the WordPress core custom header arguments and settings.
    3813 *
    3914 * Use add_theme_support() to register support for WordPress 3.4+
    40  * as well as provide backward compatibility for previous versions.
    41  *
    42  * Use feature detection of wp_get_theme() which was introduced
    43  * in WordPress 3.4.
    4415 *
    4516 * @uses twentytwelve_header_style()
    4617 * @uses twentytwelve_admin_header_style()
     
    7243                'admin-preview-callback' => 'twentytwelve_admin_header_image',
    7344        );
    7445
    75         // Allow child themes to filter any of these arguments.
    76         $args = apply_filters( 'twentytwelve_custom_header_args', $args );
    77 
    78         if ( function_exists( 'wp_get_theme' ) ) {
    79                 add_theme_support( 'custom-header', $args );
    80         } else {
    81                 // Back compat for < 3.4 versions.
    82                 define( 'HEADER_TEXTCOLOR',    $args['default-text-color'] );
    83                 define( 'HEADER_IMAGE',        $args['default-image'] );
    84                 define( 'HEADER_IMAGE_WIDTH',  $args['width'] );
    85                 define( 'HEADER_IMAGE_HEIGHT', $args['height'] );
    86                 add_custom_image_header( $args['wp-head-callback'], $args['admin-head-callback'], $args['admin-preview-callback'] );
    87         }
     46        // Add support and allow child themes to filter any of these arguments.
     47        add_theme_support( 'custom-header', apply_filters( 'twentytwelve_custom_header_args', $args ) );
    8848}
    8949add_action( 'after_setup_theme', 'twentytwelve_custom_header_setup' );
    9050
  • wp-content/plugins/wordpress-importer/wordpress-importer.php

     
     1<?php
     2/*
     3Plugin Name: WordPress Importer
     4Plugin URI: http://wordpress.org/extend/plugins/wordpress-importer/
     5Description: Import posts, pages, comments, custom fields, categories, tags and more from a WordPress export file.
     6Author: wordpressdotorg
     7Author URI: http://wordpress.org/
     8Version: 0.6
     9Text Domain: wordpress-importer
     10License: GPL version 2 or later - http://www.gnu.org/licenses/old-licenses/gpl-2.0.html
     11*/
     12
     13if ( ! defined( 'WP_LOAD_IMPORTERS' ) )
     14        return;
     15
     16/** Display verbose errors */
     17define( 'IMPORT_DEBUG', false );
     18
     19// Load Importer API
     20require_once ABSPATH . 'wp-admin/includes/import.php';
     21
     22if ( ! class_exists( 'WP_Importer' ) ) {
     23        $class_wp_importer = ABSPATH . 'wp-admin/includes/class-wp-importer.php';
     24        if ( file_exists( $class_wp_importer ) )
     25                require $class_wp_importer;
     26}
     27
     28// include WXR file parsers
     29require dirname( __FILE__ ) . '/parsers.php';
     30
     31/**
     32 * WordPress Importer class for managing the import process of a WXR file
     33 *
     34 * @package WordPress
     35 * @subpackage Importer
     36 */
     37if ( class_exists( 'WP_Importer' ) ) {
     38class WP_Import extends WP_Importer {
     39        var $max_wxr_version = 1.2; // max. supported WXR version
     40
     41        var $id; // WXR attachment ID
     42
     43        // information to import from WXR file
     44        var $version;
     45        var $authors = array();
     46        var $posts = array();
     47        var $terms = array();
     48        var $categories = array();
     49        var $tags = array();
     50        var $base_url = '';
     51
     52        // mappings from old information to new
     53        var $processed_authors = array();
     54        var $author_mapping = array();
     55        var $processed_terms = array();
     56        var $processed_posts = array();
     57        var $post_orphans = array();
     58        var $processed_menu_items = array();
     59        var $menu_item_orphans = array();
     60        var $missing_menu_items = array();
     61
     62        var $fetch_attachments = false;
     63        var $url_remap = array();
     64        var $featured_images = array();
     65
     66        function WP_Import() { /* nothing */ }
     67
     68        /**
     69         * Registered callback function for the WordPress Importer
     70         *
     71         * Manages the three separate stages of the WXR import process
     72         */
     73        function dispatch() {
     74                $this->header();
     75
     76                $step = empty( $_GET['step'] ) ? 0 : (int) $_GET['step'];
     77                switch ( $step ) {
     78                        case 0:
     79                                $this->greet();
     80                                break;
     81                        case 1:
     82                                check_admin_referer( 'import-upload' );
     83                                if ( $this->handle_upload() )
     84                                        $this->import_options();
     85                                break;
     86                        case 2:
     87                                check_admin_referer( 'import-wordpress' );
     88                                $this->fetch_attachments = ( ! empty( $_POST['fetch_attachments'] ) && $this->allow_fetch_attachments() );
     89                                $this->id = (int) $_POST['import_id'];
     90                                $file = get_attached_file( $this->id );
     91                                set_time_limit(0);
     92                                $this->import( $file );
     93                                break;
     94                }
     95
     96                $this->footer();
     97        }
     98
     99        /**
     100         * The main controller for the actual import stage.
     101         *
     102         * @param string $file Path to the WXR file for importing
     103         */
     104        function import( $file ) {
     105                add_filter( 'import_post_meta_key', array( $this, 'is_valid_meta_key' ) );
     106                add_filter( 'http_request_timeout', array( &$this, 'bump_request_timeout' ) );
     107
     108                $this->import_start( $file );
     109
     110                $this->get_author_mapping();
     111
     112                wp_suspend_cache_invalidation( true );
     113                $this->process_categories();
     114                $this->process_tags();
     115                $this->process_terms();
     116                $this->process_posts();
     117                wp_suspend_cache_invalidation( false );
     118
     119                // update incorrect/missing information in the DB
     120                $this->backfill_parents();
     121                $this->backfill_attachment_urls();
     122                $this->remap_featured_images();
     123
     124                $this->import_end();
     125        }
     126
     127        /**
     128         * Parses the WXR file and prepares us for the task of processing parsed data
     129         *
     130         * @param string $file Path to the WXR file for importing
     131         */
     132        function import_start( $file ) {
     133                if ( ! is_file($file) ) {
     134                        echo '<p><strong>' . __( 'Sorry, there has been an error.', 'wordpress-importer' ) . '</strong><br />';
     135                        echo __( 'The file does not exist, please try again.', 'wordpress-importer' ) . '</p>';
     136                        $this->footer();
     137                        die();
     138                }
     139
     140                $import_data = $this->parse( $file );
     141
     142                if ( is_wp_error( $import_data ) ) {
     143                        echo '<p><strong>' . __( 'Sorry, there has been an error.', 'wordpress-importer' ) . '</strong><br />';
     144                        echo esc_html( $import_data->get_error_message() ) . '</p>';
     145                        $this->footer();
     146                        die();
     147                }
     148
     149                $this->version = $import_data['version'];
     150                $this->get_authors_from_import( $import_data );
     151                $this->posts = $import_data['posts'];
     152                $this->terms = $import_data['terms'];
     153                $this->categories = $import_data['categories'];
     154                $this->tags = $import_data['tags'];
     155                $this->base_url = esc_url( $import_data['base_url'] );
     156
     157                wp_defer_term_counting( true );
     158                wp_defer_comment_counting( true );
     159
     160                do_action( 'import_start' );
     161        }
     162
     163        /**
     164         * Performs post-import cleanup of files and the cache
     165         */
     166        function import_end() {
     167                wp_import_cleanup( $this->id );
     168
     169                wp_cache_flush();
     170                foreach ( get_taxonomies() as $tax ) {
     171                        delete_option( "{$tax}_children" );
     172                        _get_term_hierarchy( $tax );
     173                }
     174
     175                wp_defer_term_counting( false );
     176                wp_defer_comment_counting( false );
     177
     178                echo '<p>' . __( 'All done.', 'wordpress-importer' ) . ' <a href="' . admin_url() . '">' . __( 'Have fun!', 'wordpress-importer' ) . '</a>' . '</p>';
     179                echo '<p>' . __( 'Remember to update the passwords and roles of imported users.', 'wordpress-importer' ) . '</p>';
     180
     181                do_action( 'import_end' );
     182        }
     183
     184        /**
     185         * Handles the WXR upload and initial parsing of the file to prepare for
     186         * displaying author import options
     187         *
     188         * @return bool False if error uploading or invalid file, true otherwise
     189         */
     190        function handle_upload() {
     191                $file = wp_import_handle_upload();
     192
     193                if ( isset( $file['error'] ) ) {
     194                        echo '<p><strong>' . __( 'Sorry, there has been an error.', 'wordpress-importer' ) . '</strong><br />';
     195                        echo esc_html( $file['error'] ) . '</p>';
     196                        return false;
     197                } else if ( ! file_exists( $file['file'] ) ) {
     198                        echo '<p><strong>' . __( 'Sorry, there has been an error.', 'wordpress-importer' ) . '</strong><br />';
     199                        printf( __( 'The export file could not be found at <code>%s</code>. It is likely that this was caused by a permissions problem.', 'wordpress-importer' ), esc_html( $file['file'] ) );
     200                        echo '</p>';
     201                        return false;
     202                }
     203
     204                $this->id = (int) $file['id'];
     205                $import_data = $this->parse( $file['file'] );
     206                if ( is_wp_error( $import_data ) ) {
     207                        echo '<p><strong>' . __( 'Sorry, there has been an error.', 'wordpress-importer' ) . '</strong><br />';
     208                        echo esc_html( $import_data->get_error_message() ) . '</p>';
     209                        return false;
     210                }
     211
     212                $this->version = $import_data['version'];
     213                if ( $this->version > $this->max_wxr_version ) {
     214                        echo '<div class="error"><p><strong>';
     215                        printf( __( 'This WXR file (version %s) may not be supported by this version of the importer. Please consider updating.', 'wordpress-importer' ), esc_html($import_data['version']) );
     216                        echo '</strong></p></div>';
     217                }
     218
     219                $this->get_authors_from_import( $import_data );
     220
     221                return true;
     222        }
     223
     224        /**
     225         * Retrieve authors from parsed WXR data
     226         *
     227         * Uses the provided author information from WXR 1.1 files
     228         * or extracts info from each post for WXR 1.0 files
     229         *
     230         * @param array $import_data Data returned by a WXR parser
     231         */
     232        function get_authors_from_import( $import_data ) {
     233                if ( ! empty( $import_data['authors'] ) ) {
     234                        $this->authors = $import_data['authors'];
     235                // no author information, grab it from the posts
     236                } else {
     237                        foreach ( $import_data['posts'] as $post ) {
     238                                $login = sanitize_user( $post['post_author'], true );
     239                                if ( empty( $login ) ) {
     240                                        printf( __( 'Failed to import author %s. Their posts will be attributed to the current user.', 'wordpress-importer' ), esc_html( $post['post_author'] ) );
     241                                        echo '<br />';
     242                                        continue;
     243                                }
     244
     245                                if ( ! isset($this->authors[$login]) )
     246                                        $this->authors[$login] = array(
     247                                                'author_login' => $login,
     248                                                'author_display_name' => $post['post_author']
     249                                        );
     250                        }
     251                }
     252        }
     253
     254        /**
     255         * Display pre-import options, author importing/mapping and option to
     256         * fetch attachments
     257         */
     258        function import_options() {
     259                $j = 0;
     260?>
     261<form action="<?php echo admin_url( 'admin.php?import=wordpress&amp;step=2' ); ?>" method="post">
     262        <?php wp_nonce_field( 'import-wordpress' ); ?>
     263        <input type="hidden" name="import_id" value="<?php echo $this->id; ?>" />
     264
     265<?php if ( ! empty( $this->authors ) ) : ?>
     266        <h3><?php _e( 'Assign Authors', 'wordpress-importer' ); ?></h3>
     267        <p><?php _e( 'To make it easier for you to edit and save the imported content, you may want to reassign the author of the imported item to an existing user of this site. For example, you may want to import all the entries as <code>admin</code>s entries.', 'wordpress-importer' ); ?></p>
     268<?php if ( $this->allow_create_users() ) : ?>
     269        <p><?php printf( __( 'If a new user is created by WordPress, a new password will be randomly generated and the new user&#8217;s role will be set as %s. Manually changing the new user&#8217;s details will be necessary.', 'wordpress-importer' ), esc_html( get_option('default_role') ) ); ?></p>
     270<?php endif; ?>
     271        <ol id="authors">
     272<?php foreach ( $this->authors as $author ) : ?>
     273                <li><?php $this->author_select( $j++, $author ); ?></li>
     274<?php endforeach; ?>
     275        </ol>
     276<?php endif; ?>
     277
     278<?php if ( $this->allow_fetch_attachments() ) : ?>
     279        <h3><?php _e( 'Import Attachments', 'wordpress-importer' ); ?></h3>
     280        <p>
     281                <input type="checkbox" value="1" name="fetch_attachments" id="import-attachments" />
     282                <label for="import-attachments"><?php _e( 'Download and import file attachments', 'wordpress-importer' ); ?></label>
     283        </p>
     284<?php endif; ?>
     285
     286        <p class="submit"><input type="submit" class="button" value="<?php esc_attr_e( 'Submit', 'wordpress-importer' ); ?>" /></p>
     287</form>
     288<?php
     289        }
     290
     291        /**
     292         * Display import options for an individual author. That is, either create
     293         * a new user based on import info or map to an existing user
     294         *
     295         * @param int $n Index for each author in the form
     296         * @param array $author Author information, e.g. login, display name, email
     297         */
     298        function author_select( $n, $author ) {
     299                _e( 'Import author:', 'wordpress-importer' );
     300                echo ' <strong>' . esc_html( $author['author_display_name'] );
     301                if ( $this->version != '1.0' ) echo ' (' . esc_html( $author['author_login'] ) . ')';
     302                echo '</strong><br />';
     303
     304                if ( $this->version != '1.0' )
     305                        echo '<div style="margin-left:18px">';
     306
     307                $create_users = $this->allow_create_users();
     308                if ( $create_users ) {
     309                        if ( $this->version != '1.0' ) {
     310                                _e( 'or create new user with login name:', 'wordpress-importer' );
     311                                $value = '';
     312                        } else {
     313                                _e( 'as a new user:', 'wordpress-importer' );
     314                                $value = esc_attr( sanitize_user( $author['author_login'], true ) );
     315                        }
     316
     317                        echo ' <input type="text" name="user_new['.$n.']" value="'. $value .'" /><br />';
     318                }
     319
     320                if ( ! $create_users && $this->version == '1.0' )
     321                        _e( 'assign posts to an existing user:', 'wordpress-importer' );
     322                else
     323                        _e( 'or assign posts to an existing user:', 'wordpress-importer' );
     324                wp_dropdown_users( array( 'name' => "user_map[$n]", 'multi' => true, 'show_option_all' => __( '- Select -', 'wordpress-importer' ) ) );
     325                echo '<input type="hidden" name="imported_authors['.$n.']" value="' . esc_attr( $author['author_login'] ) . '" />';
     326
     327                if ( $this->version != '1.0' )
     328                        echo '</div>';
     329        }
     330
     331        /**
     332         * Map old author logins to local user IDs based on decisions made
     333         * in import options form. Can map to an existing user, create a new user
     334         * or falls back to the current user in case of error with either of the previous
     335         */
     336        function get_author_mapping() {
     337                if ( ! isset( $_POST['imported_authors'] ) )
     338                        return;
     339
     340                $create_users = $this->allow_create_users();
     341
     342                foreach ( (array) $_POST['imported_authors'] as $i => $old_login ) {
     343                        // Multisite adds strtolower to sanitize_user. Need to sanitize here to stop breakage in process_posts.
     344                        $santized_old_login = sanitize_user( $old_login, true );
     345                        $old_id = isset( $this->authors[$old_login]['author_id'] ) ? intval($this->authors[$old_login]['author_id']) : false;
     346
     347                        if ( ! empty( $_POST['user_map'][$i] ) ) {
     348                                $user = get_userdata( intval($_POST['user_map'][$i]) );
     349                                if ( isset( $user->ID ) ) {
     350                                        if ( $old_id )
     351                                                $this->processed_authors[$old_id] = $user->ID;
     352                                        $this->author_mapping[$santized_old_login] = $user->ID;
     353                                }
     354                        } else if ( $create_users ) {
     355                                if ( ! empty($_POST['user_new'][$i]) ) {
     356                                        $user_id = wp_create_user( $_POST['user_new'][$i], wp_generate_password() );
     357                                } else if ( $this->version != '1.0' ) {
     358                                        $user_data = array(
     359                                                'user_login' => $old_login,
     360                                                'user_pass' => wp_generate_password(),
     361                                                'user_email' => isset( $this->authors[$old_login]['author_email'] ) ? $this->authors[$old_login]['author_email'] : '',
     362                                                'display_name' => $this->authors[$old_login]['author_display_name'],
     363                                                'first_name' => isset( $this->authors[$old_login]['author_first_name'] ) ? $this->authors[$old_login]['author_first_name'] : '',
     364                                                'last_name' => isset( $this->authors[$old_login]['author_last_name'] ) ? $this->authors[$old_login]['author_last_name'] : '',
     365                                        );
     366                                        $user_id = wp_insert_user( $user_data );
     367                                }
     368
     369                                if ( ! is_wp_error( $user_id ) ) {
     370                                        if ( $old_id )
     371                                                $this->processed_authors[$old_id] = $user_id;
     372                                        $this->author_mapping[$santized_old_login] = $user_id;
     373                                } else {
     374                                        printf( __( 'Failed to create new user for %s. Their posts will be attributed to the current user.', 'wordpress-importer' ), esc_html($this->authors[$old_login]['author_display_name']) );
     375                                        if ( defined('IMPORT_DEBUG') && IMPORT_DEBUG )
     376                                                echo ' ' . $user_id->get_error_message();
     377                                        echo '<br />';
     378                                }
     379                        }
     380
     381                        // failsafe: if the user_id was invalid, default to the current user
     382                        if ( ! isset( $this->author_mapping[$santized_old_login] ) ) {
     383                                if ( $old_id )
     384                                        $this->processed_authors[$old_id] = (int) get_current_user_id();
     385                                $this->author_mapping[$santized_old_login] = (int) get_current_user_id();
     386                        }
     387                }
     388        }
     389
     390        /**
     391         * Create new categories based on import information
     392         *
     393         * Doesn't create a new category if its slug already exists
     394         */
     395        function process_categories() {
     396                if ( empty( $this->categories ) )
     397                        return;
     398
     399                foreach ( $this->categories as $cat ) {
     400                        // if the category already exists leave it alone
     401                        $term_id = term_exists( $cat['category_nicename'], 'category' );
     402                        if ( $term_id ) {
     403                                if ( is_array($term_id) ) $term_id = $term_id['term_id'];
     404                                if ( isset($cat['term_id']) )
     405                                        $this->processed_terms[intval($cat['term_id'])] = (int) $term_id;
     406                                continue;
     407                        }
     408
     409                        $category_parent = empty( $cat['category_parent'] ) ? 0 : category_exists( $cat['category_parent'] );
     410                        $category_description = isset( $cat['category_description'] ) ? $cat['category_description'] : '';
     411                        $catarr = array(
     412                                'category_nicename' => $cat['category_nicename'],
     413                                'category_parent' => $category_parent,
     414                                'cat_name' => $cat['cat_name'],
     415                                'category_description' => $category_description
     416                        );
     417
     418                        $id = wp_insert_category( $catarr );
     419                        if ( ! is_wp_error( $id ) ) {
     420                                if ( isset($cat['term_id']) )
     421                                        $this->processed_terms[intval($cat['term_id'])] = $id;
     422                        } else {
     423                                printf( __( 'Failed to import category %s', 'wordpress-importer' ), esc_html($cat['category_nicename']) );
     424                                if ( defined('IMPORT_DEBUG') && IMPORT_DEBUG )
     425                                        echo ': ' . $id->get_error_message();
     426                                echo '<br />';
     427                                continue;
     428                        }
     429                }
     430
     431                unset( $this->categories );
     432        }
     433
     434        /**
     435         * Create new post tags based on import information
     436         *
     437         * Doesn't create a tag if its slug already exists
     438         */
     439        function process_tags() {
     440                if ( empty( $this->tags ) )
     441                        return;
     442
     443                foreach ( $this->tags as $tag ) {
     444                        // if the tag already exists leave it alone
     445                        $term_id = term_exists( $tag['tag_slug'], 'post_tag' );
     446                        if ( $term_id ) {
     447                                if ( is_array($term_id) ) $term_id = $term_id['term_id'];
     448                                if ( isset($tag['term_id']) )
     449                                        $this->processed_terms[intval($tag['term_id'])] = (int) $term_id;
     450                                continue;
     451                        }
     452
     453                        $tag_desc = isset( $tag['tag_description'] ) ? $tag['tag_description'] : '';
     454                        $tagarr = array( 'slug' => $tag['tag_slug'], 'description' => $tag_desc );
     455
     456                        $id = wp_insert_term( $tag['tag_name'], 'post_tag', $tagarr );
     457                        if ( ! is_wp_error( $id ) ) {
     458                                if ( isset($tag['term_id']) )
     459                                        $this->processed_terms[intval($tag['term_id'])] = $id['term_id'];
     460                        } else {
     461                                printf( __( 'Failed to import post tag %s', 'wordpress-importer' ), esc_html($tag['tag_name']) );
     462                                if ( defined('IMPORT_DEBUG') && IMPORT_DEBUG )
     463                                        echo ': ' . $id->get_error_message();
     464                                echo '<br />';
     465                                continue;
     466                        }
     467                }
     468
     469                unset( $this->tags );
     470        }
     471
     472        /**
     473         * Create new terms based on import information
     474         *
     475         * Doesn't create a term its slug already exists
     476         */
     477        function process_terms() {
     478                if ( empty( $this->terms ) )
     479                        return;
     480
     481                foreach ( $this->terms as $term ) {
     482                        // if the term already exists in the correct taxonomy leave it alone
     483                        $term_id = term_exists( $term['slug'], $term['term_taxonomy'] );
     484                        if ( $term_id ) {
     485                                if ( is_array($term_id) ) $term_id = $term_id['term_id'];
     486                                if ( isset($term['term_id']) )
     487                                        $this->processed_terms[intval($term['term_id'])] = (int) $term_id;
     488                                continue;
     489                        }
     490
     491                        if ( empty( $term['term_parent'] ) ) {
     492                                $parent = 0;
     493                        } else {
     494                                $parent = term_exists( $term['term_parent'], $term['term_taxonomy'] );
     495                                if ( is_array( $parent ) ) $parent = $parent['term_id'];
     496                        }
     497                        $description = isset( $term['term_description'] ) ? $term['term_description'] : '';
     498                        $termarr = array( 'slug' => $term['slug'], 'description' => $description, 'parent' => intval($parent) );
     499
     500                        $id = wp_insert_term( $term['term_name'], $term['term_taxonomy'], $termarr );
     501                        if ( ! is_wp_error( $id ) ) {
     502                                if ( isset($term['term_id']) )
     503                                        $this->processed_terms[intval($term['term_id'])] = $id['term_id'];
     504                        } else {
     505                                printf( __( 'Failed to import %s %s', 'wordpress-importer' ), esc_html($term['term_taxonomy']), esc_html($term['term_name']) );
     506                                if ( defined('IMPORT_DEBUG') && IMPORT_DEBUG )
     507                                        echo ': ' . $id->get_error_message();
     508                                echo '<br />';
     509                                continue;
     510                        }
     511                }
     512
     513                unset( $this->terms );
     514        }
     515
     516        /**
     517         * Create new posts based on import information
     518         *
     519         * Posts marked as having a parent which doesn't exist will become top level items.
     520         * Doesn't create a new post if: the post type doesn't exist, the given post ID
     521         * is already noted as imported or a post with the same title and date already exists.
     522         * Note that new/updated terms, comments and meta are imported for the last of the above.
     523         */
     524        function process_posts() {
     525                foreach ( $this->posts as $post ) {
     526                        if ( ! post_type_exists( $post['post_type'] ) ) {
     527                                printf( __( 'Failed to import &#8220;%s&#8221;: Invalid post type %s', 'wordpress-importer' ),
     528                                        esc_html($post['post_title']), esc_html($post['post_type']) );
     529                                echo '<br />';
     530                                continue;
     531                        }
     532
     533                        if ( isset( $this->processed_posts[$post['post_id']] ) && ! empty( $post['post_id'] ) )
     534                                continue;
     535
     536                        if ( $post['status'] == 'auto-draft' )
     537                                continue;
     538
     539                        if ( 'nav_menu_item' == $post['post_type'] ) {
     540                                $this->process_menu_item( $post );
     541                                continue;
     542                        }
     543
     544                        $post_type_object = get_post_type_object( $post['post_type'] );
     545
     546                        $post_exists = post_exists( $post['post_title'], '', $post['post_date'] );
     547                        if ( $post_exists && get_post_type( $post_exists ) == $post['post_type'] ) {
     548                                printf( __('%s &#8220;%s&#8221; already exists.', 'wordpress-importer'), $post_type_object->labels->singular_name, esc_html($post['post_title']) );
     549                                echo '<br />';
     550                                $comment_post_ID = $post_id = $post_exists;
     551                        } else {
     552                                $post_parent = (int) $post['post_parent'];
     553                                if ( $post_parent ) {
     554                                        // if we already know the parent, map it to the new local ID
     555                                        if ( isset( $this->processed_posts[$post_parent] ) ) {
     556                                                $post_parent = $this->processed_posts[$post_parent];
     557                                        // otherwise record the parent for later
     558                                        } else {
     559                                                $this->post_orphans[intval($post['post_id'])] = $post_parent;
     560                                                $post_parent = 0;
     561                                        }
     562                                }
     563
     564                                // map the post author
     565                                $author = sanitize_user( $post['post_author'], true );
     566                                if ( isset( $this->author_mapping[$author] ) )
     567                                        $author = $this->author_mapping[$author];
     568                                else
     569                                        $author = (int) get_current_user_id();
     570
     571                                $postdata = array(
     572                                        'import_id' => $post['post_id'], 'post_author' => $author, 'post_date' => $post['post_date'],
     573                                        'post_date_gmt' => $post['post_date_gmt'], 'post_content' => $post['post_content'],
     574                                        'post_excerpt' => $post['post_excerpt'], 'post_title' => $post['post_title'],
     575                                        'post_status' => $post['status'], 'post_name' => $post['post_name'],
     576                                        'comment_status' => $post['comment_status'], 'ping_status' => $post['ping_status'],
     577                                        'guid' => $post['guid'], 'post_parent' => $post_parent, 'menu_order' => $post['menu_order'],
     578                                        'post_type' => $post['post_type'], 'post_password' => $post['post_password']
     579                                );
     580
     581                                if ( 'attachment' == $postdata['post_type'] ) {
     582                                        $remote_url = ! empty($post['attachment_url']) ? $post['attachment_url'] : $post['guid'];
     583
     584                                        // try to use _wp_attached file for upload folder placement to ensure the same location as the export site
     585                                        // e.g. location is 2003/05/image.jpg but the attachment post_date is 2010/09, see media_handle_upload()
     586                                        $postdata['upload_date'] = $post['post_date'];
     587                                        if ( isset( $post['postmeta'] ) ) {
     588                                                foreach( $post['postmeta'] as $meta ) {
     589                                                        if ( $meta['key'] == '_wp_attached_file' ) {
     590                                                                if ( preg_match( '%^[0-9]{4}/[0-9]{2}%', $meta['value'], $matches ) )
     591                                                                        $postdata['upload_date'] = $matches[0];
     592                                                                break;
     593                                                        }
     594                                                }
     595                                        }
     596
     597                                        $comment_post_ID = $post_id = $this->process_attachment( $postdata, $remote_url );
     598                                } else {
     599                                        $comment_post_ID = $post_id = wp_insert_post( $postdata, true );
     600                                }
     601
     602                                if ( is_wp_error( $post_id ) ) {
     603                                        printf( __( 'Failed to import %s &#8220;%s&#8221;', 'wordpress-importer' ),
     604                                                $post_type_object->labels->singular_name, esc_html($post['post_title']) );
     605                                        if ( defined('IMPORT_DEBUG') && IMPORT_DEBUG )
     606                                                echo ': ' . $post_id->get_error_message();
     607                                        echo '<br />';
     608                                        continue;
     609                                }
     610
     611                                if ( $post['is_sticky'] == 1 )
     612                                        stick_post( $post_id );
     613                        }
     614
     615                        // map pre-import ID to local ID
     616                        $this->processed_posts[intval($post['post_id'])] = (int) $post_id;
     617
     618                        // add categories, tags and other terms
     619                        if ( ! empty( $post['terms'] ) ) {
     620                                $terms_to_set = array();
     621                                foreach ( $post['terms'] as $term ) {
     622                                        // back compat with WXR 1.0 map 'tag' to 'post_tag'
     623                                        $taxonomy = ( 'tag' == $term['domain'] ) ? 'post_tag' : $term['domain'];
     624                                        $term_exists = term_exists( $term['slug'], $taxonomy );
     625                                        $term_id = is_array( $term_exists ) ? $term_exists['term_id'] : $term_exists;
     626                                        if ( ! $term_id ) {
     627                                                $t = wp_insert_term( $term['name'], $taxonomy, array( 'slug' => $term['slug'] ) );
     628                                                if ( ! is_wp_error( $t ) ) {
     629                                                        $term_id = $t['term_id'];
     630                                                } else {
     631                                                        printf( __( 'Failed to import %s %s', 'wordpress-importer' ), esc_html($taxonomy), esc_html($term['name']) );
     632                                                        if ( defined('IMPORT_DEBUG') && IMPORT_DEBUG )
     633                                                                echo ': ' . $t->get_error_message();
     634                                                        echo '<br />';
     635                                                        continue;
     636                                                }
     637                                        }
     638                                        $terms_to_set[$taxonomy][] = intval( $term_id );
     639                                }
     640
     641                                foreach ( $terms_to_set as $tax => $ids ) {
     642                                        $tt_ids = wp_set_post_terms( $post_id, $ids, $tax );
     643                                }
     644                                unset( $post['terms'], $terms_to_set );
     645                        }
     646
     647                        // add/update comments
     648                        if ( ! empty( $post['comments'] ) ) {
     649                                $num_comments = 0;
     650                                $inserted_comments = array();
     651                                foreach ( $post['comments'] as $comment ) {
     652                                        $comment_id     = $comment['comment_id'];
     653                                        $newcomments[$comment_id]['comment_post_ID']      = $comment_post_ID;
     654                                        $newcomments[$comment_id]['comment_author']       = $comment['comment_author'];
     655                                        $newcomments[$comment_id]['comment_author_email'] = $comment['comment_author_email'];
     656                                        $newcomments[$comment_id]['comment_author_IP']    = $comment['comment_author_IP'];
     657                                        $newcomments[$comment_id]['comment_author_url']   = $comment['comment_author_url'];
     658                                        $newcomments[$comment_id]['comment_date']         = $comment['comment_date'];
     659                                        $newcomments[$comment_id]['comment_date_gmt']     = $comment['comment_date_gmt'];
     660                                        $newcomments[$comment_id]['comment_content']      = $comment['comment_content'];
     661                                        $newcomments[$comment_id]['comment_approved']     = $comment['comment_approved'];
     662                                        $newcomments[$comment_id]['comment_type']         = $comment['comment_type'];
     663                                        $newcomments[$comment_id]['comment_parent']       = $comment['comment_parent'];
     664                                        $newcomments[$comment_id]['commentmeta']          = isset( $comment['commentmeta'] ) ? $comment['commentmeta'] : array();
     665                                        if ( isset( $this->processed_authors[$comment['comment_user_id']] ) )
     666                                                $newcomments[$comment_id]['user_id'] = $this->processed_authors[$comment['comment_user_id']];
     667                                }
     668                                ksort( $newcomments );
     669
     670                                foreach ( $newcomments as $key => $comment ) {
     671                                        // if this is a new post we can skip the comment_exists() check
     672                                        if ( ! $post_exists || ! comment_exists( $comment['comment_author'], $comment['comment_date'] ) ) {
     673                                                if ( isset( $inserted_comments[$comment['comment_parent']] ) )
     674                                                        $comment['comment_parent'] = $inserted_comments[$comment['comment_parent']];
     675                                                $comment = wp_filter_comment( $comment );
     676                                                $inserted_comments[$key] = wp_insert_comment( $comment );
     677
     678                                                foreach( $comment['commentmeta'] as $meta ) {
     679                                                        $value = maybe_unserialize( $meta['value'] );
     680                                                        add_comment_meta( $inserted_comments[$key], $meta['key'], $value );
     681                                                }
     682
     683                                                $num_comments++;
     684                                        }
     685                                }
     686                                unset( $newcomments, $inserted_comments, $post['comments'] );
     687                        }
     688
     689                        // add/update post meta
     690                        if ( isset( $post['postmeta'] ) ) {
     691                                foreach ( $post['postmeta'] as $meta ) {
     692                                        $key = apply_filters( 'import_post_meta_key', $meta['key'] );
     693                                        $value = false;
     694
     695                                        if ( '_edit_last' == $key ) {
     696                                                if ( isset( $this->processed_authors[intval($meta['value'])] ) )
     697                                                        $value = $this->processed_authors[intval($meta['value'])];
     698                                                else
     699                                                        $key = false;
     700                                        }
     701
     702                                        if ( $key ) {
     703                                                // export gets meta straight from the DB so could have a serialized string
     704                                                if ( ! $value )
     705                                                        $value = maybe_unserialize( $meta['value'] );
     706
     707                                                add_post_meta( $post_id, $key, $value );
     708                                                do_action( 'import_post_meta', $post_id, $key, $value );
     709
     710                                                // if the post has a featured image, take note of this in case of remap
     711                                                if ( '_thumbnail_id' == $key )
     712                                                        $this->featured_images[$post_id] = (int) $value;
     713                                        }
     714                                }
     715                        }
     716                }
     717
     718                unset( $this->posts );
     719        }
     720
     721        /**
     722         * Attempt to create a new menu item from import data
     723         *
     724         * Fails for draft, orphaned menu items and those without an associated nav_menu
     725         * or an invalid nav_menu term. If the post type or term object which the menu item
     726         * represents doesn't exist then the menu item will not be imported (waits until the
     727         * end of the import to retry again before discarding).
     728         *
     729         * @param array $item Menu item details from WXR file
     730         */
     731        function process_menu_item( $item ) {
     732                // skip draft, orphaned menu items
     733                if ( 'draft' == $item['status'] )
     734                        return;
     735
     736                $menu_slug = false;
     737                if ( isset($item['terms']) ) {
     738                        // loop through terms, assume first nav_menu term is correct menu
     739                        foreach ( $item['terms'] as $term ) {
     740                                if ( 'nav_menu' == $term['domain'] ) {
     741                                        $menu_slug = $term['slug'];
     742                                        break;
     743                                }
     744                        }
     745                }
     746
     747                // no nav_menu term associated with this menu item
     748                if ( ! $menu_slug ) {
     749                        _e( 'Menu item skipped due to missing menu slug', 'wordpress-importer' );
     750                        echo '<br />';
     751                        return;
     752                }
     753
     754                $menu_id = term_exists( $menu_slug, 'nav_menu' );
     755                if ( ! $menu_id ) {
     756                        printf( __( 'Menu item skipped due to invalid menu slug: %s', 'wordpress-importer' ), esc_html( $menu_slug ) );
     757                        echo '<br />';
     758                        return;
     759                } else {
     760                        $menu_id = is_array( $menu_id ) ? $menu_id['term_id'] : $menu_id;
     761                }
     762
     763                foreach ( $item['postmeta'] as $meta )
     764                        $$meta['key'] = $meta['value'];
     765
     766                if ( 'taxonomy' == $_menu_item_type && isset( $this->processed_terms[intval($_menu_item_object_id)] ) ) {
     767                        $_menu_item_object_id = $this->processed_terms[intval($_menu_item_object_id)];
     768                } else if ( 'post_type' == $_menu_item_type && isset( $this->processed_posts[intval($_menu_item_object_id)] ) ) {
     769                        $_menu_item_object_id = $this->processed_posts[intval($_menu_item_object_id)];
     770                } else if ( 'custom' != $_menu_item_type ) {
     771                        // associated object is missing or not imported yet, we'll retry later
     772                        $this->missing_menu_items[] = $item;
     773                        return;
     774                }
     775
     776                if ( isset( $this->processed_menu_items[intval($_menu_item_menu_item_parent)] ) ) {
     777                        $_menu_item_menu_item_parent = $this->processed_menu_items[intval($_menu_item_menu_item_parent)];
     778                } else if ( $_menu_item_menu_item_parent ) {
     779                        $this->menu_item_orphans[intval($item['post_id'])] = (int) $_menu_item_menu_item_parent;
     780                        $_menu_item_menu_item_parent = 0;
     781                }
     782
     783                // wp_update_nav_menu_item expects CSS classes as a space separated string
     784                $_menu_item_classes = maybe_unserialize( $_menu_item_classes );
     785                if ( is_array( $_menu_item_classes ) )
     786                        $_menu_item_classes = implode( ' ', $_menu_item_classes );
     787
     788                $args = array(
     789                        'menu-item-object-id' => $_menu_item_object_id,
     790                        'menu-item-object' => $_menu_item_object,
     791                        'menu-item-parent-id' => $_menu_item_menu_item_parent,
     792                        'menu-item-position' => intval( $item['menu_order'] ),
     793                        'menu-item-type' => $_menu_item_type,
     794                        'menu-item-title' => $item['post_title'],
     795                        'menu-item-url' => $_menu_item_url,
     796                        'menu-item-description' => $item['post_content'],
     797                        'menu-item-attr-title' => $item['post_excerpt'],
     798                        'menu-item-target' => $_menu_item_target,
     799                        'menu-item-classes' => $_menu_item_classes,
     800                        'menu-item-xfn' => $_menu_item_xfn,
     801                        'menu-item-status' => $item['status']
     802                );
     803
     804                $id = wp_update_nav_menu_item( $menu_id, 0, $args );
     805                if ( $id && ! is_wp_error( $id ) )
     806                        $this->processed_menu_items[intval($item['post_id'])] = (int) $id;
     807        }
     808
     809        /**
     810         * If fetching attachments is enabled then attempt to create a new attachment
     811         *
     812         * @param array $post Attachment post details from WXR
     813         * @param string $url URL to fetch attachment from
     814         * @return int|WP_Error Post ID on success, WP_Error otherwise
     815         */
     816        function process_attachment( $post, $url ) {
     817                if ( ! $this->fetch_attachments )
     818                        return new WP_Error( 'attachment_processing_error',
     819                                __( 'Fetching attachments is not enabled', 'wordpress-importer' ) );
     820
     821                // if the URL is absolute, but does not contain address, then upload it assuming base_site_url
     822                if ( preg_match( '|^/[\w\W]+$|', $url ) )
     823                        $url = rtrim( $this->base_url, '/' ) . $url;
     824
     825                $upload = $this->fetch_remote_file( $url, $post );
     826                if ( is_wp_error( $upload ) )
     827                        return $upload;
     828
     829                if ( $info = wp_check_filetype( $upload['file'] ) )
     830                        $post['post_mime_type'] = $info['type'];
     831                else
     832                        return new WP_Error( 'attachment_processing_error', __('Invalid file type', 'wordpress-importer') );
     833
     834                $post['guid'] = $upload['url'];
     835
     836                // as per wp-admin/includes/upload.php
     837                $post_id = wp_insert_attachment( $post, $upload['file'] );
     838                wp_update_attachment_metadata( $post_id, wp_generate_attachment_metadata( $post_id, $upload['file'] ) );
     839
     840                // remap resized image URLs, works by stripping the extension and remapping the URL stub.
     841                if ( preg_match( '!^image/!', $info['type'] ) ) {
     842                        $parts = pathinfo( $url );
     843                        $name = basename( $parts['basename'], ".{$parts['extension']}" ); // PATHINFO_FILENAME in PHP 5.2
     844
     845                        $parts_new = pathinfo( $upload['url'] );
     846                        $name_new = basename( $parts_new['basename'], ".{$parts_new['extension']}" );
     847
     848                        $this->url_remap[$parts['dirname'] . '/' . $name] = $parts_new['dirname'] . '/' . $name_new;
     849                }
     850
     851                return $post_id;
     852        }
     853
     854        /**
     855         * Attempt to download a remote file attachment
     856         *
     857         * @param string $url URL of item to fetch
     858         * @param array $post Attachment details
     859         * @return array|WP_Error Local file location details on success, WP_Error otherwise
     860         */
     861        function fetch_remote_file( $url, $post ) {
     862                // extract the file name and extension from the url
     863                $file_name = basename( $url );
     864
     865                // get placeholder file in the upload dir with a unique, sanitized filename
     866                $upload = wp_upload_bits( $file_name, 0, '', $post['upload_date'] );
     867                if ( $upload['error'] )
     868                        return new WP_Error( 'upload_dir_error', $upload['error'] );
     869
     870                // fetch the remote url and write it to the placeholder file
     871                $headers = wp_get_http( $url, $upload['file'] );
     872
     873                // request failed
     874                if ( ! $headers ) {
     875                        @unlink( $upload['file'] );
     876                        return new WP_Error( 'import_file_error', __('Remote server did not respond', 'wordpress-importer') );
     877                }
     878
     879                // make sure the fetch was successful
     880                if ( $headers['response'] != '200' ) {
     881                        @unlink( $upload['file'] );
     882                        return new WP_Error( 'import_file_error', sprintf( __('Remote server returned error response %1$d %2$s', 'wordpress-importer'), esc_html($headers['response']), get_status_header_desc($headers['response']) ) );
     883                }
     884
     885                $filesize = filesize( $upload['file'] );
     886
     887                if ( isset( $headers['content-length'] ) && $filesize != $headers['content-length'] ) {
     888                        @unlink( $upload['file'] );
     889                        return new WP_Error( 'import_file_error', __('Remote file is incorrect size', 'wordpress-importer') );
     890                }
     891
     892                if ( 0 == $filesize ) {
     893                        @unlink( $upload['file'] );
     894                        return new WP_Error( 'import_file_error', __('Zero size file downloaded', 'wordpress-importer') );
     895                }
     896
     897                $max_size = (int) $this->max_attachment_size();
     898                if ( ! empty( $max_size ) && $filesize > $max_size ) {
     899                        @unlink( $upload['file'] );
     900                        return new WP_Error( 'import_file_error', sprintf(__('Remote file is too large, limit is %s', 'wordpress-importer'), size_format($max_size) ) );
     901                }
     902
     903                // keep track of the old and new urls so we can substitute them later
     904                $this->url_remap[$url] = $upload['url'];
     905                $this->url_remap[$post['guid']] = $upload['url']; // r13735, really needed?
     906                // keep track of the destination if the remote url is redirected somewhere else
     907                if ( isset($headers['x-final-location']) && $headers['x-final-location'] != $url )
     908                        $this->url_remap[$headers['x-final-location']] = $upload['url'];
     909
     910                return $upload;
     911        }
     912
     913        /**
     914         * Attempt to associate posts and menu items with previously missing parents
     915         *
     916         * An imported post's parent may not have been imported when it was first created
     917         * so try again. Similarly for child menu items and menu items which were missing
     918         * the object (e.g. post) they represent in the menu
     919         */
     920        function backfill_parents() {
     921                global $wpdb;
     922
     923                // find parents for post orphans
     924                foreach ( $this->post_orphans as $child_id => $parent_id ) {
     925                        $local_child_id = $local_parent_id = false;
     926                        if ( isset( $this->processed_posts[$child_id] ) )
     927                                $local_child_id = $this->processed_posts[$child_id];
     928                        if ( isset( $this->processed_posts[$parent_id] ) )
     929                                $local_parent_id = $this->processed_posts[$parent_id];
     930
     931                        if ( $local_child_id && $local_parent_id )
     932                                $wpdb->update( $wpdb->posts, array( 'post_parent' => $local_parent_id ), array( 'ID' => $local_child_id ), '%d', '%d' );
     933                }
     934
     935                // all other posts/terms are imported, retry menu items with missing associated object
     936                $missing_menu_items = $this->missing_menu_items;
     937                foreach ( $missing_menu_items as $item )
     938                        $this->process_menu_item( $item );
     939
     940                // find parents for menu item orphans
     941                foreach ( $this->menu_item_orphans as $child_id => $parent_id ) {
     942                        $local_child_id = $local_parent_id = 0;
     943                        if ( isset( $this->processed_menu_items[$child_id] ) )
     944                                $local_child_id = $this->processed_menu_items[$child_id];
     945                        if ( isset( $this->processed_menu_items[$parent_id] ) )
     946                                $local_parent_id = $this->processed_menu_items[$parent_id];
     947
     948                        if ( $local_child_id && $local_parent_id )
     949                                update_post_meta( $local_child_id, '_menu_item_menu_item_parent', (int) $local_parent_id );
     950                }
     951        }
     952
     953        /**
     954         * Use stored mapping information to update old attachment URLs
     955         */
     956        function backfill_attachment_urls() {
     957                global $wpdb;
     958                // make sure we do the longest urls first, in case one is a substring of another
     959                uksort( $this->url_remap, array(&$this, 'cmpr_strlen') );
     960
     961                foreach ( $this->url_remap as $from_url => $to_url ) {
     962                        // remap urls in post_content
     963                        $wpdb->query( $wpdb->prepare("UPDATE {$wpdb->posts} SET post_content = REPLACE(post_content, %s, %s)", $from_url, $to_url) );
     964                        // remap enclosure urls
     965                        $result = $wpdb->query( $wpdb->prepare("UPDATE {$wpdb->postmeta} SET meta_value = REPLACE(meta_value, %s, %s) WHERE meta_key='enclosure'", $from_url, $to_url) );
     966                }
     967        }
     968
     969        /**
     970         * Update _thumbnail_id meta to new, imported attachment IDs
     971         */
     972        function remap_featured_images() {
     973                // cycle through posts that have a featured image
     974                foreach ( $this->featured_images as $post_id => $value ) {
     975                        if ( isset( $this->processed_posts[$value] ) ) {
     976                                $new_id = $this->processed_posts[$value];
     977                                // only update if there's a difference
     978                                if ( $new_id != $value )
     979                                        update_post_meta( $post_id, '_thumbnail_id', $new_id );
     980                        }
     981                }
     982        }
     983
     984        /**
     985         * Parse a WXR file
     986         *
     987         * @param string $file Path to WXR file for parsing
     988         * @return array Information gathered from the WXR file
     989         */
     990        function parse( $file ) {
     991                $parser = new WXR_Parser();
     992                return $parser->parse( $file );
     993        }
     994
     995        // Display import page title
     996        function header() {
     997                echo '<div class="wrap">';
     998                screen_icon();
     999                echo '<h2>' . __( 'Import WordPress', 'wordpress-importer' ) . '</h2>';
     1000
     1001                $updates = get_plugin_updates();
     1002                $basename = plugin_basename(__FILE__);
     1003                if ( isset( $updates[$basename] ) ) {
     1004                        $update = $updates[$basename];
     1005                        echo '<div class="error"><p><strong>';
     1006                        printf( __( 'A new version of this importer is available. Please update to version %s to ensure compatibility with newer export files.', 'wordpress-importer' ), $update->update->new_version );
     1007                        echo '</strong></p></div>';
     1008                }
     1009        }
     1010
     1011        // Close div.wrap
     1012        function footer() {
     1013                echo '</div>';
     1014        }
     1015
     1016        /**
     1017         * Display introductory text and file upload form
     1018         */
     1019        function greet() {
     1020                echo '<div class="narrow">';
     1021                echo '<p>'.__( 'Howdy! Upload your WordPress eXtended RSS (WXR) file and we&#8217;ll import the posts, pages, comments, custom fields, categories, and tags into this site.', 'wordpress-importer' ).'</p>';
     1022                echo '<p>'.__( 'Choose a WXR (.xml) file to upload, then click Upload file and import.', 'wordpress-importer' ).'</p>';
     1023                wp_import_upload_form( 'admin.php?import=wordpress&amp;step=1' );
     1024                echo '</div>';
     1025        }
     1026
     1027        /**
     1028         * Decide if the given meta key maps to information we will want to import
     1029         *
     1030         * @param string $key The meta key to check
     1031         * @return string|bool The key if we do want to import, false if not
     1032         */
     1033        function is_valid_meta_key( $key ) {
     1034                // skip attachment metadata since we'll regenerate it from scratch
     1035                // skip _edit_lock as not relevant for import
     1036                if ( in_array( $key, array( '_wp_attached_file', '_wp_attachment_metadata', '_edit_lock' ) ) )
     1037                        return false;
     1038                return $key;
     1039        }
     1040
     1041        /**
     1042         * Decide whether or not the importer is allowed to create users.
     1043         * Default is true, can be filtered via import_allow_create_users
     1044         *
     1045         * @return bool True if creating users is allowed
     1046         */
     1047        function allow_create_users() {
     1048                return apply_filters( 'import_allow_create_users', true );
     1049        }
     1050
     1051        /**
     1052         * Decide whether or not the importer should attempt to download attachment files.
     1053         * Default is true, can be filtered via import_allow_fetch_attachments. The choice
     1054         * made at the import options screen must also be true, false here hides that checkbox.
     1055         *
     1056         * @return bool True if downloading attachments is allowed
     1057         */
     1058        function allow_fetch_attachments() {
     1059                return apply_filters( 'import_allow_fetch_attachments', true );
     1060        }
     1061
     1062        /**
     1063         * Decide what the maximum file size for downloaded attachments is.
     1064         * Default is 0 (unlimited), can be filtered via import_attachment_size_limit
     1065         *
     1066         * @return int Maximum attachment file size to import
     1067         */
     1068        function max_attachment_size() {
     1069                return apply_filters( 'import_attachment_size_limit', 0 );
     1070        }
     1071
     1072        /**
     1073         * Added to http_request_timeout filter to force timeout at 60 seconds during import
     1074         * @return int 60
     1075         */
     1076        function bump_request_timeout() {
     1077                return 60;
     1078        }
     1079
     1080        // return the difference in length between two strings
     1081        function cmpr_strlen( $a, $b ) {
     1082                return strlen($b) - strlen($a);
     1083        }
     1084}
     1085
     1086} // class_exists( 'WP_Importer' )
     1087
     1088function wordpress_importer_init() {
     1089        load_plugin_textdomain( 'wordpress-importer', false, dirname( plugin_basename( __FILE__ ) ) . '/languages' );
     1090
     1091        /**
     1092         * WordPress Importer object for registering the import callback
     1093         * @global WP_Import $wp_import
     1094         */
     1095        $GLOBALS['wp_import'] = new WP_Import();
     1096        register_importer( 'wordpress', 'WordPress', __('Import <strong>posts, pages, comments, custom fields, categories, and tags</strong> from a WordPress export file.', 'wordpress-importer'), array( $GLOBALS['wp_import'], 'dispatch' ) );
     1097}
     1098add_action( 'admin_init', 'wordpress_importer_init' );
  • wp-content/plugins/wordpress-importer/readme.txt

     
     1=== Plugin Name ===
     2Contributors: wordpressdotorg
     3Donate link:
     4Tags: importer, wordpress
     5Requires at least: 3.0
     6Tested up to: 3.4
     7Stable tag: 0.6
     8
     9Import posts, pages, comments, custom fields, categories, tags and more from a WordPress export file.
     10
     11== Description ==
     12
     13The WordPress Importer will import the following content from a WordPress export file:
     14
     15* Posts, pages and other custom post types
     16* Comments
     17* Custom fields and post meta
     18* Categories, tags and terms from custom taxonomies
     19* Authors
     20
     21For further information and instructions please see the [Codex page on Importing Content](http://codex.wordpress.org/Importing_Content#WordPress)
     22
     23== Installation ==
     24
     25The quickest method for installing the importer is:
     26
     271. Visit Tools -> Import in the WordPress dashboard
     281. Click on the WordPress link in the list of importers
     291. Click "Install Now"
     301. Finally click "Activate Plugin & Run Importer"
     31
     32If you would prefer to do things manually then follow these instructions:
     33
     341. Upload the `wordpress-importer` folder to the `/wp-content/plugins/` directory
     351. Activate the plugin through the 'Plugins' menu in WordPress
     361. Go to the Tools -> Import screen, click on WordPress
     37
     38== Changelog ==
     39
     40= 0.6 =
     41* Support for WXR 1.2 and multiple CDATA sections
     42* Post aren't duplicates if their post_type's are different
     43
     44= 0.5.2 =
     45* Double check that the uploaded export file exists before processing it. This prevents incorrect error messages when
     46an export file is uploaded to a server with bad permissions and WordPress 3.3 or 3.3.1 is being used.
     47
     48= 0.5 =
     49* Import comment meta (requires export from WordPress 3.2)
     50* Minor bugfixes and enhancements
     51
     52= 0.4 =
     53* Map comment user_id where possible
     54* Import attachments from `wp:attachment_url`
     55* Upload attachments to correct directory
     56* Remap resized image URLs correctly
     57
     58= 0.3 =
     59* Use an XML Parser if possible
     60* Proper import support for nav menus
     61* ... and much more, see [Trac ticket #15197](http://core.trac.wordpress.org/ticket/15197)
     62
     63= 0.1 =
     64* Initial release
     65
     66== Upgrade Notice ==
     67
     68= 0.6 =
     69Support for exports from WordPress 3.4.
     70
     71= 0.5.2 =
     72Fix incorrect error message when the export file could not be uploaded.
     73
     74= 0.5 =
     75Import comment meta and other minor bugfixes and enhancements.
     76
     77= 0.4 =
     78Bug fixes for attachment importing and other small enhancements.
     79
     80= 0.3 =
     81Upgrade for a more robust and reliable experience when importing WordPress export files, and for compatibility with WordPress 3.1.
     82
     83== Frequently Asked Questions ==
     84
     85= Help! I'm getting out of memory errors or a blank screen. =
     86If your exported file is very large, the import script may run into your host's configured memory limit for PHP.
     87
     88A message like "Fatal error: Allowed memory size of 8388608 bytes exhausted" indicates that the script can't successfully import your XML file under the current PHP memory limit. If you have access to the php.ini file, you can manually increase the limit; if you do not (your WordPress installation is hosted on a shared server, for instance), you might have to break your exported XML file into several smaller pieces and run the import script one at a time.
     89
     90For those with shared hosting, the best alternative may be to consult hosting support to determine the safest approach for running the import. A host may be willing to temporarily lift the memory limit and/or run the process directly from their end.
     91
     92-- [WordPress Codex: Importing Content](http://codex.wordpress.org/Importing_Content#Before_Importing)
     93
     94== Filters ==
     95
     96The importer has a couple of filters to allow you to completely enable/block certain features:
     97
     98* `import_allow_create_users`: return false if you only want to allow mapping to existing users
     99* `import_allow_fetch_attachments`: return false if you do not wish to allow importing and downloading of attachments
     100* `import_attachment_size_limit`: return an integer value for the maximum file size in bytes to save (default is 0, which is unlimited)
     101
     102There are also a few actions available to hook into:
     103
     104* `import_start`: occurs after the export file has been uploaded and author import settings have been chosen
     105* `import_end`: called after the last output from the importer
  • wp-content/plugins/wordpress-importer/parsers.php

     
     1<?php
     2/**
     3 * WordPress eXtended RSS file parser implementations
     4 *
     5 * @package WordPress
     6 * @subpackage Importer
     7 */
     8
     9/**
     10 * WordPress Importer class for managing parsing of WXR files.
     11 */
     12class WXR_Parser {
     13        function parse( $file ) {
     14                // Attempt to use proper XML parsers first
     15                if ( extension_loaded( 'simplexml' ) ) {
     16                        $parser = new WXR_Parser_SimpleXML;
     17                        $result = $parser->parse( $file );
     18
     19                        // If SimpleXML succeeds or this is an invalid WXR file then return the results
     20                        if ( ! is_wp_error( $result ) || 'SimpleXML_parse_error' != $result->get_error_code() )
     21                                return $result;
     22                } else if ( extension_loaded( 'xml' ) ) {
     23                        $parser = new WXR_Parser_XML;
     24                        $result = $parser->parse( $file );
     25
     26                        // If XMLParser succeeds or this is an invalid WXR file then return the results
     27                        if ( ! is_wp_error( $result ) || 'XML_parse_error' != $result->get_error_code() )
     28                                return $result;
     29                }
     30
     31                // We have a malformed XML file, so display the error and fallthrough to regex
     32                if ( isset($result) && defined('IMPORT_DEBUG') && IMPORT_DEBUG ) {
     33                        echo '<pre>';
     34                        if ( 'SimpleXML_parse_error' == $result->get_error_code() ) {
     35                                foreach  ( $result->get_error_data() as $error )
     36                                        echo $error->line . ':' . $error->column . ' ' . esc_html( $error->message ) . "\n";
     37                        } else if ( 'XML_parse_error' == $result->get_error_code() ) {
     38                                $error = $result->get_error_data();
     39                                echo $error[0] . ':' . $error[1] . ' ' . esc_html( $error[2] );
     40                        }
     41                        echo '</pre>';
     42                        echo '<p><strong>' . __( 'There was an error when reading this WXR file', 'wordpress-importer' ) . '</strong><br />';
     43                        echo __( 'Details are shown above. The importer will now try again with a different parser...', 'wordpress-importer' ) . '</p>';
     44                }
     45
     46                // use regular expressions if nothing else available or this is bad XML
     47                $parser = new WXR_Parser_Regex;
     48                return $parser->parse( $file );
     49        }
     50}
     51
     52/**
     53 * WXR Parser that makes use of the SimpleXML PHP extension.
     54 */
     55class WXR_Parser_SimpleXML {
     56        function parse( $file ) {
     57                $authors = $posts = $categories = $tags = $terms = array();
     58
     59                $internal_errors = libxml_use_internal_errors(true);
     60                $xml = simplexml_load_file( $file );
     61                // halt if loading produces an error
     62                if ( ! $xml )
     63                        return new WP_Error( 'SimpleXML_parse_error', __( 'There was an error when reading this WXR file', 'wordpress-importer' ), libxml_get_errors() );
     64
     65                $wxr_version = $xml->xpath('/rss/channel/wp:wxr_version');
     66                if ( ! $wxr_version )
     67                        return new WP_Error( 'WXR_parse_error', __( 'This does not appear to be a WXR file, missing/invalid WXR version number', 'wordpress-importer' ) );
     68
     69                $wxr_version = (string) trim( $wxr_version[0] );
     70                // confirm that we are dealing with the correct file format
     71                if ( ! preg_match( '/^\d+\.\d+$/', $wxr_version ) )
     72                        return new WP_Error( 'WXR_parse_error', __( 'This does not appear to be a WXR file, missing/invalid WXR version number', 'wordpress-importer' ) );
     73
     74                $base_url = $xml->xpath('/rss/channel/wp:base_site_url');
     75                $base_url = (string) trim( $base_url[0] );
     76
     77                $namespaces = $xml->getDocNamespaces();
     78                if ( ! isset( $namespaces['wp'] ) )
     79                        $namespaces['wp'] = 'http://wordpress.org/export/1.1/';
     80                if ( ! isset( $namespaces['excerpt'] ) )
     81                        $namespaces['excerpt'] = 'http://wordpress.org/export/1.1/excerpt/';
     82
     83                // grab authors
     84                foreach ( $xml->xpath('/rss/channel/wp:author') as $author_arr ) {
     85                        $a = $author_arr->children( $namespaces['wp'] );
     86                        $login = (string) $a->author_login;
     87                        $authors[$login] = array(
     88                                'author_id' => (int) $a->author_id,
     89                                'author_login' => $login,
     90                                'author_email' => (string) $a->author_email,
     91                                'author_display_name' => (string) $a->author_display_name,
     92                                'author_first_name' => (string) $a->author_first_name,
     93                                'author_last_name' => (string) $a->author_last_name
     94                        );
     95                }
     96
     97                // grab cats, tags and terms
     98                foreach ( $xml->xpath('/rss/channel/wp:category') as $term_arr ) {
     99                        $t = $term_arr->children( $namespaces['wp'] );
     100                        $categories[] = array(
     101                                'term_id' => (int) $t->term_id,
     102                                'category_nicename' => (string) $t->category_nicename,
     103                                'category_parent' => (string) $t->category_parent,
     104                                'cat_name' => (string) $t->cat_name,
     105                                'category_description' => (string) $t->category_description
     106                        );
     107                }
     108
     109                foreach ( $xml->xpath('/rss/channel/wp:tag') as $term_arr ) {
     110                        $t = $term_arr->children( $namespaces['wp'] );
     111                        $tags[] = array(
     112                                'term_id' => (int) $t->term_id,
     113                                'tag_slug' => (string) $t->tag_slug,
     114                                'tag_name' => (string) $t->tag_name,
     115                                'tag_description' => (string) $t->tag_description
     116                        );
     117                }
     118
     119                foreach ( $xml->xpath('/rss/channel/wp:term') as $term_arr ) {
     120                        $t = $term_arr->children( $namespaces['wp'] );
     121                        $terms[] = array(
     122                                'term_id' => (int) $t->term_id,
     123                                'term_taxonomy' => (string) $t->term_taxonomy,
     124                                'slug' => (string) $t->term_slug,
     125                                'term_parent' => (string) $t->term_parent,
     126                                'term_name' => (string) $t->term_name,
     127                                'term_description' => (string) $t->term_description
     128                        );
     129                }
     130
     131                // grab posts
     132                foreach ( $xml->channel->item as $item ) {
     133                        $post = array(
     134                                'post_title' => (string) $item->title,
     135                                'guid' => (string) $item->guid,
     136                        );
     137
     138                        $dc = $item->children( 'http://purl.org/dc/elements/1.1/' );
     139                        $post['post_author'] = (string) $dc->creator;
     140
     141                        $content = $item->children( 'http://purl.org/rss/1.0/modules/content/' );
     142                        $excerpt = $item->children( $namespaces['excerpt'] );
     143                        $post['post_content'] = (string) $content->encoded;
     144                        $post['post_excerpt'] = (string) $excerpt->encoded;
     145
     146                        $wp = $item->children( $namespaces['wp'] );
     147                        $post['post_id'] = (int) $wp->post_id;
     148                        $post['post_date'] = (string) $wp->post_date;
     149                        $post['post_date_gmt'] = (string) $wp->post_date_gmt;
     150                        $post['comment_status'] = (string) $wp->comment_status;
     151                        $post['ping_status'] = (string) $wp->ping_status;
     152                        $post['post_name'] = (string) $wp->post_name;
     153                        $post['status'] = (string) $wp->status;
     154                        $post['post_parent'] = (int) $wp->post_parent;
     155                        $post['menu_order'] = (int) $wp->menu_order;
     156                        $post['post_type'] = (string) $wp->post_type;
     157                        $post['post_password'] = (string) $wp->post_password;
     158                        $post['is_sticky'] = (int) $wp->is_sticky;
     159
     160                        if ( isset($wp->attachment_url) )
     161                                $post['attachment_url'] = (string) $wp->attachment_url;
     162
     163                        foreach ( $item->category as $c ) {
     164                                $att = $c->attributes();
     165                                if ( isset( $att['nicename'] ) )
     166                                        $post['terms'][] = array(
     167                                                'name' => (string) $c,
     168                                                'slug' => (string) $att['nicename'],
     169                                                'domain' => (string) $att['domain']
     170                                        );
     171                        }
     172
     173                        foreach ( $wp->postmeta as $meta ) {
     174                                $post['postmeta'][] = array(
     175                                        'key' => (string) $meta->meta_key,
     176                                        'value' => (string) $meta->meta_value
     177                                );
     178                        }
     179
     180                        foreach ( $wp->comment as $comment ) {
     181                                $meta = array();
     182                                if ( isset( $comment->commentmeta ) ) {
     183                                        foreach ( $comment->commentmeta as $m ) {
     184                                                $meta[] = array(
     185                                                        'key' => (string) $m->meta_key,
     186                                                        'value' => (string) $m->meta_value
     187                                                );
     188                                        }
     189                                }
     190                       
     191                                $post['comments'][] = array(
     192                                        'comment_id' => (int) $comment->comment_id,
     193                                        'comment_author' => (string) $comment->comment_author,
     194                                        'comment_author_email' => (string) $comment->comment_author_email,
     195                                        'comment_author_IP' => (string) $comment->comment_author_IP,
     196                                        'comment_author_url' => (string) $comment->comment_author_url,
     197                                        'comment_date' => (string) $comment->comment_date,
     198                                        'comment_date_gmt' => (string) $comment->comment_date_gmt,
     199                                        'comment_content' => (string) $comment->comment_content,
     200                                        'comment_approved' => (string) $comment->comment_approved,
     201                                        'comment_type' => (string) $comment->comment_type,
     202                                        'comment_parent' => (string) $comment->comment_parent,
     203                                        'comment_user_id' => (int) $comment->comment_user_id,
     204                                        'commentmeta' => $meta,
     205                                );
     206                        }
     207
     208                        $posts[] = $post;
     209                }
     210
     211                return array(
     212                        'authors' => $authors,
     213                        'posts' => $posts,
     214                        'categories' => $categories,
     215                        'tags' => $tags,
     216                        'terms' => $terms,
     217                        'base_url' => $base_url,
     218                        'version' => $wxr_version
     219                );
     220        }
     221}
     222
     223/**
     224 * WXR Parser that makes use of the XML Parser PHP extension.
     225 */
     226class WXR_Parser_XML {
     227        var $wp_tags = array(
     228                'wp:post_id', 'wp:post_date', 'wp:post_date_gmt', 'wp:comment_status', 'wp:ping_status', 'wp:attachment_url',
     229                'wp:status', 'wp:post_name', 'wp:post_parent', 'wp:menu_order', 'wp:post_type', 'wp:post_password',
     230                'wp:is_sticky', 'wp:term_id', 'wp:category_nicename', 'wp:category_parent', 'wp:cat_name', 'wp:category_description',
     231                'wp:tag_slug', 'wp:tag_name', 'wp:tag_description', 'wp:term_taxonomy', 'wp:term_parent',
     232                'wp:term_name', 'wp:term_description', 'wp:author_id', 'wp:author_login', 'wp:author_email', 'wp:author_display_name',
     233                'wp:author_first_name', 'wp:author_last_name',
     234        );
     235        var $wp_sub_tags = array(
     236                'wp:comment_id', 'wp:comment_author', 'wp:comment_author_email', 'wp:comment_author_url',
     237                'wp:comment_author_IP', 'wp:comment_date', 'wp:comment_date_gmt', 'wp:comment_content',
     238                'wp:comment_approved', 'wp:comment_type', 'wp:comment_parent', 'wp:comment_user_id',
     239        );
     240
     241        function parse( $file ) {
     242                $this->wxr_version = $this->in_post = $this->cdata = $this->data = $this->sub_data = $this->in_tag = $this->in_sub_tag = false;
     243                $this->authors = $this->posts = $this->term = $this->category = $this->tag = array();
     244
     245                $xml = xml_parser_create( 'UTF-8' );
     246                xml_parser_set_option( $xml, XML_OPTION_SKIP_WHITE, 1 );
     247                xml_parser_set_option( $xml, XML_OPTION_CASE_FOLDING, 0 );
     248                xml_set_object( $xml, $this );
     249                xml_set_character_data_handler( $xml, 'cdata' );
     250                xml_set_element_handler( $xml, 'tag_open', 'tag_close' );
     251
     252                if ( ! xml_parse( $xml, file_get_contents( $file ), true ) ) {
     253                        $current_line = xml_get_current_line_number( $xml );
     254                        $current_column = xml_get_current_column_number( $xml );
     255                        $error_code = xml_get_error_code( $xml );
     256                        $error_string = xml_error_string( $error_code );
     257                        return new WP_Error( 'XML_parse_error', 'There was an error when reading this WXR file', array( $current_line, $current_column, $error_string ) );
     258                }
     259                xml_parser_free( $xml );
     260
     261                if ( ! preg_match( '/^\d+\.\d+$/', $this->wxr_version ) )
     262                        return new WP_Error( 'WXR_parse_error', __( 'This does not appear to be a WXR file, missing/invalid WXR version number', 'wordpress-importer' ) );
     263
     264                return array(
     265                        'authors' => $this->authors,
     266                        'posts' => $this->posts,
     267                        'categories' => $this->category,
     268                        'tags' => $this->tag,
     269                        'terms' => $this->term,
     270                        'base_url' => $this->base_url,
     271                        'version' => $this->wxr_version
     272                );
     273        }
     274
     275        function tag_open( $parse, $tag, $attr ) {
     276                if ( in_array( $tag, $this->wp_tags ) ) {
     277                        $this->in_tag = substr( $tag, 3 );
     278                        return;
     279                }
     280
     281                if ( in_array( $tag, $this->wp_sub_tags ) ) {
     282                        $this->in_sub_tag = substr( $tag, 3 );
     283                        return;
     284                }
     285
     286                switch ( $tag ) {
     287                        case 'category':
     288                                if ( isset($attr['domain'], $attr['nicename']) ) {
     289                                        $this->sub_data['domain'] = $attr['domain'];
     290                                        $this->sub_data['slug'] = $attr['nicename'];
     291                                }
     292                                break;
     293                        case 'item': $this->in_post = true;
     294                        case 'title': if ( $this->in_post ) $this->in_tag = 'post_title'; break;
     295                        case 'guid': $this->in_tag = 'guid'; break;
     296                        case 'dc:creator': $this->in_tag = 'post_author'; break;
     297                        case 'content:encoded': $this->in_tag = 'post_content'; break;
     298                        case 'excerpt:encoded': $this->in_tag = 'post_excerpt'; break;
     299
     300                        case 'wp:term_slug': $this->in_tag = 'slug'; break;
     301                        case 'wp:meta_key': $this->in_sub_tag = 'key'; break;
     302                        case 'wp:meta_value': $this->in_sub_tag = 'value'; break;
     303                }
     304        }
     305
     306        function cdata( $parser, $cdata ) {
     307                if ( ! trim( $cdata ) )
     308                        return;
     309
     310                $this->cdata .= trim( $cdata );
     311        }
     312
     313        function tag_close( $parser, $tag ) {
     314                switch ( $tag ) {
     315                        case 'wp:comment':
     316                                unset( $this->sub_data['key'], $this->sub_data['value'] ); // remove meta sub_data
     317                                if ( ! empty( $this->sub_data ) )
     318                                        $this->data['comments'][] = $this->sub_data;
     319                                $this->sub_data = false;
     320                                break;
     321                        case 'wp:commentmeta':
     322                                $this->sub_data['commentmeta'][] = array(
     323                                        'key' => $this->sub_data['key'],
     324                                        'value' => $this->sub_data['value']
     325                                );
     326                                break;
     327                        case 'category':
     328                                if ( ! empty( $this->sub_data ) ) {
     329                                        $this->sub_data['name'] = $this->cdata;
     330                                        $this->data['terms'][] = $this->sub_data;
     331                                }
     332                                $this->sub_data = false;
     333                                break;
     334                        case 'wp:postmeta':
     335                                if ( ! empty( $this->sub_data ) )
     336                                        $this->data['postmeta'][] = $this->sub_data;
     337                                $this->sub_data = false;
     338                                break;
     339                        case 'item':
     340                                $this->posts[] = $this->data;
     341                                $this->data = false;
     342                                break;
     343                        case 'wp:category':
     344                        case 'wp:tag':
     345                        case 'wp:term':
     346                                $n = substr( $tag, 3 );
     347                                array_push( $this->$n, $this->data );
     348                                $this->data = false;
     349                                break;
     350                        case 'wp:author':
     351                                if ( ! empty($this->data['author_login']) )
     352                                        $this->authors[$this->data['author_login']] = $this->data;
     353                                $this->data = false;
     354                                break;
     355                        case 'wp:base_site_url':
     356                                $this->base_url = $this->cdata;
     357                                break;
     358                        case 'wp:wxr_version':
     359                                $this->wxr_version = $this->cdata;
     360                                break;
     361
     362                        default:
     363                                if ( $this->in_sub_tag ) {
     364                                        $this->sub_data[$this->in_sub_tag] = ! empty( $this->cdata ) ? $this->cdata : '';
     365                                        $this->in_sub_tag = false;
     366                                } else if ( $this->in_tag ) {
     367                                        $this->data[$this->in_tag] = ! empty( $this->cdata ) ? $this->cdata : '';
     368                                        $this->in_tag = false;
     369                                }
     370                }
     371
     372                $this->cdata = false;
     373        }
     374}
     375
     376/**
     377 * WXR Parser that uses regular expressions. Fallback for installs without an XML parser.
     378 */
     379class WXR_Parser_Regex {
     380        var $authors = array();
     381        var $posts = array();
     382        var $categories = array();
     383        var $tags = array();
     384        var $terms = array();
     385        var $base_url = '';
     386
     387        function WXR_Parser_Regex() {
     388                $this->__construct();
     389        }
     390
     391        function __construct() {
     392                $this->has_gzip = is_callable( 'gzopen' );
     393        }
     394
     395        function parse( $file ) {
     396                $wxr_version = $in_post = false;
     397
     398                $fp = $this->fopen( $file, 'r' );
     399                if ( $fp ) {
     400                        while ( ! $this->feof( $fp ) ) {
     401                                $importline = rtrim( $this->fgets( $fp ) );
     402
     403                                if ( ! $wxr_version && preg_match( '|<wp:wxr_version>(\d+\.\d+)</wp:wxr_version>|', $importline, $version ) )
     404                                        $wxr_version = $version[1];
     405
     406                                if ( false !== strpos( $importline, '<wp:base_site_url>' ) ) {
     407                                        preg_match( '|<wp:base_site_url>(.*?)</wp:base_site_url>|is', $importline, $url );
     408                                        $this->base_url = $url[1];
     409                                        continue;
     410                                }
     411                                if ( false !== strpos( $importline, '<wp:category>' ) ) {
     412                                        preg_match( '|<wp:category>(.*?)</wp:category>|is', $importline, $category );
     413                                        $this->categories[] = $this->process_category( $category[1] );
     414                                        continue;
     415                                }
     416                                if ( false !== strpos( $importline, '<wp:tag>' ) ) {
     417                                        preg_match( '|<wp:tag>(.*?)</wp:tag>|is', $importline, $tag );
     418                                        $this->tags[] = $this->process_tag( $tag[1] );
     419                                        continue;
     420                                }
     421                                if ( false !== strpos( $importline, '<wp:term>' ) ) {
     422                                        preg_match( '|<wp:term>(.*?)</wp:term>|is', $importline, $term );
     423                                        $this->terms[] = $this->process_term( $term[1] );
     424                                        continue;
     425                                }
     426                                if ( false !== strpos( $importline, '<wp:author>' ) ) {
     427                                        preg_match( '|<wp:author>(.*?)</wp:author>|is', $importline, $author );
     428                                        $a = $this->process_author( $author[1] );
     429                                        $this->authors[$a['author_login']] = $a;
     430                                        continue;
     431                                }
     432                                if ( false !== strpos( $importline, '<item>' ) ) {
     433                                        $post = '';
     434                                        $in_post = true;
     435                                        continue;
     436                                }
     437                                if ( false !== strpos( $importline, '</item>' ) ) {
     438                                        $in_post = false;
     439                                        $this->posts[] = $this->process_post( $post );
     440                                        continue;
     441                                }
     442                                if ( $in_post ) {
     443                                        $post .= $importline . "\n";
     444                                }
     445                        }
     446
     447                        $this->fclose($fp);
     448                }
     449
     450                if ( ! $wxr_version )
     451                        return new WP_Error( 'WXR_parse_error', __( 'This does not appear to be a WXR file, missing/invalid WXR version number', 'wordpress-importer' ) );
     452
     453                return array(
     454                        'authors' => $this->authors,
     455                        'posts' => $this->posts,
     456                        'categories' => $this->categories,
     457                        'tags' => $this->tags,
     458                        'terms' => $this->terms,
     459                        'base_url' => $this->base_url,
     460                        'version' => $wxr_version
     461                );
     462        }
     463
     464        function get_tag( $string, $tag ) {
     465                preg_match( "|<$tag.*?>(.*?)</$tag>|is", $string, $return );
     466                if ( isset( $return[1] ) ) {
     467                        if ( substr( $return[1], 0, 9 ) == '<![CDATA[' ) {
     468                                if ( strpos( $return[1], ']]]]><![CDATA[>' ) !== false ) {
     469                                        preg_match_all( '|<!\[CDATA\[(.*?)\]\]>|s', $return[1], $matches );
     470                                        $return = '';
     471                                        foreach( $matches[1] as $match )
     472                                                $return .= $match;
     473                                } else {
     474                                        $return = preg_replace( '|^<!\[CDATA\[(.*)\]\]>$|s', '$1', $return[1] );
     475                                }
     476                        } else {
     477                                $return = $return[1];
     478                        }
     479                } else {
     480                        $return = '';
     481                }
     482                return $return;
     483        }
     484
     485        function process_category( $c ) {
     486                return array(
     487                        'term_id' => $this->get_tag( $c, 'wp:term_id' ),
     488                        'cat_name' => $this->get_tag( $c, 'wp:cat_name' ),
     489                        'category_nicename'     => $this->get_tag( $c, 'wp:category_nicename' ),
     490                        'category_parent' => $this->get_tag( $c, 'wp:category_parent' ),
     491                        'category_description' => $this->get_tag( $c, 'wp:category_description' ),
     492                );
     493        }
     494
     495        function process_tag( $t ) {
     496                return array(
     497                        'term_id' => $this->get_tag( $t, 'wp:term_id' ),
     498                        'tag_name' => $this->get_tag( $t, 'wp:tag_name' ),
     499                        'tag_slug' => $this->get_tag( $t, 'wp:tag_slug' ),
     500                        'tag_description' => $this->get_tag( $t, 'wp:tag_description' ),
     501                );
     502        }
     503
     504        function process_term( $t ) {
     505                return array(
     506                        'term_id' => $this->get_tag( $t, 'wp:term_id' ),
     507                        'term_taxonomy' => $this->get_tag( $t, 'wp:term_taxonomy' ),
     508                        'slug' => $this->get_tag( $t, 'wp:term_slug' ),
     509                        'term_parent' => $this->get_tag( $t, 'wp:term_parent' ),
     510                        'term_name' => $this->get_tag( $t, 'wp:term_name' ),
     511                        'term_description' => $this->get_tag( $t, 'wp:term_description' ),
     512                );
     513        }
     514
     515        function process_author( $a ) {
     516                return array(
     517                        'author_id' => $this->get_tag( $a, 'wp:author_id' ),
     518                        'author_login' => $this->get_tag( $a, 'wp:author_login' ),
     519                        'author_email' => $this->get_tag( $a, 'wp:author_email' ),
     520                        'author_display_name' => $this->get_tag( $a, 'wp:author_display_name' ),
     521                        'author_first_name' => $this->get_tag( $a, 'wp:author_first_name' ),
     522                        'author_last_name' => $this->get_tag( $a, 'wp:author_last_name' ),
     523                );
     524        }
     525
     526        function process_post( $post ) {
     527                $post_id        = $this->get_tag( $post, 'wp:post_id' );
     528                $post_title     = $this->get_tag( $post, 'title' );
     529                $post_date      = $this->get_tag( $post, 'wp:post_date' );
     530                $post_date_gmt  = $this->get_tag( $post, 'wp:post_date_gmt' );
     531                $comment_status = $this->get_tag( $post, 'wp:comment_status' );
     532                $ping_status    = $this->get_tag( $post, 'wp:ping_status' );
     533                $status         = $this->get_tag( $post, 'wp:status' );
     534                $post_name      = $this->get_tag( $post, 'wp:post_name' );
     535                $post_parent    = $this->get_tag( $post, 'wp:post_parent' );
     536                $menu_order     = $this->get_tag( $post, 'wp:menu_order' );
     537                $post_type      = $this->get_tag( $post, 'wp:post_type' );
     538                $post_password  = $this->get_tag( $post, 'wp:post_password' );
     539                $is_sticky      = $this->get_tag( $post, 'wp:is_sticky' );
     540                $guid           = $this->get_tag( $post, 'guid' );
     541                $post_author    = $this->get_tag( $post, 'dc:creator' );
     542
     543                $post_excerpt = $this->get_tag( $post, 'excerpt:encoded' );
     544                $post_excerpt = preg_replace_callback( '|<(/?[A-Z]+)|', array( &$this, '_normalize_tag' ), $post_excerpt );
     545                $post_excerpt = str_replace( '<br>', '<br />', $post_excerpt );
     546                $post_excerpt = str_replace( '<hr>', '<hr />', $post_excerpt );
     547
     548                $post_content = $this->get_tag( $post, 'content:encoded' );
     549                $post_content = preg_replace_callback( '|<(/?[A-Z]+)|', array( &$this, '_normalize_tag' ), $post_content );
     550                $post_content = str_replace( '<br>', '<br />', $post_content );
     551                $post_content = str_replace( '<hr>', '<hr />', $post_content );
     552
     553                $postdata = compact( 'post_id', 'post_author', 'post_date', 'post_date_gmt', 'post_content', 'post_excerpt',
     554                        'post_title', 'status', 'post_name', 'comment_status', 'ping_status', 'guid', 'post_parent',
     555                        'menu_order', 'post_type', 'post_password', 'is_sticky'
     556                );
     557
     558                $attachment_url = $this->get_tag( $post, 'wp:attachment_url' );
     559                if ( $attachment_url )
     560                        $postdata['attachment_url'] = $attachment_url;
     561
     562                preg_match_all( '|<category domain="([^"]+?)" nicename="([^"]+?)">(.+?)</category>|is', $post, $terms, PREG_SET_ORDER );
     563                foreach ( $terms as $t ) {
     564                        $post_terms[] = array(
     565                                'slug' => $t[2],
     566                                'domain' => $t[1],
     567                                'name' => str_replace( array( '<![CDATA[', ']]>' ), '', $t[3] ),
     568                        );
     569                }
     570                if ( ! empty( $post_terms ) ) $postdata['terms'] = $post_terms;
     571
     572                preg_match_all( '|<wp:comment>(.+?)</wp:comment>|is', $post, $comments );
     573                $comments = $comments[1];
     574                if ( $comments ) {
     575                        foreach ( $comments as $comment ) {
     576                                preg_match_all( '|<wp:commentmeta>(.+?)</wp:commentmeta>|is', $comment, $commentmeta );
     577                                $commentmeta = $commentmeta[1];
     578                                $c_meta = array();
     579                                foreach ( $commentmeta as $m ) {
     580                                        $c_meta[] = array(
     581                                                'key' => $this->get_tag( $m, 'wp:meta_key' ),
     582                                                'value' => $this->get_tag( $m, 'wp:meta_value' ),
     583                                        );
     584                                }
     585
     586                                $post_comments[] = array(
     587                                        'comment_id' => $this->get_tag( $comment, 'wp:comment_id' ),
     588                                        'comment_author' => $this->get_tag( $comment, 'wp:comment_author' ),
     589                                        'comment_author_email' => $this->get_tag( $comment, 'wp:comment_author_email' ),
     590                                        'comment_author_IP' => $this->get_tag( $comment, 'wp:comment_author_IP' ),
     591                                        'comment_author_url' => $this->get_tag( $comment, 'wp:comment_author_url' ),
     592                                        'comment_date' => $this->get_tag( $comment, 'wp:comment_date' ),
     593                                        'comment_date_gmt' => $this->get_tag( $comment, 'wp:comment_date_gmt' ),
     594                                        'comment_content' => $this->get_tag( $comment, 'wp:comment_content' ),
     595                                        'comment_approved' => $this->get_tag( $comment, 'wp:comment_approved' ),
     596                                        'comment_type' => $this->get_tag( $comment, 'wp:comment_type' ),
     597                                        'comment_parent' => $this->get_tag( $comment, 'wp:comment_parent' ),
     598                                        'comment_user_id' => $this->get_tag( $comment, 'wp:comment_user_id' ),
     599                                        'commentmeta' => $c_meta,
     600                                );
     601                        }
     602                }
     603                if ( ! empty( $post_comments ) ) $postdata['comments'] = $post_comments;
     604
     605                preg_match_all( '|<wp:postmeta>(.+?)</wp:postmeta>|is', $post, $postmeta );
     606                $postmeta = $postmeta[1];
     607                if ( $postmeta ) {
     608                        foreach ( $postmeta as $p ) {
     609                                $post_postmeta[] = array(
     610                                        'key' => $this->get_tag( $p, 'wp:meta_key' ),
     611                                        'value' => $this->get_tag( $p, 'wp:meta_value' ),
     612                                );
     613                        }
     614                }
     615                if ( ! empty( $post_postmeta ) ) $postdata['postmeta'] = $post_postmeta;
     616
     617                return $postdata;
     618        }
     619
     620        function _normalize_tag( $matches ) {
     621                return '<' . strtolower( $matches[1] );
     622        }
     623
     624        function fopen( $filename, $mode = 'r' ) {
     625                if ( $this->has_gzip )
     626                        return gzopen( $filename, $mode );
     627                return fopen( $filename, $mode );
     628        }
     629
     630        function feof( $fp ) {
     631                if ( $this->has_gzip )
     632                        return gzeof( $fp );
     633                return feof( $fp );
     634        }
     635
     636        function fgets( $fp, $len = 8192 ) {
     637                if ( $this->has_gzip )
     638                        return gzgets( $fp, $len );
     639                return fgets( $fp, $len );
     640        }
     641
     642        function fclose( $fp ) {
     643                if ( $this->has_gzip )
     644                        return gzclose( $fp );
     645                return fclose( $fp );
     646        }
     647}
  • wp-content/plugins/wordpress-importer/languages/wordpress-importer.pot

     
     1# Copyright (C) 2011 WordPress Importer
     2# This file is distributed under the same license as the WordPress Importer package.
     3msgid ""
     4msgstr ""
     5"Project-Id-Version: WordPress Importer 0.5\n"
     6"Report-Msgid-Bugs-To: http://wordpress.org/tag/wordpress-importer\n"
     7"POT-Creation-Date: 2011-07-16 15:45:12+00:00\n"
     8"MIME-Version: 1.0\n"
     9"Content-Type: text/plain; charset=UTF-8\n"
     10"Content-Transfer-Encoding: 8bit\n"
     11"PO-Revision-Date: 2010-MO-DA HO:MI+ZONE\n"
     12"Last-Translator: FULL NAME <EMAIL@ADDRESS>\n"
     13"Language-Team: LANGUAGE <LL@li.org>\n"
     14
     15#: parsers.php:42 parsers.php:63
     16msgid "There was an error when reading this WXR file"
     17msgstr ""
     18
     19#: parsers.php:43
     20msgid ""
     21"Details are shown above. The importer will now try again with a different "
     22"parser..."
     23msgstr ""
     24
     25#: parsers.php:67 parsers.php:72 parsers.php:262 parsers.php:451
     26msgid ""
     27"This does not appear to be a WXR file, missing/invalid WXR version number"
     28msgstr ""
     29
     30#: wordpress-importer.php:134 wordpress-importer.php:143
     31#: wordpress-importer.php:194 wordpress-importer.php:202
     32msgid "Sorry, there has been an error."
     33msgstr ""
     34
     35#: wordpress-importer.php:135
     36msgid "The file does not exist, please try again."
     37msgstr ""
     38
     39#: wordpress-importer.php:178
     40msgid "All done."
     41msgstr ""
     42
     43#: wordpress-importer.php:178
     44msgid "Have fun!"
     45msgstr ""
     46
     47#: wordpress-importer.php:179
     48msgid "Remember to update the passwords and roles of imported users."
     49msgstr ""
     50
     51#: wordpress-importer.php:210
     52msgid ""
     53"This WXR file (version %s) may not be supported by this version of the "
     54"importer. Please consider updating."
     55msgstr ""
     56
     57#: wordpress-importer.php:235
     58msgid ""
     59"Failed to import author %s. Their posts will be attributed to the current "
     60"user."
     61msgstr ""
     62
     63#: wordpress-importer.php:261
     64msgid "Assign Authors"
     65msgstr ""
     66
     67#: wordpress-importer.php:262
     68msgid ""
     69"To make it easier for you to edit and save the imported content, you may "
     70"want to reassign the author of the imported item to an existing user of this "
     71"site. For example, you may want to import all the entries as <code>admin</"
     72"code>s entries."
     73msgstr ""
     74
     75#: wordpress-importer.php:264
     76msgid ""
     77"If a new user is created by WordPress, a new password will be randomly "
     78"generated and the new user&#8217;s role will be set as %s. Manually changing "
     79"the new user&#8217;s details will be necessary."
     80msgstr ""
     81
     82#: wordpress-importer.php:274
     83msgid "Import Attachments"
     84msgstr ""
     85
     86#: wordpress-importer.php:277
     87msgid "Download and import file attachments"
     88msgstr ""
     89
     90#: wordpress-importer.php:281
     91msgid "Submit"
     92msgstr ""
     93
     94#: wordpress-importer.php:294
     95msgid "Import author:"
     96msgstr ""
     97
     98#: wordpress-importer.php:305
     99msgid "or create new user with login name:"
     100msgstr ""
     101
     102#: wordpress-importer.php:308
     103msgid "as a new user:"
     104msgstr ""
     105
     106#: wordpress-importer.php:316
     107msgid "assign posts to an existing user:"
     108msgstr ""
     109
     110#: wordpress-importer.php:318
     111msgid "or assign posts to an existing user:"
     112msgstr ""
     113
     114#: wordpress-importer.php:319
     115msgid "- Select -"
     116msgstr ""
     117
     118#: wordpress-importer.php:369
     119msgid ""
     120"Failed to create new user for %s. Their posts will be attributed to the "
     121"current user."
     122msgstr ""
     123
     124#: wordpress-importer.php:418
     125msgid "Failed to import category %s"
     126msgstr ""
     127
     128#: wordpress-importer.php:456
     129msgid "Failed to import post tag %s"
     130msgstr ""
     131
     132#: wordpress-importer.php:500 wordpress-importer.php:626
     133msgid "Failed to import %s %s"
     134msgstr ""
     135
     136#: wordpress-importer.php:522
     137msgid "Failed to import &#8220;%s&#8221;: Invalid post type %s"
     138msgstr ""
     139
     140#: wordpress-importer.php:543
     141msgid "%s &#8220;%s&#8221; already exists."
     142msgstr ""
     143
     144#: wordpress-importer.php:598
     145msgid "Failed to import %s &#8220;%s&#8221;"
     146msgstr ""
     147
     148#: wordpress-importer.php:744
     149msgid "Menu item skipped due to missing menu slug"
     150msgstr ""
     151
     152#: wordpress-importer.php:751
     153msgid "Menu item skipped due to invalid menu slug: %s"
     154msgstr ""
     155
     156#: wordpress-importer.php:814
     157msgid "Fetching attachments is not enabled"
     158msgstr ""
     159
     160#: wordpress-importer.php:827
     161msgid "Invalid file type"
     162msgstr ""
     163
     164#: wordpress-importer.php:871
     165msgid "Remote server did not respond"
     166msgstr ""
     167
     168#: wordpress-importer.php:877
     169msgid "Remote server returned error response %1$d %2$s"
     170msgstr ""
     171
     172#: wordpress-importer.php:884
     173msgid "Remote file is incorrect size"
     174msgstr ""
     175
     176#: wordpress-importer.php:889
     177msgid "Zero size file downloaded"
     178msgstr ""
     179
     180#: wordpress-importer.php:895
     181msgid "Remote file is too large, limit is %s"
     182msgstr ""
     183
     184#: wordpress-importer.php:994
     185msgid "Import WordPress"
     186msgstr ""
     187
     188#: wordpress-importer.php:1001
     189msgid ""
     190"A new version of this importer is available. Please update to version %s to "
     191"ensure compatibility with newer export files."
     192msgstr ""
     193
     194#: wordpress-importer.php:1016
     195msgid ""
     196"Howdy! Upload your WordPress eXtended RSS (WXR) file and we&#8217;ll import "
     197"the posts, pages, comments, custom fields, categories, and tags into this "
     198"site."
     199msgstr ""
     200
     201#: wordpress-importer.php:1017
     202msgid "Choose a WXR (.xml) file to upload, then click Upload file and import."
     203msgstr ""
     204
     205#: wordpress-importer.php:1091
     206msgid ""
     207"Import <strong>posts, pages, comments, custom fields, categories, and tags</"
     208"strong> from a WordPress export file."
     209msgstr ""
     210
     211#. Plugin Name of the plugin/theme
     212msgid "WordPress Importer"
     213msgstr ""
     214
     215#. Plugin URI of the plugin/theme
     216msgid "http://wordpress.org/extend/plugins/wordpress-importer/"
     217msgstr ""
     218
     219#. Description of the plugin/theme
     220msgid ""
     221"Import posts, pages, comments, custom fields, categories, tags and more from "
     222"a WordPress export file."
     223msgstr ""
     224
     225#. Author of the plugin/theme
     226msgid "wordpressdotorg"
     227msgstr ""
     228
     229#. Author URI of the plugin/theme
     230msgid "http://wordpress.org/"
     231msgstr ""
  • .buildpath

     
     1<?xml version="1.0" encoding="UTF-8"?>
     2<buildpath>
     3        <buildpathentry kind="src" path=""/>
     4        <buildpathentry kind="con" path="org.eclipse.php.core.LANGUAGE"/>
     5</buildpath>
  • wp-cnnonfig.php

     
     1<?php
     2/**
     3 * The base configurations of the WordPress.
     4 *
     5 * This file has the following configurations: MySQL settings, Table Prefix,
     6 * Secret Keys, WordPress Language, and ABSPATH. You can find more information
     7 * by visiting {@link http://codex.wordpress.org/Editing_wp-config.php Editing
     8 * wp-config.php} Codex page. You can get the MySQL settings from your web host.
     9 *
     10 * This file is used by the wp-config.php creation script during the
     11 * installation. You don't have to use the web site, you can just copy this file
     12 * to "wp-config.php" and fill in the values.
     13 *
     14 * @package WordPress
     15 */
     16
     17// ** MySQL settings - You can get this info from your web host ** //
     18/** The name of the database for WordPress */
     19define('DB_NAME', 'wordpress');
     20
     21/** MySQL database username */
     22define('DB_USER', 'root');
     23
     24/** MySQL database password */
     25define('DB_PASSWORD', 'root');
     26
     27/** MySQL hostname */
     28define('DB_HOST', 'localhost');
     29
     30/** Database Charset to use in creating database tables. */
     31define('DB_CHARSET', 'utf8');
     32
     33/** The Database Collate type. Don't change this if in doubt. */
     34define('DB_COLLATE', '');
     35
     36/**#@+
     37 * Authentication Unique Keys and Salts.
     38 *
     39 * Change these to different unique phrases!
     40 * You can generate these using the {@link https://api.wordpress.org/secret-key/1.1/salt/ WordPress.org secret-key service}
     41 * You can change these at any point in time to invalidate all existing cookies. This will force all users to have to log in again.
     42 *
     43 * @since 2.6.0
     44 */
     45define('AUTH_KEY',         'm8hYEX:N#3?/D6U6m|<A{ky9[[~AHQ<OkLg+)[oWL=M46x-Q-e}i([, -,xMz^6 ');
     46define('SECURE_AUTH_KEY',  'g}#7~UjkGYia^$yX0cxP(cY`x5,/Ap9[qcT/}dB}E^pobJE4C*1L+}6`i9e|:J41');
     47define('LOGGED_IN_KEY',    'rKDJO>/1*ZwgDT0Uk_+rXw,t/$(R!f&-7x49O[4pv;v~SDo?+yJ37w-s{F(%5pyz');
     48define('NONCE_KEY',        'KEBCdW_c-1x849p{>7,f_8~g$^mi]b-L-:9u?l+]qIY>q`C6us1KLC_rJOc{v303');
     49define('AUTH_SALT',        'P?Fs& ~E;,{:&8/A>p|~b|-8Nnik!!Ds92gpP:q ?xz7LZ4gTC/ZrnfZYBO;C-kj');
     50define('SECURE_AUTH_SALT', '7>{$NA[RR47shL1$N0;rnzS*L)NJB4`?wQS]8l>ZY-hr=-wx5(|y?RxfpJbyInYU');
     51define('LOGGED_IN_SALT',   'N D`&LDrDDaW.y]Z<jM6f%QrP_!-8KiIY{g|s|HNH8f?#5SGf*V?5/2?eB=K!(x8');
     52define('NONCE_SALT',       '1I<M3%)1nkgjKwfO2I(;9|xcDL#>![q~j%w?DcI pwe)7zX1->l|d_TZ|eO5>/|&');
     53
     54/**#@-*/
     55
     56/**
     57 * WordPress Database Table prefix.
     58 *
     59 * You can have multiple installations in one database if you give each a unique
     60 * prefix. Only numbers, letters, and underscores please!
     61 */
     62$table_prefix  = 'wp_trunk_';
     63
     64/**
     65 * WordPress Localized Language, defaults to English.
     66 *
     67 * Change this to localize WordPress. A corresponding MO file for the chosen
     68 * language must be installed to wp-content/languages. For example, install
     69 * de_DE.mo to wp-content/languages and set WPLANG to 'de_DE' to enable German
     70 * language support.
     71 */
     72define('WPLANG', '');
     73
     74/**
     75 * For developers: WordPress debugging mode.
     76 *
     77 * Change this to true to enable the display of notices during development.
     78 * It is strongly recommended that plugin and theme developers use WP_DEBUG
     79 * in their development environments.
     80 */
     81define('WP_DEBUG', true);
     82define('SCRIPT_DEBUG', true);
     83
     84/* That's all, stop editing! Happy blogging. */
     85
     86/** Absolute path to the WordPress directory. */
     87if ( !defined('ABSPATH') )
     88        define('ABSPATH', dirname(__FILE__) . '/');
     89
     90/** Sets up WordPress vars and included files. */
     91require_once(ABSPATH . 'wp-settings.php');
  • wp-config.php

     
     1<?php
     2/**
     3 * The base configurations of the WordPress.
     4 *
     5 * This file has the following configurations: MySQL settings, Table Prefix,
     6 * Secret Keys, WordPress Language, and ABSPATH. You can find more information
     7 * by visiting {@link http://codex.wordpress.org/Editing_wp-config.php Editing
     8 * wp-config.php} Codex page. You can get the MySQL settings from your web host.
     9 *
     10 * This file is used by the wp-config.php creation script during the
     11 * installation. You don't have to use the web site, you can just copy this file
     12 * to "wp-config.php" and fill in the values.
     13 *
     14 * @package WordPress
     15 */
     16
     17// ** MySQL settings - You can get this info from your web host ** //
     18/** The name of the database for WordPress */
     19define('DB_NAME', 'wordpress');
     20
     21/** MySQL database username */
     22define('DB_USER', 'root');
     23
     24/** MySQL database password */
     25define('DB_PASSWORD', 'root');
     26
     27/** MySQL hostname */
     28define('DB_HOST', 'localhost');
     29
     30/** Database Charset to use in creating database tables. */
     31define('DB_CHARSET', 'utf8');
     32
     33/** The Database Collate type. Don't change this if in doubt. */
     34define('DB_COLLATE', '');
     35
     36/**#@+
     37 * Authentication Unique Keys and Salts.
     38 *
     39 * Change these to different unique phrases!
     40 * You can generate these using the {@link https://api.wordpress.org/secret-key/1.1/salt/ WordPress.org secret-key service}
     41 * You can change these at any point in time to invalidate all existing cookies. This will force all users to have to log in again.
     42 *
     43 * @since 2.6.0
     44 */
     45define('AUTH_KEY',         '-J)N4BN!zn6B4(l2ko%@VH>m:|-hc{}.ow[[|9-CY[RQ+dA/Ur.kb@)HfsAvH D6');
     46define('SECURE_AUTH_KEY',  'eCp7N/R5g/F/<0o8Mw,atf;JW*y`8|&o_oiF]D=[sRfi:eFW49~JT-`>LEn/A^%t');
     47define('LOGGED_IN_KEY',    '>.;9*>7#2+CR-VD}`Tx+_<Y=-JLrVRmLyXn:NqV@RWn*`~Sc;a[qDZZdHT<tq:T+');
     48define('NONCE_KEY',        'gr/0ZM9?g{4~a.rQq/u/@}U7:}8bv4hM^d3ZYY_,rGsyj0Of2JIeO]J[dD!L{QML');
     49define('AUTH_SALT',        'XKS+/:3V/*,iX,b~%7dlr?(+-p|qtt_ <R|l?8/TNQi5>ygc7<|<oa;I5IW6{Uq`');
     50define('SECURE_AUTH_SALT', 'P^>y!.)rCW5n:#APw${c+Q*.gsvA~<[jrAH}/|dDnwV=H&rark-JWp:[st-@[x9y');
     51define('LOGGED_IN_SALT',   'uP00|SVHVTCcz>e;^jq,!]y->-$YgmV2z c!yr|hr9370VgZx!B}&hsn</3_S!q+');
     52define('NONCE_SALT',       ',A@anfC2mP9}buH}uC|CYCYuGG4Lu:(g}(0XA6=zp<-@BJ$oS2FN?J6FZJusT-ty');
     53
     54/**#@-*/
     55
     56/**
     57 * WordPress Database Table prefix.
     58 *
     59 * You can have multiple installations in one database if you give each a unique
     60 * prefix. Only numbers, letters, and underscores please!
     61 */
     62$table_prefix  = 'wp44_';
     63
     64/**
     65 * WordPress Localized Language, defaults to English.
     66 *
     67 * Change this to localize WordPress. A corresponding MO file for the chosen
     68 * language must be installed to wp-content/languages. For example, install
     69 * de_DE.mo to wp-content/languages and set WPLANG to 'de_DE' to enable German
     70 * language support.
     71 */
     72define('WPLANG', '');
     73
     74/**
     75 * For developers: WordPress debugging mode.
     76 *
     77 * Change this to true to enable the display of notices during development.
     78 * It is strongly recommended that plugin and theme developers use WP_DEBUG
     79 * in their development environments.
     80 */
     81define('WP_DEBUG', true);
     82
     83/* That's all, stop editing! Happy blogging. */
     84
     85/** Absolute path to the WordPress directory. */
     86if ( !defined('ABSPATH') )
     87        define('ABSPATH', dirname(__FILE__) . '/');
     88
     89/** Sets up WordPress vars and included files. */
     90require_once(ABSPATH . 'wp-settings.php');
  • .project

     
     1<?xml version="1.0" encoding="UTF-8"?>
     2<projectDescription>
     3        <name>trunk</name>
     4        <comment></comment>
     5        <projects>
     6        </projects>
     7        <buildSpec>
     8                <buildCommand>
     9                        <name>org.eclipse.wst.jsdt.core.javascriptValidator</name>
     10                        <arguments>
     11                        </arguments>
     12                </buildCommand>
     13                <buildCommand>
     14                        <name>org.eclipse.wst.validation.validationbuilder</name>
     15                        <arguments>
     16                        </arguments>
     17                </buildCommand>
     18                <buildCommand>
     19                        <name>org.eclipse.dltk.core.scriptbuilder</name>
     20                        <arguments>
     21                        </arguments>
     22                </buildCommand>
     23        </buildSpec>
     24        <natures>
     25                <nature>org.eclipse.php.core.PHPNature</nature>
     26                <nature>org.eclipse.wst.jsdt.core.jsNature</nature>
     27        </natures>
     28</projectDescription>
  • .settings/.jsdtscope

     
     1<?xml version="1.0" encoding="UTF-8"?>
     2<classpath>
     3        <classpathentry kind="src" path="">
     4                <attributes>
     5                        <attribute name="provider" value="org.eclipse.wst.jsdt.web.core.internal.project.ModuleSourcePathProvider"/>
     6                </attributes>
     7        </classpathentry>
     8        <classpathentry kind="con" path="org.eclipse.wst.jsdt.launching.JRE_CONTAINER"/>
     9        <classpathentry kind="con" path="org.eclipse.wst.jsdt.launching.WebProject">
     10                <attributes>
     11                        <attribute name="hide" value="true"/>
     12                </attributes>
     13        </classpathentry>
     14        <classpathentry kind="con" path="org.eclipse.wst.jsdt.launching.baseBrowserLibrary"/>
     15        <classpathentry kind="output" path=""/>
     16</classpath>
  • .settings/org.eclipse.php.core.prefs

     
     1eclipse.preferences.version=1
     2include_path=0;/trunk
  • .settings/org.eclipse.wst.jsdt.ui.superType.container

     
     1org.eclipse.wst.jsdt.launching.baseBrowserLibrary
     2 No newline at end of file
  • .settings/org.eclipse.wst.jsdt.ui.superType.name

     
     1Window
     2 No newline at end of file