Ticket #22435: export.5.diff

new file src/wp-includes/Oxymel.php

@@ +1 @@
+<?php
+class Oxymel {
+        private $xml;
+        private $dom;
+        private $current_element;
+        private $last_inserted;
+        private $go_deep_on_next_element = 0;
+        private $go_up_on_next_element = 0;
+        private $nesting_level = 0;
+        private $contains_nesting_level = 0;
+        private $indentation= '  ';
+
+        public function __construct() {
+                $this->xml = '';
+                $this->init_new_dom();
+        }
+
+        public function to_string() {
+                return $this->xml .= $this->indent( $this->xml_from_dom(), $this->nesting_level );
+        }
+
+        public function __call( $name, $args ) {
+                array_unshift( $args, $name );
+                return call_user_func_array( array( $this, 'tag' ), $args );
+        }
+
+        public function __get( $name ) {
+                return $this->$name();
+        }
+
+        public function contains() {
+                $this->contains_nesting_level++;
+                $this->nesting_level++;
+                if ( $this->go_deep_on_next_element ) {
+                        throw new OxymelException( 'contains cannot be used consecutively more than once' );
+                }
+                $this->go_deep_on_next_element++;
+                return $this;
+        }
+
+        public function end() {
+                $this->contains_nesting_level--;
+                $this->nesting_level--;
+                if ( $this->contains_nesting_level < 0 ) {
+                        throw new OxymelException( 'end is used without a matching contains' );
+                }
+                $this->go_up_on_next_element++;
+                return $this;
+        }
+
+        public function tag( $name, $content_or_attributes = null, $attributes = array() ) {
+                list( $content, $attributes ) = $this->get_content_and_attributes_from_tag_args( $content_or_attributes, $attributes );
+                $is_opening =  0 === strpos( $name, 'open_' );
+                $is_closing =  0 === strpos( $name, 'close_' );
+                $name = preg_replace("/^(open|close)_/", '', $name );
+
+                $element = $this->create_element( $name, $content, $attributes );
+
+                if ( !$is_opening && !$is_closing )
+                        $this->add_element_to_dom( $element );
+                elseif ( $is_opening )
+                        $this->add_opening_tag_from_element( $element );
+                elseif ( $is_closing )
+                        $this->add_closing_tag_from_tag_name( $name );
+
+                return $this;
+        }
+
+        public function cdata( $text ) {
+                $this->add_element_to_dom( $this->dom->createCDATASection( $text ) );
+                return $this;
+        }
+
+        public function text( $text ) {
+                $this->add_element_to_dom( $this->dom->createTextNode( $text ) );
+                return $this;
+        }
+
+        public function comment( $text ) {
+                $this->add_element_to_dom( $this->dom->createComment( $text ) );
+                return $this;
+        }
+
+        public function xml() {
+                $this->add_element_to_dom( $this->dom->createProcessingInstruction( 'xml', 'version="1.0" encoding="UTF-8"' ) );
+                return $this;
+        }
+
+        public function oxymel( Oxymel $other ) {
+                foreach( $other->dom->childNodes as $child ) {
+                        $child = $this->dom->importNode( $child, true );
+                        $this->add_element_to_dom( $child );
+                }
+                return $this;
+        }
+
+        public function raw(  $raw_xml ) {
+                if ( !$raw_xml ) {
+                        return $this;
+                }
+                $fragment = $this->dom->createDocumentFragment();
+                $fragment->appendXML($raw_xml);
+                $this->add_element_to_dom( $fragment );
+                return $this;
+        }
+
+        private function add_element_to_dom( $element ) {
+                $this->move_current_element_deep();
+                $this->move_current_element_up();
+                $this->last_inserted = $this->current_element->appendChild($element);
+        }
+
+        private function move_current_element_deep() {
+                if ( $this->go_deep_on_next_element ) {
+                        if ( !$this->last_inserted ) {
+                                throw new OxymelException( 'contains has been used before adding any tags' );
+                        }
+                        $this->current_element = $this->last_inserted;
+                        $this->go_deep_on_next_element--;
+                }
+        }
+
+        private function move_current_element_up() {
+                if ( $this->go_up_on_next_element ) {
+                        while ( $this->go_up_on_next_element ) {
+                                $this->current_element = $this->current_element->parentNode;
+                                $this->go_up_on_next_element--;
+                        }
+                }
+        }
+
+        private function get_content_and_attributes_from_tag_args( $content_or_attributes, array $attributes ) {
+                $content = null;
+                if ( !$attributes ) {
+                        if ( is_array( $content_or_attributes ) )
+                                $attributes = $content_or_attributes;
+                        else
+                                $content = $content_or_attributes;
+                } else {
+                        $content = $content_or_attributes;
+                }
+                return array( $content, $attributes );
+        }
+
+        private function init_new_dom() {
+                unset( $this->dom, $this->current_element );
+                $this->dom = new DOMDocument();
+                $this->dom->formatOutput = true;
+                $this->current_element = $this->dom;
+                $this->last_inserted = null;
+        }
+
+        private function xml_from_dom() {
+                if ( 0 !== $this->contains_nesting_level ) {
+                        throw new OxymelException( 'contains and end calls do not match' );
+                }
+                $xml = '';
+                foreach( $this->dom->childNodes as $child ) {
+                        $xml .= $this->dom->saveXML( $child ) . "\n";
+                }
+                return $xml;
+        }
+
+        private function create_element( $name, $content, $attributes ) {
+                if ( !is_null( $content ) )
+                        $element = $this->dom->createElement( $name, $content );
+                else
+                        $element = $this->dom->createElement( $name );
+
+                foreach( $attributes as $attribute_name => $attribute_value ) {
+                        $element->setAttribute( $attribute_name, $attribute_value );
+                }
+
+                return $element;
+        }
+
+        private function add_opening_tag_from_element( $element ) {
+                $this->xml .= $this->indent( $this->xml_from_dom(), $this->nesting_level );
+                $tag = $this->dom->saveXML($element);
+                $this->xml .= $this->indent( str_replace( '/>', '>', $tag ) . "\n", $this->nesting_level );
+                $this->nesting_level++;
+                $this->init_new_dom();
+        }
+
+        private function add_closing_tag_from_tag_name( $name ) {
+                $this->xml .= $this->xml_from_dom();
+                $this->nesting_level--;
+                if ( $this->nesting_level < 0 ) {
+                        $this->xml = $this->indent( $this->xml, -$this->nesting_level );
+                        $this->nesting_level = 0;
+                }
+                $this->xml .= $this->indent( "</$name>\n", $this->nesting_level );
+                $this->init_new_dom();
+        }
+
+        private function indent( $string, $level ) {
+                if ( !$level ) {
+                        return $string;
+                }
+                $lines = explode( "\n", $string );
+                foreach( $lines as &$line ) {
+                        if ( !trim( $line ) )
+                                continue;
+                        $line = str_repeat( $this->indentation, $level ) . $line;
+                }
+                return implode( "\n", $lines );
+        }
+}
+
+class OxymelException extends Exception {
+}

src/wp-includes/default-constants.php

@@ -87 +87 @@
         define( 'DAY_IN_SECONDS',    24 * HOUR_IN_SECONDS   );
         define( 'WEEK_IN_SECONDS',    7 * DAY_IN_SECONDS    );
         define( 'YEAR_IN_SECONDS',  365 * DAY_IN_SECONDS    );
+
+        // Constants for expressing human-readable data sizes
+        // in their respective number of bytes.
+        define( 'KB_IN_BYTES', 1024 );
+        define( 'MB_IN_BYTES', 1024 * KB_IN_BYTES );
+        define( 'GB_IN_BYTES', 1024 * MB_IN_BYTES );
+        define( 'TB_IN_BYTES', 1024 * GB_IN_BYTES );
+        define( 'PB_IN_BYTES', 1024 * TB_IN_BYTES );
+        define( 'EB_IN_BYTES', 1024 * PB_IN_BYTES );
+        define( 'ZB_IN_BYTES', 1024 * EB_IN_BYTES );
+        define( 'YB_IN_BYTES', 1024 * ZB_IN_BYTES );
 }
 
 /**

new file src/wp-includes/export/class-wp-export-query.php

@@ +1 @@
+<?php
+/**
+ * Represents a set of posts and other site data to be exported.
+ *
+ * An immutable object, which gathers all data needed for the export.
+ */
+class WP_Export_Query {
+        const QUERY_CHUNK = 100;
+
+        private static $defaults = array(
+                'post_ids' => null,
+                'post_type' => null,
+                'status' => null,
+                'author' => null,
+                'start_date' => null,
+                'end_date' => null,
+                'category' => null,
+        );
+
+        private $post_ids;
+        private $filters;
+        private $xml_gen;
+
+        private $wheres = array();
+        private $joins = array();
+
+        private $author;
+        private $category;
+
+        public $missing_parents = false;
+
+        public function __construct( $filters = array() ) {
+                $this->filters = wp_parse_args( $filters, self::$defaults );
+                $this->post_ids = $this->calculate_post_ids();
+        }
+
+        public function post_ids() {
+                return $this->post_ids;
+        }
+
+        public function charset() {
+                return get_bloginfo( 'charset' );
+        }
+
+        public function site_metadata() {
+                $metadata = array(
+                        'name' => $this->bloginfo_rss( 'name' ),
+                        'url' => $this->bloginfo_rss( 'url' ),
+                        'language' => $this->bloginfo_rss( 'language' ),
+                        'description' => $this->bloginfo_rss( 'description' ),
+                        'pubDate' => date( 'D, d M Y H:i:s +0000' ),
+                        'site_url' => is_multisite()? network_home_url() : $this->bloginfo_rss( 'url' ),
+                        'blog_url' => $this->bloginfo_rss( 'url' ),
+                );
+                return $metadata;
+        }
+
+        public function wp_generator_tag() {
+                return apply_filters( 'the_generator', get_the_generator( 'export' ), 'export' );
+        }
+
+        public function authors() {
+                global $wpdb;
+                $authors = array();
+                $author_ids = $wpdb->get_col( "SELECT DISTINCT post_author FROM $wpdb->posts WHERE post_status != 'auto-draft'" );
+                foreach ( (array) $author_ids as $author_id ) {
+                        $authors[] = get_userdata( $author_id );
+                }
+                $authors = array_filter( $authors );
+                return $authors;
+        }
+
+        public function categories() {
+                if ( $this->category ) {
+                        return array( $this->category );
+                }
+                if ( $this->filters['post_type'] ) {
+                        return array();
+                }
+                $categories = (array) get_categories( array( 'get' => 'all' ) );
+
+                $this->check_for_orphaned_terms( $categories );
+
+                $categories = self::topologically_sort_terms( $categories );
+
+                return $categories;
+        }
+
+        public function tags() {
+                if ( $this->filters['post_type'] ) {
+                        return array();
+                }
+                $tags = (array) get_tags( array( 'get' => 'all' ) );
+
+                $this->check_for_orphaned_terms( $tags );
+
+                return $tags;
+        }
+
+        public function custom_taxonomies_terms() {
+                if ( $this->filters['post_type'] ) {
+                        return array();
+                }
+                $custom_taxonomies = get_taxonomies( array( '_builtin' => false ) );
+                $custom_terms = (array) get_terms( $custom_taxonomies, array( 'get' => 'all' ) );
+                $this->check_for_orphaned_terms( $custom_terms );
+                $custom_terms = self::topologically_sort_terms( $custom_terms );
+                return $custom_terms;
+        }
+
+        public function nav_menu_terms() {
+                $nav_menus = wp_get_nav_menus();
+                foreach( $nav_menus as &$term ) {
+                        $term->description = '';
+                }
+                return $nav_menus;
+        }
+
+        public function exportify_post( $post ) {
+                $GLOBALS['wp_query']->in_the_loop = true;
+                $previous_global_post = isset( $GLOBALS['post'] )? $GLOBALS['post'] : null;
+                $GLOBALS['post'] = $post;
+                setup_postdata( $post );
+                $post->post_content = apply_filters( 'the_content_export', $post->post_content );
+                $post->post_excerpt = apply_filters( 'the_excerpt_export', $post->post_excerpt );
+                $post->is_sticky = is_sticky( $post->ID ) ? 1 : 0;
+                $post->terms = self::get_terms_for_post( $post );
+                $post->meta = self::get_meta_for_post( $post );
+                $post->comments = self::get_comments_for_post( $post );
+                $GLOBALS['post'] = $previous_global_post;
+                return $post;
+        }
+
+        public function posts() {
+                $posts_iterator = new WP_Post_IDs_Iterator( $this->post_ids, self::QUERY_CHUNK );
+                return new WP_Map_Iterator( $posts_iterator, array( $this, 'exportify_post' ) );
+        }
+
+        private function calculate_post_ids() {
+                global $wpdb;
+                if ( is_array( $this->filters['post_ids'] ) ) {
+                        return $this->filters['post_ids'];
+                }
+                $this->post_type_where();
+                $this->status_where();
+                $this->author_where();
+                $this->start_date_where();
+                $this->end_date_where();
+                $this->category_where();
+
+                $where = implode( ' AND ', array_filter( $this->wheres ) );
+                if ( $where ) $where = "WHERE $where";
+                $join = implode( ' ', array_filter( $this->joins ) );
+
+                $post_ids = $wpdb->get_col( "SELECT ID FROM {$wpdb->posts} AS p $join $where" );
+                $post_ids = array_merge( $post_ids, $this->attachments_for_specific_post_types( $post_ids ) );
+                return $post_ids;
+        }
+
+        private function post_type_where() {
+                global $wpdb;
+                $post_types_filters = array( 'can_export' => true );
+                if ( $this->filters['post_type'] ) {
+                        $post_types_filters = array_merge( $post_types_filters, array( 'name' => $this->filters['post_type'] ) );
+                }
+                $post_types = get_post_types( $post_types_filters );
+                if ( !$post_types ) {
+                        $this->wheres[] = 'p.post_type IS NULL';
+                        return;
+                }
+                $this->wheres[] = $wpdb->build_IN_condition( 'p.post_type', $post_types );
+        }
+
+        private function status_where() {
+                global $wpdb;
+                if ( !$this->filters['status'] ) {
+                        $this->wheres[] = "p.post_status != 'auto-draft'";
+                        return;
+                }
+                $this->wheres[] = $wpdb->prepare( 'p.post_status = %s', $this->filters['status'] );
+        }
+
+        private function author_where() {
+                global $wpdb;
+                $user = $this->find_user_from_any_object( $this->filters['author'] );
+                if ( !$user || is_wp_error( $user ) ) {
+                        return;
+                }
+                $this->author = $user;
+                $this->wheres[] = $wpdb->prepare( 'p.post_author = %d', $user->ID );
+        }
+
+        private function start_date_where() {
+                global $wpdb;
+                $timestamp = strtotime( $this->filters['start_date'] );
+                if ( !$timestamp ) {
+                        return;
+                }
+                $this->wheres[] = $wpdb->prepare( 'p.post_date >= %s', date( 'Y-m-d 00:00:00', $timestamp ) );
+        }
+
+        private function end_date_where() {
+                global $wpdb;
+                $timestamp = strtotime( $this->filters['end_date'] );
+                if ( !$timestamp ) {
+                        return;
+                }
+                $this->wheres[] = $wpdb->prepare( 'p.post_date <= %s', date( 'Y-m-d 23:59:59', $timestamp ) );
+        }
+
+        private function category_where() {
+                global $wpdb;
+                if ( 'post' != $this->filters['post_type'] ) {
+                        return;
+                }
+                $category = $this->find_category_from_any_object( $this->filters['category'] );
+                if ( !$category ) {
+                        return;
+                }
+                $this->category = $category;
+                $this->joins[] = "INNER JOIN {$wpdb->term_relationships} AS tr ON (p.ID = tr.object_id)";
+                $this->wheres[] = $wpdb->prepare( 'tr.term_taxonomy_id = %d', $category->term_taxonomy_id );
+        }
+
+        private function attachments_for_specific_post_types( $post_ids ) {
+                global $wpdb;
+                if ( !$this->filters['post_type'] ) {
+                        return array();
+                }
+                $attachment_ids = array();
+                while ( $batch_of_post_ids = array_splice( $post_ids, 0, self::QUERY_CHUNK ) ) {
+                        $post_parent_condition = $wpdb->build_IN_condition( 'post_parent', $batch_of_post_ids );
+                        $attachment_ids = array_merge( $attachment_ids, (array)$wpdb->get_col( "SELECT ID FROM {$wpdb->posts} WHERE post_type = 'attachment' AND $post_parent_condition" ) );
+                }
+                return array_map( 'intval', $attachment_ids );
+        }
+
+        private function bloginfo_rss( $section ) {
+                return apply_filters( 'bloginfo_rss', get_bloginfo_rss( $section ), $section );
+        }
+
+        private function find_user_from_any_object( $user ) {
+                if ( is_numeric( $user ) ) {
+                        return get_user_by( 'id', $user );
+                } elseif ( is_string( $user ) ) {
+                        return get_user_by( 'login', $user );
+                } elseif ( isset( $user->ID ) ) {
+                        return get_user_by( 'id', $user->ID );
+                }
+                return false;
+        }
+
+        private function find_category_from_any_object( $category ) {
+                if ( is_numeric( $category ) ) {
+                        return get_term( $category, 'category' );
+                } elseif ( is_string( $category ) ) {
+                        $term = term_exists( $category, 'category' );
+                        return isset( $term['term_id'] )? get_term( $term['term_id'], 'category' ) : false;
+                } elseif ( isset( $category->term_id ) ) {
+                        return get_term( $category->term_id, 'category' );
+                }
+                return false;
+        }
+
+        private static function topologically_sort_terms( $terms ) {
+                $sorted = array();
+                while ( $term = array_shift( $terms ) ) {
+                        if ( $term->parent == 0 || isset( $sorted[$term->parent] ) )
+                                $sorted[$term->term_id] = $term;
+                        else
+                                $terms[] = $term;
+                }
+                return $sorted;
+        }
+
+        private function check_for_orphaned_terms( $terms ) {
+                $term_ids = array();
+                $have_parent = array();
+
+                foreach ( $terms as $term ) {
+                        $term_ids[ $term->term_id ] = true;
+                        if ( $term->parent != 0 )
+                                $have_parent[] = $term;
+                }
+
+                foreach ( $have_parent as $has_parent ) {
+                        if ( ! isset( $term_ids[ $has_parent->parent ] ) ) {
+                                $this->missing_parents = $has_parent;
+                                throw new WP_Export_Term_Exception( __( 'Term is missing a parent.' ) );
+                        }
+                }
+        }
+
+        private static function get_terms_for_post( $post ) {
+                $taxonomies = get_object_taxonomies( $post->post_type );
+                if ( empty( $taxonomies ) )
+                        return array();
+                $terms = wp_get_object_terms( $post->ID, $taxonomies );
+                $terms = $terms? $terms : array();
+                return $terms;
+        }
+
+        private static function get_meta_for_post( $post ) {
+                global $wpdb;
+                $meta_for_export = array();
+                $meta_from_db = $wpdb->get_results( $wpdb->prepare( "SELECT * FROM $wpdb->postmeta WHERE post_id = %d", $post->ID ) );
+                foreach ( $meta_from_db as $meta ) {
+                        if ( apply_filters( 'wxr_export_skip_postmeta', false, $meta->meta_key, $meta ) )
+                                continue;
+                        $meta_for_export[] = $meta;
+                }
+                return $meta_for_export;
+        }
+
+        private static function get_comments_for_post( $post ) {
+                global $wpdb;
+                $comments = $wpdb->get_results( $wpdb->prepare( "SELECT * FROM $wpdb->comments WHERE comment_post_ID = %d AND comment_approved <> 'spam'", $post->ID ) );
+                foreach( $comments as $comment ) {
+                        $meta = $wpdb->get_results( $wpdb->prepare( "SELECT * FROM $wpdb->commentmeta WHERE comment_id = %d", $comment->comment_ID ) );
+                        $meta = $meta? $meta : array();
+                        $comment->meta = $meta;
+                }
+                return $comments;
+        }
+}
+
+class WP_Export_Exception extends RuntimeException {
+}
+
+class WP_Export_Term_Exception extends RuntimeException {
+}

new file src/wp-includes/export/class-wp-export-wxr-formatter.php

@@ +1 @@
+<?php
+/**
+ * Version number for the export format.
+ *
+ * Bump this when something changes that might affect compatibility.
+ *
+ * @since 2.5.0
+ */
+define( 'WXR_VERSION', '1.2' );
+
+require_once ABSPATH . WPINC . '/Oxymel.php';
+
+class WP_Export_Oxymel extends Oxymel {
+        public function optional( $tag_name, $contents ) {
+                if ( $contents ) {
+                        $this->$tag_name( $contents );
+                }
+                return $this;
+        }
+
+        public function optional_cdata( $tag_name, $contents ) {
+                if ( $contents ) {
+                        $this->$tag_name->contains->cdata( $contents )->end;
+                }
+                return $this;
+        }
+}
+
+/**
+ * Responsible for formatting the data in WP_Export_Query to WXR
+ */
+class WP_Export_WXR_Formatter {
+        function __construct( $export ) {
+                $this->export = $export;
+                $this->wxr_version = WXR_VERSION;
+        }
+
+        function before_posts() {
+                $before_posts_xml = '';
+                $before_posts_xml .= $this->header();
+                $before_posts_xml .= $this->site_metadata();
+                $before_posts_xml .= $this->authors();
+                $before_posts_xml .= $this->categories();
+                $before_posts_xml .= $this->tags();
+                $before_posts_xml .= $this->nav_menu_terms();
+                $before_posts_xml .= $this->custom_taxonomies_terms();
+                $before_posts_xml .= $this->rss2_head_action();
+                return $before_posts_xml;
+        }
+
+        function posts() {
+                return new WP_Map_Iterator( $this->export->posts(), array( $this, 'post' ) );
+        }
+
+        function after_posts() {
+                return $this->footer();
+        }
+
+        function header() {
+                $oxymel = new Oxymel;
+                $charset = $this->export->charset();
+                $wp_generator_tag = $this->export->wp_generator_tag();
+                $comment = <<<COMMENT
+
+ This is a WordPress eXtended RSS file generated by WordPress as an export of your site.
+ It contains information about your site's posts, pages, comments, categories, and other content.
+ You may use this file to transfer that content from one site to another.
+ This file is not intended to serve as a complete backup of your site.
+
+ To import this information into a WordPress site follow these steps:
+ 1. Log in to that site as an administrator.
+ 2. Go to Tools: Import in the WordPress admin panel.
+ 3. Install the "WordPress" importer from the list.
+ 4. Activate & Run Importer.
+ 5. Upload this file using the form provided on that page.
+ 6. You will first be asked to map the authors in this export file to users
+    on the site. For each author, you may choose to map to an
+    existing user on the site or to create a new user.
+ 7. WordPress will then import each of the posts, pages, comments, categories, etc.
+    contained in this file into your site.
+
+COMMENT;
+                return $oxymel
+                        ->xml
+                        ->comment( $comment )
+                        ->raw( $wp_generator_tag )
+                        ->open_rss( array(
+                                'version' => '2.0',
+                                'xmlns:excerpt' => "http://wordpress.org/export/{$this->wxr_version}/excerpt/",
+                                'xmlns:content' => "http://purl.org/rss/1.0/modules/content/",
+                                'xmlns:wfw' => "http://wellformedweb.org/CommentAPI/",
+                                'xmlns:dc' => "http://purl.org/dc/elements/1.1/",
+                                'xmlns:wp' => "http://wordpress.org/export/{$this->wxr_version}/",
+                        ) )
+                                ->open_channel
+                                ->to_string();
+
+        }
+
+        function site_metadata() {
+                $oxymel = new Oxymel;
+                $metadata = $this->export->site_metadata();
+                return $oxymel
+                        ->title( $metadata['name'] )
+                        ->link( $metadata['url'] )
+                        ->description( $metadata['description'] )
+                        ->pubDate( $metadata['pubDate'] )
+                        ->language( $metadata['language'] )
+                        ->tag( 'wp:wxr_version', $this->wxr_version )
+                        ->tag( 'wp:base_site_url', $metadata['site_url'] )
+                        ->tag( 'wp:base_blog_url', $metadata['blog_url'] )
+                        ->to_string();
+        }
+
+        function authors() {
+                $oxymel = new Oxymel;
+                $authors = $this->export->authors();
+                foreach ( $authors as $author ) {
+                        $oxymel
+                                ->tag( 'wp:author' )->contains
+                                        ->tag( 'wp:author_login', $author->user_login )
+                                        ->tag( 'wp:author_email', $author->user_email )
+                                        ->tag( 'wp:author_display_name' )->contains->cdata( $author->display_name )->end
+                                        ->tag( 'wp:author_first_name' )->contains->cdata( $author->user_first_name )->end
+                                        ->tag( 'wp:author_last_name' )->contains->cdata( $author->user_last_name )->end
+                                        ->end;
+                }
+                return $oxymel->to_string();
+        }
+
+        function categories() {
+                $oxymel = new WP_Export_Oxymel;
+                $categories = $this->export->categories();
+                foreach( $categories as $term_id => $category ) {
+                        $category->parent_slug = $category->parent? $categories[$category->parent]->slug : '';
+                        $oxymel->tag( 'wp:category' )->contains
+                                ->tag( 'wp:term_id', $category->term_id )
+                                ->tag( 'wp:category_nicename', $category->slug )
+                                ->tag( 'wp:category_parent', $category->parent_slug )
+                                ->optional_cdata( 'wp:cat_name', $category->name )
+                                ->optional_cdata( 'wp:category_description', $category->description )
+                                ->end;
+                }
+                return $oxymel->to_string();
+        }
+
+        function tags() {
+                $oxymel = new WP_Export_Oxymel;
+                $tags = $this->export->tags();
+                foreach( $tags as $tag ) {
+                        $oxymel->tag( 'wp:tag' )->contains
+                                ->tag( 'wp:term_id', $tag->term_id )
+                                ->tag( 'wp:tag_slug', $tag->slug )
+                                ->optional_cdata( 'wp:tag_name', $tag->name )
+                                ->optional_cdata( 'wp:tag_description', $tag->description )
+                                ->end;
+                }
+                return $oxymel->to_string();
+        }
+
+        function nav_menu_terms() {
+                return $this->terms( $this->export->nav_menu_terms() );
+        }
+
+        function custom_taxonomies_terms() {
+                return $this->terms( $this->export->custom_taxonomies_terms() );
+        }
+
+        function rss2_head_action() {
+                ob_start();
+                do_action( 'rss2_head' );
+                $action_output = ob_get_clean();
+                return $action_output;
+        }
+
+        private function terms( $terms ) {
+                $oxymel = new WP_Export_Oxymel;
+                foreach( $terms as $term ) {
+                        $term->parent_slug = $term->parent? $terms[$term->parent]->slug : '';
+                        $oxymel->tag( 'wp:term' )->contains
+                                ->tag( 'wp:term_id', $term->term_id )
+                                ->tag( 'wp:term_taxonomy', $term->taxonomy )
+                                ->tag( 'wp:term_slug', $term->slug );
+                        if ( 'nav_menu' != $term->taxonomy ) {
+                                $oxymel
+                                ->tag( 'wp:term_parent', $term->parent_slug );
+                        }
+                                $oxymel
+                                ->optional_cdata( 'wp:term_name', $term->name )
+                                ->optional_cdata( 'wp:term_description', $term->description )
+                                ->end;
+                }
+                return $oxymel->to_string();
+        }
+
+        function post( $post ) {
+                $oxymel = new WP_Export_Oxymel;
+                $GLOBALS['wp_query']->in_the_loop = true;
+                $GLOBALS['post'] = $post;
+                setup_postdata( $post );
+
+                $oxymel->item->contains
+                        ->title( apply_filters( 'the_title_rss', $post->post_title ) )
+                        ->link( apply_filters('the_permalink_rss', get_permalink() ) )
+                        ->pubDate( mysql2date( 'D, d M Y H:i:s +0000', get_post_time( 'Y-m-d H:i:s', true ), false ) )
+                        ->tag( 'dc:creator', get_the_author_meta( 'login' ) )
+                        ->guid( get_the_guid(), array( 'isPermaLink' => 'false' ) )
+                        ->description( '' )
+                        ->tag( 'content:encoded' )->contains->cdata( $post->post_content )->end
+                        ->tag( 'excerpt:encoded' )->contains->cdata( $post->post_excerpt )->end
+                        ->tag( 'wp:post_id', $post->ID )
+                        ->tag( 'wp:post_date', $post->post_date )
+                        ->tag( 'wp:post_date_gmt', $post->post_date_gmt )
+                        ->tag( 'wp:comment_status', $post->comment_status )
+                        ->tag( 'wp:ping_status', $post->ping_status )
+                        ->tag( 'wp:post_name', $post->post_name )
+                        ->tag( 'wp:status', $post->post_status )
+                        ->tag( 'wp:post_parent', $post->post_parent )
+                        ->tag( 'wp:menu_order', $post->menu_order )
+                        ->tag( 'wp:post_type', $post->post_type )
+                        ->tag( 'wp:post_password', $post->post_password )
+                        ->tag( 'wp:is_sticky', $post->is_sticky )
+                        ->optional( 'wp:attachment_url', wp_get_attachment_url( $post->ID ) );
+                foreach( $post->terms as $term ) {
+                        $oxymel
+                        ->category( array( 'domain' => $term->taxonomy, 'nicename' => $term->slug  ) )->contains->cdata( $term->name )->end;
+                }
+                foreach( $post->meta as $meta ) {
+                        $oxymel
+                        ->tag( 'wp:postmeta' )->contains
+                                ->tag( 'wp:meta_key', $meta->meta_key )
+                                ->tag( 'wp:meta_value' )->contains->cdata( $meta->meta_value )->end
+                                ->end;
+                }
+                foreach( $post->comments as $comment ) {
+                        $oxymel
+                        ->tag( 'wp:comment' )->contains
+                                ->tag( 'wp:comment_id', $comment->comment_ID )
+                                ->tag( 'wp:comment_author' )->contains->cdata( $comment->comment_author )->end
+                                ->tag( 'wp:comment_author_email', $comment->comment_author_email )
+                                ->tag( 'wp:comment_author_url', $comment->comment_author_url )
+                                ->tag( 'wp:comment_author_IP', $comment->comment_author_IP )
+                                ->tag( 'wp:comment_date', $comment->comment_date )
+                                ->tag( 'wp:comment_date_gmt', $comment->comment_date_gmt )
+                                ->tag( 'wp:comment_content' )->contains->cdata( $comment->comment_content )->end
+                                ->tag( 'wp:comment_approved', $comment->comment_approved )
+                                ->tag( 'wp:comment_type', $comment->comment_type )
+                                ->tag( 'wp:comment_parent', $comment->comment_parent )
+                                ->tag( 'wp:comment_user_id', $comment->user_id )
+                                ->oxymel( $this->comment_meta( $comment ) )
+                                ->end;
+                }
+                $oxymel
+                        ->end;
+                return $oxymel->to_string();
+        }
+
+        private function comment_meta( $comment ) {
+                global $wpdb;
+                $metas = $wpdb->get_results( $wpdb->prepare( "SELECT * FROM $wpdb->commentmeta WHERE comment_id = %d", $comment->comment_ID ) );
+                if ( !$metas ) {
+                        return new Oxymel;
+                }
+                $oxymel = new WP_Export_Oxymel;
+                foreach( $metas as $meta ) {
+                        $oxymel->tag( 'wp:commentmeta' )->contains
+                                ->tag( 'wp:meta_key', $meta->meta_key )
+                                ->tag( 'wp:meta_value', $meta->meta_value )
+                        ->end;
+                }
+                return $oxymel;
+        }
+
+
+        function footer() {
+                $oxymel = new Oxymel;
+                return $oxymel->close_channel->close_rss->to_string();
+        }
+}

new file src/wp-includes/export/functions.export.php

@@ +1 @@
+<?php
+
+function wp_export( $args = array() ) {
+        $defaults = array(
+                'filters' => array(),
+                'format' => 'WP_Export_WXR_Formatter',
+                'writer' => 'WP_Export_Returner',
+                'writer_args' => null,
+        );
+        $args = wp_parse_args( $args, $defaults );
+        $export_query = new WP_Export_Query( $args['filters'] );
+        $formatter = new $args['format']( $export_query );
+        $writer = new $args['writer']( $formatter, $args['writer_args'] );
+        try {
+                return $writer->export();
+        } catch ( WP_Export_Exception $e ) {
+                return new WP_Error( 'wp-export-error', $e->getMessage() );
+        }
+}

new file src/wp-includes/export/writers.php

@@ +1 @@
+<?php
+abstract class WP_Export_Base_Writer {
+        protected $formatter;
+
+        function __construct( $formatter ) {
+                $this->formatter = $formatter;
+        }
+
+        public function export() {
+                $this->write( $this->formatter->before_posts() );
+                foreach( $this->formatter->posts() as $post_in_wxr ) {
+                        $this->write( $post_in_wxr );
+                }
+                $this->write( $this->formatter->after_posts() );
+        }
+
+        abstract protected function write( $xml );
+}
+
+class WP_Export_XML_Over_HTTP extends WP_Export_Base_Writer {
+        private $file_name;
+
+        function __construct( $formatter, $file_name ) {
+                parent::__construct( $formatter );
+                $this->file_name = $file_name;
+        }
+
+        public function export() {
+                try {
+                        $export = $this->get_export();
+                        $this->send_headers();
+                        echo $export;
+                } catch ( WP_Export_Exception $e ) {
+                        $message = apply_filters( 'export_error_message', $e->getMessage() );
+                        wp_die( $message, __( 'Export Error' ), array( 'back_link' => true ) );
+                } catch ( WP_Export_Term_Exception $e ) {
+                        do_action( 'export_term_orphaned', $this->formatter->export->missing_parents );
+                        $message = apply_filters( 'export_term_error_message', $e->getMessage() );
+                        wp_die( $message, __( 'Export Error' ), array( 'back_link' => true ) );
+                }
+        }
+
+        protected function write( $xml ) {
+                $this->result .= $xml;
+        }
+
+        protected function get_export() {
+                $this->result = '';
+                parent::export();
+                return $this->result;
+        }
+
+        protected function send_headers() {
+                header( 'Content-Description: File Transfer' );
+                header( 'Content-Disposition: attachment; filename=' . $this->file_name );
+                header( 'Content-Type: text/xml; charset=' . get_option( 'blog_charset' ), true );
+        }
+}
+
+class WP_Export_Returner extends WP_Export_Base_Writer {
+        private $result = '';
+
+        public function export() {
+                $this->private = '';
+                try { 
+                        parent::export();
+                } catch ( WP_Export_Exception $e ) {
+                        $message = apply_filters( 'export_error_message', $e->getMessage() );
+                        return new WP_Error( 'wp-export-error', $message );
+                        
+                } catch ( WP_Export_Term_Exception $e ) {
+                        do_action( 'export_term_orphaned', $this->formatter->export->missing_parents );
+                        $message = apply_filters( 'export_term_error_message', $e->getMessage() );
+                        return new WP_Error( 'wp-export-error', $message );
+                }
+                return $this->result;
+        }
+        protected function write( $xml ) {
+                $this->result .= $xml;
+        }
+}
+
+class WP_Export_File_Writer extends WP_Export_Base_Writer {
+        private $f;
+        private $file_name;
+
+        public function __construct( $formatter, $file_name ) {
+                parent::__construct( $formatter );
+                $this->file_name = $file_name;
+        }
+
+        public function export() {
+                $this->f = fopen( $this->file_name, 'w' );
+                if ( !$this->f ) {
+                        throw new WP_Export_Exception( sprintf( __( 'WP Export: error opening %s for writing.' ), $this->file_name ) );
+                }
+
+                try { 
+                        parent::export();
+                } catch ( WP_Export_Exception $e ) {
+                        throw $e;
+                } catch ( WP_Export_Term_Exception $e ) {
+                        throw $e;
+                }
+
+                fclose( $this->f );
+        }
+
+        protected function write( $xml ) {
+                $res = fwrite( $this->f, $xml);
+                if ( false === $res ) {
+                        throw new WP_Export_Exception( __( 'WP Export: error writing to export file.' ) );
+                }
+        }
+}
+
+class WP_Export_Split_Files_Writer extends WP_Export_Base_Writer {
+        private $result = '';
+        private $f;
+        private $next_file_number = 0;
+        private $current_file_size = 0;
+
+        function __construct( $formatter, $writer_args = array() ) {
+                parent::__construct( $formatter );
+                //TODO: check if args are not missing
+                $this->max_file_size = is_null( $writer_args['max_file_size'] ) ? 15 * MB_IN_BYTES : $max_file_size;
+                $this->destination_directory = $writer_args['destination_directory'];
+                $this->filename_template = $writer_args['filename_template'];
+                $this->before_posts_xml = $this->formatter->before_posts();
+                $this->after_posts_xml = $this->formatter->after_posts();
+        }
+
+        public function export() {
+                $this->start_new_file();
+                foreach( $this->formatter->posts() as $post_xml ) {
+                        if ( $this->current_file_size + strlen( $post_xml ) > $this->max_file_size ) {
+                                $this->start_new_file();
+                        }
+                        $this->write( $post_xml );
+                }
+                $this->close_current_file();
+        }
+
+        protected function write( $xml ) {
+                $res = fwrite( $this->f, $xml);
+                if ( false === $res ) {
+                        throw new WP_Export_Exception( __( 'WP Export: error writing to export file.' ) );
+                }
+                $this->current_file_size += strlen( $xml );
+        }
+
+        private function start_new_file() {
+                if ( $this->f ) {
+                        $this->close_current_file();
+                }
+                $file_path = $this->next_file_path();
+                $this->f = fopen( $file_path, 'w' );
+                if ( !$this->f ) {
+                        throw new WP_Export_Exception( sprintf( __( 'WP Export: error opening %s for writing.' ), $file_path ) );
+                }
+                $this->current_file_size = 0;
+                $this->write( $this->before_posts_xml );
+        }
+
+        private function close_current_file() {
+                if ( !$this->f ) {
+                        return;
+                }
+                $this->write( $this->after_posts_xml );
+                fclose( $this->f );
+        }
+
+        private function next_file_name() {
+                $next_file_name = sprintf( $this->filename_template, $this->next_file_number );
+                $this->next_file_number++;
+                return $next_file_name;
+        }
+
+        private function next_file_path() {
+                return untrailingslashit( $this->destination_directory ) . DIRECTORY_SEPARATOR . $this->next_file_name();
+        }
+
+}

new file src/wp-includes/iterators.php

@@ +1 @@
+<?php
+class WP_Map_Iterator extends IteratorIterator {
+        function __construct( $iterator, $callback ) {
+                $this->callback = $callback;
+                parent::__construct( $iterator );
+        }
+
+        function current() {
+                $original_current = parent::current();
+                return call_user_func( $this->callback, $original_current );
+        }
+}
+
+class WP_Post_IDs_Iterator implements Iterator {
+        private $limit = 100;
+        private $post_ids;
+        private $ids_left;
+        private $results = array();
+
+        public function __construct( $post_ids, $limit = null ) {
+                $this->db = $GLOBALS['wpdb'];
+                $this->post_ids = $post_ids;
+                $this->ids_left = $post_ids;
+                if ( !is_null( $limit ) ) {
+                        $this->limit = $limit;
+                }
+        }
+
+        public function current() {
+                return $this->results[$this->index_in_results];
+        }
+
+        public function key() {
+                return $this->global_index;
+        }
+
+        public function next() {
+                $this->index_in_results++;
+                $this->global_index++;
+        }
+
+        public function rewind() {
+                $this->results = array();
+                $this->global_index = 0;
+                $this->index_in_results = 0;
+                $this->ids_left = $this->post_ids;
+        }
+
+        public function valid() {
+                if ( isset( $this->results[$this->index_in_results] ) ) {
+                        return true;
+                }
+                if ( empty( $this->ids_left ) ) {
+                        return false;
+                }
+                $has_posts = $this->load_next_posts_from_db();
+                if ( !$has_posts ) {
+                        return false;
+                }
+                $this->index_in_results = 0;
+                return true;
+        }
+
+        private function load_next_posts_from_db() {
+                $next_batch_post_ids = array_splice( $this->ids_left, 0, $this->limit );
+                $in_post_ids_sql = $this->db->build_IN_condition( 'ID', $next_batch_post_ids );
+                $this->results = $this->db->get_results( "SELECT * FROM {$this->db->posts} WHERE $in_post_ids_sql" );
+                if ( !$this->results ) {
+                        if ( $this->db->last_error ) {
+                                throw new WP_Iterator_Exception( 'Database error: ' . $this->db->last_error );
+                        } else {
+                                return false;
+                        }
+                }
+                return true;
+        }
+}
+
+class WP_Iterator_Exception extends Exception {
+}

src/wp-includes/wp-db.php

@@ -2843 +2843 @@
                 }
                 return preg_replace( '/[^0-9.].*/', '', $server_info );
         }
+
+        /**
+         * Builds a SQL condition in the form "post_id IN (1, 2, 3, 4)"
+         *
+         * @since 3.6.0
+         *
+         * @param string $column_name The name of the table column from the IN condition
+         * @param array $values Array of values in which the column value should be
+         * @param string $format Optional printf format specifier for the elements of the array. Defaults to %s.
+         * @return string The IN condition, with escaped values. If there are no values, the return value is an empty string.
+         */
+        function build_IN_condition( $column_name, $values, $format = '%s' ) {
+                if ( !is_array( $values ) || empty( $values ) ) {
+                        return '';
+                }
+                $formats = implode( ', ', array_fill( 0, count( $values ), $format ) );
+                return $this->prepare( "$column_name IN ($formats)", $values );
+        }
 }

src/wp-settings.php

@@ -134 +134 @@
 require( ABSPATH . WPINC . '/comment.php' );
 require( ABSPATH . WPINC . '/comment-template.php' );
 require( ABSPATH . WPINC . '/rewrite.php' );
+require( ABSPATH . WPINC . '/iterators.php' );
+require( ABSPATH . WPINC . '/export/class-wp-export-query.php' );
+require( ABSPATH . WPINC . '/export/class-wp-export-wxr-formatter.php' );
+require( ABSPATH . WPINC . '/export/writers.php' );
+require( ABSPATH . WPINC . '/export/functions.export.php' );
 require( ABSPATH . WPINC . '/feed.php' );
 require( ABSPATH . WPINC . '/bookmark.php' );
 require( ABSPATH . WPINC . '/bookmark-template.php' );

new file tests/phpunit/tests/export/class-wp-export-query.php

@@ +1 @@
+<?php
+
+/**
+ * Test WP_Export_Query class
+ *
+ * @group export
+ * @ticket 22435
+ */
+class Test_WP_Export_Query extends WP_UnitTestCase {
+        function setUp() {
+                if ( ! class_exists( 'WP_Export_Query' ) ) {
+                        $this->markTestSkipped( "WP_Export_Query class doesn't exist" );
+                }
+
+                parent::setUp();
+        }
+
+        function test_WP_Export_Query_should_be_initialized_with_an_array() {
+                $export = new WP_Export_Query( array( 'author' => 'all' ) );
+                $this->assertTrue( (bool) $export );
+        }
+
+        function test_WP_Export_Query_should_use_post_ids_if_passed() {
+                $export = new WP_Export_Query( array( 'post_ids' => array( 1, 2, 3 ) ) );
+                $this->assertEquals( array( 1, 2, 3 ), $export->post_ids() );
+        }
+
+        function test_WP_Export_Query_should_filter_all_posts_if_all_arg_is_true() {
+                $post_id = $this->factory->post->create();
+                $export = new WP_Export_Query();
+                $this->assertEquals( array( $post_id ), $export->post_ids() );
+        }
+
+        function test_WP_Export_Query_should_filter_all_posts_if_no_args_passed() {
+                $post_id = $this->factory->post->create();
+                $export = new WP_Export_Query();
+                $this->assertEquals( array( $post_id ), $export->post_ids() );
+        }
+
+        function test_WP_Export_Query_should_not_export_anything_if_post_type_arg_is_set_to_non_existing_post_type() {
+                $post_id = $this->factory->post->create();
+                $export = new WP_Export_Query( array( 'post_type' => 'baba' ) );
+                $this->assertEquals( array(), $export->post_ids() );
+        }
+
+        function test_WP_Export_Query_should_filter_only_posts_with_a_certain_post_type_if_the_post_type_arg_is_set() {
+                register_post_type( 'baba' );
+                $post_id = $this->factory->post->create( array( 'post_type' => 'baba' ) );
+                $_       = $this->factory->post->create( array( 'post_type' => 'dyado' ) );
+                $export = new WP_Export_Query( array( 'post_type' => 'baba' ) );
+                $this->assertEquals( array( $post_id ), $export->post_ids() );
+                _unregister_post_type( 'baba' );
+        }
+
+        function test_WP_Export_Query_should_not_export_post_types_with_can_export_set_to_false() {
+                register_post_type( 'non-exportable', array( 'can_export' => false ) );
+                register_post_type( 'exportable', array( 'can_export' => true ) );
+                $non_exportable_post_id = $this->factory->post->create( array( 'post_type' => 'non-exportable' ) );
+                $exportable_post_id = $this->factory->post->create( array( 'post_type' => 'exportable' ) );
+                $export = new WP_Export_Query();
+                $this->assertEquals( array( $exportable_post_id ), $export->post_ids() );
+                _unregister_post_type( 'non-exportable' );
+                _unregister_post_type( 'exportable' );
+        }
+
+        function test_WP_Export_Query_should_not_export_auto_drafts_by_default() {
+                $post_id = $this->factory->post->create( array( 'post_status' => 'auto-draft' ) );
+                $export = new WP_Export_Query();
+                $this->assertEquals( array(), $export->post_ids() );
+        }
+
+        function test_WP_Export_Query_should_filter_only_posts_with_certain_status_if_status_arg_is_set() {
+                $post_id_baba = $this->factory->post->create( array( 'post_status' => 'baba' ) );
+                $post_id_dudu = $this->factory->post->create( array( 'post_status' => 'dudu' ) );
+                $export = new WP_Export_Query( array( 'status' => 'baba' ) );
+                $this->assertEquals( array( $post_id_baba ), $export->post_ids() );
+        }
+
+        function test_WP_Export_Query_should_filter_only_posts_with_certain_author_id_if_status_arg_is_a_number() {
+                $user_id = $this->factory->user->create();
+                $post_by_user = $this->factory->post->create( array( 'post_author' => $user_id ) );
+                $other_post = $this->factory->post->create( array( 'post_author' => $user_id + 1 ) );
+                $export = new WP_Export_Query( array( 'author' => $user_id ) );
+                $this->assertEquals( array( $post_by_user ), $export->post_ids() );
+        }
+
+        function test_WP_Export_Query_should_filter_only_posts_with_certain_author_name_if_status_arg_is_a_username() {
+                $user = $this->factory->user->create_and_get( array( 'user_login' => 'baba' ) );
+                $post_by_user = $this->factory->post->create( array( 'post_author' => $user->ID ) );
+                $other_post = $this->factory->post->create( array( 'post_author' => $user->ID + 1 ) );
+                $export = new WP_Export_Query( array( 'author' => 'baba' ) );
+                $this->assertEquals( array( $post_by_user ), $export->post_ids() );
+        }
+
+        function test_WP_Export_Query_should_filter_only_posts_with_certain_author_object_if_author_is_an_object_with_ID_member_variable() {
+                $user = $this->factory->user->create_and_get();
+                $post_by_user = $this->factory->post->create( array( 'post_author' => $user->ID ) );
+                $other_post = $this->factory->post->create( array( 'post_author' => $user->ID + 1 ) );
+                $export = new WP_Export_Query( array( 'author' => $user ) );
+                $this->assertEquals( array( $post_by_user ), $export->post_ids() );
+        }
+
+        function test_WP_Export_Query_should_filter_only_posts_after_certain_start_date_if_start_date_arg_is_passed() {
+                $post_before = $this->factory->post->create( array( 'post_date' => '2012-11-10 23:59:59' ) );
+                $post_after = $this->factory->post->create( array( 'post_date' => '2012-11-11 00:00:00' ) );
+                $export = new WP_Export_Query( array( 'start_date' => '2012-11-11' ) );
+                $this->assertEquals( array( $post_after ), $export->post_ids() );
+        }
+
+        function test_WP_Export_Query_should_filter_only_posts_after_certain_end_date_if_end_date_arg_is_passed() {
+                $post_before = $this->factory->post->create( array( 'post_date' => '2012-11-10 23:59:59' ) );
+                $post_after = $this->factory->post->create( array( 'post_date' => '2012-11-11 00:00:00' ) );
+                $export = new WP_Export_Query( array( 'end_date' => '2012-11-10' ) );
+                $this->assertEquals( array( $post_before ), $export->post_ids() );
+        }
+
+        function test_WP_Export_Query_should_filter_only_posts_with_certain_category_if_category_arg_is_passed() {
+                $category_id = $this->factory->category->create( array( 'name' => 'baba' ) );
+                $post_with_category = $this->factory->post->create( array( 'post_category' => array( $category_id ) ) );
+                $post_without = $this->factory->post->create();
+                $export = new WP_Export_Query( array( 'post_type' => 'post', 'category' => 'baba' ) );
+                $this->assertEquals( array( $post_with_category ), $export->post_ids() );
+        }
+
+        function test_WP_Export_Query_should_filter_only_posts_with_certain_category_id_if_category_arg_is_passed() {
+                $category_id = $this->factory->category->create( array( 'name' => 'baba' ) );
+                $post_with_category = $this->factory->post->create( array( 'post_category' => array( $category_id ) ) );
+                $post_without = $this->factory->post->create();
+                $export = new WP_Export_Query( array( 'post_type' => 'post', 'category' => $category_id ) );
+                $this->assertEquals( array( $post_with_category ), $export->post_ids() );
+        }
+
+        function test_WP_Export_Query_should_filter_posts_by_category_only_for_post_post_type() {
+                $category_id = $this->factory->category->create( array( 'name' => 'baba' ) );
+                $post_with_category = $this->factory->post->create( array( 'post_category' => array( $category_id ) ) );
+                $post_without = $this->factory->post->create();
+                $different_post_type = $this->factory->post->create( array( 'post_type' => 'page' ) );
+                $export = new WP_Export_Query( array( 'category' => $category_id ) );
+                $this->assertEqualSets( array( $post_with_category, $post_without, $different_post_type ), $export->post_ids() );
+        }
+
+        function test_WP_Export_Query_should_include_attachments_of_posts_if_we_are_filtering_only_some_post_types() {
+                register_post_type( 'baba' );
+                $post_id = $this->factory->post->create( array( 'post_type' => 'baba' ) );
+                $attachment_post_id = $this->factory->post->create( array( 'post_type' => 'attachment', 'post_parent' => $post_id ) );
+                $export = new WP_Export_Query( array( 'post_type' => 'baba' ) );
+                $this->assertEquals( array( $post_id, $attachment_post_id ), $export->post_ids() );
+                _unregister_post_type( 'baba' );
+        }
+
+        function test_authors_should_return_list_of_users_for_each_post_author() {
+                $user_id = $this->factory->user->create();
+                $this->factory->post->create( array( 'post_author' => $user_id ) );
+                $export = new WP_Export_Query();
+                $authors = $export->authors();
+                $this->assertEquals( 1, count( $authors ) );
+                $this->assertEquals( $user_id, $authors[0]->ID );
+        }
+
+        function test_authors_should_skip_non_existing_authors() {
+                $this->factory->post->create( array( 'post_author' => 11 ) );
+                $export = new WP_Export_Query();
+                $this->assertEquals( array(), $export->authors() );
+        }
+
+        function test_authors_should_skip_auto_draft_authors() {
+                $user_id = $this->factory->user->create();
+                $this->factory->post->create( array( 'post_author' => $user_id, 'post_status' => 'auto-draft' ) );
+                $export = new WP_Export_Query();
+                $this->assertEquals( array(), $export->authors() );
+        }
+
+        function test_categories_should_return_only_the_category_we_are_filtering_on() {
+                $category_id = $this->factory->category->create( array( 'name' => 'baba' ) );
+                $other_category_id = $this->factory->category->create( array( 'name' => 'dyado' ) );
+                $export = new WP_Export_Query( array( 'post_type' => 'post', 'category' => $category_id ) );
+                $categories = $export->categories();
+                $this->assertTrue( is_array( $categories ) );
+                $this->assertEquals( 1, count( $categories ) );
+        }
+
+        function test_categories_should_return_no_categories_if_we_are_requesting_only_one_post_type() {
+                $category_id = $this->factory->category->create();
+                $export = new WP_Export_Query( array( 'post_type' => 'post' ) );
+                $this->assertEquals( array(), $export->categories() );
+        }
+
+        function test_categories_should_return_all_categories_if_we_are_requesting_all_post_types() {
+                $category_id = $this->factory->category->create();
+                $another_category_id = $this->factory->category->create();
+                $export = new WP_Export_Query();
+                $this->assertEqualSets( array( 1, $category_id, $another_category_id ), self::get_term_ids( $export->categories() ) );
+        }
+
+        function test_categories_should_not_return_a_child_before_its_parent_category() {
+                $child_category_id = $this->factory->category->create();
+                $top_category_id = $this->factory->category->create();
+                wp_update_term( $child_category_id, 'category', array( 'parent' => $top_category_id ) );
+                $export = new WP_Export_Query();
+                $this->assertNoChildBeforeParent( $export->categories() );
+        }
+
+        function test_tags_should_return_all_tags() {
+                $tag_id = $this->factory->tag->create();
+                $export = new WP_Export_Query();
+                $this->assertEquals( array( $tag_id ), self::get_term_ids( $export->tags() ) );
+        }
+
+        function test_tags_should_return_no_tags_if_we_are_requesting_only_one_post_type() {
+                $category_id = $this->factory->tag->create();
+                $export = new WP_Export_Query( array( 'post_type' => 'post' ) );
+                $this->assertEquals( array(), $export->tags() );
+        }
+
+        function test_custom_taxonomies_terms_should_return_all_terms() {
+                register_taxonomy( 'taxonomy_all', 'post' );
+                $term_id = $this->factory->term->create( array( 'taxonomy' => 'taxonomy_all' ) );
+                $export = new WP_Export_Query();
+                $this->assertEquals( array( $term_id ), self::get_term_ids( $export->custom_taxonomies_terms() ) );
+                _unregister_taxonomy( 'taxonomy_all' );
+        }
+
+        function test_custom_taxonomes_terms_should_return_no_terms_if_we_are_requesting_only_one_post_type() {
+                register_taxonomy( 'taxonomy_one_post_type', 'post' );
+                $term_id = $this->factory->term->create( array( 'taxonomy' => 'taxonomy_one_post_type' ) );
+                $export = new WP_Export_Query( array( 'post_type' => 'post' ) );
+                $this->assertEquals( array(), $export->custom_taxonomies_terms() );
+                _unregister_taxonomy( 'taxonomy_one_post_type' );
+        }
+
+        function test_custom_taxonomies_terms_should_not_return_a_child_before_its_parent_term() {
+                register_taxonomy( 'heir', 'post', array( 'hierarchical' => true ) );
+                $child_term_id = $this->factory->term->create( array( 'taxonomy' => 'heir' ) );
+                $top_term_id = $this->factory->term->create( array( 'taxonomy' => 'heir' ) );
+                wp_update_term( $child_term_id, 'heir', array( 'parent' => $top_term_id ) );
+                $export = new WP_Export_Query();
+                $this->assertNoChildBeforeParent( $export->custom_taxonomies_terms() );
+                _unregister_taxonomy( 'heir' );
+        }
+
+        private function assertNoChildBeforeParent( $terms ) {
+                $visited = array();
+                foreach( $terms as $term ) {
+                        $this->assertTrue( isset( $visited[$term->parent] ) || !$term->parent );
+                        $visited[$term->term_id] = true;
+                }
+        }
+
+        private static function get_term_ids( $terms ) {
+                return array_values( array_map( array( __CLASS__, '_get_term_ids_cb' ), $terms ) );
+        }
+
+        private static function _get_term_ids_cb( $c ) {
+                return intval( $c->term_id );
+        }
+
+}
+

new file tests/phpunit/tests/export/functions.export.php

@@ +1 @@
+<?php
+
+/**
+ * Test export functions
+ *
+ * @group export
+ * @ticket 22435
+ */
+class Test_WP_Export_Functions extends WP_UnitTestCase {
+        function setUp() {
+                if ( ! function_exists( 'wp_export' ) ) {
+                        $this->markTestSkipped( "wp_export function doesn't exist" );
+                }
+
+                parent::setUp();
+        }
+        
+        function test_wp_export_returns_wp_error_if_the_writer_throws_Export_exception() {
+                $this->assertTrue( is_wp_error( wp_export( array( 'writer' => 'Test_WP_Export_Stub_Writer_Throws_Export_Exception' ) ) ) );
+        }
+
+        function test_wp_export_passes_the_exception_if_the_writer_throws_other_exception() {
+                $this->setExpectedException( 'Exception' );
+                wp_export( array( 'writer' => 'Test_WP_Export_Stub_Writer_Throws_Other_Exception' ) );
+        }
+
+}
+
+class Test_WP_Export_Stub_Writer_Throws_Export_Exception {
+        function __construct( $formatter ) {
+        }
+        function export() {
+                throw new WP_Export_Exception( 'baba' );
+        }
+}
+
+class Test_WP_Export_Stub_Writer_Throws_Other_Exception {
+        function __construct( $formatter ) {
+        }
+        function export() {
+                throw new Exception( 'baba' );
+        }
+}

new file tests/phpunit/tests/export/writers.php

@@ +1 @@
+<?php
+
+/**
+ * Test WP_Export_*_Writer classes
+ *
+ * @group export
+ * @ticket 22435
+ */
+class Test_WP_Export_Writers extends WP_UnitTestCase {
+        function test_export_returner_returns_all_the_return_values() {
+                if ( ! class_exists( 'WP_Export_Returner' ) ) {
+                        $this->markTestSkipped( "WP_Export_Returner class doesn't exist" );
+                }
+                $returner = new WP_Export_Returner( $this->get_x_formatter() );
+                $this->assertEquals( 'xxx' , $returner->export() );
+        }
+
+        private function get_x_formatter() {
+                $methods = array( 'before_posts', 'posts', 'after_posts' );
+                $formatter = $this->getMock( 'WP_Export_WXR_Formatter', $methods, array( null ) );
+                foreach( $methods as $method ) {
+                        $return = 'posts' == $method? array( 'x' ) : 'x';
+                        $formatter->expects( $this->once() )->method( $method )->with()->will( $this->returnValue( $return ) );
+                }
+                return $formatter;
+        }
+}
+

new file tests/phpunit/tests/iterators.php

@@ +1 @@
+<?php
+
+/**
+ * @ticket 22435
+ */
+class Test_WP_Post_IDs_Iterator extends WP_UnitTestCase {
+        function setUp() {
+                if ( ! class_exists( 'WP_Post_IDs_Iterator' ) ) {
+                        $this->markTestSkipped( "WP_Post_IDs_Iterator class doesn't exist" );
+                }
+
+                parent::setUp();
+        }
+
+        function test_create() {
+                new WP_Post_IDs_Iterator( array( 1, 2, 3 ) );
+        }
+
+        function test_no_posts() {
+                $this->assertIteratorReturnsSamePostIDs( array() );
+        }
+
+        function test_less_ids_than_limit() {
+                $post_id_0 = $this->factory->post->create();
+                $post_id_1 = $this->factory->post->create();
+                $this->assertIteratorReturnsSamePostIDs( array( $post_id_0, $post_id_1 ), 10 );
+        }
+
+        function test_ids_exactly_as_limit() {
+                $post_id_0 = $this->factory->post->create();
+                $post_id_1 = $this->factory->post->create();
+                $this->assertIteratorReturnsSamePostIDs( array( $post_id_0, $post_id_1 ), 2 );
+        }
+
+        function test_more_ids_than_limit() {
+                $post_id_0 = $this->factory->post->create();
+                $post_id_1 = $this->factory->post->create();
+                $post_id_2 = $this->factory->post->create();
+                $this->assertIteratorReturnsSamePostIDs( array( $post_id_0, $post_id_1, $post_id_2 ), 2 );
+        }
+
+        function test_ids_exactly_twice_more_than_limit() {
+                $post_id_0 = $this->factory->post->create();
+                $post_id_1 = $this->factory->post->create();
+                $post_id_2 = $this->factory->post->create();
+                $post_id_3 = $this->factory->post->create();
+                $this->assertIteratorReturnsSamePostIDs( array( $post_id_0, $post_id_1, $post_id_2, $post_id_3 ), 2 );
+        }
+
+        private function assertIteratorReturnsSamePostIDs( $post_ids, $limit = 2 ) {
+                $this->assertEquals( $post_ids, wp_list_pluck( iterator_to_array( new WP_Post_IDs_Iterator( $post_ids, $limit ) ), 'ID' ) );
+        }
+}